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 8C4E2CFB43F for ; Mon, 7 Oct 2024 15:00:25 +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:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=gHTueMbNrT7R145UYH08UmclYmiu8SYYUfXE1WjKflc=; b=uincbglLlrHeiZ 8D/aLiUWu37JrVRId2f5Uj0n2FuTwlTMoTrtjSXDvE+IMI0wS7p98E0osDLeqVW9BDIFd9q+yZDbT /mXCQkcVfGgQHycghWuXTXkVzTEMBXe9r1RWkpNucDdws+jOwhePaEi8AFGDGNlgdeOtn9z3XRQlI xqJ+mXa70kkvKksXdu8wtUJYjByTywwza4JsQR7tWqBQtWvm3ZUhQVzA1waSPPkSY8dHcKteinp7k 07YKIZDxBvOoehERsc71orvdzBr9vRNit0aEXDYA3V9Ki5fQBRAFNKRqdck1nONcLjyLDUqBa+lED NtNG6xcflrXUsz/+QgkA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1sxpDh-00000002pve-0kRa; Mon, 07 Oct 2024 15:00:21 +0000 Received: from relay6-d.mail.gandi.net ([217.70.183.198]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1sxpDS-00000002pl4-1Bwu for linux-mtd@lists.infradead.org; Mon, 07 Oct 2024 15:00:09 +0000 Received: by mail.gandi.net (Postfix) with ESMTPSA id 3633CC0008; Mon, 7 Oct 2024 15:00:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1728313204; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1u+t30S4U0QrUxj08WB3PEspD5MBQ2xVAOijbNiE6NE=; b=HWfgBKTQEOfaJ2O9LZ2wSRIJD5fsYPNZmAaycK2BSUosek/xjzHgvHJbih/+RVXy7c8y+c YpUT4/GEqJ6hkZxNORUIVIGzRLa4Q2SdI9PTCYTHyQQUhHe6ol9IRAXc2b0miH7nDlVDS3 dOM38nsQWJy+u76pXT+9kDBrwRoQOau44CJueOf1mwk4vCJexo0ggWvjvjY5sM07ox0qzO TG0thbMrhCVJ99aDBKDuSVw6L8sNsp1brmqwTKKrUsUgMfeujY2EzmRTccFyyDS7A5idxK mgCjy8q94tzHh313zqK1McvL4fiFzGqEcIdyIE2HVy1xQ//BY5MoiQ4g7VVryA== Date: Mon, 7 Oct 2024 17:00:02 +0200 From: Miquel Raynal To: Keguang Zhang via B4 Relay Cc: keguang.zhang@gmail.com, Richard Weinberger , Vignesh Raghavendra , Rob Herring , Krzysztof Kozlowski , Conor Dooley , linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-media@vger.kernel.org Subject: Re: [PATCH v10 2/2] mtd: rawnand: Add Loongson-1 NAND Controller Driver Message-ID: <20241007170002.71f3a029@xps-13> In-Reply-To: <20241002-loongson1-nand-v10-2-17162eff80e2@gmail.com> References: <20241002-loongson1-nand-v10-0-17162eff80e2@gmail.com> <20241002-loongson1-nand-v10-2-17162eff80e2@gmail.com> Organization: Bootlin X-Mailer: Claws Mail 4.2.0 (GTK 3.24.41; x86_64-pc-linux-gnu) MIME-Version: 1.0 X-GND-Sasl: miquel.raynal@bootlin.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20241007_080006_767604_55C80E7E X-CRM114-Status: GOOD ( 44.48 ) X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-mtd" Errors-To: linux-mtd-bounces+linux-mtd=archiver.kernel.org@lists.infradead.org SGkgS2VndWFuZywKCmRldm51bGwra2VndWFuZy56aGFuZy5nbWFpbC5jb21Aa2VybmVsLm9yZyB3 cm90ZSBvbiBXZWQsIDAyIE9jdCAyMDI0CjE2OjEwOjQ2ICswODAwOgoKPiBGcm9tOiBLZWd1YW5n IFpoYW5nIDxrZWd1YW5nLnpoYW5nQGdtYWlsLmNvbT4KPiAKPiBBZGQgTkFORCBjb250cm9sbGVy IGRyaXZlciBmb3IgTG9vbmdzb24tMSBTb0NzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEtlZ3Vhbmcg WmhhbmcgPGtlZ3VhbmcuemhhbmdAZ21haWwuY29tPgo+IC0tLQo+IENoYW5nZXMgaW4gdjEwOgo+ IC0gRml4IHRoZSBidWlsZCBlcnJvciByZXBvcnRlZCBieSBrZXJuZWwgdGVzdCByb2JvdC4KPiAg IExpbms6IGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL29lLWtidWlsZC1hbGwvMjAyNDA5MjIwMDEw LnZjdGtIZGRaLWxrcEBpbnRlbC5jb20KPiAKPiBDaGFuZ2VzIGluIHY5Ogo+IC0gQ2hhbmdlIHRo ZSBjb21wYXRpYmxlIHRvICdsb29uZ3NvbixsczEqLW5hbmQtY29udHJvbGxlcicuCj4gLSBVcGRh dGUgTUFJTlRBSU5FUlMgZmlsZSBhY2NvcmRpbmdseS4KPiAtIFJlYmFzaW5nIGR1ZSB0byByZWNl bnQgdXBzdHJlYW0gY2hhbmdlcy4KPiAKPiBDaGFuZ2VzIGluIHY4Ogo+IC0gRHJvcCBOQU5EX01P Tk9MSVRISUNfUkVBRCBhbmQgYWRkIHN1cHBvcnQgZm9yIHJlYWwgc3VicGFnZSByZWFkIGluc3Rl YWQuCj4gLSBTaW1wbGlmeSB0aGUgbG9naWMgb2YgbHMxYl9uYW5kX3BhcnNlX2FkZHJlc3MoKSBh bmQgbHMxY19uYW5kX3BhcnNlX2FkZHJlc3MoKS4KPiAtIFNwbGl0IGxzMXhfbmFuZF9zZXRfY29u dHJvbGxlcigpIGludG8gbHMxeF9uYW5kX3BhcnNlX2luc3RydWN0aW9ucygpCj4gICBhbmQgbHMx eF9uYW5kX3RyaWdnZXJfb3AoKS4KPiAtIEltcGxlbWVudCBsczF4X25hbmRfb3BfY21kX21hcHBp bmcoKSB0byBjb252ZXJ0IHRoZSBvcGNvZGVzIGluc3RlYWQgb2YgZm9yY2luZyB0aGVtLgo+IC0g QWRkIGxzMXhfbmFuZF9jaGVja19vcCgpLgo+IC0gUmVtb3ZlIHN0cnVjdCBsczF4X25hbmQgYWZ0 ZXIgbW92aW5nIGl0cyBtZW1iZXJzIHRvIHN0cnVjdCBsczF4X25mYy4KPiAtIEFkZCB0aGUgcHJl Zml4ICdMUzFYXycgZm9yIGFsbCByZWdpc3RlcnMgYW5kIHRoZWlyIGJpdHMuCj4gLSBEcm9wIHRo ZSBtYWNyb3M6IG5hbmRfcmVhZGwoKSBhbmQgbmFuZF93cml0ZWwoKS4KPiAtIFNvbWUgbWlub3Ig Zml4ZXMgYW5kIGltcHJvdmVtZW50cy4KPiAKPiBDaGFuZ2VzIGluIHY3Ogo+IC0gUmVuYW1lIHRo ZSBLY29uZmlnIGRlcGVuZGVuY3kgdG8gTE9PTkdTT04xX0FQQl9ETUEKPiAKPiBDaGFuZ2VzIGlu IHY2Ogo+IC0gQW1lbmQgS2NvbmZpZwo+IC0gQWRkIERUIHN1cHBvcnQKPiAtIFVzZSBEVCBkYXRh IGluc3RlYWQgb2YgcGxhdGZvcm0gZGF0YQo+IC0gUmVtb3ZlIE1BWF9JRF9TSVpFCj4gLSBSZW1v dmUgY2FzZSBOQU5EX09QX0NNRF9JTlNUUiBpbiBsczF4X25hbmRfc2V0X2NvbnRyb2xsZXIoKQo+ IC0gTW92ZSBFQ0MgY29uZmlndXJhdGlvbiB0byBsczF4X25hbmRfYXR0YWNoX2NoaXAoKQo+IC0g UmVuYW1lIHZhcmlhYmxlICJuYW5kIiB0byAibHMxeCIKPiAtIFJlbmFtZSB2YXJpYWJsZSAibmMi IHRvICJuZmMiCj4gLSBTb21lIG1pbm9yIGZpeGVzCj4gLSBMaW5rIHRvIHY1OiBodHRwczovL2xv cmUua2VybmVsLm9yZy9hbGwvMjAyMTA1MjAyMjQyMTMuNzkwNy0xLWtlZ3VhbmcuemhhbmdAZ21h aWwuY29tCj4gCj4gQ2hhbmdlcyBpbiB2NToKPiAtIFVwZGF0ZSB0aGUgZHJpdmVyIHRvIGZpdCB0 aGUgcmF3IE5BTkQgZnJhbWV3b3JrLgo+IC0gSW1wbGVtZW50IGV4ZWNfb3AoKSBpbnN0ZWFkIG9m IGxlZ2FjeSBjbWRmdW5jKCkuCj4gLSBVc2UgZG1hX3JlcXVlc3RfY2hhbigpIGluc3RlYWQgb2Yg ZG1hX3JlcXVlc3RfY2hhbm5lbCgpLgo+IC0gU29tZSBtaW5vciBmaXhlcyBhbmQgY2xlYW51cHMu Cj4gCj4gQ2hhbmdlcyBpbiB2NDoKPiAtIFJldHJpZXZlIHRoZSBjb250cm9sbGVyIGZyb20gbmFu ZF9od19jb250cm9sLgo+IAo+IENoYW5nZXMgaW4gdjM6Cj4gLSBSZXBsYWNlIF9fcmF3X3JlYWRs L19fcmF3X3dyaXRlbCB3aXRoIHJlYWRsL3dyaXRlbC4KPiAtIFNwbGl0IGxzMXhfbmFuZCBpbnRv IHR3byBzdHJ1Y3R1cmVzOgo+IGxzMXhfbmFuZF9jaGlwIGFuZCBsczF4X25hbmRfY29udHJvbGxl ci4KPiAKPiBDaGFuZ2VzIGluIHYyOgo+IC0gTW9kaWZ5IHRoZSBkZXBlbmRlbmN5IGluIEtjb25m aWcgZHVlIHRvIHRoZSBjaGFuZ2VzIG9mIERNQSBtb2R1bGUuCj4gLS0tCj4gIE1BSU5UQUlORVJT ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL210ZC9uYW5kL3Jh dy9LY29uZmlnICAgICAgICAgIHwgICA3ICsKPiAgZHJpdmVycy9tdGQvbmFuZC9yYXcvTWFrZWZp bGUgICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMvbXRkL25hbmQvcmF3L2xvb25nc29uMV9uYW5k LmMgfCA4MjUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICA0IGZpbGVzIGNo YW5nZWQsIDgzNCBpbnNlcnRpb25zKCspCj4gCj4gZGlmZiAtLWdpdCBhL01BSU5UQUlORVJTIGIv TUFJTlRBSU5FUlMKPiBpbmRleCA5NGNiMzE4Njg2NWYuLjEwZjVkMzI5YzYyNSAxMDA2NDQKPiAt LS0gYS9NQUlOVEFJTkVSUwo+ICsrKyBiL01BSU5UQUlORVJTCj4gQEAgLTE1NTk1LDYgKzE1NTk1 LDcgQEAgRjoJRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzLyovbG9vbmdzb24sbHMx Ki55YW1sCj4gIEY6CWFyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWxvb25nc29uMzIvCj4gIEY6 CWFyY2gvbWlwcy9sb29uZ3NvbjMyLwo+ICBGOglkcml2ZXJzLyovKmxvb25nc29uMSoKPiArRjoJ ZHJpdmVycy9tdGQvbmFuZC9yYXcvbG9vbmdzb24xX25hbmQuYwo+ICBGOglkcml2ZXJzL25ldC9l dGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9kd21hYy1sb29uZ3NvbjEuYwo+ICAKPiAgTUlQUy9MT09O R1NPTjJFRiBBUkNISVRFQ1RVUkUKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9yYXcv S2NvbmZpZyBiL2RyaXZlcnMvbXRkL25hbmQvcmF3L0tjb25maWcKPiBpbmRleCBkMGFhY2NmNzJk NzguLjU0YWQxNmE2YTY0ZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL210ZC9uYW5kL3Jhdy9LY29u ZmlnCj4gKysrIGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvS2NvbmZpZwo+IEBAIC00NTQsNiArNDU0 LDEzIEBAIGNvbmZpZyBNVERfTkFORF9UUzcyWFgKPiAgCWhlbHAKPiAgCSAgRW5hYmxlcyBzdXBw b3J0IGZvciBOQU5EIGNvbnRyb2xsZXIgb24gdHM3Mnh4IFNCQ3MuCj4gIAo+ICtjb25maWcgTVRE X05BTkRfTE9PTkdTT04xCj4gKwl0cmlzdGF0ZSAiTG9vbmdzb24xIE5BTkQgY29udHJvbGxlciIK PiArCWRlcGVuZHMgb24gTE9PTkdTT04xX0FQQl9ETUEgfHwgQ09NUElMRV9URVNUCj4gKwlzZWxl Y3QgUkVHTUFQX01NSU8KPiArCWhlbHAKPiArCSAgRW5hYmxlcyBzdXBwb3J0IGZvciBOQU5EIGNv bnRyb2xsZXIgb24gTG9vbmdzb24xIFNvQ3MuCj4gKwo+ICBjb21tZW50ICJNaXNjIgo+ICAKPiAg Y29uZmlnIE1URF9TTV9DT01NT04KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9yYXcv TWFrZWZpbGUgYi9kcml2ZXJzL210ZC9uYW5kL3Jhdy9NYWtlZmlsZQo+IGluZGV4IGQwYjBlNmI4 MzU2OC4uOWVjMGMzOGI0ZWU3IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbXRkL25hbmQvcmF3L01h a2VmaWxlCj4gKysrIGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvTWFrZWZpbGUKPiBAQCAtNTgsNiAr NTgsNyBAQCBvYmotJChDT05GSUdfTVREX05BTkRfSU5URUxfTEdNKQkrPSBpbnRlbC1uYW5kLWNv bnRyb2xsZXIubwo+ICBvYmotJChDT05GSUdfTVREX05BTkRfUk9DS0NISVApCQkrPSByb2NrY2hp cC1uYW5kLWNvbnRyb2xsZXIubwo+ICBvYmotJChDT05GSUdfTVREX05BTkRfUEwzNVgpCQkrPSBw bDM1eC1uYW5kLWNvbnRyb2xsZXIubwo+ICBvYmotJChDT05GSUdfTVREX05BTkRfUkVORVNBUykJ CSs9IHJlbmVzYXMtbmFuZC1jb250cm9sbGVyLm8KPiArb2JqLSQoQ09ORklHX01URF9OQU5EX0xP T05HU09OMSkJKz0gbG9vbmdzb24xX25hbmQubwoKCQkJCQlsb29uZ3NvbjEtbmFuZC1jb250cm9s bGVyLm8gPwoKPiAgCj4gIG5hbmQtb2JqcyA6PSBuYW5kX2Jhc2UubyBuYW5kX2xlZ2FjeS5vIG5h bmRfYmJ0Lm8gbmFuZF90aW1pbmdzLm8gbmFuZF9pZHMubwo+ICBuYW5kLW9ianMgKz0gbmFuZF9v bmZpLm8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9yYXcvbG9vbmdzb24xX25hbmQu YyBiL2RyaXZlcnMvbXRkL25hbmQvcmF3L2xvb25nc29uMV9uYW5kLmMKPiBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uODllOGEwNDhiMWE1Cj4gLS0tIC9kZXYvbnVs bAo+ICsrKyBiL2RyaXZlcnMvbXRkL25hbmQvcmF3L2xvb25nc29uMV9uYW5kLmMKPiBAQCAtMCww ICsxLDgyNSBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vci1sYXRl cgo+ICsvKgo+ICsgKiBOQU5EIENvbnRyb2xsZXIgRHJpdmVyIGZvciBMb29uZ3Nvbi0xIFNvQwo+ ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTUtMjAyNCBLZWd1YW5nIFpoYW5nIDxrZWd1YW5n LnpoYW5nQGdtYWlsLmNvbT4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2RtYWVuZ2lu ZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KPiArI2luY2x1ZGUgPGxpbnV4 L2lvcG9sbC5oPgo+ICsjaW5jbHVkZSA8bGludXgvbXRkL210ZC5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvbXRkL3Jhd25hbmQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L29mLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgo+ICsj aW5jbHVkZSA8bGludXgvc2l6ZXMuaD4KPiArCj4gKy8qIExvb25nc29uLTEgTkFORCBDb250cm9s bGVyIFJlZ2lzdGVycyAqLwo+ICsjZGVmaW5lIExTMVhfTkFORF9DTUQJCTB4MAo+ICsjZGVmaW5l IExTMVhfTkFORF9BRERSMQkJMHg0Cj4gKyNkZWZpbmUgTFMxWF9OQU5EX0FERFIyCQkweDgKPiAr I2RlZmluZSBMUzFYX05BTkRfVElNSU5HCTB4Ywo+ICsjZGVmaW5lIExTMVhfTkFORF9JREwJCTB4 MTAKPiArI2RlZmluZSBMUzFYX05BTkRfSURIX1NUQVRVUwkweDE0Cj4gKyNkZWZpbmUgTFMxWF9O QU5EX1BBUkFNCQkweDE4Cj4gKyNkZWZpbmUgTFMxWF9OQU5EX09QX05VTQkweDFjCj4gKwo+ICsv KiBOQU5EIENvbW1hbmQgUmVnaXN0ZXIgQml0cyAqLwo+ICsjZGVmaW5lIExTMVhfTkFORF9DTURf T1BfRE9ORQkJQklUKDEwKQo+ICsjZGVmaW5lIExTMVhfTkFORF9DTURfT1BfU1BBUkUJCUJJVCg5 KQo+ICsjZGVmaW5lIExTMVhfTkFORF9DTURfT1BfTUFJTgkJQklUKDgpCj4gKyNkZWZpbmUgTFMx WF9OQU5EX0NNRF9TVEFUVVMJCUJJVCg3KQo+ICsjZGVmaW5lIExTMVhfTkFORF9DTURfUkVTRVQJ CUJJVCg2KQo+ICsjZGVmaW5lIExTMVhfTkFORF9DTURfUkVBRElECQlCSVQoNSkKPiArI2RlZmlu ZSBMUzFYX05BTkRfQ01EX0JMT0NLU19FUkFTRQlCSVQoNCkKPiArI2RlZmluZSBMUzFYX05BTkRf Q01EX0VSQVNFCQlCSVQoMykKPiArI2RlZmluZSBMUzFYX05BTkRfQ01EX1dSSVRFCQlCSVQoMikK PiArI2RlZmluZSBMUzFYX05BTkRfQ01EX1JFQUQJCUJJVCgxKQo+ICsjZGVmaW5lIExTMVhfTkFO RF9DTURfVkFMSUQJCUJJVCgwKQo+ICsKPiArI2RlZmluZSBMUzFYX05BTkRfQ01EX09QX0FSRUFf TUFTSwlHRU5NQVNLKDksIDgpCj4gKyNkZWZpbmUgTFMxWF9OQU5EX1dBSVRfQ1lDTEVfTUFTSwlH RU5NQVNLKDcsIDApCj4gKyNkZWZpbmUgTFMxWF9OQU5EX0hPTERfQ1lDTEVfTUFTSwlHRU5NQVNL KDE1LCA4KQo+ICsjZGVmaW5lIExTMVhfTkFORF9DRUxMX1NJWkVfTUFTSwlHRU5NQVNLKDExLCA4 KQo+ICsKPiArI2RlZmluZSBMUzFYX05BTkRfTUFYX0FERFJfQ1lDCQk1VQo+ICsjZGVmaW5lIExT MVhfTkFORF9ETUFfQUREUgkJMHgxZmU3ODA0MAoKUGxlYXNlLCBuZXZlciBoYXJkY29kZSByZWdp c3RlciBwaHlzaWNhbCB2YWx1ZXMgaW4gYSBkcml2ZXIgbGlrZSB0aGF0CjotKQoKVGhpcyBpcyBh IHJlc291cmNlIHlvdSBzaG91bGQgZ2V0IGZyb20gRFQuIEZ1cnRoZXJtb3JlLCB3aGVuIHVzaW5n IGl0CmFzIERNQSBhZGRyZXNzIHlvdSBzaG91bGQgZmlyc3QgY2FsbCBkbWFfbWFwX3Jlc291cmNl KCkgb24gaXQuCgo+ICsKPiArI2RlZmluZSBCSVRTX1BFUl9XT1JECQkoNCAqIEJJVFNfUEVSX0JZ VEUpCj4gKwo+ICtzdHJ1Y3QgbHMxeF9uZmNfb3Agewo+ICsJY2hhciBhZGRyc1tMUzFYX05BTkRf TUFYX0FERFJfQ1lDXTsKPiArCXVuc2lnbmVkIGludCBuYWRkcnM7Cj4gKwl1bnNpZ25lZCBpbnQg YWRkcnNfb2Zmc2V0Owo+ICsJdW5zaWduZWQgaW50IGFkZHIxX3JlZzsKPiArCXVuc2lnbmVkIGlu dCBhZGRyMl9yZWc7Cj4gKwl1bnNpZ25lZCBpbnQgYWxpZ25lZF9vZmZzZXQ7Cj4gKwl1bnNpZ25l ZCBpbnQgcm93X3NoaWZ0Owo+ICsJdW5zaWduZWQgaW50IGNtZF9yZWc7Cj4gKwl1bnNpZ25lZCBp bnQgcmR5X3RpbWVvdXRfbXM7Cj4gKwl1bnNpZ25lZCBpbnQgbGVuOwo+ICsJc2l6ZV90IGRtYV9s ZW47Cj4gKwlib29sIHJlc3RvcmVfcm93Owo+ICsJYm9vbCBpc193cml0ZTsKPiArCWNoYXIgKmJ1 ZjsKPiArfTsKPiArCj4gK3N0cnVjdCBsczF4X25mY19kYXRhIHsKPiArCXVuc2lnbmVkIGludCBz dGF0dXNfZmllbGQ7Cj4gKwl1bnNpZ25lZCBpbnQgb3Bfc2NvcGVfZmllbGQ7Cj4gKwl1bnNpZ25l ZCBpbnQgaG9sZF9jeWNsZTsKPiArCXVuc2lnbmVkIGludCB3YWl0X2N5Y2xlOwo+ICsJdm9pZCAo KnBhcnNlX2FkZHJlc3MpKHN0cnVjdCBsczF4X25mY19vcCAqb3ApOwo+ICt9Owo+ICsKPiArc3Ry dWN0IGxzMXhfbmZjIHsKPiArCXN0cnVjdCBkZXZpY2UgKmRldjsKPiArCXN0cnVjdCBuYW5kX2No aXAgY2hpcDsKPiArCXN0cnVjdCBuYW5kX2NvbnRyb2xsZXIgY29udHJvbGxlcjsKPiArCWNvbnN0 IHN0cnVjdCBsczF4X25mY19kYXRhICpkYXRhOwo+ICsJdm9pZCBfX2lvbWVtICpyZWdfYmFzZTsK PiArCXN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPiArCS8qIERNQSBFbmdpbmUgc3R1ZmYgKi8KPiAr CXN0cnVjdCBkbWFfY2hhbiAqZG1hX2NoYW47Cj4gKwlkbWFfY29va2llX3QgZG1hX2Nvb2tpZTsK PiArCXN0cnVjdCBjb21wbGV0aW9uIGRtYV9jb21wbGV0ZTsKPiArfTsKPiArCj4gK3N0YXRpYyBj b25zdCBzdHJ1Y3QgcmVnbWFwX2NvbmZpZyBsczF4X25hbmRfcmVnbWFwX2NvbmZpZyA9IHsKPiAr CS5yZWdfYml0cyA9IDMyLAo+ICsJLnZhbF9iaXRzID0gMzIsCj4gKwkucmVnX3N0cmlkZSA9IDQs Cj4gK307Cj4gKwo+ICtzdGF0aWMgaW50IGxzMXhfbmFuZF9vcF9jbWRfbWFwcGluZyhzdHJ1Y3Qg bmFuZF9jaGlwICpjaGlwLAo+ICsJCQkJICAgIHN0cnVjdCBsczF4X25mY19vcCAqb3AsIHU4IG9w Y29kZSkKPiArewo+ICsJc3RydWN0IGxzMXhfbmZjICpuZmMgPSBuYW5kX2dldF9jb250cm9sbGVy X2RhdGEoY2hpcCk7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwlvcC0+cm93X3NoaWZ0ID0gY2hp cC0+cGFnZV9zaGlmdCArIDE7CgpMb29rcyBsaWtlIHlvdSdyZSBoYXJkY29kaW5nIHRoZSB0aGly ZCByb3cgZm9yIGxhcmdlIG5hbmRzPwpXaGF0IGFib3V0IHVzaW5nIGNoaXAtPm9wdGlvbnMgJiBO QU5EX1JPV19BRERSXzMgaW5zdGVhZD8KCj4gKwo+ICsJLyogVGhlIGNvbnRyb2xsZXIgYWJzdHJh Y3RzIHRoZSBmb2xsb3dpbmcgTkFORCBvcGVyYXRpb25zLiAqLwo+ICsJc3dpdGNoIChvcGNvZGUp IHsKPiArCWNhc2UgTkFORF9DTURfUkVTRVQ6Cj4gKwkJb3AtPmNtZF9yZWcgPSBMUzFYX05BTkRf Q01EX1JFU0VUOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBOQU5EX0NNRF9SRUFESUQ6Cj4gKwkJb3At PmNtZF9yZWcgPSBMUzFYX05BTkRfQ01EX1JFQURJRDsKPiArCQlicmVhazsKPiArCWNhc2UgTkFO RF9DTURfRVJBU0UxOgo+ICsJY2FzZSBOQU5EX0NNRF9FUkFTRTI6Cj4gKwkJb3AtPmNtZF9yZWcg PSBMUzFYX05BTkRfQ01EX0VSQVNFOwo+ICsJCW9wLT5hZGRyc19vZmZzZXQgPSAyOwo+ICsJCW9w LT5yb3dfc2hpZnQgPSBjaGlwLT5wYWdlX3NoaWZ0Owo+ICsJCWJyZWFrOwo+ICsJY2FzZSBOQU5E X0NNRF9TVEFUVVM6Cj4gKwkJb3AtPmNtZF9yZWcgPSBMUzFYX05BTkRfQ01EX1NUQVRVUzsKPiAr CQlicmVhazsKPiArCWNhc2UgTkFORF9DTURfU0VRSU46Cj4gKwljYXNlIE5BTkRfQ01EX1BBR0VQ Uk9HOgoKVGhpcyBpcyB0eXBpY2FsbHkgc29tZXRoaW5nIHRoYXQgc2NhcmVzIG1lLiBNYXBwaW5n IHR3byBkaXN0aW5jdApjb21tYW5kcyB0byBhIHNpbmdsZSByZWdpc3RlciB2YWx1ZS4gSG93IGNh biB0aGlzIGJlIHZhbGlkPyBZb3Ugc2hvdWxkCm5ldmVyIGd1ZXNzIHdoYXQgdGhlIGNvcmUgd2Fu dHMgdG8gZG8uIFlvdSBoYXZlIGFsbCB0aGUgb3BlcmF0aW9uLCBzbwppZiB5b3Ugd2FudCB0byBt YXAgdHdvIGNvbW1hbmRzIHRvIGEgc2luZ2xlIHJlZ2lzdGVyIHZhbHVlLCB0aGVuIHBsZWFzZQpj aGVjayB3aGF0IHlvdSBkbyBpcyB2YWxpZCBhbmQgZG8gbm90IGl0ZXJhdGUgYmxpbmRseSBhY3Jv c3MgY29tbWFuZHMKbGlrZSB0aGF0LiBPdGhlcndpc2UgcGxlYXNlIGVycm9yIG91dCBpZiB0aGF0 J3MgdW5zdXBwb3J0ZWQuCgpQbGVhc2UgY2FyZWZ1bGx5IHRyeSB0byBkZXNjcmliZSBhbGwgcG9z c2libGUgY2FzZXMgYW5kIGVycm9yIHdoYXQgd2hlbgp0aGV5IGFyZSBub3Qgc3VwcG9ydGVkLgoK QWxzbywgYmFzZWQgb24gdGhpcyBmZWVkYmFjaywgeW91ciBjaGVja19vcCgpIGZ1bmN0aW9uIG1p Z2h0IG5lZWQgYQpsaXR0bGUgYml0IG9mIHBvbGlzaGluZy4KCj4gKwkJb3AtPmNtZF9yZWcgPSBM UzFYX05BTkRfQ01EX1dSSVRFOwo+ICsJCW9wLT5pc193cml0ZSA9IHRydWU7Cj4gKwkJYnJlYWs7 Cj4gKwljYXNlIE5BTkRfQ01EX1JORE9VVDoKPiArCWNhc2UgTkFORF9DTURfUk5ET1VUU1RBUlQ6 Cj4gKwkJb3AtPnJlc3RvcmVfcm93ID0gdHJ1ZTsKPiArCQlmYWxsdGhyb3VnaDsKPiArCWNhc2Ug TkFORF9DTURfUkVBRDA6Cj4gKwljYXNlIE5BTkRfQ01EX1JFQURTVEFSVDoKPiArCQlvcC0+Y21k X3JlZyA9IExTMVhfTkFORF9DTURfUkVBRDsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJ ZGV2X2VycihuZmMtPmRldiwgIk9wY29kZSBub3Qgc3VwcG9ydGVkOiAldVxuIiwgb3Bjb2RlKTsK PiArCQlyZXR1cm4gLUVPUE5PVFNVUFA7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ ICsKPiArc3RhdGljIGludCBsczF4X25hbmRfcGFyc2VfaW5zdHJ1Y3Rpb25zKHN0cnVjdCBuYW5k X2NoaXAgKmNoaXAsCj4gKwkJCQkJY29uc3Qgc3RydWN0IG5hbmRfc3Vib3AgKnN1Ym9wLAo+ICsJ CQkJCXN0cnVjdCBsczF4X25mY19vcCAqb3ApCj4gK3sKPiArCXVuc2lnbmVkIGludCBvcF9pZDsK PiArCWludCByZXQ7Cj4gKwo+ICsJZm9yIChvcF9pZCA9IDA7IG9wX2lkIDwgc3Vib3AtPm5pbnN0 cnM7IG9wX2lkKyspIHsKPiArCQljb25zdCBzdHJ1Y3QgbmFuZF9vcF9pbnN0ciAqaW5zdHIgPSAm c3Vib3AtPmluc3Ryc1tvcF9pZF07Cj4gKwkJdW5zaWduZWQgaW50IG9mZnNldCwgbmFkZHJzOwo+ ICsJCWNvbnN0IHU4ICphZGRyczsKPiArCj4gKwkJc3dpdGNoIChpbnN0ci0+dHlwZSkgewo+ICsJ CWNhc2UgTkFORF9PUF9DTURfSU5TVFI6Cj4gKwkJCXJldCA9IGxzMXhfbmFuZF9vcF9jbWRfbWFw cGluZyhjaGlwLCBvcCwKPiArCQkJCQkJICAgICAgIGluc3RyLT5jdHguY21kLm9wY29kZSk7Cj4g KwkJCWlmIChyZXQgPCAwKQo+ICsJCQkJcmV0dXJuIHJldDsKPiArCQkJYnJlYWs7Cj4gKwkJY2Fz ZSBOQU5EX09QX0FERFJfSU5TVFI6Cj4gKwkJCW5hZGRycyA9IG5hbmRfc3Vib3BfZ2V0X251bV9h ZGRyX2N5YyhzdWJvcCwgb3BfaWQpOwo+ICsJCQlpZiAobmFkZHJzID4gTFMxWF9OQU5EX01BWF9B RERSX0NZQykKPiArCQkJCXJldHVybiAtRU9QTk9UU1VQUDsKPiArCQkJb3AtPm5hZGRycyA9IG5h ZGRyczsKPiArCQkJb2Zmc2V0ID0gbmFuZF9zdWJvcF9nZXRfYWRkcl9zdGFydF9vZmYoc3Vib3As IG9wX2lkKTsKPiArCQkJYWRkcnMgPSAmaW5zdHItPmN0eC5hZGRyLmFkZHJzW29mZnNldF07Cj4g KwkJCW1lbWNweShvcC0+YWRkcnMgKyBvcC0+YWRkcnNfb2Zmc2V0LCBhZGRycywgbmFkZHJzKTsK PiArCQkJYnJlYWs7Cj4gKwkJY2FzZSBOQU5EX09QX0RBVEFfSU5fSU5TVFI6Cj4gKwkJY2FzZSBO QU5EX09QX0RBVEFfT1VUX0lOU1RSOgo+ICsJCQlvZmZzZXQgPSBuYW5kX3N1Ym9wX2dldF9kYXRh X3N0YXJ0X29mZihzdWJvcCwgb3BfaWQpOwo+ICsJCQlvcC0+bGVuID0gbmFuZF9zdWJvcF9nZXRf ZGF0YV9sZW4oc3Vib3AsIG9wX2lkKTsKPiArCQkJaWYgKGluc3RyLT50eXBlID09IE5BTkRfT1Bf REFUQV9JTl9JTlNUUikKPiArCQkJCW9wLT5idWYgPSBpbnN0ci0+Y3R4LmRhdGEuYnVmLmluICsg b2Zmc2V0Owo+ICsJCQllbHNlIGlmIChpbnN0ci0+dHlwZSA9PSBOQU5EX09QX0RBVEFfT1VUX0lO U1RSKQo+ICsJCQkJb3AtPmJ1ZiA9Cj4gKwkJCQkgICAgKHZvaWQgKilpbnN0ci0+Y3R4LmRhdGEu YnVmLm91dCArIG9mZnNldDsKPiArCj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgTkFORF9PUF9XQUlU UkRZX0lOU1RSOgo+ICsJCQlvcC0+cmR5X3RpbWVvdXRfbXMgPSBpbnN0ci0+Y3R4LndhaXRyZHku dGltZW91dF9tczsKPiArCQkJYnJlYWs7Cj4gKwkJZGVmYXVsdDoKPiArCQkJYnJlYWs7Cj4gKwkJ fQo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBsczFiX25h bmRfcGFyc2VfYWRkcmVzcyhzdHJ1Y3QgbHMxeF9uZmNfb3AgKm9wKQo+ICt7Cj4gKwlpbnQgaTsK PiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgTFMxWF9OQU5EX01BWF9BRERSX0NZQzsgaSsrKSB7Cj4g KwkJaWYgKGkgPCAyKQo+ICsJCQlvcC0+YWRkcjFfcmVnIHw9ICh1MzIpb3AtPmFkZHJzW2ldIDw8 IGkgKiBCSVRTX1BFUl9CWVRFOwo+ICsJCWVsc2UgaWYgKGkgPCA0KQo+ICsJCQlvcC0+YWRkcjFf cmVnIHw9Cj4gKwkJCSAgICAodTMyKW9wLT5hZGRyc1tpXSA8PCAob3AtPnJvd19zaGlmdCArCj4g KwkJCQkJCSAgKGkgLSAyKSAqIEJJVFNfUEVSX0JZVEUpOwo+ICsJCWVsc2UKPiArCQkJb3AtPmFk ZHIyX3JlZyB8PQo+ICsJCQkgICAgKHUzMilvcC0+YWRkcnNbaV0gPj4gKEJJVFNfUEVSX1dPUkQg LQo+ICsJCQkJCQkgIG9wLT5yb3dfc2hpZnQgLSAoaSAtIDQpICoKPiArCQkJCQkJICBCSVRTX1BF Ul9CWVRFKTsKClBsZWFzZSBicmVhayB0aGVzZSBsaW5lcyBhdCAxMDAgY2hhciwgbm90IDgwLCBp dCB3aWxsIG1ha2UgdGhlIHJlYWRpbmcKZWFzaWVyLgoKPiArCX0KPiArfQo+ICsKPiArc3RhdGlj IHZvaWQgbHMxY19uYW5kX3BhcnNlX2FkZHJlc3Moc3RydWN0IGxzMXhfbmZjX29wICpvcCkKPiAr ewo+ICsJaW50IGk7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IExTMVhfTkFORF9NQVhfQUREUl9D WUM7IGkrKykgewo+ICsJCWlmIChpIDwgMikKPiArCQkJb3AtPmFkZHIxX3JlZyB8PSAodTMyKW9w LT5hZGRyc1tpXSA8PCBpICogQklUU19QRVJfQllURTsKPiArCQllbHNlCj4gKwkJCW9wLT5hZGRy Ml9yZWcgfD0KPiArCQkJICAgICh1MzIpb3AtPmFkZHJzW2ldIDw8IChpIC0gMikgKiBCSVRTX1BF Ul9CWVRFOwoKU2FtZQoKPiArCX0KPiArfQo+ICsKPiArc3RhdGljIHZvaWQgbHMxeF9uYW5kX3Ry aWdnZXJfb3Aoc3RydWN0IGxzMXhfbmZjICpuZmMsIHN0cnVjdCBsczF4X25mY19vcCAqb3ApCj4g K3sKPiArCXN0cnVjdCBuYW5kX2NoaXAgKmNoaXAgPSAmbmZjLT5jaGlwOwo+ICsJc3RydWN0IG10 ZF9pbmZvICptdGQgPSBuYW5kX3RvX210ZChjaGlwKTsKPiArCWludCBjb2wwID0gb3AtPmFkZHJz WzBdOwo+ICsJc2hvcnQgY29sOwo+ICsKPiArCS8qIHJlc3RvcmUgcm93IGFkZHJlc3MgZm9yIGNv bHVtbiBjaGFuZ2UgKi8KPiArCWlmIChvcC0+cmVzdG9yZV9yb3cpIHsKPiArCQlvcC0+YWRkcjJf cmVnID0gcmVhZGwobmZjLT5yZWdfYmFzZSArIExTMVhfTkFORF9BRERSMik7Cj4gKwkJb3AtPmFk ZHIxX3JlZyA9IHJlYWRsKG5mYy0+cmVnX2Jhc2UgKyBMUzFYX05BTkRfQUREUjEpOwo+ICsJCW9w LT5hZGRyMV9yZWcgJj0gfihtdGQtPndyaXRlc2l6ZSAtIDEpOwoKVGhpcyBpcyBzdHJhbmdlIGFu ZCBjYW5ub3Qgd29yayBkdXJpbmcgdGhlIGlkZW50aWZpY2F0aW9uIHBoYXNlIHdoaWxlCm10ZC0+ d3JpdGVzaXplIGlzIG5vdCB5ZXQga25vd24uCgo+ICsJfQo+ICsKPiArCWlmICghSVNfQUxJR05F RChjb2wwLCBjaGlwLT5idWZfYWxpZ24pKSB7Cj4gKwkJY29sMCA9IEFMSUdOX0RPV04ob3AtPmFk ZHJzWzBdLCBjaGlwLT5idWZfYWxpZ24pOwo+ICsJCW9wLT5hbGlnbmVkX29mZnNldCA9IG9wLT5h ZGRyc1swXSAtIGNvbDA7Cj4gKwkJb3AtPmFkZHJzWzBdID0gY29sMDsKPiArCX0KPiArCj4gKwlp ZiAobmZjLT5kYXRhLT5wYXJzZV9hZGRyZXNzKQo+ICsJCW5mYy0+ZGF0YS0+cGFyc2VfYWRkcmVz cyhvcCk7Cj4gKwo+ICsJLyogc2V0IGFkZHJlc3MgKi8KPiArCXdyaXRlbChvcC0+YWRkcjFfcmVn LCBuZmMtPnJlZ19iYXNlICsgTFMxWF9OQU5EX0FERFIxKTsKPiArCXdyaXRlbChvcC0+YWRkcjJf cmVnLCBuZmMtPnJlZ19iYXNlICsgTFMxWF9OQU5EX0FERFIyKTsKPiArCj4gKwkvKiBzZXQgZGF0 YSBsZW5ndGggKi8KPiArCW9wLT5kbWFfbGVuID0gQUxJR04ob3AtPmxlbiArIG9wLT5hbGlnbmVk X29mZnNldCwgY2hpcC0+YnVmX2FsaWduKTsKPiArCWlmIChvcC0+Y21kX3JlZyAmIExTMVhfTkFO RF9DTURfRVJBU0UpCj4gKwkJd3JpdGVsKDEsIG5mYy0+cmVnX2Jhc2UgKyBMUzFYX05BTkRfT1Bf TlVNKTsKPiArCWVsc2UKPiArCQl3cml0ZWwob3AtPmRtYV9sZW4sIG5mYy0+cmVnX2Jhc2UgKyBM UzFYX05BTkRfT1BfTlVNKTsKPiArCj4gKwkvKiBzZXQgb3BlcmF0aW9uIGFyZWEgKi8KPiArCWNv bCA9IG9wLT5hZGRyc1sxXSA8PCBCSVRTX1BFUl9CWVRFIHwgb3AtPmFkZHJzWzBdOwo+ICsJaWYg KG9wLT5sZW4pIHsKPiArCQlpZiAoY29sIDwgbXRkLT53cml0ZXNpemUpCgpzaG91bGQnbnQgdGhp cyBiZSA8PSBtdGQtPndyaXRlc2l6ZT8KCkFsc28gd2hhdCBhYm91dCBzdGFydHVwLXRpbWVzIGFn YWluLCB3aGlsZSB3ZSBkb24ndCB5ZXQga25vdyB3cml0ZXNpemU/Cgo+ICsJCQlvcC0+Y21kX3Jl ZyB8PSBMUzFYX05BTkRfQ01EX09QX01BSU47Cj4gKwo+ICsJCW9wLT5jbWRfcmVnIHw9IExTMVhf TkFORF9DTURfT1BfU1BBUkU7Cj4gKwl9Cj4gKwo+ICsJLyogc2V0IG9wZXJhdGlvbiBzY29wZSAq Lwo+ICsJaWYgKG5mYy0+ZGF0YS0+b3Bfc2NvcGVfZmllbGQpIHsKPiArCQlpbnQgb3BfYXJlYSA9 IG9wLT5jbWRfcmVnICYgTFMxWF9OQU5EX0NNRF9PUF9BUkVBX01BU0s7Cj4gKwkJdW5zaWduZWQg aW50IG9wX3Njb3BlOwo+ICsKPiArCQlzd2l0Y2ggKG9wX2FyZWEpIHsKPiArCQljYXNlIExTMVhf TkFORF9DTURfT1BfTUFJTjoKPiArCQkJb3Bfc2NvcGUgPSBtdGQtPndyaXRlc2l6ZTsKPiArCQkJ YnJlYWs7Cj4gKwkJY2FzZSBMUzFYX05BTkRfQ01EX09QX1NQQVJFOgo+ICsJCQlvcF9zY29wZSA9 IG10ZC0+b29ic2l6ZTsKPiArCQkJYnJlYWs7Cj4gKwkJY2FzZSBMUzFYX05BTkRfQ01EX09QX0FS RUFfTUFTSzoKPiArCQkJb3Bfc2NvcGUgPSBtdGQtPndyaXRlc2l6ZSArIG10ZC0+b29ic2l6ZTsK CkNhbiB5b3UgcGxlYXNlIGp1c3QgdXNlIHRoZSBsZW5ndGggb2YgdGhlIG9wZXJhdGlvbj8KCj4g KwkJCWJyZWFrOwo+ICsJCWRlZmF1bHQ6Cj4gKwkJCW9wX3Njb3BlID0gMDsKPiArCQkJYnJlYWs7 Cj4gKwkJfQo+ICsKPiArCQlvcF9zY29wZSA8PD0gX19mZnMobmZjLT5kYXRhLT5vcF9zY29wZV9m aWVsZCk7Cj4gKwkJcmVnbWFwX3VwZGF0ZV9iaXRzKG5mYy0+cmVnbWFwLCBMUzFYX05BTkRfUEFS QU0sCj4gKwkJCQkgICBuZmMtPmRhdGEtPm9wX3Njb3BlX2ZpZWxkLCBvcF9zY29wZSk7Cj4gKwl9 Cj4gKwo+ICsJLyogc2V0IGNvbW1hbmQgKi8KPiArCXdyaXRlbChvcC0+Y21kX3JlZywgbmZjLT5y ZWdfYmFzZSArIExTMVhfTkFORF9DTUQpOwo+ICsKPiArCS8qIHRyaWdnZXIgb3BlcmF0aW9uICov Cj4gKwlyZWdtYXBfd3JpdGVfYml0cyhuZmMtPnJlZ21hcCwgTFMxWF9OQU5EX0NNRCwKPiArCQkJ ICBMUzFYX05BTkRfQ01EX1ZBTElELCBMUzFYX05BTkRfQ01EX1ZBTElEKTsKPiArfQo+ICsKPiAr c3RhdGljIGludCBsczF4X25hbmRfd2FpdF9mb3Jfb3BfZG9uZShzdHJ1Y3QgbHMxeF9uZmMgKm5m YywKPiArCQkJCSAgICAgIHN0cnVjdCBsczF4X25mY19vcCAqb3ApCj4gK3sKPiArCXVuc2lnbmVk IGludCB2YWw7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwlpZiAob3AtPnJkeV90aW1lb3V0X21z KSB7Cj4gKwkJcmV0ID0gcmVnbWFwX3JlYWRfcG9sbF90aW1lb3V0KG5mYy0+cmVnbWFwLCBMUzFY X05BTkRfQ01ELAo+ICsJCQkJCSAgICAgICB2YWwsIHZhbCAmIExTMVhfTkFORF9DTURfT1BfRE9O RSwKPiArCQkJCQkgICAgICAgMCwgb3AtPnJkeV90aW1lb3V0X21zICogMTAwMCk7CgogKiBNU0VD U19QRVJfU0VDPwoKPiArCQlpZiAocmV0KQo+ICsJCQlkZXZfZXJyKG5mYy0+ZGV2LCAib3BlcmF0 aW9uIGZhaWxlZFxuIik7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3Rh dGljIHZvaWQgbHMxeF9uYW5kX2RtYV9jYWxsYmFjayh2b2lkICpkYXRhKQo+ICt7Cj4gKwlzdHJ1 Y3QgbHMxeF9uZmMgKm5mYyA9IChzdHJ1Y3QgbHMxeF9uZmMgKilkYXRhOwo+ICsJc3RydWN0IGRt YV9jaGFuICpjaGFuID0gbmZjLT5kbWFfY2hhbjsKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNo YW4tPmRldmljZS0+ZGV2Owo+ICsJZW51bSBkbWFfc3RhdHVzIHN0YXR1czsKPiArCj4gKwlzdGF0 dXMgPSBkbWFlbmdpbmVfdHhfc3RhdHVzKGNoYW4sIG5mYy0+ZG1hX2Nvb2tpZSwgTlVMTCk7Cj4g KwlpZiAobGlrZWx5KHN0YXR1cyA9PSBETUFfQ09NUExFVEUpKQo+ICsJCWRldl9kYmcoZGV2LCAi RE1BIGNvbXBsZXRlIHdpdGggY29va2llPSVkXG4iLCBuZmMtPmRtYV9jb29raWUpOwo+ICsJZWxz ZQo+ICsJCWRldl9lcnIoZGV2LCAiRE1BIGVycm9yIHdpdGggY29va2llPSVkXG4iLCBuZmMtPmRt YV9jb29raWUpOwo+ICsKPiArCWNvbXBsZXRlKCZuZmMtPmRtYV9jb21wbGV0ZSk7CgpEbyB5b3Ug Z3JhY2VmdWxseSBoYW5kbGUgdGhlIGRtYSBlcnJvciBjb25kaXRpb24/IFlvdSBzaG91bGQgbm90 IHJldHVybgpub3JtYWxseSB0byB1c2Vyc3BhY2UgaWYgRE1BIGZhaWxlZCBhbmQgSSBzZWUgbm8g bWVjaGFuaXNtIHRvIGZvcndhcmQKdGhlIGVycm9yIHVwLgoKPiArfQo+ICsKPiArc3RhdGljIGlu dCBsczF4X25hbmRfZG1hX3RyYW5zZmVyKHN0cnVjdCBsczF4X25mYyAqbmZjLAo+ICsJCQkJICBz dHJ1Y3QgbHMxeF9uZmNfb3AgKm9wKQo+ICt7Cj4gKwlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0g Jm5mYy0+Y2hpcDsKPiArCXN0cnVjdCBkbWFfY2hhbiAqY2hhbiA9IG5mYy0+ZG1hX2NoYW47Cj4g KwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjaGFuLT5kZXZpY2UtPmRldjsKPiArCXN0cnVjdCBkbWFf YXN5bmNfdHhfZGVzY3JpcHRvciAqZGVzYzsKPiArCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRh dGFfZGlyID0KPiArCSAgICBvcC0+aXNfd3JpdGUgPyBETUFfVE9fREVWSUNFIDogRE1BX0ZST01f REVWSUNFOwo+ICsJZW51bSBkbWFfdHJhbnNmZXJfZGlyZWN0aW9uIHhmZXJfZGlyID0KPiArCSAg ICBvcC0+aXNfd3JpdGUgPyBETUFfTUVNX1RPX0RFViA6IERNQV9ERVZfVE9fTUVNOwo+ICsJdm9p ZCAqYnVmID0gb3AtPmJ1ZjsKPiArCWNoYXIgKmRtYV9idWYgPSBOVUxMOwo+ICsJZG1hX2FkZHJf dCBkbWFfYWRkcjsKPiArCWludCByZXQ7Cj4gKwo+ICsJaWYgKElTX0FMSUdORUQoKHVpbnRwdHJf dClidWYsIGNoaXAtPmJ1Zl9hbGlnbikgJiYKPiArCSAgICBJU19BTElHTkVEKG9wLT5sZW4sIGNo aXAtPmJ1Zl9hbGlnbikpIHsKPiArCQlkbWFfYWRkciA9IGRtYV9tYXBfc2luZ2xlKGRldiwgYnVm LCBvcC0+bGVuLCBkYXRhX2Rpcik7Cj4gKwkJaWYgKGRtYV9tYXBwaW5nX2Vycm9yKGRldiwgZG1h X2FkZHIpKSB7Cj4gKwkJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIG1hcCBETUEgYnVmZmVyXG4i KTsKPiArCQkJcmV0dXJuIC1FTlhJTzsKPiArCQl9Cj4gKwl9IGVsc2UgaWYgKCFvcC0+aXNfd3Jp dGUpIHsKPiArCQlkbWFfYnVmID0gZG1hX2FsbG9jX2NvaGVyZW50KGRldiwgb3AtPmRtYV9sZW4s ICZkbWFfYWRkciwKPiArCQkJCQkgICAgIEdGUF9LRVJORUwpOwo+ICsJCWlmICghZG1hX2J1ZikK PiArCQkJcmV0dXJuIC1FTk9NRU07Cj4gKwl9IGVsc2Ugewo+ICsJCWRldl9lcnIoZGV2LCAic3Vi cGFnZSB3cml0aW5nIG5vdCBzdXBwb3J0ZWRcbiIpOwo+ICsJCXJldHVybiAtRU9QTk9UU1VQUDsK PiArCX0KPiArCj4gKwlkZXNjID0gZG1hZW5naW5lX3ByZXBfc2xhdmVfc2luZ2xlKGNoYW4sIGRt YV9hZGRyLCBvcC0+ZG1hX2xlbiwKPiArCQkJCQkgICB4ZmVyX2RpciwgRE1BX1BSRVBfSU5URVJS VVBUKTsKPiArCWlmICghZGVzYykgewo+ICsJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHByZXBh cmUgRE1BIGRlc2NyaXB0b3JcbiIpOwo+ICsJCXJldCA9IFBUUl9FUlIoZGVzYyk7Cj4gKwkJZ290 byBlcnI7Cj4gKwl9Cj4gKwlkZXNjLT5jYWxsYmFjayA9IGxzMXhfbmFuZF9kbWFfY2FsbGJhY2s7 Cj4gKwlkZXNjLT5jYWxsYmFja19wYXJhbSA9IG5mYzsKPiArCj4gKwluZmMtPmRtYV9jb29raWUg PSBkbWFlbmdpbmVfc3VibWl0KGRlc2MpOwo+ICsJcmV0ID0gZG1hX3N1Ym1pdF9lcnJvcihuZmMt PmRtYV9jb29raWUpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRv IHN1Ym1pdCBETUEgZGVzY3JpcHRvclxuIik7Cj4gKwkJZ290byBlcnI7Cj4gKwl9Cj4gKwo+ICsJ ZGV2X2RiZyhkZXYsICJpc3N1ZSBETUEgd2l0aCBjb29raWU9JWRcbiIsIG5mYy0+ZG1hX2Nvb2tp ZSk7Cj4gKwlkbWFfYXN5bmNfaXNzdWVfcGVuZGluZyhjaGFuKTsKPiArCj4gKwlyZXQgPSB3YWl0 X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJm5mYy0+ZG1hX2NvbXBsZXRlLAo+ICsJCQkJCSAgbXNl Y3NfdG9famlmZmllcygyMDAwKSk7Cj4gKwlpZiAoIXJldCkgewo+ICsJCWRtYWVuZ2luZV90ZXJt aW5hdGVfc3luYyhjaGFuKTsKPiArCQlyZWluaXRfY29tcGxldGlvbigmbmZjLT5kbWFfY29tcGxl dGUpOwo+ICsJCXJldCA9IC1FVElNRURPVVQ7Cj4gKwkJZ290byBlcnI7Cj4gKwl9Cj4gKwlyZXQg PSAwOwo+ICsKPiArCWlmIChkbWFfYnVmKQo+ICsJCW1lbWNweShidWYsIGRtYV9idWYgKyBvcC0+ YWxpZ25lZF9vZmZzZXQsIG9wLT5sZW4pOwo+ICtlcnI6Cj4gKwlpZiAoZG1hX2J1ZikKPiArCQlk bWFfZnJlZV9jb2hlcmVudChkZXYsIG9wLT5kbWFfbGVuLCBkbWFfYnVmLCBkbWFfYWRkcik7Cj4g KwllbHNlCj4gKwkJZG1hX3VubWFwX3NpbmdsZShkZXYsIGRtYV9hZGRyLCBvcC0+bGVuLCBkYXRh X2Rpcik7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCBsczF4X25h bmRfZGF0YV90eXBlX2V4ZWMoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwKPiArCQkJCSAgICBjb25z dCBzdHJ1Y3QgbmFuZF9zdWJvcCAqc3Vib3ApCj4gK3sKPiArCXN0cnVjdCBsczF4X25mYyAqbmZj ID0gbmFuZF9nZXRfY29udHJvbGxlcl9kYXRhKGNoaXApOwo+ICsJc3RydWN0IGxzMXhfbmZjX29w IG9wID0geyB9Owo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBsczF4X25hbmRfcGFyc2VfaW5z dHJ1Y3Rpb25zKGNoaXAsIHN1Ym9wLCAmb3ApOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0 Owo+ICsKPiArCWxzMXhfbmFuZF90cmlnZ2VyX29wKG5mYywgJm9wKTsKPiArCj4gKwlyZXQgPSBs czF4X25hbmRfZG1hX3RyYW5zZmVyKG5mYywgJm9wKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJu IHJldDsKPiArCj4gKwlyZXR1cm4gbHMxeF9uYW5kX3dhaXRfZm9yX29wX2RvbmUobmZjLCAmb3Ap Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGxzMXhfbmFuZF9taXNjX3R5cGVfZXhlYyhzdHJ1Y3Qg bmFuZF9jaGlwICpjaGlwLAo+ICsJCQkJICAgIGNvbnN0IHN0cnVjdCBuYW5kX3N1Ym9wICpzdWJv cCwKPiArCQkJCSAgICBzdHJ1Y3QgbHMxeF9uZmNfb3AgKm9wKQo+ICt7Cj4gKwlzdHJ1Y3QgbHMx eF9uZmMgKm5mYyA9IG5hbmRfZ2V0X2NvbnRyb2xsZXJfZGF0YShjaGlwKTsKPiArCWludCByZXQ7 Cj4gKwo+ICsJcmV0ID0gbHMxeF9uYW5kX3BhcnNlX2luc3RydWN0aW9ucyhjaGlwLCBzdWJvcCwg b3ApOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWxzMXhfbmFuZF90cmln Z2VyX29wKG5mYywgb3ApOwo+ICsKPiArCXJldHVybiBsczF4X25hbmRfd2FpdF9mb3Jfb3BfZG9u ZShuZmMsIG9wKTsKPiArfQo+ICsKPiArc3RhdGljIGludCBsczF4X25hbmRfemVyb2xlbl90eXBl X2V4ZWMoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwKPiArCQkJCSAgICAgICBjb25zdCBzdHJ1Y3Qg bmFuZF9zdWJvcCAqc3Vib3ApCj4gK3sKPiArCXN0cnVjdCBsczF4X25mY19vcCBvcCA9IHsgfTsK CllvdSBkb24ndCBuZWVkIHRoaXMgc3BhY2UgICAgICAgIF4KCj4gKwo+ICsJcmV0dXJuIGxzMXhf bmFuZF9taXNjX3R5cGVfZXhlYyhjaGlwLCBzdWJvcCwgJm9wKTsKPiArfQo+ICsKPiArc3RhdGlj IGludCBsczF4X25hbmRfcmVhZF9pZF90eXBlX2V4ZWMoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwK PiArCQkJCSAgICAgICBjb25zdCBzdHJ1Y3QgbmFuZF9zdWJvcCAqc3Vib3ApCj4gK3sKPiArCXN0 cnVjdCBsczF4X25mYyAqbmZjID0gbmFuZF9nZXRfY29udHJvbGxlcl9kYXRhKGNoaXApOwo+ICsJ c3RydWN0IGxzMXhfbmZjX29wIG9wID0geyB9Owo+ICsJaW50IGksIHJldDsKPiArCXVuaW9uIHsK PiArCQljaGFyIGlkc1s1XTsKPiArCQlzdHJ1Y3Qgewo+ICsJCQlpbnQgaWRsOwo+ICsJCQljaGFy IGlkaDsKPiArCQl9Owo+ICsJfSBuYW5kX2lkOwo+ICsKPiArCXJldCA9IGxzMXhfbmFuZF9taXNj X3R5cGVfZXhlYyhjaGlwLCBzdWJvcCwgJm9wKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJy KG5mYy0+ZGV2LCAiZmFpbGVkIHRvIHJlYWQgSUQhICVkXG4iLCByZXQpOwo+ICsJCXJldHVybiBy ZXQ7Cj4gKwl9Cj4gKwo+ICsJbmFuZF9pZC5pZGwgPSByZWFkbChuZmMtPnJlZ19iYXNlICsgTFMx WF9OQU5EX0lETCk7Cj4gKwluYW5kX2lkLmlkaCA9IHJlYWRiKG5mYy0+cmVnX2Jhc2UgKyBMUzFY X05BTkRfSURIX1NUQVRVUyk7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IG1pbihzaXplb2YobmFu ZF9pZC5pZHMpLCBvcC5sZW4pOyBpKyspCj4gKwkJb3AuYnVmW2ldID0gbmFuZF9pZC5pZHNbc2l6 ZW9mKG5hbmRfaWQuaWRzKSAtIDEgLSBpXTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW50IGxzMXhfbmFuZF9yZWFkX3N0YXR1c190eXBlX2V4ZWMoc3RydWN0IG5hbmRf Y2hpcCAqY2hpcCwKPiArCQkJCQkgICBjb25zdCBzdHJ1Y3QgbmFuZF9zdWJvcCAqc3Vib3ApCj4g K3sKPiArCXN0cnVjdCBsczF4X25mYyAqbmZjID0gbmFuZF9nZXRfY29udHJvbGxlcl9kYXRhKGNo aXApOwo+ICsJc3RydWN0IGxzMXhfbmZjX29wIG9wID0geyB9Owo+ICsJaW50IHZhbCwgcmV0Owo+ ICsKPiArCXJldCA9IGxzMXhfbmFuZF9taXNjX3R5cGVfZXhlYyhjaGlwLCBzdWJvcCwgJm9wKTsK PiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKG5mYy0+ZGV2LCAiZmFpbGVkIHRvIHJlYWQgc3Rh dHVzISAlZFxuIiwgcmV0KTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCXZhbCA9IHJl YWRsKG5mYy0+cmVnX2Jhc2UgKwo+ICsJCSAgICBMUzFYX05BTkRfSURIX1NUQVRVUykgJiB+bmZj LT5kYXRhLT5zdGF0dXNfZmllbGQ7CgpKdXN0IHNwbGl0IHRoaXMgaW50bzoKCgl2YWwgPSByZWFk bCgpOwoJdmFsICY9IH5tYXNrOwoKPiArCW9wLmJ1ZlswXSA9IHZhbCA8PCBmZnMobmZjLT5kYXRh LT5zdGF0dXNfZmllbGQpOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCgpUaGUgcmVzdCBs b29rIGdvb2QuCgpUaGFua3MsCk1pcXXDqGwKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eCBNVEQgZGlzY3Vzc2lvbiBtYWlsaW5nIGxp c3QKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1tdGQv Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from relay6-d.mail.gandi.net (relay6-d.mail.gandi.net [217.70.183.198]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 080D61D7E47; Mon, 7 Oct 2024 15:00:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.198 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1728313209; cv=none; b=Ul5EeMZt26n3lKX8uzHMeA2C8lKZKaMcp4qy5883tYwbzUsPAzRGJshAKLwEcBU2w9FareCQyCDJ2YrupNfgQjQiQKVG/B85RktmaT0efCaaIlr9obci0ixpQHCf1Z+6p6izrBX/bq3kzLKdYEi+bGOiGbPxAsd3jKF07VyXEHo= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1728313209; c=relaxed/simple; bh=Dx9PLmuVECAcNhvxGlpAl5AXTv6lgKJyJFqsJJOcgZo=; h=Date:From:To:Cc:Subject:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=C1/LBsA2e6V+/BJYuZw1HUWUpKUV1aStzWgLy+6xXjD34N2jkaC3uFSfAJVytTyUbSOkWoQ7p2aaVZ3/spa/gbHr1yT7RLMIfJ9jP65HAkCpFEzY+ijVnAF5Y5QeDFbrBd1jjQha+NiO+JXwDrPT/x9TzAq4aVTRw6Ru/ncbmfY= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=HWfgBKTQ; arc=none smtp.client-ip=217.70.183.198 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="HWfgBKTQ" Received: by mail.gandi.net (Postfix) with ESMTPSA id 3633CC0008; Mon, 7 Oct 2024 15:00:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1728313204; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1u+t30S4U0QrUxj08WB3PEspD5MBQ2xVAOijbNiE6NE=; b=HWfgBKTQEOfaJ2O9LZ2wSRIJD5fsYPNZmAaycK2BSUosek/xjzHgvHJbih/+RVXy7c8y+c YpUT4/GEqJ6hkZxNORUIVIGzRLa4Q2SdI9PTCYTHyQQUhHe6ol9IRAXc2b0miH7nDlVDS3 dOM38nsQWJy+u76pXT+9kDBrwRoQOau44CJueOf1mwk4vCJexo0ggWvjvjY5sM07ox0qzO TG0thbMrhCVJ99aDBKDuSVw6L8sNsp1brmqwTKKrUsUgMfeujY2EzmRTccFyyDS7A5idxK mgCjy8q94tzHh313zqK1McvL4fiFzGqEcIdyIE2HVy1xQ//BY5MoiQ4g7VVryA== Date: Mon, 7 Oct 2024 17:00:02 +0200 From: Miquel Raynal To: Keguang Zhang via B4 Relay Cc: keguang.zhang@gmail.com, Richard Weinberger , Vignesh Raghavendra , Rob Herring , Krzysztof Kozlowski , Conor Dooley , linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-media@vger.kernel.org Subject: Re: [PATCH v10 2/2] mtd: rawnand: Add Loongson-1 NAND Controller Driver Message-ID: <20241007170002.71f3a029@xps-13> In-Reply-To: <20241002-loongson1-nand-v10-2-17162eff80e2@gmail.com> References: <20241002-loongson1-nand-v10-0-17162eff80e2@gmail.com> <20241002-loongson1-nand-v10-2-17162eff80e2@gmail.com> Organization: Bootlin X-Mailer: Claws Mail 4.2.0 (GTK 3.24.41; x86_64-pc-linux-gnu) Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-GND-Sasl: miquel.raynal@bootlin.com Hi Keguang, devnull+keguang.zhang.gmail.com@kernel.org wrote on Wed, 02 Oct 2024 16:10:46 +0800: > From: Keguang Zhang >=20 > Add NAND controller driver for Loongson-1 SoCs. >=20 > Signed-off-by: Keguang Zhang > --- > Changes in v10: > - Fix the build error reported by kernel test robot. > Link: https://lore.kernel.org/oe-kbuild-all/202409220010.vctkHddZ-lkp@i= ntel.com >=20 > Changes in v9: > - Change the compatible to 'loongson,ls1*-nand-controller'. > - Update MAINTAINERS file accordingly. > - Rebasing due to recent upstream changes. >=20 > Changes in v8: > - Drop NAND_MONOLITHIC_READ and add support for real subpage read instead. > - Simplify the logic of ls1b_nand_parse_address() and ls1c_nand_parse_add= ress(). > - Split ls1x_nand_set_controller() into ls1x_nand_parse_instructions() > and ls1x_nand_trigger_op(). > - Implement ls1x_nand_op_cmd_mapping() to convert the opcodes instead of = forcing them. > - Add ls1x_nand_check_op(). > - Remove struct ls1x_nand after moving its members to struct ls1x_nfc. > - Add the prefix 'LS1X_' for all registers and their bits. > - Drop the macros: nand_readl() and nand_writel(). > - Some minor fixes and improvements. >=20 > Changes in v7: > - Rename the Kconfig dependency to LOONGSON1_APB_DMA >=20 > Changes in v6: > - Amend Kconfig > - Add DT support > - Use DT data instead of platform data > - Remove MAX_ID_SIZE > - Remove case NAND_OP_CMD_INSTR in ls1x_nand_set_controller() > - Move ECC configuration to ls1x_nand_attach_chip() > - Rename variable "nand" to "ls1x" > - Rename variable "nc" to "nfc" > - Some minor fixes > - Link to v5: https://lore.kernel.org/all/20210520224213.7907-1-keguang.z= hang@gmail.com >=20 > Changes in v5: > - Update the driver to fit the raw NAND framework. > - Implement exec_op() instead of legacy cmdfunc(). > - Use dma_request_chan() instead of dma_request_channel(). > - Some minor fixes and cleanups. >=20 > Changes in v4: > - Retrieve the controller from nand_hw_control. >=20 > Changes in v3: > - Replace __raw_readl/__raw_writel with readl/writel. > - Split ls1x_nand into two structures: > ls1x_nand_chip and ls1x_nand_controller. >=20 > Changes in v2: > - Modify the dependency in Kconfig due to the changes of DMA module. > --- > MAINTAINERS | 1 + > drivers/mtd/nand/raw/Kconfig | 7 + > drivers/mtd/nand/raw/Makefile | 1 + > drivers/mtd/nand/raw/loongson1_nand.c | 825 ++++++++++++++++++++++++++++= ++++++ > 4 files changed, 834 insertions(+) >=20 > diff --git a/MAINTAINERS b/MAINTAINERS > index 94cb3186865f..10f5d329c625 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -15595,6 +15595,7 @@ F: Documentation/devicetree/bindings/*/loongson,l= s1*.yaml > F: arch/mips/include/asm/mach-loongson32/ > F: arch/mips/loongson32/ > F: drivers/*/*loongson1* > +F: drivers/mtd/nand/raw/loongson1_nand.c > F: drivers/net/ethernet/stmicro/stmmac/dwmac-loongson1.c > =20 > MIPS/LOONGSON2EF ARCHITECTURE > diff --git a/drivers/mtd/nand/raw/Kconfig b/drivers/mtd/nand/raw/Kconfig > index d0aaccf72d78..54ad16a6a64e 100644 > --- a/drivers/mtd/nand/raw/Kconfig > +++ b/drivers/mtd/nand/raw/Kconfig > @@ -454,6 +454,13 @@ config MTD_NAND_TS72XX > help > Enables support for NAND controller on ts72xx SBCs. > =20 > +config MTD_NAND_LOONGSON1 > + tristate "Loongson1 NAND controller" > + depends on LOONGSON1_APB_DMA || COMPILE_TEST > + select REGMAP_MMIO > + help > + Enables support for NAND controller on Loongson1 SoCs. > + > comment "Misc" > =20 > config MTD_SM_COMMON > diff --git a/drivers/mtd/nand/raw/Makefile b/drivers/mtd/nand/raw/Makefile > index d0b0e6b83568..9ec0c38b4ee7 100644 > --- a/drivers/mtd/nand/raw/Makefile > +++ b/drivers/mtd/nand/raw/Makefile > @@ -58,6 +58,7 @@ obj-$(CONFIG_MTD_NAND_INTEL_LGM) +=3D intel-nand-contro= ller.o > obj-$(CONFIG_MTD_NAND_ROCKCHIP) +=3D rockchip-nand-controller.o > obj-$(CONFIG_MTD_NAND_PL35X) +=3D pl35x-nand-controller.o > obj-$(CONFIG_MTD_NAND_RENESAS) +=3D renesas-nand-controller.o > +obj-$(CONFIG_MTD_NAND_LOONGSON1) +=3D loongson1_nand.o loongson1-nand-controller.o ? > =20 > nand-objs :=3D nand_base.o nand_legacy.o nand_bbt.o nand_timings.o nand_= ids.o > nand-objs +=3D nand_onfi.o > diff --git a/drivers/mtd/nand/raw/loongson1_nand.c b/drivers/mtd/nand/raw= /loongson1_nand.c > new file mode 100644 > index 000000000000..89e8a048b1a5 > --- /dev/null > +++ b/drivers/mtd/nand/raw/loongson1_nand.c > @@ -0,0 +1,825 @@ > +// SPDX-License-Identifier: GPL-2.0-or-later > +/* > + * NAND Controller Driver for Loongson-1 SoC > + * > + * Copyright (C) 2015-2024 Keguang Zhang > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* Loongson-1 NAND Controller Registers */ > +#define LS1X_NAND_CMD 0x0 > +#define LS1X_NAND_ADDR1 0x4 > +#define LS1X_NAND_ADDR2 0x8 > +#define LS1X_NAND_TIMING 0xc > +#define LS1X_NAND_IDL 0x10 > +#define LS1X_NAND_IDH_STATUS 0x14 > +#define LS1X_NAND_PARAM 0x18 > +#define LS1X_NAND_OP_NUM 0x1c > + > +/* NAND Command Register Bits */ > +#define LS1X_NAND_CMD_OP_DONE BIT(10) > +#define LS1X_NAND_CMD_OP_SPARE BIT(9) > +#define LS1X_NAND_CMD_OP_MAIN BIT(8) > +#define LS1X_NAND_CMD_STATUS BIT(7) > +#define LS1X_NAND_CMD_RESET BIT(6) > +#define LS1X_NAND_CMD_READID BIT(5) > +#define LS1X_NAND_CMD_BLOCKS_ERASE BIT(4) > +#define LS1X_NAND_CMD_ERASE BIT(3) > +#define LS1X_NAND_CMD_WRITE BIT(2) > +#define LS1X_NAND_CMD_READ BIT(1) > +#define LS1X_NAND_CMD_VALID BIT(0) > + > +#define LS1X_NAND_CMD_OP_AREA_MASK GENMASK(9, 8) > +#define LS1X_NAND_WAIT_CYCLE_MASK GENMASK(7, 0) > +#define LS1X_NAND_HOLD_CYCLE_MASK GENMASK(15, 8) > +#define LS1X_NAND_CELL_SIZE_MASK GENMASK(11, 8) > + > +#define LS1X_NAND_MAX_ADDR_CYC 5U > +#define LS1X_NAND_DMA_ADDR 0x1fe78040 Please, never hardcode register physical values in a driver like that :-) This is a resource you should get from DT. Furthermore, when using it as DMA address you should first call dma_map_resource() on it. > + > +#define BITS_PER_WORD (4 * BITS_PER_BYTE) > + > +struct ls1x_nfc_op { > + char addrs[LS1X_NAND_MAX_ADDR_CYC]; > + unsigned int naddrs; > + unsigned int addrs_offset; > + unsigned int addr1_reg; > + unsigned int addr2_reg; > + unsigned int aligned_offset; > + unsigned int row_shift; > + unsigned int cmd_reg; > + unsigned int rdy_timeout_ms; > + unsigned int len; > + size_t dma_len; > + bool restore_row; > + bool is_write; > + char *buf; > +}; > + > +struct ls1x_nfc_data { > + unsigned int status_field; > + unsigned int op_scope_field; > + unsigned int hold_cycle; > + unsigned int wait_cycle; > + void (*parse_address)(struct ls1x_nfc_op *op); > +}; > + > +struct ls1x_nfc { > + struct device *dev; > + struct nand_chip chip; > + struct nand_controller controller; > + const struct ls1x_nfc_data *data; > + void __iomem *reg_base; > + struct regmap *regmap; > + /* DMA Engine stuff */ > + struct dma_chan *dma_chan; > + dma_cookie_t dma_cookie; > + struct completion dma_complete; > +}; > + > +static const struct regmap_config ls1x_nand_regmap_config =3D { > + .reg_bits =3D 32, > + .val_bits =3D 32, > + .reg_stride =3D 4, > +}; > + > +static int ls1x_nand_op_cmd_mapping(struct nand_chip *chip, > + struct ls1x_nfc_op *op, u8 opcode) > +{ > + struct ls1x_nfc *nfc =3D nand_get_controller_data(chip); > + int ret =3D 0; > + > + op->row_shift =3D chip->page_shift + 1; Looks like you're hardcoding the third row for large nands? What about using chip->options & NAND_ROW_ADDR_3 instead? > + > + /* The controller abstracts the following NAND operations. */ > + switch (opcode) { > + case NAND_CMD_RESET: > + op->cmd_reg =3D LS1X_NAND_CMD_RESET; > + break; > + case NAND_CMD_READID: > + op->cmd_reg =3D LS1X_NAND_CMD_READID; > + break; > + case NAND_CMD_ERASE1: > + case NAND_CMD_ERASE2: > + op->cmd_reg =3D LS1X_NAND_CMD_ERASE; > + op->addrs_offset =3D 2; > + op->row_shift =3D chip->page_shift; > + break; > + case NAND_CMD_STATUS: > + op->cmd_reg =3D LS1X_NAND_CMD_STATUS; > + break; > + case NAND_CMD_SEQIN: > + case NAND_CMD_PAGEPROG: This is typically something that scares me. Mapping two distinct commands to a single register value. How can this be valid? You should never guess what the core wants to do. You have all the operation, so if you want to map two commands to a single register value, then please check what you do is valid and do not iterate blindly across commands like that. Otherwise please error out if that's unsupported. Please carefully try to describe all possible cases and error what when they are not supported. Also, based on this feedback, your check_op() function might need a little bit of polishing. > + op->cmd_reg =3D LS1X_NAND_CMD_WRITE; > + op->is_write =3D true; > + break; > + case NAND_CMD_RNDOUT: > + case NAND_CMD_RNDOUTSTART: > + op->restore_row =3D true; > + fallthrough; > + case NAND_CMD_READ0: > + case NAND_CMD_READSTART: > + op->cmd_reg =3D LS1X_NAND_CMD_READ; > + break; > + default: > + dev_err(nfc->dev, "Opcode not supported: %u\n", opcode); > + return -EOPNOTSUPP; > + } > + > + return ret; > +} > + > +static int ls1x_nand_parse_instructions(struct nand_chip *chip, > + const struct nand_subop *subop, > + struct ls1x_nfc_op *op) > +{ > + unsigned int op_id; > + int ret; > + > + for (op_id =3D 0; op_id < subop->ninstrs; op_id++) { > + const struct nand_op_instr *instr =3D &subop->instrs[op_id]; > + unsigned int offset, naddrs; > + const u8 *addrs; > + > + switch (instr->type) { > + case NAND_OP_CMD_INSTR: > + ret =3D ls1x_nand_op_cmd_mapping(chip, op, > + instr->ctx.cmd.opcode); > + if (ret < 0) > + return ret; > + break; > + case NAND_OP_ADDR_INSTR: > + naddrs =3D nand_subop_get_num_addr_cyc(subop, op_id); > + if (naddrs > LS1X_NAND_MAX_ADDR_CYC) > + return -EOPNOTSUPP; > + op->naddrs =3D naddrs; > + offset =3D nand_subop_get_addr_start_off(subop, op_id); > + addrs =3D &instr->ctx.addr.addrs[offset]; > + memcpy(op->addrs + op->addrs_offset, addrs, naddrs); > + break; > + case NAND_OP_DATA_IN_INSTR: > + case NAND_OP_DATA_OUT_INSTR: > + offset =3D nand_subop_get_data_start_off(subop, op_id); > + op->len =3D nand_subop_get_data_len(subop, op_id); > + if (instr->type =3D=3D NAND_OP_DATA_IN_INSTR) > + op->buf =3D instr->ctx.data.buf.in + offset; > + else if (instr->type =3D=3D NAND_OP_DATA_OUT_INSTR) > + op->buf =3D > + (void *)instr->ctx.data.buf.out + offset; > + > + break; > + case NAND_OP_WAITRDY_INSTR: > + op->rdy_timeout_ms =3D instr->ctx.waitrdy.timeout_ms; > + break; > + default: > + break; > + } > + } > + > + return 0; > +} > + > +static void ls1b_nand_parse_address(struct ls1x_nfc_op *op) > +{ > + int i; > + > + for (i =3D 0; i < LS1X_NAND_MAX_ADDR_CYC; i++) { > + if (i < 2) > + op->addr1_reg |=3D (u32)op->addrs[i] << i * BITS_PER_BYTE; > + else if (i < 4) > + op->addr1_reg |=3D > + (u32)op->addrs[i] << (op->row_shift + > + (i - 2) * BITS_PER_BYTE); > + else > + op->addr2_reg |=3D > + (u32)op->addrs[i] >> (BITS_PER_WORD - > + op->row_shift - (i - 4) * > + BITS_PER_BYTE); Please break these lines at 100 char, not 80, it will make the reading easier. > + } > +} > + > +static void ls1c_nand_parse_address(struct ls1x_nfc_op *op) > +{ > + int i; > + > + for (i =3D 0; i < LS1X_NAND_MAX_ADDR_CYC; i++) { > + if (i < 2) > + op->addr1_reg |=3D (u32)op->addrs[i] << i * BITS_PER_BYTE; > + else > + op->addr2_reg |=3D > + (u32)op->addrs[i] << (i - 2) * BITS_PER_BYTE; Same > + } > +} > + > +static void ls1x_nand_trigger_op(struct ls1x_nfc *nfc, struct ls1x_nfc_o= p *op) > +{ > + struct nand_chip *chip =3D &nfc->chip; > + struct mtd_info *mtd =3D nand_to_mtd(chip); > + int col0 =3D op->addrs[0]; > + short col; > + > + /* restore row address for column change */ > + if (op->restore_row) { > + op->addr2_reg =3D readl(nfc->reg_base + LS1X_NAND_ADDR2); > + op->addr1_reg =3D readl(nfc->reg_base + LS1X_NAND_ADDR1); > + op->addr1_reg &=3D ~(mtd->writesize - 1); This is strange and cannot work during the identification phase while mtd->writesize is not yet known. > + } > + > + if (!IS_ALIGNED(col0, chip->buf_align)) { > + col0 =3D ALIGN_DOWN(op->addrs[0], chip->buf_align); > + op->aligned_offset =3D op->addrs[0] - col0; > + op->addrs[0] =3D col0; > + } > + > + if (nfc->data->parse_address) > + nfc->data->parse_address(op); > + > + /* set address */ > + writel(op->addr1_reg, nfc->reg_base + LS1X_NAND_ADDR1); > + writel(op->addr2_reg, nfc->reg_base + LS1X_NAND_ADDR2); > + > + /* set data length */ > + op->dma_len =3D ALIGN(op->len + op->aligned_offset, chip->buf_align); > + if (op->cmd_reg & LS1X_NAND_CMD_ERASE) > + writel(1, nfc->reg_base + LS1X_NAND_OP_NUM); > + else > + writel(op->dma_len, nfc->reg_base + LS1X_NAND_OP_NUM); > + > + /* set operation area */ > + col =3D op->addrs[1] << BITS_PER_BYTE | op->addrs[0]; > + if (op->len) { > + if (col < mtd->writesize) should'nt this be <=3D mtd->writesize? Also what about startup-times again, while we don't yet know writesize? > + op->cmd_reg |=3D LS1X_NAND_CMD_OP_MAIN; > + > + op->cmd_reg |=3D LS1X_NAND_CMD_OP_SPARE; > + } > + > + /* set operation scope */ > + if (nfc->data->op_scope_field) { > + int op_area =3D op->cmd_reg & LS1X_NAND_CMD_OP_AREA_MASK; > + unsigned int op_scope; > + > + switch (op_area) { > + case LS1X_NAND_CMD_OP_MAIN: > + op_scope =3D mtd->writesize; > + break; > + case LS1X_NAND_CMD_OP_SPARE: > + op_scope =3D mtd->oobsize; > + break; > + case LS1X_NAND_CMD_OP_AREA_MASK: > + op_scope =3D mtd->writesize + mtd->oobsize; Can you please just use the length of the operation? > + break; > + default: > + op_scope =3D 0; > + break; > + } > + > + op_scope <<=3D __ffs(nfc->data->op_scope_field); > + regmap_update_bits(nfc->regmap, LS1X_NAND_PARAM, > + nfc->data->op_scope_field, op_scope); > + } > + > + /* set command */ > + writel(op->cmd_reg, nfc->reg_base + LS1X_NAND_CMD); > + > + /* trigger operation */ > + regmap_write_bits(nfc->regmap, LS1X_NAND_CMD, > + LS1X_NAND_CMD_VALID, LS1X_NAND_CMD_VALID); > +} > + > +static int ls1x_nand_wait_for_op_done(struct ls1x_nfc *nfc, > + struct ls1x_nfc_op *op) > +{ > + unsigned int val; > + int ret =3D 0; > + > + if (op->rdy_timeout_ms) { > + ret =3D regmap_read_poll_timeout(nfc->regmap, LS1X_NAND_CMD, > + val, val & LS1X_NAND_CMD_OP_DONE, > + 0, op->rdy_timeout_ms * 1000); * MSECS_PER_SEC? > + if (ret) > + dev_err(nfc->dev, "operation failed\n"); > + } > + > + return ret; > +} > + > +static void ls1x_nand_dma_callback(void *data) > +{ > + struct ls1x_nfc *nfc =3D (struct ls1x_nfc *)data; > + struct dma_chan *chan =3D nfc->dma_chan; > + struct device *dev =3D chan->device->dev; > + enum dma_status status; > + > + status =3D dmaengine_tx_status(chan, nfc->dma_cookie, NULL); > + if (likely(status =3D=3D DMA_COMPLETE)) > + dev_dbg(dev, "DMA complete with cookie=3D%d\n", nfc->dma_cookie); > + else > + dev_err(dev, "DMA error with cookie=3D%d\n", nfc->dma_cookie); > + > + complete(&nfc->dma_complete); Do you gracefully handle the dma error condition? You should not return normally to userspace if DMA failed and I see no mechanism to forward the error up. > +} > + > +static int ls1x_nand_dma_transfer(struct ls1x_nfc *nfc, > + struct ls1x_nfc_op *op) > +{ > + struct nand_chip *chip =3D &nfc->chip; > + struct dma_chan *chan =3D nfc->dma_chan; > + struct device *dev =3D chan->device->dev; > + struct dma_async_tx_descriptor *desc; > + enum dma_data_direction data_dir =3D > + op->is_write ? DMA_TO_DEVICE : DMA_FROM_DEVICE; > + enum dma_transfer_direction xfer_dir =3D > + op->is_write ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM; > + void *buf =3D op->buf; > + char *dma_buf =3D NULL; > + dma_addr_t dma_addr; > + int ret; > + > + if (IS_ALIGNED((uintptr_t)buf, chip->buf_align) && > + IS_ALIGNED(op->len, chip->buf_align)) { > + dma_addr =3D dma_map_single(dev, buf, op->len, data_dir); > + if (dma_mapping_error(dev, dma_addr)) { > + dev_err(dev, "failed to map DMA buffer\n"); > + return -ENXIO; > + } > + } else if (!op->is_write) { > + dma_buf =3D dma_alloc_coherent(dev, op->dma_len, &dma_addr, > + GFP_KERNEL); > + if (!dma_buf) > + return -ENOMEM; > + } else { > + dev_err(dev, "subpage writing not supported\n"); > + return -EOPNOTSUPP; > + } > + > + desc =3D dmaengine_prep_slave_single(chan, dma_addr, op->dma_len, > + xfer_dir, DMA_PREP_INTERRUPT); > + if (!desc) { > + dev_err(dev, "failed to prepare DMA descriptor\n"); > + ret =3D PTR_ERR(desc); > + goto err; > + } > + desc->callback =3D ls1x_nand_dma_callback; > + desc->callback_param =3D nfc; > + > + nfc->dma_cookie =3D dmaengine_submit(desc); > + ret =3D dma_submit_error(nfc->dma_cookie); > + if (ret) { > + dev_err(dev, "failed to submit DMA descriptor\n"); > + goto err; > + } > + > + dev_dbg(dev, "issue DMA with cookie=3D%d\n", nfc->dma_cookie); > + dma_async_issue_pending(chan); > + > + ret =3D wait_for_completion_timeout(&nfc->dma_complete, > + msecs_to_jiffies(2000)); > + if (!ret) { > + dmaengine_terminate_sync(chan); > + reinit_completion(&nfc->dma_complete); > + ret =3D -ETIMEDOUT; > + goto err; > + } > + ret =3D 0; > + > + if (dma_buf) > + memcpy(buf, dma_buf + op->aligned_offset, op->len); > +err: > + if (dma_buf) > + dma_free_coherent(dev, op->dma_len, dma_buf, dma_addr); > + else > + dma_unmap_single(dev, dma_addr, op->len, data_dir); > + > + return ret; > +} > + > +static int ls1x_nand_data_type_exec(struct nand_chip *chip, > + const struct nand_subop *subop) > +{ > + struct ls1x_nfc *nfc =3D nand_get_controller_data(chip); > + struct ls1x_nfc_op op =3D { }; > + int ret; > + > + ret =3D ls1x_nand_parse_instructions(chip, subop, &op); > + if (ret) > + return ret; > + > + ls1x_nand_trigger_op(nfc, &op); > + > + ret =3D ls1x_nand_dma_transfer(nfc, &op); > + if (ret) > + return ret; > + > + return ls1x_nand_wait_for_op_done(nfc, &op); > +} > + > +static int ls1x_nand_misc_type_exec(struct nand_chip *chip, > + const struct nand_subop *subop, > + struct ls1x_nfc_op *op) > +{ > + struct ls1x_nfc *nfc =3D nand_get_controller_data(chip); > + int ret; > + > + ret =3D ls1x_nand_parse_instructions(chip, subop, op); > + if (ret) > + return ret; > + > + ls1x_nand_trigger_op(nfc, op); > + > + return ls1x_nand_wait_for_op_done(nfc, op); > +} > + > +static int ls1x_nand_zerolen_type_exec(struct nand_chip *chip, > + const struct nand_subop *subop) > +{ > + struct ls1x_nfc_op op =3D { }; You don't need this space ^ > + > + return ls1x_nand_misc_type_exec(chip, subop, &op); > +} > + > +static int ls1x_nand_read_id_type_exec(struct nand_chip *chip, > + const struct nand_subop *subop) > +{ > + struct ls1x_nfc *nfc =3D nand_get_controller_data(chip); > + struct ls1x_nfc_op op =3D { }; > + int i, ret; > + union { > + char ids[5]; > + struct { > + int idl; > + char idh; > + }; > + } nand_id; > + > + ret =3D ls1x_nand_misc_type_exec(chip, subop, &op); > + if (ret) { > + dev_err(nfc->dev, "failed to read ID! %d\n", ret); > + return ret; > + } > + > + nand_id.idl =3D readl(nfc->reg_base + LS1X_NAND_IDL); > + nand_id.idh =3D readb(nfc->reg_base + LS1X_NAND_IDH_STATUS); > + > + for (i =3D 0; i < min(sizeof(nand_id.ids), op.len); i++) > + op.buf[i] =3D nand_id.ids[sizeof(nand_id.ids) - 1 - i]; > + > + return ret; > +} > + > +static int ls1x_nand_read_status_type_exec(struct nand_chip *chip, > + const struct nand_subop *subop) > +{ > + struct ls1x_nfc *nfc =3D nand_get_controller_data(chip); > + struct ls1x_nfc_op op =3D { }; > + int val, ret; > + > + ret =3D ls1x_nand_misc_type_exec(chip, subop, &op); > + if (ret) { > + dev_err(nfc->dev, "failed to read status! %d\n", ret); > + return ret; > + } > + > + val =3D readl(nfc->reg_base + > + LS1X_NAND_IDH_STATUS) & ~nfc->data->status_field; Just split this into: val =3D readl(); val &=3D ~mask; > + op.buf[0] =3D val << ffs(nfc->data->status_field); > + > + return ret; > +} > + The rest look good. Thanks, Miqu=C3=A8l