From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 6B238C43217 for ; Tue, 4 Oct 2022 10:49:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=IfL5IrewD8sV8kuKr2m3tmn98sYzVctPWOA82an3jLI=; b=xPZ2nuVZtg3hHI RpfkHnW6SUDXnGhUOomntDXfeUuLLkici1VktYLROcnVjLaO6zmTL49nbBatfwbdLLK0ttBbrFB4p uWY5sLKp1FbohnzWFCWXrvFJnat+o/zkaeUlUTHoDsh4KmUEs7N99vLi6eW0nXybltAP6zr2c8dW4 L3jhYGVtCUyj1sJlr9+2OQgNR59hwMMWmV8rVi7sHv+AyHLNrozLc+lOVKMBSOF4rjRIgEQkoe3CG UT0W3iuP+i2ZZYkTMS+80tWIvRDfN7o5jb/Vgxvsp/2tBJ86OSt2haXIUwdeYEfm4iVu6KUKPZm0T LFtdWqKPuC0LWmhDox3w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1offUi-009Pvt-AC; Tue, 04 Oct 2022 10:49:48 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1offUe-009PuB-9C for linux-riscv@lists.infradead.org; Tue, 04 Oct 2022 10:49:46 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 0F47F61353; Tue, 4 Oct 2022 10:49:43 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6BAE2C4347C; Tue, 4 Oct 2022 10:49:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1664880581; bh=EiG7MLXpt/ieQf/scjf2AjsAsALEw0iDo5jOA5XLK1o=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=PuVLtqtDLOT35uK/LKnFhKdO0kypUV5cjbuQpI1HoAo/jyjXpt0+wXMugbV9m+DH1 rtjsLiAd/QPE3wrlBKsAgA8c8fLOQpgmoth5DWgiQddc779ITsKE5MbOjL9jis3Gus e+zgNVycSJbIax0Fzpu4RqkALLumzUjWKLO+R421G5GgutWK7Ut7RKt5NKPKhZu/S2 BhXtJdVBlmMNHO5szSGb0i8jYIJaMtJvXSgif7/EcdNG2iKkegj7VbXe2SgmVKkcY5 Lk6y5yk4YHUikyo2kUJ77MEAzmivbFTC3NEHc5Swhicqze11ubW4qA/2Qh1Tb1NPA8 YhVI37WXg8xTA== From: "Jiri Slaby (SUSE)" To: gregkh@linuxfoundation.org Cc: linux-serial@vger.kernel.org, linux-kernel@vger.kernel.org, "Jiri Slaby (SUSE)" , Russell King , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, =?UTF-8?q?Pali=20Roh=C3=A1r?= , Kevin Cernekee , Palmer Dabbelt , Paul Walmsley , Orson Zhai , Baolin Wang , Chunyan Zhang , Patrice Chotard , linux-riscv@lists.infradead.org Subject: [PATCH v5 3/3] tty: serial: use uart_port_tx_limited() Date: Tue, 4 Oct 2022 12:49:27 +0200 Message-Id: <20221004104927.14361-4-jirislaby@kernel.org> X-Mailer: git-send-email 2.37.3 In-Reply-To: <20221004104927.14361-1-jirislaby@kernel.org> References: <20221004104927.14361-1-jirislaby@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20221004_034944_442154_46F0DA9D X-CRM114-Status: GOOD ( 20.88 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org dWFydF9wb3J0X3R4X2xpbWl0ZWQoKSBpcyBhIG5ldyBoZWxwZXIgdG8gc2VuZCBjaGFyYWN0ZXJz IHRvIHRoZSBkZXZpY2UuClVzZSBpdCBpbiB0aGVzZSBkcml2ZXJzLgoKbXV4LmMgYWxzbyBuZWVk cyB0byBkZWZpbmUgdHhfZG9uZSgpLiBCdXQgSSdtIG5vdCBzdXJlIGlmIHRoZSBkcml2ZXIKcmVh bGx5IHdhbnRzIHRvIHdhaXQgZm9yIGFsbCB0aGUgY2hhcmFjdGVycyB0byBkaXNtaXNzIGZyb20g dGhlIEhXIGZpZm8KYXQgdGhpcyBjb2RlIHBvaW50LiBIZW5jZSBJIG1hcmtlZCB0aGlzIGFzIEZJ WE1FLgoKQ2M6IFJ1c3NlbGwgS2luZyA8bGludXhAYXJtbGludXgub3JnLnVrPgpDYzogRmxvcmlh biBGYWluZWxsaSA8Zi5mYWluZWxsaUBnbWFpbC5jb20+CkNjOiBiY20ta2VybmVsLWZlZWRiYWNr LWxpc3RAYnJvYWRjb20uY29tCkNjOiAiUGFsaSBSb2jDoXIiIDxwYWxpQGtlcm5lbC5vcmc+CkNj OiBLZXZpbiBDZXJuZWtlZSA8Y2VybmVrZWVAZ21haWwuY29tPgpDYzogUGFsbWVyIERhYmJlbHQg PHBhbG1lckBkYWJiZWx0LmNvbT4KQ2M6IFBhdWwgV2FsbXNsZXkgPHBhdWwud2FsbXNsZXlAc2lm aXZlLmNvbT4KQ2M6IE9yc29uIFpoYWkgPG9yc29uemhhaUBnbWFpbC5jb20+CkNjOiBCYW9saW4g V2FuZyA8YmFvbGluLndhbmc3QGdtYWlsLmNvbT4KQ2M6IENodW55YW4gWmhhbmcgPHpoYW5nLmx5 cmFAZ21haWwuY29tPgpDYzogUGF0cmljZSBDaG90YXJkIDxwYXRyaWNlLmNob3RhcmRAZm9zcy5z dC5jb20+CkNjOiBsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnClNpZ25lZC1vZmYtYnk6 IEppcmkgU2xhYnkgKFNVU0UpIDxqaXJpc2xhYnlAa2VybmVsLm9yZz4KLS0tCgpOb3RlczoKICAg IFt2NF0gc3dpdGNoIGZyb20gREVGSU5FX1VBUlRfUE9SVF9UWF9IRUxQRVJfTElNSVRFRCgpICho ZWxwZXIgZ2VuZXJhdG9yKQogICAgICAgICB0byB1YXJ0X3BvcnRfdHhfbGltaXRlZCgpIChha2lu IHRvIHdhaXRfZXZlbnQoKSkKCiBkcml2ZXJzL3R0eS9zZXJpYWwvMjEyODUuYyAgICAgICAgICAg fCAzMiArKystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvYWx0ZXJhX2p0YWd1 YXJ0LmMgfCAzNiArKysrLS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvdHR5L3NlcmlhbC9hbWJh LXBsMDEwLmMgICAgICB8IDMyICsrKy0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvdHR5L3Nlcmlh bC9hcGJ1YXJ0LmMgICAgICAgICB8IDM0ICsrKy0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0 eS9zZXJpYWwvYmNtNjN4eF91YXJ0LmMgICAgfCA0NyArKysrKystLS0tLS0tLS0tLS0tLS0tLS0t LS0KIGRyaXZlcnMvdHR5L3NlcmlhbC9tdXguYyAgICAgICAgICAgICB8IDQ1ICsrKysrKysrLS0t LS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvbXZlYnUtdWFydC5jICAgICAgfCAz OCArKystLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvb21hcC1zZXJpYWwu YyAgICAgfCAzMiArKystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvcHhhLmMg ICAgICAgICAgICAgfCAzMyArKystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwv cnAyLmMgICAgICAgICAgICAgfCAzMSArKysrLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvdHR5L3Nl cmlhbC9zZXJpYWxfdHh4OS5jICAgICB8IDMyICsrKy0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMv dHR5L3NlcmlhbC9zaWZpdmUuYyAgICAgICAgICB8IDMxICsrKy0tLS0tLS0tLS0tLS0tLQogZHJp dmVycy90dHkvc2VyaWFsL3NwcmRfc2VyaWFsLmMgICAgIHwgMzMgKysrLS0tLS0tLS0tLS0tLS0t LQogZHJpdmVycy90dHkvc2VyaWFsL3N0LWFzYy5jICAgICAgICAgIHwgNDggKysrLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQogMTQgZmlsZXMgY2hhbmdlZCwgODUgaW5zZXJ0aW9ucygrKSwgNDE5 IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC8yMTI4NS5jIGIv ZHJpdmVycy90dHkvc2VyaWFsLzIxMjg1LmMKaW5kZXggYzdkMzQ4MjNmNzE1Li4xODU0NjJmZDk1 OWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC8yMTI4NS5jCisrKyBiL2RyaXZlcnMv dHR5L3NlcmlhbC8yMTI4NS5jCkBAIC0xNTQsMzUgKzE1NCwxMyBAQCBzdGF0aWMgaXJxcmV0dXJu X3Qgc2VyaWFsMjEyODVfcnhfY2hhcnMoaW50IGlycSwgdm9pZCAqZGV2X2lkKQogc3RhdGljIGly cXJldHVybl90IHNlcmlhbDIxMjg1X3R4X2NoYXJzKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIHsK IAlzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0ID0gZGV2X2lkOwotCXN0cnVjdCBjaXJjX2J1ZiAqeG1p dCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQlpbnQgY291bnQgPSAyNTY7Ci0KLQlpZiAocG9ydC0+ eF9jaGFyKSB7Ci0JCSpDU1JfVUFSVERSID0gcG9ydC0+eF9jaGFyOwotCQlwb3J0LT5pY291bnQu dHgrKzsKLQkJcG9ydC0+eF9jaGFyID0gMDsKLQkJZ290byBvdXQ7Ci0JfQotCWlmICh1YXJ0X2Np cmNfZW1wdHkoeG1pdCkgfHwgdWFydF90eF9zdG9wcGVkKHBvcnQpKSB7Ci0JCXNlcmlhbDIxMjg1 X3N0b3BfdHgocG9ydCk7Ci0JCWdvdG8gb3V0OwotCX0KLQotCWRvIHsKLQkJKkNTUl9VQVJURFIg PSB4bWl0LT5idWZbeG1pdC0+dGFpbF07Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEp ICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlpZiAodWFy dF9jaXJjX2VtcHR5KHhtaXQpKQotCQkJYnJlYWs7Ci0JfSB3aGlsZSAoLS1jb3VudCA+IDAgJiYg ISgqQ1NSX1VBUlRGTEcgJiAweDIwKSk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmco eG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOworCXU4IGNo OwogCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJc2VyaWFsMjEyODVfc3RvcF90eChw b3J0KTsKKwl1YXJ0X3BvcnRfdHhfbGltaXRlZChwb3J0LCBjaCwgMjU2LAorCQkhKCpDU1JfVUFS VEZMRyAmIDB4MjApLAorCQkqQ1NSX1VBUlREUiA9IGNoLAorCQkoe30pKTsKIAotIG91dDoKIAly ZXR1cm4gSVJRX0hBTkRMRUQ7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9h bHRlcmFfanRhZ3VhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hbHRlcmFfanRhZ3VhcnQuYwpp bmRleCBjMmQxNTRkNzhlNTQuLmFhNDk1NTNmYWM1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkv c2VyaWFsL2FsdGVyYV9qdGFndWFydC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hbHRlcmFf anRhZ3VhcnQuYwpAQCAtMTQ2LDM3ICsxNDYsMTUgQEAgc3RhdGljIHZvaWQgYWx0ZXJhX2p0YWd1 YXJ0X3J4X2NoYXJzKHN0cnVjdCBhbHRlcmFfanRhZ3VhcnQgKnBwKQogc3RhdGljIHZvaWQgYWx0 ZXJhX2p0YWd1YXJ0X3R4X2NoYXJzKHN0cnVjdCBhbHRlcmFfanRhZ3VhcnQgKnBwKQogewogCXN0 cnVjdCB1YXJ0X3BvcnQgKnBvcnQgPSAmcHAtPnBvcnQ7Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0 ID0gJnBvcnQtPnN0YXRlLT54bWl0OwotCXVuc2lnbmVkIGludCBwZW5kaW5nLCBjb3VudDsKLQot CWlmIChwb3J0LT54X2NoYXIpIHsKLQkJLyogU2VuZCBzcGVjaWFsIGNoYXIgLSBwcm9iYWJseSBm bG93IGNvbnRyb2wgKi8KLQkJd3JpdGVsKHBvcnQtPnhfY2hhciwgcG9ydC0+bWVtYmFzZSArIEFM VEVSQV9KVEFHVUFSVF9EQVRBX1JFRyk7Ci0JCXBvcnQtPnhfY2hhciA9IDA7Ci0JCXBvcnQtPmlj b3VudC50eCsrOwotCQlyZXR1cm47Ci0JfQorCXVuc2lnbmVkIGludCBjb3VudDsKKwl1OCBjaDsK IAotCXBlbmRpbmcgPSB1YXJ0X2NpcmNfY2hhcnNfcGVuZGluZyh4bWl0KTsKLQlpZiAocGVuZGlu ZyA+IDApIHsKLQkJY291bnQgPSBhbHRlcmFfanRhZ3VhcnRfdHhfc3BhY2UocG9ydCwgTlVMTCk7 Ci0JCWlmIChjb3VudCA+IHBlbmRpbmcpCi0JCQljb3VudCA9IHBlbmRpbmc7Ci0JCWlmIChjb3Vu dCA+IDApIHsKLQkJCXBlbmRpbmcgLT0gY291bnQ7Ci0JCQl3aGlsZSAoY291bnQtLSkgewotCQkJ CXdyaXRlbCh4bWl0LT5idWZbeG1pdC0+dGFpbF0sCi0JCQkJICAgICAgIHBvcnQtPm1lbWJhc2Ug KyBBTFRFUkFfSlRBR1VBUlRfREFUQV9SRUcpOwotCQkJCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFp bCArIDEpICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7Ci0JCQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0J CQl9Ci0JCQlpZiAocGVuZGluZyA8IFdBS0VVUF9DSEFSUykKLQkJCQl1YXJ0X3dyaXRlX3dha2V1 cChwb3J0KTsKLQkJfQotCX0KKwljb3VudCA9IGFsdGVyYV9qdGFndWFydF90eF9zcGFjZShwb3J0 LCBOVUxMKTsKIAotCWlmIChwZW5kaW5nID09IDApCi0JCWFsdGVyYV9qdGFndWFydF9zdG9wX3R4 KHBvcnQpOworCXVhcnRfcG9ydF90eF9saW1pdGVkKHBvcnQsIGNoLCBjb3VudCwKKwkJdHJ1ZSwK KwkJd3JpdGVsKGNoLCBwb3J0LT5tZW1iYXNlICsgQUxURVJBX0pUQUdVQVJUX0RBVEFfUkVHKSwK KwkJKHt9KSk7CiB9CiAKIHN0YXRpYyBpcnFyZXR1cm5fdCBhbHRlcmFfanRhZ3VhcnRfaW50ZXJy dXB0KGludCBpcnEsIHZvaWQgKmRhdGEpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwv YW1iYS1wbDAxMC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2FtYmEtcGwwMTAuYwppbmRleCBhZjI3 ZmI4ZWMxNDUuLmE5OGZhZTJjYTQyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL2Ft YmEtcGwwMTAuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvYW1iYS1wbDAxMC5jCkBAIC0xNjQs MzQgKzE2NCwxMiBAQCBzdGF0aWMgdm9pZCBwbDAxMF9yeF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0 ICpwb3J0KQogCiBzdGF0aWMgdm9pZCBwbDAxMF90eF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0ICpw b3J0KQogewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQlp bnQgY291bnQ7CisJdTggY2g7CiAKLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0JCXdyaXRlbChwb3J0 LT54X2NoYXIsIHBvcnQtPm1lbWJhc2UgKyBVQVJUMDF4X0RSKTsKLQkJcG9ydC0+aWNvdW50LnR4 Kys7Ci0JCXBvcnQtPnhfY2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19l bXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKLQkJcGwwMTBfc3RvcF90eChw b3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCWNvdW50ID0gcG9ydC0+Zmlmb3NpemUgPj4gMTsKLQlk byB7Ci0JCXdyaXRlbCh4bWl0LT5idWZbeG1pdC0+dGFpbF0sIHBvcnQtPm1lbWJhc2UgKyBVQVJU MDF4X0RSKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJ WkUgLSAxKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1p dCkpCi0JCQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJj X2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVw KHBvcnQpOwotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJcGwwMTBfc3RvcF90eChw b3J0KTsKKwl1YXJ0X3BvcnRfdHhfbGltaXRlZChwb3J0LCBjaCwgcG9ydC0+Zmlmb3NpemUgPj4g MSwKKwkJdHJ1ZSwKKwkJd3JpdGVsKGNoLCBwb3J0LT5tZW1iYXNlICsgVUFSVDAxeF9EUiksCisJ CSh7fSkpOwogfQogCiBzdGF0aWMgdm9pZCBwbDAxMF9tb2RlbV9zdGF0dXMoc3RydWN0IHVhcnRf YW1iYV9wb3J0ICp1YXApCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvYXBidWFydC5j IGIvZHJpdmVycy90dHkvc2VyaWFsL2FwYnVhcnQuYwppbmRleCA0NTBmNGVkZmRhMGYuLjkxNWVl NGIwZDU5NCAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL2FwYnVhcnQuYworKysgYi9k cml2ZXJzL3R0eS9zZXJpYWwvYXBidWFydC5jCkBAIC0xMjIsMzYgKzEyMiwxMiBAQCBzdGF0aWMg dm9pZCBhcGJ1YXJ0X3J4X2NoYXJzKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCiAKIHN0YXRpYyB2 b2lkIGFwYnVhcnRfdHhfY2hhcnMoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKIHsKLQlzdHJ1Y3Qg Y2lyY19idWYgKnhtaXQgPSAmcG9ydC0+c3RhdGUtPnhtaXQ7Ci0JaW50IGNvdW50OwotCi0JaWYg KHBvcnQtPnhfY2hhcikgewotCQlVQVJUX1BVVF9DSEFSKHBvcnQsIHBvcnQtPnhfY2hhcik7Ci0J CXBvcnQtPmljb3VudC50eCsrOwotCQlwb3J0LT54X2NoYXIgPSAwOwotCQlyZXR1cm47Ci0JfQot Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsK LQkJYXBidWFydF9zdG9wX3R4KHBvcnQpOwotCQlyZXR1cm47Ci0JfQotCi0JLyogYW1iYTogZmls bCBGSUZPICovCi0JY291bnQgPSBwb3J0LT5maWZvc2l6ZSA+PiAxOwotCWRvIHsKLQkJVUFSVF9Q VVRfQ0hBUihwb3J0LCB4bWl0LT5idWZbeG1pdC0+dGFpbF0pOwotCQl4bWl0LT50YWlsID0gKHht aXQtPnRhaWwgKyAxKSAmIChVQVJUX1hNSVRfU0laRSAtIDEpOwotCQlwb3J0LT5pY291bnQudHgr KzsKLQkJaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJCWJyZWFrOwotCX0gd2hpbGUgKC0t Y291bnQgPiAwKTsKLQotCWlmICh1YXJ0X2NpcmNfY2hhcnNfcGVuZGluZyh4bWl0KSA8IFdBS0VV UF9DSEFSUykKLQkJdWFydF93cml0ZV93YWtldXAocG9ydCk7CisJdTggY2g7CiAKLQlpZiAodWFy dF9jaXJjX2VtcHR5KHhtaXQpKQotCQlhcGJ1YXJ0X3N0b3BfdHgocG9ydCk7CisJdWFydF9wb3J0 X3R4X2xpbWl0ZWQocG9ydCwgY2gsIHBvcnQtPmZpZm9zaXplID4+IDEsCisJCXRydWUsCisJCVVB UlRfUFVUX0NIQVIocG9ydCwgY2gpLAorCQkoe30pKTsKIH0KIAogc3RhdGljIGlycXJldHVybl90 IGFwYnVhcnRfaW50KGludCBpcnEsIHZvaWQgKmRldl9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMv dHR5L3NlcmlhbC9iY202M3h4X3VhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9iY202M3h4X3Vh cnQuYwppbmRleCA1ZDk3MzdjMmQxZjIuLjYyYmM3MjQ0ZGM2NyAxMDA2NDQKLS0tIGEvZHJpdmVy cy90dHkvc2VyaWFsL2JjbTYzeHhfdWFydC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9iY202 M3h4X3VhcnQuYwpAQCAtMzAzLDUzICszMDMsMjQgQEAgc3RhdGljIHZvaWQgYmNtX3VhcnRfZG9f cngoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKICAqLwogc3RhdGljIHZvaWQgYmNtX3VhcnRfZG9f dHgoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKIHsKLQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQ7Ci0J dW5zaWduZWQgaW50IHZhbCwgbWF4X2NvdW50OwotCi0JaWYgKHBvcnQtPnhfY2hhcikgewotCQli Y21fdWFydF93cml0ZWwocG9ydCwgcG9ydC0+eF9jaGFyLCBVQVJUX0ZJRk9fUkVHKTsKLQkJcG9y dC0+aWNvdW50LnR4Kys7Ci0JCXBvcnQtPnhfY2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0KLQlp ZiAodWFydF90eF9zdG9wcGVkKHBvcnQpKSB7Ci0JCWJjbV91YXJ0X3N0b3BfdHgocG9ydCk7Ci0J CXJldHVybjsKLQl9Ci0KLQl4bWl0ID0gJnBvcnQtPnN0YXRlLT54bWl0OwotCWlmICh1YXJ0X2Np cmNfZW1wdHkoeG1pdCkpCi0JCWdvdG8gdHhxX2VtcHR5OworCXVuc2lnbmVkIGludCB2YWw7CisJ Ym9vbCBwZW5kaW5nOworCXU4IGNoOwogCiAJdmFsID0gYmNtX3VhcnRfcmVhZGwocG9ydCwgVUFS VF9NQ1RMX1JFRyk7CiAJdmFsID0gKHZhbCAmIFVBUlRfTUNUTF9UWEZJRk9GSUxMX01BU0spID4+ IFVBUlRfTUNUTF9UWEZJRk9GSUxMX1NISUZUOwotCW1heF9jb3VudCA9IHBvcnQtPmZpZm9zaXpl IC0gdmFsOwotCi0Jd2hpbGUgKG1heF9jb3VudC0tKSB7Ci0JCXVuc2lnbmVkIGludCBjOwogCi0J CWMgPSB4bWl0LT5idWZbeG1pdC0+dGFpbF07Ci0JCWJjbV91YXJ0X3dyaXRlbChwb3J0LCBjLCBV QVJUX0ZJRk9fUkVHKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9Y TUlUX1NJWkUgLSAxKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1w dHkoeG1pdCkpCi0JCQlicmVhazsKLQl9Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmco eG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOwotCi0JaWYg KHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJZ290byB0eHFfZW1wdHk7Ci0JcmV0dXJuOworCXBl bmRpbmcgPSB1YXJ0X3BvcnRfdHhfbGltaXRlZChwb3J0LCBjaCwgcG9ydC0+Zmlmb3NpemUgLSB2 YWwsCisJCXRydWUsCisJCWJjbV91YXJ0X3dyaXRlbChwb3J0LCBjaCwgVUFSVF9GSUZPX1JFRyks CisJCSh7fSkpOworCWlmIChwZW5kaW5nKQorCQlyZXR1cm47CiAKLXR4cV9lbXB0eToKIAkvKiBu b3RoaW5nIHRvIHNlbmQsIGRpc2FibGUgdHJhbnNtaXQgaW50ZXJydXB0ICovCiAJdmFsID0gYmNt X3VhcnRfcmVhZGwocG9ydCwgVUFSVF9JUl9SRUcpOwogCXZhbCAmPSB+VUFSVF9UWF9JTlRfTUFT SzsKIAliY21fdWFydF93cml0ZWwocG9ydCwgdmFsLCBVQVJUX0lSX1JFRyk7Ci0JcmV0dXJuOwog fQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL211eC5jIGIvZHJpdmVycy90 dHkvc2VyaWFsL211eC5jCmluZGV4IGVkMGU3NjNmNjIyYS4uODVjZTFlOWFmNDRhIDEwMDY0NAot LS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvbXV4LmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL211 eC5jCkBAIC0xNzEsNiArMTcxLDEzIEBAIHN0YXRpYyB2b2lkIG11eF9icmVha19jdGwoc3RydWN0 IHVhcnRfcG9ydCAqcG9ydCwgaW50IGJyZWFrX3N0YXRlKQogewogfQogCitzdGF0aWMgdm9pZCBt dXhfdHhfZG9uZShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQoreworCS8qIEZJWE1FIGpzOiByZWFs bHkgbmVlZHMgdG8gd2FpdD8gKi8KKwl3aGlsZSAoVUFSVF9HRVRfRklGT19DTlQocG9ydCkpCisJ CXVkZWxheSgxKTsKK30KKwogLyoqCiAgKiBtdXhfd3JpdGUgLSBXcml0ZSBjaGFycyB0byB0aGUg bXV4IGZpZm8uCiAgKiBAcG9ydDogUHRyIHRvIHRoZSB1YXJ0X3BvcnQuCkBAIC0xODAsMzkgKzE4 NywxMyBAQCBzdGF0aWMgdm9pZCBtdXhfYnJlYWtfY3RsKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQs IGludCBicmVha19zdGF0ZSkKICAqLwogc3RhdGljIHZvaWQgbXV4X3dyaXRlKHN0cnVjdCB1YXJ0 X3BvcnQgKnBvcnQpCiB7Ci0JaW50IGNvdW50OwotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZw b3J0LT5zdGF0ZS0+eG1pdDsKLQotCWlmKHBvcnQtPnhfY2hhcikgewotCQlVQVJUX1BVVF9DSEFS KHBvcnQsIHBvcnQtPnhfY2hhcik7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlwb3J0LT54X2No YXIgPSAwOwotCQlyZXR1cm47Ci0JfQotCi0JaWYodWFydF9jaXJjX2VtcHR5KHhtaXQpIHx8IHVh cnRfdHhfc3RvcHBlZChwb3J0KSkgewotCQltdXhfc3RvcF90eChwb3J0KTsKLQkJcmV0dXJuOwot CX0KLQotCWNvdW50ID0gKHBvcnQtPmZpZm9zaXplKSAtIFVBUlRfR0VUX0ZJRk9fQ05UKHBvcnQp OwotCWRvIHsKLQkJVUFSVF9QVVRfQ0hBUihwb3J0LCB4bWl0LT5idWZbeG1pdC0+dGFpbF0pOwot CQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAxKSAmIChVQVJUX1hNSVRfU0laRSAtIDEpOwot CQlwb3J0LT5pY291bnQudHgrKzsKLQkJaWYodWFydF9jaXJjX2VtcHR5KHhtaXQpKQotCQkJYnJl YWs7Ci0KLQl9IHdoaWxlKC0tY291bnQgPiAwKTsKLQotCXdoaWxlKFVBUlRfR0VUX0ZJRk9fQ05U KHBvcnQpKSAKLQkJdWRlbGF5KDEpOwotCi0JaWYodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1p dCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOworCXU4IGNoOwog Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJbXV4X3N0b3BfdHgocG9ydCk7CisJdWFy dF9wb3J0X3R4X2xpbWl0ZWQocG9ydCwgY2gsCisJCXBvcnQtPmZpZm9zaXplIC0gVUFSVF9HRVRf RklGT19DTlQocG9ydCksCisJCXRydWUsCisJCVVBUlRfUFVUX0NIQVIocG9ydCwgY2gpLAorCQlt dXhfdHhfZG9uZShwb3J0KSk7CiB9CiAKIC8qKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2Vy aWFsL212ZWJ1LXVhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tdmVidS11YXJ0LmMKaW5kZXgg YmExNmUxZGE2YmQzLi43YjU2NjQwNGNiMzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3Nlcmlh bC9tdmVidS11YXJ0LmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL212ZWJ1LXVhcnQuYwpAQCAt MzM1LDQwICszMzUsMTIgQEAgc3RhdGljIHZvaWQgbXZlYnVfdWFydF9yeF9jaGFycyhzdHJ1Y3Qg dWFydF9wb3J0ICpwb3J0LCB1bnNpZ25lZCBpbnQgc3RhdHVzKQogCiBzdGF0aWMgdm9pZCBtdmVi dV91YXJ0X3R4X2NoYXJzKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHVuc2lnbmVkIGludCBzdGF0 dXMpCiB7Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnBvcnQtPnN0YXRlLT54bWl0OwotCXVu c2lnbmVkIGludCBjb3VudDsKLQl1bnNpZ25lZCBpbnQgc3Q7Ci0KLQlpZiAocG9ydC0+eF9jaGFy KSB7Ci0JCXdyaXRlbChwb3J0LT54X2NoYXIsIHBvcnQtPm1lbWJhc2UgKyBVQVJUX1RTSChwb3J0 KSk7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlwb3J0LT54X2NoYXIgPSAwOwotCQlyZXR1cm47 Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9y dCkpIHsKLQkJbXZlYnVfdWFydF9zdG9wX3R4KHBvcnQpOwotCQlyZXR1cm47Ci0JfQotCi0JZm9y IChjb3VudCA9IDA7IGNvdW50IDwgcG9ydC0+Zmlmb3NpemU7IGNvdW50KyspIHsKLQkJd3JpdGVs KHhtaXQtPmJ1Zlt4bWl0LT50YWlsXSwgcG9ydC0+bWVtYmFzZSArIFVBUlRfVFNIKHBvcnQpKTsK LQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsK LQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0KLQkJaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJ CWJyZWFrOwotCi0JCXN0ID0gcmVhZGwocG9ydC0+bWVtYmFzZSArIFVBUlRfU1RBVCk7Ci0JCWlm IChzdCAmIFNUQVRfVFhfRklGT19GVUwpCi0JCQlicmVhazsKLQl9Ci0KLQlpZiAodWFydF9jaXJj X2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVw KHBvcnQpOworCXU4IGNoOwogCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJbXZlYnVf dWFydF9zdG9wX3R4KHBvcnQpOworCXVhcnRfcG9ydF90eF9saW1pdGVkKHBvcnQsIGNoLCBwb3J0 LT5maWZvc2l6ZSwKKwkJIShyZWFkbChwb3J0LT5tZW1iYXNlICsgVUFSVF9TVEFUKSAmIFNUQVRf VFhfRklGT19GVUwpLAorCQl3cml0ZWwoY2gsIHBvcnQtPm1lbWJhc2UgKyBVQVJUX1RTSChwb3J0 KSksCisJCSh7fSkpOwogfQogCiBzdGF0aWMgaXJxcmV0dXJuX3QgbXZlYnVfdWFydF9pc3IoaW50 IGlycSwgdm9pZCAqZGV2X2lkKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL29tYXAt c2VyaWFsLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvb21hcC1zZXJpYWwuYwppbmRleCA3ZDBkMjcx OGVmNTkuLjgyZDM1ZGJiZmE2YyAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL29tYXAt c2VyaWFsLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMKQEAgLTM0Nywz NCArMzQ3LDEyIEBAIHN0YXRpYyB2b2lkIHNlcmlhbF9vbWFwX3B1dF9jaGFyKHN0cnVjdCB1YXJ0 X29tYXBfcG9ydCAqdXAsIHVuc2lnbmVkIGNoYXIgY2gpCiAKIHN0YXRpYyB2b2lkIHRyYW5zbWl0 X2NoYXJzKHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqdXAsIHVuc2lnbmVkIGludCBsc3IpCiB7Ci0J c3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnVwLT5wb3J0LnN0YXRlLT54bWl0OwotCWludCBjb3Vu dDsKKwl1OCBjaDsKIAotCWlmICh1cC0+cG9ydC54X2NoYXIpIHsKLQkJc2VyaWFsX29tYXBfcHV0 X2NoYXIodXAsIHVwLT5wb3J0LnhfY2hhcik7Ci0JCXVwLT5wb3J0Lmljb3VudC50eCsrOwotCQl1 cC0+cG9ydC54X2NoYXIgPSAwOwotCQlyZXR1cm47Ci0JfQotCWlmICh1YXJ0X2NpcmNfZW1wdHko eG1pdCkgfHwgdWFydF90eF9zdG9wcGVkKCZ1cC0+cG9ydCkpIHsKLQkJc2VyaWFsX29tYXBfc3Rv cF90eCgmdXAtPnBvcnQpOwotCQlyZXR1cm47Ci0JfQotCWNvdW50ID0gdXAtPnBvcnQuZmlmb3Np emUgLyA0OwotCWRvIHsKLQkJc2VyaWFsX29tYXBfcHV0X2NoYXIodXAsIHhtaXQtPmJ1Zlt4bWl0 LT50YWlsXSk7Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVBUlRfWE1JVF9T SVpFIC0gMSk7Ci0JCXVwLT5wb3J0Lmljb3VudC50eCsrOwotCi0JCWlmICh1YXJ0X2NpcmNfZW1w dHkoeG1pdCkpCi0JCQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFy dF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVf d2FrZXVwKCZ1cC0+cG9ydCk7Ci0KLQlpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpKQotCQlzZXJp YWxfb21hcF9zdG9wX3R4KCZ1cC0+cG9ydCk7CisJdWFydF9wb3J0X3R4X2xpbWl0ZWQoJnVwLT5w b3J0LCBjaCwgdXAtPnBvcnQuZmlmb3NpemUgLyA0LAorCQl0cnVlLAorCQlzZXJpYWxfb21hcF9w dXRfY2hhcih1cCwgY2gpLAorCQkoe30pKTsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIHNlcmlh bF9vbWFwX2VuYWJsZV9pZXJfdGhyaShzdHJ1Y3QgdWFydF9vbWFwX3BvcnQgKnVwKQpkaWZmIC0t Z2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL3B4YS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3B4YS5j CmluZGV4IDJkMjUyMzFmYWQ4NC4uNDQ0ZmE0YjY1NGFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0 eS9zZXJpYWwvcHhhLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL3B4YS5jCkBAIC0xNzQsMzUg KzE3NCwxMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgcmVjZWl2ZV9jaGFycyhzdHJ1Y3QgdWFydF9w eGFfcG9ydCAqdXAsIGludCAqc3RhdHVzKQogCiBzdGF0aWMgdm9pZCB0cmFuc21pdF9jaGFycyhz dHJ1Y3QgdWFydF9weGFfcG9ydCAqdXApCiB7Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnVw LT5wb3J0LnN0YXRlLT54bWl0OwotCWludCBjb3VudDsKKwl1OCBjaDsKIAotCWlmICh1cC0+cG9y dC54X2NoYXIpIHsKLQkJc2VyaWFsX291dCh1cCwgVUFSVF9UWCwgdXAtPnBvcnQueF9jaGFyKTsK LQkJdXAtPnBvcnQuaWNvdW50LnR4Kys7Ci0JCXVwLT5wb3J0LnhfY2hhciA9IDA7Ci0JCXJldHVy bjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQoJnVw LT5wb3J0KSkgewotCQlzZXJpYWxfcHhhX3N0b3BfdHgoJnVwLT5wb3J0KTsKLQkJcmV0dXJuOwot CX0KLQotCWNvdW50ID0gdXAtPnBvcnQuZmlmb3NpemUgLyAyOwotCWRvIHsKLQkJc2VyaWFsX291 dCh1cCwgVUFSVF9UWCwgeG1pdC0+YnVmW3htaXQtPnRhaWxdKTsKLQkJeG1pdC0+dGFpbCA9ICh4 bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsKLQkJdXAtPnBvcnQuaWNvdW50 LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsKLQl9IHdoaWxl ICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBX QUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKCZ1cC0+cG9ydCk7Ci0KLQotCWlmICh1 YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCXNlcmlhbF9weGFfc3RvcF90eCgmdXAtPnBvcnQpOwor CXVhcnRfcG9ydF90eF9saW1pdGVkKCZ1cC0+cG9ydCwgY2gsIHVwLT5wb3J0LmZpZm9zaXplIC8g MiwKKwkJdHJ1ZSwKKwkJc2VyaWFsX291dCh1cCwgVUFSVF9UWCwgY2gpLAorCQkoe30pKTsKIH0K IAogc3RhdGljIHZvaWQgc2VyaWFsX3B4YV9zdGFydF90eChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0 KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL3JwMi5jIGIvZHJpdmVycy90dHkvc2Vy aWFsL3JwMi5jCmluZGV4IGI4MWFmYjA2ZjFmNC4uNzQ5Yjg3M2E1ZDk5IDEwMDY0NAotLS0gYS9k cml2ZXJzL3R0eS9zZXJpYWwvcnAyLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL3JwMi5jCkBA IC00MjcsMzIgKzQyNywxMyBAQCBzdGF0aWMgdm9pZCBycDJfcnhfY2hhcnMoc3RydWN0IHJwMl91 YXJ0X3BvcnQgKnVwKQogCiBzdGF0aWMgdm9pZCBycDJfdHhfY2hhcnMoc3RydWN0IHJwMl91YXJ0 X3BvcnQgKnVwKQogewotCXUxNiBtYXhfdHggPSBGSUZPX1NJWkUgLSByZWFkdyh1cC0+YmFzZSAr IFJQMl9UWF9GSUZPX0NPVU5UKTsKLQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQgPSAmdXAtPnBvcnQu c3RhdGUtPnhtaXQ7CisJdTggY2g7CiAKLQlpZiAodWFydF90eF9zdG9wcGVkKCZ1cC0+cG9ydCkp IHsKLQkJcnAyX3VhcnRfc3RvcF90eCgmdXAtPnBvcnQpOwotCQlyZXR1cm47Ci0JfQotCi0JZm9y ICg7IG1heF90eCAhPSAwOyBtYXhfdHgtLSkgewotCQlpZiAodXAtPnBvcnQueF9jaGFyKSB7Ci0J CQl3cml0ZWIodXAtPnBvcnQueF9jaGFyLCB1cC0+YmFzZSArIFJQMl9EQVRBX0JZVEUpOwotCQkJ dXAtPnBvcnQueF9jaGFyID0gMDsKLQkJCXVwLT5wb3J0Lmljb3VudC50eCsrOwotCQkJY29udGlu dWU7Ci0JCX0KLQkJaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkgewotCQkJcnAyX3VhcnRfc3Rv cF90eCgmdXAtPnBvcnQpOwotCQkJYnJlYWs7Ci0JCX0KLQkJd3JpdGViKHhtaXQtPmJ1Zlt4bWl0 LT50YWlsXSwgdXAtPmJhc2UgKyBSUDJfREFUQV9CWVRFKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0 LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsKLQkJdXAtPnBvcnQuaWNvdW50LnR4 Kys7Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5nKHhtaXQpIDwgV0FLRVVQX0NI QVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cCgmdXAtPnBvcnQpOworCXVhcnRfcG9ydF90eF9saW1p dGVkKCZ1cC0+cG9ydCwgY2gsCisJCUZJRk9fU0laRSAtIHJlYWR3KHVwLT5iYXNlICsgUlAyX1RY X0ZJRk9fQ09VTlQpLAorCQl0cnVlLAorCQl3cml0ZWIoY2gsIHVwLT5iYXNlICsgUlAyX0RBVEFf QllURSksCisJCSh7fSkpOwogfQogCiBzdGF0aWMgdm9pZCBycDJfY2hfaW50ZXJydXB0KHN0cnVj dCBycDJfdWFydF9wb3J0ICp1cCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJp YWxfdHh4OS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF90eHg5LmMKaW5kZXggZTEyZjFk YzE4YzM4Li5lYWIzODdiMDFlMzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJp YWxfdHh4OS5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJpYWxfdHh4OS5jCkBAIC0zMjEs MzQgKzMyMSwxMiBAQCByZWNlaXZlX2NoYXJzKHN0cnVjdCB1YXJ0X3BvcnQgKnVwLCB1bnNpZ25l ZCBpbnQgKnN0YXR1cykKIAogc3RhdGljIGlubGluZSB2b2lkIHRyYW5zbWl0X2NoYXJzKHN0cnVj dCB1YXJ0X3BvcnQgKnVwKQogewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZ1cC0+c3RhdGUt PnhtaXQ7Ci0JaW50IGNvdW50OworCXU4IGNoOwogCi0JaWYgKHVwLT54X2NoYXIpIHsKLQkJc2lv X291dCh1cCwgVFhYOV9TSVRGSUZPLCB1cC0+eF9jaGFyKTsKLQkJdXAtPmljb3VudC50eCsrOwot CQl1cC0+eF9jaGFyID0gMDsKLQkJcmV0dXJuOwotCX0KLQlpZiAodWFydF9jaXJjX2VtcHR5KHht aXQpIHx8IHVhcnRfdHhfc3RvcHBlZCh1cCkpIHsKLQkJc2VyaWFsX3R4eDlfc3RvcF90eCh1cCk7 Ci0JCXJldHVybjsKLQl9Ci0KLQljb3VudCA9IFRYWDlfU0lPX1RYX0ZJRk87Ci0JZG8gewotCQlz aW9fb3V0KHVwLCBUWFg5X1NJVEZJRk8sIHhtaXQtPmJ1Zlt4bWl0LT50YWlsXSk7Ci0JCXhtaXQt PnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7Ci0JCXVwLT5p Y291bnQudHgrKzsKLQkJaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJCWJyZWFrOwotCX0g d2hpbGUgKC0tY291bnQgPiAwKTsKLQotCWlmICh1YXJ0X2NpcmNfY2hhcnNfcGVuZGluZyh4bWl0 KSA8IFdBS0VVUF9DSEFSUykKLQkJdWFydF93cml0ZV93YWtldXAodXApOwotCi0JaWYgKHVhcnRf Y2lyY19lbXB0eSh4bWl0KSkKLQkJc2VyaWFsX3R4eDlfc3RvcF90eCh1cCk7CisJdWFydF9wb3J0 X3R4X2xpbWl0ZWQodXAsIGNoLCBUWFg5X1NJT19UWF9GSUZPLAorCQl0cnVlLAorCQlzaW9fb3V0 KHVwLCBUWFg5X1NJVEZJRk8sIGNoKSwKKwkJKHt9KSk7CiB9CiAKIHN0YXRpYyBpcnFyZXR1cm5f dCBzZXJpYWxfdHh4OV9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZGV2X2lkKQpkaWZmIC0tZ2l0 IGEvZHJpdmVycy90dHkvc2VyaWFsL3NpZml2ZS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3NpZml2 ZS5jCmluZGV4IDdmYjY3NjBiNWMzNy4uMWY1NjVhMjE2ZTc0IDEwMDY0NAotLS0gYS9kcml2ZXJz L3R0eS9zZXJpYWwvc2lmaXZlLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL3NpZml2ZS5jCkBA IC0yODgsMzMgKzI4OCwxMiBAQCBzdGF0aWMgdm9pZCBfX3NzcF90cmFuc21pdF9jaGFyKHN0cnVj dCBzaWZpdmVfc2VyaWFsX3BvcnQgKnNzcCwgaW50IGNoKQogICovCiBzdGF0aWMgdm9pZCBfX3Nz cF90cmFuc21pdF9jaGFycyhzdHJ1Y3Qgc2lmaXZlX3NlcmlhbF9wb3J0ICpzc3ApCiB7Ci0Jc3Ry dWN0IGNpcmNfYnVmICp4bWl0ID0gJnNzcC0+cG9ydC5zdGF0ZS0+eG1pdDsKLQlpbnQgY291bnQ7 Ci0KLQlpZiAoc3NwLT5wb3J0LnhfY2hhcikgewotCQlfX3NzcF90cmFuc21pdF9jaGFyKHNzcCwg c3NwLT5wb3J0LnhfY2hhcik7Ci0JCXNzcC0+cG9ydC5pY291bnQudHgrKzsKLQkJc3NwLT5wb3J0 LnhfY2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8 fCB1YXJ0X3R4X3N0b3BwZWQoJnNzcC0+cG9ydCkpIHsKLQkJc2lmaXZlX3NlcmlhbF9zdG9wX3R4 KCZzc3AtPnBvcnQpOwotCQlyZXR1cm47Ci0JfQotCWNvdW50ID0gU0lGSVZFX1RYX0ZJRk9fREVQ VEg7Ci0JZG8gewotCQlfX3NzcF90cmFuc21pdF9jaGFyKHNzcCwgeG1pdC0+YnVmW3htaXQtPnRh aWxdKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUg LSAxKTsKLQkJc3NwLT5wb3J0Lmljb3VudC50eCsrOwotCQlpZiAodWFydF9jaXJjX2VtcHR5KHht aXQpKQotCQkJYnJlYWs7Ci0JfSB3aGlsZSAoLS1jb3VudCA+IDApOwotCi0JaWYgKHVhcnRfY2ly Y19jaGFyc19wZW5kaW5nKHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1 cCgmc3NwLT5wb3J0KTsKKwl1OCBjaDsKIAotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0J CXNpZml2ZV9zZXJpYWxfc3RvcF90eCgmc3NwLT5wb3J0KTsKKwl1YXJ0X3BvcnRfdHhfbGltaXRl ZCgmc3NwLT5wb3J0LCBjaCwgU0lGSVZFX1RYX0ZJRk9fREVQVEgsCisJCXRydWUsCisJCV9fc3Nw X3RyYW5zbWl0X2NoYXIoc3NwLCBjaCksCisJCSh7fSkpOwogfQogCiAvKioKZGlmZiAtLWdpdCBh L2RyaXZlcnMvdHR5L3NlcmlhbC9zcHJkX3NlcmlhbC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3Nw cmRfc2VyaWFsLmMKaW5kZXggMzQyYTg3OTY3NjMxLi4zZjM0ZjdiYjc3MDAgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvdHR5L3NlcmlhbC9zcHJkX3NlcmlhbC5jCisrKyBiL2RyaXZlcnMvdHR5L3Nlcmlh bC9zcHJkX3NlcmlhbC5jCkBAIC02MjYsMzUgKzYyNiwxMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQg c3ByZF9yeChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogCiBzdGF0aWMgaW5saW5lIHZvaWQgc3By ZF90eChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9 ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQlpbnQgY291bnQ7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7 Ci0JCXNlcmlhbF9vdXQocG9ydCwgU1BSRF9UWEQsIHBvcnQtPnhfY2hhcik7Ci0JCXBvcnQtPmlj b3VudC50eCsrOwotCQlwb3J0LT54X2NoYXIgPSAwOwotCQlyZXR1cm47Ci0JfQotCi0JaWYgKHVh cnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKLQkJc3ByZF9z dG9wX3R4KHBvcnQpOwotCQlyZXR1cm47Ci0JfQotCi0JY291bnQgPSBUSExEX1RYX0VNUFRZOwot CWRvIHsKLQkJc2VyaWFsX291dChwb3J0LCBTUFJEX1RYRCwgeG1pdC0+YnVmW3htaXQtPnRhaWxd KTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAx KTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0J CQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJz X3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQp OworCXU4IGNoOwogCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJc3ByZF9zdG9wX3R4 KHBvcnQpOworCXVhcnRfcG9ydF90eF9saW1pdGVkKHBvcnQsIGNoLCBUSExEX1RYX0VNUFRZLAor CQl0cnVlLAorCQlzZXJpYWxfb3V0KHBvcnQsIFNQUkRfVFhELCBjaCksCisJCSh7fSkpOwogfQog CiAvKiB0aGlzIGhhbmRsZXMgdGhlIGludGVycnVwdCBmcm9tIG9uZSBwb3J0ICovCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3Qt YXNjLmMKaW5kZXggZmNlY2VhNjg5YTBkLi41MjE1ZTY5MTBmNjggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvdHR5L3NlcmlhbC9zdC1hc2MuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMK QEAgLTIzNyw1MCArMjM3LDEyIEBAIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgYXNjX2h3X3R4cm9v bShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogICovCiBzdGF0aWMgdm9pZCBhc2NfdHJhbnNtaXRf Y2hhcnMoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKIHsKLQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQg PSAmcG9ydC0+c3RhdGUtPnhtaXQ7Ci0JaW50IHR4cm9vbTsKLQl1bnNpZ25lZCBjaGFyIGM7Ci0K LQl0eHJvb20gPSBhc2NfaHdfdHhyb29tKHBvcnQpOwotCi0JaWYgKCh0eHJvb20gIT0gMCkgJiYg cG9ydC0+eF9jaGFyKSB7Ci0JCWMgPSBwb3J0LT54X2NoYXI7Ci0JCXBvcnQtPnhfY2hhciA9IDA7 Ci0JCWFzY19vdXQocG9ydCwgQVNDX1RYQlVGLCBjKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0J CXR4cm9vbSA9IGFzY19od190eHJvb20ocG9ydCk7Ci0JfQotCi0JaWYgKHVhcnRfdHhfc3RvcHBl ZChwb3J0KSkgewotCQkvKgotCQkgKiBXZSBzaG91bGQgdHJ5IGFuZCBzdG9wIHRoZSBoYXJkd2Fy ZSBoZXJlLCBidXQgSQotCQkgKiBkb24ndCB0aGluayB0aGUgQVNDIGhhcyBhbnkgd2F5IHRvIGRv IHRoYXQuCi0JCSAqLwotCQlhc2NfZGlzYWJsZV90eF9pbnRlcnJ1cHRzKHBvcnQpOwotCQlyZXR1 cm47Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkgewotCQlhc2NfZGlzYWJsZV90 eF9pbnRlcnJ1cHRzKHBvcnQpOwotCQlyZXR1cm47Ci0JfQotCi0JaWYgKHR4cm9vbSA9PSAwKQot CQlyZXR1cm47Ci0KLQlkbyB7Ci0JCWMgPSB4bWl0LT5idWZbeG1pdC0+dGFpbF07Ci0JCXhtaXQt PnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7Ci0JCWFzY19v dXQocG9ydCwgQVNDX1RYQlVGLCBjKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCXR4cm9vbS0t OwotCX0gd2hpbGUgKCh0eHJvb20gPiAwKSAmJiAoIXVhcnRfY2lyY19lbXB0eSh4bWl0KSkpOwot Ci0JaWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5nKHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1 YXJ0X3dyaXRlX3dha2V1cChwb3J0KTsKKwl1OCBjaDsKIAotCWlmICh1YXJ0X2NpcmNfZW1wdHko eG1pdCkpCi0JCWFzY19kaXNhYmxlX3R4X2ludGVycnVwdHMocG9ydCk7CisJdWFydF9wb3J0X3R4 X2xpbWl0ZWQocG9ydCwgY2gsIGFzY19od190eHJvb20ocG9ydCksCisJCXRydWUsCisJCWFzY19v dXQocG9ydCwgQVNDX1RYQlVGLCBjaCksCisJCSh7fSkpOwogfQogCiBzdGF0aWMgdm9pZCBhc2Nf cmVjZWl2ZV9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQotLSAKMi4zNy4zCgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtcmlzY3YgbWFp bGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmlu ZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1955BC4332F for ; Tue, 4 Oct 2022 10:49:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229829AbiJDKtz (ORCPT ); Tue, 4 Oct 2022 06:49:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53368 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229675AbiJDKto (ORCPT ); Tue, 4 Oct 2022 06:49:44 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EA13C6420; Tue, 4 Oct 2022 03:49:42 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 3DAC66134B; Tue, 4 Oct 2022 10:49:42 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6BAE2C4347C; Tue, 4 Oct 2022 10:49:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1664880581; bh=EiG7MLXpt/ieQf/scjf2AjsAsALEw0iDo5jOA5XLK1o=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=PuVLtqtDLOT35uK/LKnFhKdO0kypUV5cjbuQpI1HoAo/jyjXpt0+wXMugbV9m+DH1 rtjsLiAd/QPE3wrlBKsAgA8c8fLOQpgmoth5DWgiQddc779ITsKE5MbOjL9jis3Gus e+zgNVycSJbIax0Fzpu4RqkALLumzUjWKLO+R421G5GgutWK7Ut7RKt5NKPKhZu/S2 BhXtJdVBlmMNHO5szSGb0i8jYIJaMtJvXSgif7/EcdNG2iKkegj7VbXe2SgmVKkcY5 Lk6y5yk4YHUikyo2kUJ77MEAzmivbFTC3NEHc5Swhicqze11ubW4qA/2Qh1Tb1NPA8 YhVI37WXg8xTA== From: "Jiri Slaby (SUSE)" To: gregkh@linuxfoundation.org Cc: linux-serial@vger.kernel.org, linux-kernel@vger.kernel.org, "Jiri Slaby (SUSE)" , Russell King , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, =?UTF-8?q?Pali=20Roh=C3=A1r?= , Kevin Cernekee , Palmer Dabbelt , Paul Walmsley , Orson Zhai , Baolin Wang , Chunyan Zhang , Patrice Chotard , linux-riscv@lists.infradead.org Subject: [PATCH v5 3/3] tty: serial: use uart_port_tx_limited() Date: Tue, 4 Oct 2022 12:49:27 +0200 Message-Id: <20221004104927.14361-4-jirislaby@kernel.org> X-Mailer: git-send-email 2.37.3 In-Reply-To: <20221004104927.14361-1-jirislaby@kernel.org> References: <20221004104927.14361-1-jirislaby@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-serial@vger.kernel.org uart_port_tx_limited() is a new helper to send characters to the device. Use it in these drivers. mux.c also needs to define tx_done(). But I'm not sure if the driver really wants to wait for all the characters to dismiss from the HW fifo at this code point. Hence I marked this as FIXME. Cc: Russell King Cc: Florian Fainelli Cc: bcm-kernel-feedback-list@broadcom.com Cc: "Pali Rohár" Cc: Kevin Cernekee Cc: Palmer Dabbelt Cc: Paul Walmsley Cc: Orson Zhai Cc: Baolin Wang Cc: Chunyan Zhang Cc: Patrice Chotard Cc: linux-riscv@lists.infradead.org Signed-off-by: Jiri Slaby (SUSE) --- Notes: [v4] switch from DEFINE_UART_PORT_TX_HELPER_LIMITED() (helper generator) to uart_port_tx_limited() (akin to wait_event()) drivers/tty/serial/21285.c | 32 +++---------------- drivers/tty/serial/altera_jtaguart.c | 36 ++++----------------- drivers/tty/serial/amba-pl010.c | 32 +++---------------- drivers/tty/serial/apbuart.c | 34 +++----------------- drivers/tty/serial/bcm63xx_uart.c | 47 ++++++--------------------- drivers/tty/serial/mux.c | 45 ++++++++------------------ drivers/tty/serial/mvebu-uart.c | 38 +++------------------- drivers/tty/serial/omap-serial.c | 32 +++---------------- drivers/tty/serial/pxa.c | 33 +++---------------- drivers/tty/serial/rp2.c | 31 ++++-------------- drivers/tty/serial/serial_txx9.c | 32 +++---------------- drivers/tty/serial/sifive.c | 31 +++--------------- drivers/tty/serial/sprd_serial.c | 33 +++---------------- drivers/tty/serial/st-asc.c | 48 +++------------------------- 14 files changed, 85 insertions(+), 419 deletions(-) diff --git a/drivers/tty/serial/21285.c b/drivers/tty/serial/21285.c index c7d34823f715..185462fd959c 100644 --- a/drivers/tty/serial/21285.c +++ b/drivers/tty/serial/21285.c @@ -154,35 +154,13 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id) static irqreturn_t serial21285_tx_chars(int irq, void *dev_id) { struct uart_port *port = dev_id; - struct circ_buf *xmit = &port->state->xmit; - int count = 256; - - if (port->x_char) { - *CSR_UARTDR = port->x_char; - port->icount.tx++; - port->x_char = 0; - goto out; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - serial21285_stop_tx(port); - goto out; - } - - do { - *CSR_UARTDR = xmit->buf[xmit->tail]; - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0 && !(*CSR_UARTFLG & 0x20)); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); + u8 ch; - if (uart_circ_empty(xmit)) - serial21285_stop_tx(port); + uart_port_tx_limited(port, ch, 256, + !(*CSR_UARTFLG & 0x20), + *CSR_UARTDR = ch, + ({})); - out: return IRQ_HANDLED; } diff --git a/drivers/tty/serial/altera_jtaguart.c b/drivers/tty/serial/altera_jtaguart.c index c2d154d78e54..aa49553fac58 100644 --- a/drivers/tty/serial/altera_jtaguart.c +++ b/drivers/tty/serial/altera_jtaguart.c @@ -146,37 +146,15 @@ static void altera_jtaguart_rx_chars(struct altera_jtaguart *pp) static void altera_jtaguart_tx_chars(struct altera_jtaguart *pp) { struct uart_port *port = &pp->port; - struct circ_buf *xmit = &port->state->xmit; - unsigned int pending, count; - - if (port->x_char) { - /* Send special char - probably flow control */ - writel(port->x_char, port->membase + ALTERA_JTAGUART_DATA_REG); - port->x_char = 0; - port->icount.tx++; - return; - } + unsigned int count; + u8 ch; - pending = uart_circ_chars_pending(xmit); - if (pending > 0) { - count = altera_jtaguart_tx_space(port, NULL); - if (count > pending) - count = pending; - if (count > 0) { - pending -= count; - while (count--) { - writel(xmit->buf[xmit->tail], - port->membase + ALTERA_JTAGUART_DATA_REG); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - } - if (pending < WAKEUP_CHARS) - uart_write_wakeup(port); - } - } + count = altera_jtaguart_tx_space(port, NULL); - if (pending == 0) - altera_jtaguart_stop_tx(port); + uart_port_tx_limited(port, ch, count, + true, + writel(ch, port->membase + ALTERA_JTAGUART_DATA_REG), + ({})); } static irqreturn_t altera_jtaguart_interrupt(int irq, void *data) diff --git a/drivers/tty/serial/amba-pl010.c b/drivers/tty/serial/amba-pl010.c index af27fb8ec145..a98fae2ca422 100644 --- a/drivers/tty/serial/amba-pl010.c +++ b/drivers/tty/serial/amba-pl010.c @@ -164,34 +164,12 @@ static void pl010_rx_chars(struct uart_port *port) static void pl010_tx_chars(struct uart_port *port) { - struct circ_buf *xmit = &port->state->xmit; - int count; + u8 ch; - if (port->x_char) { - writel(port->x_char, port->membase + UART01x_DR); - port->icount.tx++; - port->x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - pl010_stop_tx(port); - return; - } - - count = port->fifosize >> 1; - do { - writel(xmit->buf[xmit->tail], port->membase + UART01x_DR); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - pl010_stop_tx(port); + uart_port_tx_limited(port, ch, port->fifosize >> 1, + true, + writel(ch, port->membase + UART01x_DR), + ({})); } static void pl010_modem_status(struct uart_amba_port *uap) diff --git a/drivers/tty/serial/apbuart.c b/drivers/tty/serial/apbuart.c index 450f4edfda0f..915ee4b0d594 100644 --- a/drivers/tty/serial/apbuart.c +++ b/drivers/tty/serial/apbuart.c @@ -122,36 +122,12 @@ static void apbuart_rx_chars(struct uart_port *port) static void apbuart_tx_chars(struct uart_port *port) { - struct circ_buf *xmit = &port->state->xmit; - int count; - - if (port->x_char) { - UART_PUT_CHAR(port, port->x_char); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - apbuart_stop_tx(port); - return; - } - - /* amba: fill FIFO */ - count = port->fifosize >> 1; - do { - UART_PUT_CHAR(port, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); + u8 ch; - if (uart_circ_empty(xmit)) - apbuart_stop_tx(port); + uart_port_tx_limited(port, ch, port->fifosize >> 1, + true, + UART_PUT_CHAR(port, ch), + ({})); } static irqreturn_t apbuart_int(int irq, void *dev_id) diff --git a/drivers/tty/serial/bcm63xx_uart.c b/drivers/tty/serial/bcm63xx_uart.c index 5d9737c2d1f2..62bc7244dc67 100644 --- a/drivers/tty/serial/bcm63xx_uart.c +++ b/drivers/tty/serial/bcm63xx_uart.c @@ -303,53 +303,24 @@ static void bcm_uart_do_rx(struct uart_port *port) */ static void bcm_uart_do_tx(struct uart_port *port) { - struct circ_buf *xmit; - unsigned int val, max_count; - - if (port->x_char) { - bcm_uart_writel(port, port->x_char, UART_FIFO_REG); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_tx_stopped(port)) { - bcm_uart_stop_tx(port); - return; - } - - xmit = &port->state->xmit; - if (uart_circ_empty(xmit)) - goto txq_empty; + unsigned int val; + bool pending; + u8 ch; val = bcm_uart_readl(port, UART_MCTL_REG); val = (val & UART_MCTL_TXFIFOFILL_MASK) >> UART_MCTL_TXFIFOFILL_SHIFT; - max_count = port->fifosize - val; - - while (max_count--) { - unsigned int c; - c = xmit->buf[xmit->tail]; - bcm_uart_writel(port, c, UART_FIFO_REG); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - goto txq_empty; - return; + pending = uart_port_tx_limited(port, ch, port->fifosize - val, + true, + bcm_uart_writel(port, ch, UART_FIFO_REG), + ({})); + if (pending) + return; -txq_empty: /* nothing to send, disable transmit interrupt */ val = bcm_uart_readl(port, UART_IR_REG); val &= ~UART_TX_INT_MASK; bcm_uart_writel(port, val, UART_IR_REG); - return; } /* diff --git a/drivers/tty/serial/mux.c b/drivers/tty/serial/mux.c index ed0e763f622a..85ce1e9af44a 100644 --- a/drivers/tty/serial/mux.c +++ b/drivers/tty/serial/mux.c @@ -171,6 +171,13 @@ static void mux_break_ctl(struct uart_port *port, int break_state) { } +static void mux_tx_done(struct uart_port *port) +{ + /* FIXME js: really needs to wait? */ + while (UART_GET_FIFO_CNT(port)) + udelay(1); +} + /** * mux_write - Write chars to the mux fifo. * @port: Ptr to the uart_port. @@ -180,39 +187,13 @@ static void mux_break_ctl(struct uart_port *port, int break_state) */ static void mux_write(struct uart_port *port) { - int count; - struct circ_buf *xmit = &port->state->xmit; - - if(port->x_char) { - UART_PUT_CHAR(port, port->x_char); - port->icount.tx++; - port->x_char = 0; - return; - } - - if(uart_circ_empty(xmit) || uart_tx_stopped(port)) { - mux_stop_tx(port); - return; - } - - count = (port->fifosize) - UART_GET_FIFO_CNT(port); - do { - UART_PUT_CHAR(port, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if(uart_circ_empty(xmit)) - break; - - } while(--count > 0); - - while(UART_GET_FIFO_CNT(port)) - udelay(1); - - if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); + u8 ch; - if (uart_circ_empty(xmit)) - mux_stop_tx(port); + uart_port_tx_limited(port, ch, + port->fifosize - UART_GET_FIFO_CNT(port), + true, + UART_PUT_CHAR(port, ch), + mux_tx_done(port)); } /** diff --git a/drivers/tty/serial/mvebu-uart.c b/drivers/tty/serial/mvebu-uart.c index ba16e1da6bd3..7b566404cb33 100644 --- a/drivers/tty/serial/mvebu-uart.c +++ b/drivers/tty/serial/mvebu-uart.c @@ -335,40 +335,12 @@ static void mvebu_uart_rx_chars(struct uart_port *port, unsigned int status) static void mvebu_uart_tx_chars(struct uart_port *port, unsigned int status) { - struct circ_buf *xmit = &port->state->xmit; - unsigned int count; - unsigned int st; - - if (port->x_char) { - writel(port->x_char, port->membase + UART_TSH(port)); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - mvebu_uart_stop_tx(port); - return; - } - - for (count = 0; count < port->fifosize; count++) { - writel(xmit->buf[xmit->tail], port->membase + UART_TSH(port)); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - - if (uart_circ_empty(xmit)) - break; - - st = readl(port->membase + UART_STAT); - if (st & STAT_TX_FIFO_FUL) - break; - } - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); + u8 ch; - if (uart_circ_empty(xmit)) - mvebu_uart_stop_tx(port); + uart_port_tx_limited(port, ch, port->fifosize, + !(readl(port->membase + UART_STAT) & STAT_TX_FIFO_FUL), + writel(ch, port->membase + UART_TSH(port)), + ({})); } static irqreturn_t mvebu_uart_isr(int irq, void *dev_id) diff --git a/drivers/tty/serial/omap-serial.c b/drivers/tty/serial/omap-serial.c index 7d0d2718ef59..82d35dbbfa6c 100644 --- a/drivers/tty/serial/omap-serial.c +++ b/drivers/tty/serial/omap-serial.c @@ -347,34 +347,12 @@ static void serial_omap_put_char(struct uart_omap_port *up, unsigned char ch) static void transmit_chars(struct uart_omap_port *up, unsigned int lsr) { - struct circ_buf *xmit = &up->port.state->xmit; - int count; + u8 ch; - if (up->port.x_char) { - serial_omap_put_char(up, up->port.x_char); - up->port.icount.tx++; - up->port.x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) { - serial_omap_stop_tx(&up->port); - return; - } - count = up->port.fifosize / 4; - do { - serial_omap_put_char(up, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->port.icount.tx++; - - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&up->port); - - if (uart_circ_empty(xmit)) - serial_omap_stop_tx(&up->port); + uart_port_tx_limited(&up->port, ch, up->port.fifosize / 4, + true, + serial_omap_put_char(up, ch), + ({})); } static inline void serial_omap_enable_ier_thri(struct uart_omap_port *up) diff --git a/drivers/tty/serial/pxa.c b/drivers/tty/serial/pxa.c index 2d25231fad84..444fa4b654ac 100644 --- a/drivers/tty/serial/pxa.c +++ b/drivers/tty/serial/pxa.c @@ -174,35 +174,12 @@ static inline void receive_chars(struct uart_pxa_port *up, int *status) static void transmit_chars(struct uart_pxa_port *up) { - struct circ_buf *xmit = &up->port.state->xmit; - int count; + u8 ch; - if (up->port.x_char) { - serial_out(up, UART_TX, up->port.x_char); - up->port.icount.tx++; - up->port.x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) { - serial_pxa_stop_tx(&up->port); - return; - } - - count = up->port.fifosize / 2; - do { - serial_out(up, UART_TX, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->port.icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&up->port); - - - if (uart_circ_empty(xmit)) - serial_pxa_stop_tx(&up->port); + uart_port_tx_limited(&up->port, ch, up->port.fifosize / 2, + true, + serial_out(up, UART_TX, ch), + ({})); } static void serial_pxa_start_tx(struct uart_port *port) diff --git a/drivers/tty/serial/rp2.c b/drivers/tty/serial/rp2.c index b81afb06f1f4..749b873a5d99 100644 --- a/drivers/tty/serial/rp2.c +++ b/drivers/tty/serial/rp2.c @@ -427,32 +427,13 @@ static void rp2_rx_chars(struct rp2_uart_port *up) static void rp2_tx_chars(struct rp2_uart_port *up) { - u16 max_tx = FIFO_SIZE - readw(up->base + RP2_TX_FIFO_COUNT); - struct circ_buf *xmit = &up->port.state->xmit; + u8 ch; - if (uart_tx_stopped(&up->port)) { - rp2_uart_stop_tx(&up->port); - return; - } - - for (; max_tx != 0; max_tx--) { - if (up->port.x_char) { - writeb(up->port.x_char, up->base + RP2_DATA_BYTE); - up->port.x_char = 0; - up->port.icount.tx++; - continue; - } - if (uart_circ_empty(xmit)) { - rp2_uart_stop_tx(&up->port); - break; - } - writeb(xmit->buf[xmit->tail], up->base + RP2_DATA_BYTE); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->port.icount.tx++; - } - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&up->port); + uart_port_tx_limited(&up->port, ch, + FIFO_SIZE - readw(up->base + RP2_TX_FIFO_COUNT), + true, + writeb(ch, up->base + RP2_DATA_BYTE), + ({})); } static void rp2_ch_interrupt(struct rp2_uart_port *up) diff --git a/drivers/tty/serial/serial_txx9.c b/drivers/tty/serial/serial_txx9.c index e12f1dc18c38..eab387b01e36 100644 --- a/drivers/tty/serial/serial_txx9.c +++ b/drivers/tty/serial/serial_txx9.c @@ -321,34 +321,12 @@ receive_chars(struct uart_port *up, unsigned int *status) static inline void transmit_chars(struct uart_port *up) { - struct circ_buf *xmit = &up->state->xmit; - int count; + u8 ch; - if (up->x_char) { - sio_out(up, TXX9_SITFIFO, up->x_char); - up->icount.tx++; - up->x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(up)) { - serial_txx9_stop_tx(up); - return; - } - - count = TXX9_SIO_TX_FIFO; - do { - sio_out(up, TXX9_SITFIFO, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(up); - - if (uart_circ_empty(xmit)) - serial_txx9_stop_tx(up); + uart_port_tx_limited(up, ch, TXX9_SIO_TX_FIFO, + true, + sio_out(up, TXX9_SITFIFO, ch), + ({})); } static irqreturn_t serial_txx9_interrupt(int irq, void *dev_id) diff --git a/drivers/tty/serial/sifive.c b/drivers/tty/serial/sifive.c index 7fb6760b5c37..1f565a216e74 100644 --- a/drivers/tty/serial/sifive.c +++ b/drivers/tty/serial/sifive.c @@ -288,33 +288,12 @@ static void __ssp_transmit_char(struct sifive_serial_port *ssp, int ch) */ static void __ssp_transmit_chars(struct sifive_serial_port *ssp) { - struct circ_buf *xmit = &ssp->port.state->xmit; - int count; - - if (ssp->port.x_char) { - __ssp_transmit_char(ssp, ssp->port.x_char); - ssp->port.icount.tx++; - ssp->port.x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(&ssp->port)) { - sifive_serial_stop_tx(&ssp->port); - return; - } - count = SIFIVE_TX_FIFO_DEPTH; - do { - __ssp_transmit_char(ssp, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - ssp->port.icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&ssp->port); + u8 ch; - if (uart_circ_empty(xmit)) - sifive_serial_stop_tx(&ssp->port); + uart_port_tx_limited(&ssp->port, ch, SIFIVE_TX_FIFO_DEPTH, + true, + __ssp_transmit_char(ssp, ch), + ({})); } /** diff --git a/drivers/tty/serial/sprd_serial.c b/drivers/tty/serial/sprd_serial.c index 342a87967631..3f34f7bb7700 100644 --- a/drivers/tty/serial/sprd_serial.c +++ b/drivers/tty/serial/sprd_serial.c @@ -626,35 +626,12 @@ static inline void sprd_rx(struct uart_port *port) static inline void sprd_tx(struct uart_port *port) { - struct circ_buf *xmit = &port->state->xmit; - int count; - - if (port->x_char) { - serial_out(port, SPRD_TXD, port->x_char); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - sprd_stop_tx(port); - return; - } - - count = THLD_TX_EMPTY; - do { - serial_out(port, SPRD_TXD, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); + u8 ch; - if (uart_circ_empty(xmit)) - sprd_stop_tx(port); + uart_port_tx_limited(port, ch, THLD_TX_EMPTY, + true, + serial_out(port, SPRD_TXD, ch), + ({})); } /* this handles the interrupt from one port */ diff --git a/drivers/tty/serial/st-asc.c b/drivers/tty/serial/st-asc.c index fcecea689a0d..5215e6910f68 100644 --- a/drivers/tty/serial/st-asc.c +++ b/drivers/tty/serial/st-asc.c @@ -237,50 +237,12 @@ static inline unsigned asc_hw_txroom(struct uart_port *port) */ static void asc_transmit_chars(struct uart_port *port) { - struct circ_buf *xmit = &port->state->xmit; - int txroom; - unsigned char c; - - txroom = asc_hw_txroom(port); - - if ((txroom != 0) && port->x_char) { - c = port->x_char; - port->x_char = 0; - asc_out(port, ASC_TXBUF, c); - port->icount.tx++; - txroom = asc_hw_txroom(port); - } - - if (uart_tx_stopped(port)) { - /* - * We should try and stop the hardware here, but I - * don't think the ASC has any way to do that. - */ - asc_disable_tx_interrupts(port); - return; - } - - if (uart_circ_empty(xmit)) { - asc_disable_tx_interrupts(port); - return; - } - - if (txroom == 0) - return; - - do { - c = xmit->buf[xmit->tail]; - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - asc_out(port, ASC_TXBUF, c); - port->icount.tx++; - txroom--; - } while ((txroom > 0) && (!uart_circ_empty(xmit))); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); + u8 ch; - if (uart_circ_empty(xmit)) - asc_disable_tx_interrupts(port); + uart_port_tx_limited(port, ch, asc_hw_txroom(port), + true, + asc_out(port, ASC_TXBUF, ch), + ({})); } static void asc_receive_chars(struct uart_port *port) -- 2.37.3