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 X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_2 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1A182C433FF for ; Wed, 7 Aug 2019 09:49:31 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id E3EC7222FC for ; Wed, 7 Aug 2019 09:49:30 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="sT7UXU3s" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E3EC7222FC Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=bootlin.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mtd-bounces+linux-mtd=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Subject: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=Wcl9zLoqDX+dDHvnM8Nm+dY0zJjeaHc/3sMOyU4Ll70=; b=sT7UXU3s8KJUjj DAF26NvBhpPJoz0qORas7qKutD1LPaL6h11zzD1S49OPSq9SmVQWuqoXQV+MR827qk92AXpHzbm5g W0c39YgX3orcS84P739l+wb2WUgUARjqzULUPbzjtv1vFyleERCv4yuJQW3yiUEKVmKtnPzeZEGaL v/l9ZoV41KrdKrlmhYZ+6ec0aSFczMNfJU4jtX81fc4j8ieqDYc7vOqIeDzHtc7GeWh++KPKT0u4R qeTA6ME5zbo2uqBG3ld5ZHmr5yR3PAr6xFvOpZIH01aydzDO4SotVfN1DlneRvEtVg7cEnyFvEn1n yJK6GGgJpAvx3I8534Lw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1hvIZD-0002Ys-T3; Wed, 07 Aug 2019 09:49:11 +0000 Received: from relay1-d.mail.gandi.net ([217.70.183.193]) by bombadil.infradead.org with esmtps (Exim 4.92 #3 (Red Hat Linux)) id 1hvIZ7-0002Th-Rz for linux-mtd@lists.infradead.org; Wed, 07 Aug 2019 09:49:10 +0000 X-Originating-IP: 86.250.200.211 Received: from xps13 (lfbn-1-17395-211.w86-250.abo.wanadoo.fr [86.250.200.211]) (Authenticated sender: miquel.raynal@bootlin.com) by relay1-d.mail.gandi.net (Postfix) with ESMTPSA id A879D24000B; Wed, 7 Aug 2019 09:48:56 +0000 (UTC) Date: Wed, 7 Aug 2019 11:48:55 +0200 From: Miquel Raynal To: shiva.linuxworks@gmail.com Subject: Re: [PATCH 4/8] mtd: spinand: enabled parameter page support Message-ID: <20190807114855.35f26229@xps13> In-Reply-To: <20190722055621.23526-5-sshivamurthy@micron.com> References: <20190722055621.23526-1-sshivamurthy@micron.com> <20190722055621.23526-5-sshivamurthy@micron.com> Organization: Bootlin X-Mailer: Claws Mail 3.17.3 (GTK+ 2.24.32; x86_64-pc-linux-gnu) MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190807_024906_224633_887224F7 X-CRM114-Status: GOOD ( 31.29 ) X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Chuanhong Guo , Vignesh Raghavendra , Boris Brezillon , Marcel Ziswiler , Richard Weinberger , linux-kernel@vger.kernel.org, Frieder Schrempf , liaoweixiong , Marek Vasut , linux-mtd@lists.infradead.org, Jeff Kletsky , Brian Norris , David Woodhouse , Shivamurthy Shastri 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 SGkgU2hpdmEsCgpzaGl2YS5saW51eHdvcmtzQGdtYWlsLmNvbSB3cm90ZSBvbiBNb24sIDIyIEp1 bCAyMDE5IDA3OjU2OjE3ICswMjAwOgoKIm10ZDogc3BpbmFuZDogZW5hYmxlIHBhcmFtZXRlciBw YWdlIHN1cHBvcnQiCgo+IEZyb206IFNoaXZhbXVydGh5IFNoYXN0cmkgPHNzaGl2YW11cnRoeUBt aWNyb24uY29tPgo+IAo+IFNvbWUgb2YgdGhlIFNQSSBOQU5EIGRldmljZXMgaGFzIHBhcmFtZXRl ciBwYWdlLCB3aGljaCBpcyBzaW1pbGFyIHRvCiAgICAgICAgICAgICAgICAgLSAgICAgICAgICAg ICBoYXZlIGEKPiBPTkZJIHRhYmxlLgogIHJlZ3VsYXIgcmF3IE5BTkQgT05GSSB0YWJsZXMuCgo+ IAo+IEJ1dCwgaXQgbWF5IG5vdCBiZSBzZWxmIHN1ZmZpY2llbnQgdG8gcHJvcGFnYXRlIGFsbCB0 aGUgcmVxdWlyZWQKICBBcyBpdCBtYXkgbm90IGJlCj4gcGFyYW1ldGVycy4gRml4dXAgZnVuY3Rp b24gaGFzIGJlZW4gYWRkZWQgaW4gc3RydWN0IG1hbnVmYWN0dXJlciB0bwogICAgICAgICAgICAs IGEgZml4dXAgICAgICAgIGlzIGJlaW5nIGFkZGVkIGluIHRoZSBtYW51ZmFjdHVyZXIgc3RydWN0 dXJlCj4gYWNjb21tb2RhdGUgdGhpcy4KClRoZSBmaXh1cCBmdW5jdGlvbiBzZW50ZW5jZSBzaG91 bGQgYmUgZHJvcHBlZCBmcm9tIHRoZSBjb21taXQgbWVzc2FnZSwKc2VlIGJlbG93LgoKPiAKPiBT aWduZWQtb2ZmLWJ5OiBTaGl2YW11cnRoeSBTaGFzdHJpIDxzc2hpdmFtdXJ0aHlAbWljcm9uLmNv bT4KPiAtLS0KPiAgZHJpdmVycy9tdGQvbmFuZC9zcGkvY29yZS5jIHwgMTM0ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBpbmNsdWRlL2xpbnV4L210ZC9zcGluYW5kLmgg fCAgIDMgKwo+ICAyIGZpbGVzIGNoYW5nZWQsIDEzNyBpbnNlcnRpb25zKCspCj4gCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvc3BpL2NvcmUuYyBiL2RyaXZlcnMvbXRkL25hbmQvc3Bp L2NvcmUuYwo+IGluZGV4IDg5ZjZiZWVmYjAxYy4uN2FlNzZkYWI5MTQxIDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvbXRkL25hbmQvc3BpL2NvcmUuYwo+ICsrKyBiL2RyaXZlcnMvbXRkL25hbmQvc3Bp L2NvcmUuYwo+IEBAIC00MDAsNiArNDAwLDEzMSBAQCBzdGF0aWMgaW50IHNwaW5hbmRfbG9ja19i bG9jayhzdHJ1Y3Qgc3BpbmFuZF9kZXZpY2UgKnNwaW5hbmQsIHU4IGxvY2spCj4gIAlyZXR1cm4g c3BpbmFuZF93cml0ZV9yZWdfb3Aoc3BpbmFuZCwgUkVHX0JMT0NLX0xPQ0ssIGxvY2spOwo+ICB9 Cj4gIAo+ICsvKioKPiArICogc3BpbmFuZF9yZWFkX3BhcmFtX3BhZ2Vfb3AgLSBSZWFkIHBhcmFt ZXRlciBwYWdlIG9wZXJhdGlvbgoKQWdhaW4sIHRoZSBuYW1lIGluIHRoZSBkb2MgZG9lcyBub3Qg Zml0IHRoZSBmdW5jdGlvbiB5b3UgZGVzY3JpYmUKCj4gKyAqIEBzcGluYW5kOiB0aGUgc3BpbmFu ZAogICAgICAgICAgICAgICAgICAgIFNQSS1OQU5EIGNoaXAKClNoaXZhLCB0aGVyZSBhcmUgd2F5 IHRvbyBtdWNoIHR5cG9zIGFuZCBzaG9ydGN1dHMgaW4geW91ciBzZXJpZXMuClBsZWFzZSBiZSBt b3JlIGNhcmVmdWwgb3RoZXJ3aXNlIHdlIGNhbid0IGZvY3VzIG9uIHRoZSB0ZWNobmljYWwKYXNw ZWN0cy4gSSBhbSBub3QgYSBuYXRpdmUgRW5nbGlzaCBzcGVha2VyIGF0IGFsbCBidXQgcGxlYXNl LCBwbGFpbgpFbmdsaXNoIGlzIG5vdCBDIGNvZGUuIFdlIHRhbGsgU1BJLU5BTkQgYW5kIG5vdCBz cGluYW5kLCB3ZSBzYXkKc3RydWN0dXJlIGFuZCBub3Qgc3RydWN0LCBhY3JvbnltcyBhcmUgdXBw ZXJjYXNlLCBldGMuCgo+ICsgKiBAcGFnZTogcGFnZSBudW1iZXIgd2hlcmUgcGFyYW1ldGVyIHBh Z2UgdGFibGVzIGNhbiBiZSBmb3VuZAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBeIHRo ZQo+ICsgKiBAYnVmOiBidWZmZXIgdXNlZCB0byBzdG9yZSB0aGUgcGFyYW1ldGVyIHBhZ2UKPiAr ICogQGxlbjogbGVuZ3RoIG9mIHRoZSBidWZmZXIKPiArICoKPiArICogUmVhZCBwYXJhbWV0ZXIg cGFnZQogICAgICAgICAgdGhlCj4gKyAqCj4gKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzLCBhIG5l Z2F0aXZlIGVycm9yIGNvZGUgb3RoZXJ3aXNlLgo+ICsgKi8KPiArc3RhdGljIGludCBzcGluYW5k X3BhcmFtZXRlcl9wYWdlX3JlYWQoc3RydWN0IHNwaW5hbmRfZGV2aWNlICpzcGluYW5kLAo+ICsJ CQkJICAgICAgIHU4IHBhZ2UsIHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKPiArewo+ICsJ c3RydWN0IHNwaV9tZW1fb3AgcHJlYWRfb3AgPSBTUElOQU5EX1BBR0VfUkVBRF9PUChwYWdlKTsK PiArCXN0cnVjdCBzcGlfbWVtX29wIHByZWFkX2NhY2hlX29wID0KPiArCQkJCVNQSU5BTkRfUEFH RV9SRUFEX0ZST01fQ0FDSEVfT1AoZmFsc2UsCj4gKwkJCQkJCQkJMCwKPiArCQkJCQkJCQkxLAo+ ICsJCQkJCQkJCWJ1ZiwKPiArCQkJCQkJCQlsZW4pOwoKVGhhdCdzIG9rIGlmIHlvdSBjcm9zcyB0 aGUgODAgY2hhcmFjdGVycyBib3VuZGFyeSBoZXJlLiBZb3UgbWF5IHB1dCAiMCwKMSwiIG9uIHRo ZSBmaXJzdCBsaW5lIGFuZCAiYnVmLCBsZW4pOyIgb24gdGhlIHNlY29uZC4KCj4gKwl1OCBmZWF0 dXJlOwo+ICsJdTggc3RhdHVzOwo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAobGVuICYmICFidWYp Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJcmV0ID0gc3BpbmFuZF9yZWFkX3JlZ19vcChz cGluYW5kLCBSRUdfQ0ZHLAo+ICsJCQkJICAmZmVhdHVyZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJl dHVybiByZXQ7Cj4gKwo+ICsJLyogQ0ZHX09UUF9FTkFCTEUgaXMgdXNlZCB0byBlbmFibGUgcGFy YW1ldGVyIHBhZ2UgYWNjZXNzICovCj4gKwlmZWF0dXJlIHw9IENGR19PVFBfRU5BQkxFOwo+ICsK PiArCXNwaW5hbmRfd3JpdGVfcmVnX29wKHNwaW5hbmQsIFJFR19DRkcsIGZlYXR1cmUpOwo+ICsK PiArCXJldCA9IHNwaV9tZW1fZXhlY19vcChzcGluYW5kLT5zcGltZW0sICZwcmVhZF9vcCk7Cj4g KwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gc3BpbmFuZF93YWl0KHNw aW5hbmQsICZzdGF0dXMpOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCj4g KwlyZXQgPSBzcGlfbWVtX2V4ZWNfb3Aoc3BpbmFuZC0+c3BpbWVtLCAmcHJlYWRfY2FjaGVfb3Ap Owo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IHNwaW5hbmRfcmVh ZF9yZWdfb3Aoc3BpbmFuZCwgUkVHX0NGRywKPiArCQkJCSAgJmZlYXR1cmUpOwo+ICsJaWYgKHJl dCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWZlYXR1cmUgJj0gfkNGR19PVFBfRU5BQkxFOwo+ ICsKPiArCXNwaW5hbmRfd3JpdGVfcmVnX29wKHNwaW5hbmQsIFJFR19DRkcsIGZlYXR1cmUpOwo+ ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwpBZGQgdGhlIGtlcm5lbCBkb2MgcGxlYXNlCgpDaGFu Z2UgdGhlIGJlbG93IGZ1bmN0aW9uIHNvIHRoYXQgaXQgcmV0dXJucyAxIGlmIHRoZSBwYWdlIHdh cwpkZXRlY3RlZCwgMCBpZiBpdCBkaWQgbm90LCBhbiBuZWdhdGl2ZSBlcnJvciBjb2RlIG90aGVy d2lzZS4KCj4gK3N0YXRpYyBpbnQgc3BpbmFuZF9wYXJhbV9wYWdlX2RldGVjdChzdHJ1Y3Qgc3Bp bmFuZF9kZXZpY2UgKnNwaW5hbmQpCj4gK3sKPiArCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0gc3Bp bmFuZF90b19tdGQoc3BpbmFuZCk7Cj4gKwlzdHJ1Y3QgbmFuZF9tZW1vcnlfb3JnYW5pemF0aW9u ICptZW1vcmc7Cj4gKwlzdHJ1Y3QgbmFuZF9vbmZpX3BhcmFtcyAqcDsKPiArCXN0cnVjdCBuYW5k X2RldmljZSAqYmFzZSA9IHNwaW5hbmRfdG9fbmFuZChzcGluYW5kKTsKPiArCWludCBpLCByZXQ7 Cj4gKwo+ICsJbWVtb3JnID0gbmFuZGRldl9nZXRfbWVtb3JnKGJhc2UpOwo+ICsKPiArCS8qIEFs bG9jYXRlIGJ1ZmZlciB0byBob2xkIHBhcmFtZXRlciBwYWdlICovCj4gKwlwID0ga3phbGxvYygo c2l6ZW9mKCpwKSAqIDMpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghcCkKPiArCQlyZXR1cm4gLUVO T01FTTsKPiArCj4gKwlyZXQgPSBzcGluYW5kX3BhcmFtZXRlcl9wYWdlX3JlYWQoc3BpbmFuZCwg MHgwMSwgcCwgc2l6ZW9mKCpwKSAqIDMpOwo+ICsJaWYgKHJldCkgewo+ICsJCXJldCA9IDA7CgpO bywgeW91IHNob3VsZCByZXR1cm4gdGhlIGVycm9yIGluIGNhc2Ugb2YgZXJyb3IuIFlvdSB3aWxs IGxhdGVyIGhhbmRsZQp0aGUgZmFjdCB0aGF0IHRoZXJlIGlzIG5vIHBhcmFtZXRlciBwYWdlLgoK PiArCQlnb3RvIGZyZWVfcGFyYW1fcGFnZTsKPiArCX0KPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwg MzsgaSsrKSB7Cj4gKwkJaWYgKG9uZmlfY3JjMTYoT05GSV9DUkNfQkFTRSwgKHU4ICopJnBbaV0s IDI1NCkgPT0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBeCklmIHlvdSBmb3JjZSB0aGUgcGFyYW1ldGVyIHBhZ2UgdG8gYmUgMjU0IGJ5 dGVzIGxvbmcgaXQgbWVhbnMgeW91IGxpbWl0CnlvdXJzZWxmIHRvIE9ORkkgc3RhbmRhcmQuIFRo YXQncyBub3QgYSBwcm9ibGVtLCBidXQgdGhlbiB5b3Ugc2hvdWxkCm1lbnRpb24gaXQgaW4gdGhl IGZ1bmN0aW9uIG5hbWUuCgo+ICsJCQkJbGUxNl90b19jcHUocC0+Y3JjKSkgewo+ICsJCQlpZiAo aSkKPiArCQkJCW1lbWNweShwLCAmcFtpXSwgc2l6ZW9mKCpwKSk7Cj4gKwkJCWJyZWFrOwo+ICsJ CX0KPiArCX0KPiArCj4gKwlpZiAoaSA9PSAzKSB7Cj4gKwkJY29uc3Qgdm9pZCAqc3JjYnVmc1sz XSA9IHtwLCBwICsgMSwgcCArIDJ9Owo+ICsKPiArCQlwcl93YXJuKCJDb3VsZCBub3QgZmluZCBh IHZhbGlkIE9ORkkgcGFyYW1ldGVyIHBhZ2UsIHRyeWluZyBiaXQtd2lzZSBtYWpvcml0eSB0byBy ZWNvdmVyIGl0XG4iKTsKPiArCQluYW5kX2JpdF93aXNlX21ham9yaXR5KHNyY2J1ZnMsIEFSUkFZ X1NJWkUoc3JjYnVmcyksIHAsCj4gKwkJCQkgICAgICAgc2l6ZW9mKCpwKSk7Cj4gKwo+ICsJCWlm IChvbmZpX2NyYzE2KE9ORklfQ1JDX0JBU0UsICh1OCAqKXAsIDI1NCkgIT0KPiArCQkJCWxlMTZf dG9fY3B1KHAtPmNyYykpIHsKPiArCQkJcHJfZXJyKCJPTkZJIHBhcmFtZXRlciByZWNvdmVyeSBm YWlsZWQsIGFib3J0aW5nXG4iKTsKPiArCQkJZ290byBmcmVlX3BhcmFtX3BhZ2U7Cj4gKwkJfQo+ ICsJfQoKVGhlIHdob2xlIGZvci1sb29wIGFuZCB0aGUgaWYgKGk9PTMpIGNvbmRpdGlvbiBpcyBl eGFjdGx5IHRoZSBzYW1lIGFzCmZvciByYXcgTkFORHMgYW5kIG11c3QgYmUgZXh0cmFjdGVkIGlu IGEgZ2VuZXJpYyBmdW5jdGlvbjoKMS8gZXh0cmFjdCB0aGUgZnVuY3Rpb24gZnJvbSBuYW5kL3Jh dy9uYW5kX29uZmkuYyBhbmQgcHV0IGl0IGluCm5hbmQvb25maS5jLgoyLyB0aGVuIHVzZSBpdCBp biB0aGlzIHBhdGNoLgoKPiArCj4gKwlwYXJzZV9vbmZpX3BhcmFtcyhtZW1vcmcsIHApOwo+ICsK PiArCW10ZC0+d3JpdGVzaXplID0gbWVtb3JnLT5wYWdlc2l6ZTsKPiArCW10ZC0+ZXJhc2VzaXpl ID0gbWVtb3JnLT5wYWdlc19wZXJfZXJhc2VibG9jayAqIG1lbW9yZy0+cGFnZXNpemU7Cj4gKwlt dGQtPm9vYnNpemUgPSBtZW1vcmctPm9vYnNpemU7CgpUaGlzIHdpbGwgYmUgaGFuZGxlZCBieSBu YW5kZGV2X2luaXQsIHNob3VsZCBiZSByZW1vdmVkLgoKPiArCj4gKwkvKiBNYW51ZmFjdHVyZXJz IG1heSBpbnRlcnByZXQgdGhlIHBhcmFtZXRlciBwYWdlIGRpZmZlcmVudGx5ICovCj4gKwlpZiAo c3BpbmFuZC0+bWFudWZhY3R1cmVyLT5vcHMtPmZpeHVwX3BhcmFtX3BhZ2UpCj4gKwkJc3BpbmFu ZC0+bWFudWZhY3R1cmVyLT5vcHMtPmZpeHVwX3BhcmFtX3BhZ2Uoc3BpbmFuZCwgcCk7CgpUaGUg d2hvbGUgIm1hbnVmYWN0dXJlciBmaXh1cCIgc2hvdWxkIGJlIGRvbmUgc2VwYXJhdGVseS4KCj4g Kwo+ICsJLyogSWRlbnRpZmljYXRpb24gZG9uZSwgZnJlZSB0aGUgZnVsbCBwYXJhbWV0ZXIgcGFn ZSBhbmQgZXhpdCAqLwo+ICsJcmV0ID0gMTsKPiArCj4gK2ZyZWVfcGFyYW1fcGFnZToKPiArCWtm cmVlKHApOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gIHN0YXRpYyBpbnQgc3BpbmFu ZF9jaGVja19lY2Nfc3RhdHVzKHN0cnVjdCBzcGluYW5kX2RldmljZSAqc3BpbmFuZCwgdTggc3Rh dHVzKQo+ICB7Cj4gIAlzdHJ1Y3QgbmFuZF9kZXZpY2UgKm5hbmQgPSBzcGluYW5kX3RvX25hbmQo c3BpbmFuZCk7Cj4gQEAgLTkxMSw2ICsxMDM2LDE1IEBAIHN0YXRpYyBpbnQgc3BpbmFuZF9kZXRl Y3Qoc3RydWN0IHNwaW5hbmRfZGV2aWNlICpzcGluYW5kKQo+ICAJCXJldHVybiByZXQ7Cj4gIAl9 Cj4gIAo+ICsJaWYgKCFzcGluYW5kLT5iYXNlLm1lbW9yZy5wYWdlc2l6ZSkgewo+ICsJCXJldCA9 IHNwaW5hbmRfcGFyYW1fcGFnZV9kZXRlY3Qoc3BpbmFuZCk7Cj4gKwkJaWYgKHJldCA8PSAwKSB7 Cj4gKwkJCWRldl9lcnIoZGV2LCAibm8gcGFyYW1ldGVyIHBhZ2UgZm9yICUqcGhOXG4iLAoKTm90 IHN1cmUgYXQgdGhpcyBzdGFnZSBkZXYgd2lsbCBnaXZlIHNvbWV0aGluZyBtZWFuaW5nZnVsLiBB bnl3YXkgSQpkb24ndCB0aGluayB3ZSBzaG91bGQgc2NyZWFtIGF0IHRoZSB1c2VyIGlmIGhpcyBO QU5EIGlzIG5vdCBhbiBPTkZJIG9uZQpzbyBwbGVhc2UgcmV0dXJuIGFuIGVycm9yIG9ubHkgaWYg cmV0IDwgMC4gSWYgcmV0ID09IDAgb3IgcmV0ID09IDEsCmRvbid0IHdhcm4gdGhlIHVzZXIuCgo+ ICsJCQkJU1BJTkFORF9NQVhfSURfTEVOLCBzcGluYW5kLT5pZC5kYXRhKTsKPiArCQkJcmV0dXJu IC1FTk9ERVY7Cj4gKwkJfQo+ICsJfQo+ICsKPiAgCWlmIChuYW5kLT5tZW1vcmcubnRhcmdldHMg PiAxICYmICFzcGluYW5kLT5zZWxlY3RfdGFyZ2V0KSB7Cj4gIAkJZGV2X2VycihkZXYsCj4gIAkJ CSJTUEkgTkFORHMgd2l0aCBtb3JlIHRoYW4gb25lIGRpZSBtdXN0IGltcGxlbWVudCAtPnNlbGVj dF90YXJnZXQoKVxuIik7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXRkL3NwaW5hbmQu aCBiL2luY2x1ZGUvbGludXgvbXRkL3NwaW5hbmQuaAo+IGluZGV4IDRlYTU1OGJkM2M0Ni4uZmVh ODIwYTIwYmM5IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbXRkL3NwaW5hbmQuaAo+ICsr KyBiL2luY2x1ZGUvbGludXgvbXRkL3NwaW5hbmQuaAo+IEBAIC0xNSw2ICsxNSw3IEBACj4gICNp bmNsdWRlIDxsaW51eC9tdGQvbmFuZC5oPgo+ICAjaW5jbHVkZSA8bGludXgvc3BpL3NwaS5oPgo+ ICAjaW5jbHVkZSA8bGludXgvc3BpL3NwaS1tZW0uaD4KPiArI2luY2x1ZGUgPGxpbnV4L210ZC9v bmZpLmg+Cj4gIAo+ICAvKioKPiAgICogU3RhbmRhcmQgU1BJIE5BTkQgZmxhc2ggb3BlcmF0aW9u cwo+IEBAIC0yMDksNiArMjEwLDggQEAgc3RydWN0IHNwaW5hbmRfbWFudWZhY3R1cmVyX29wcyB7 Cj4gIAlpbnQgKCpkZXRlY3QpKHN0cnVjdCBzcGluYW5kX2RldmljZSAqc3BpbmFuZCk7Cj4gIAlp bnQgKCppbml0KShzdHJ1Y3Qgc3BpbmFuZF9kZXZpY2UgKnNwaW5hbmQpOwo+ICAJdm9pZCAoKmNs ZWFudXApKHN0cnVjdCBzcGluYW5kX2RldmljZSAqc3BpbmFuZCk7Cj4gKwl2b2lkICgqZml4dXBf cGFyYW1fcGFnZSkoc3RydWN0IHNwaW5hbmRfZGV2aWNlICpzcGluYW5kLAo+ICsJCQkJIHN0cnVj dCBuYW5kX29uZmlfcGFyYW1zICpwKTsKClBsZWFzZSBkbyB0aGlzIGluIGEgc2VwYXJhdGUgcGF0 Y2guCgo+ICB9Owo+ICAKPiAgLyoqCgpUaGFua3MsCk1pcXXDqGwKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eCBNVEQgZGlzY3Vzc2lv biBtYWlsaW5nIGxpc3QKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5m by9saW51eC1tdGQvCg== 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 X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_SANE_2 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 88916C32751 for ; Wed, 7 Aug 2019 09:49:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 59350222FC for ; Wed, 7 Aug 2019 09:49:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729133AbfHGJtB convert rfc822-to-8bit (ORCPT ); Wed, 7 Aug 2019 05:49:01 -0400 Received: from relay1-d.mail.gandi.net ([217.70.183.193]:34109 "EHLO relay1-d.mail.gandi.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727842AbfHGJtA (ORCPT ); Wed, 7 Aug 2019 05:49:00 -0400 X-Originating-IP: 86.250.200.211 Received: from xps13 (lfbn-1-17395-211.w86-250.abo.wanadoo.fr [86.250.200.211]) (Authenticated sender: miquel.raynal@bootlin.com) by relay1-d.mail.gandi.net (Postfix) with ESMTPSA id A879D24000B; Wed, 7 Aug 2019 09:48:56 +0000 (UTC) Date: Wed, 7 Aug 2019 11:48:55 +0200 From: Miquel Raynal To: shiva.linuxworks@gmail.com Cc: Richard Weinberger , David Woodhouse , Brian Norris , Marek Vasut , Vignesh Raghavendra , Boris Brezillon , Marcel Ziswiler , Frieder Schrempf , Shivamurthy Shastri , linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org, Jeff Kletsky , Chuanhong Guo , liaoweixiong Subject: Re: [PATCH 4/8] mtd: spinand: enabled parameter page support Message-ID: <20190807114855.35f26229@xps13> In-Reply-To: <20190722055621.23526-5-sshivamurthy@micron.com> References: <20190722055621.23526-1-sshivamurthy@micron.com> <20190722055621.23526-5-sshivamurthy@micron.com> Organization: Bootlin X-Mailer: Claws Mail 3.17.3 (GTK+ 2.24.32; x86_64-pc-linux-gnu) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8BIT Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Shiva, shiva.linuxworks@gmail.com wrote on Mon, 22 Jul 2019 07:56:17 +0200: "mtd: spinand: enable parameter page support" > From: Shivamurthy Shastri > > Some of the SPI NAND devices has parameter page, which is similar to - have a > ONFI table. regular raw NAND ONFI tables. > > But, it may not be self sufficient to propagate all the required As it may not be > parameters. Fixup function has been added in struct manufacturer to , a fixup is being added in the manufacturer structure > accommodate this. The fixup function sentence should be dropped from the commit message, see below. > > Signed-off-by: Shivamurthy Shastri > --- > drivers/mtd/nand/spi/core.c | 134 ++++++++++++++++++++++++++++++++++++ > include/linux/mtd/spinand.h | 3 + > 2 files changed, 137 insertions(+) > > diff --git a/drivers/mtd/nand/spi/core.c b/drivers/mtd/nand/spi/core.c > index 89f6beefb01c..7ae76dab9141 100644 > --- a/drivers/mtd/nand/spi/core.c > +++ b/drivers/mtd/nand/spi/core.c > @@ -400,6 +400,131 @@ static int spinand_lock_block(struct spinand_device *spinand, u8 lock) > return spinand_write_reg_op(spinand, REG_BLOCK_LOCK, lock); > } > > +/** > + * spinand_read_param_page_op - Read parameter page operation Again, the name in the doc does not fit the function you describe > + * @spinand: the spinand SPI-NAND chip Shiva, there are way too much typos and shortcuts in your series. Please be more careful otherwise we can't focus on the technical aspects. I am not a native English speaker at all but please, plain English is not C code. We talk SPI-NAND and not spinand, we say structure and not struct, acronyms are uppercase, etc. > + * @page: page number where parameter page tables can be found ^ the > + * @buf: buffer used to store the parameter page > + * @len: length of the buffer > + * > + * Read parameter page the > + * > + * Returns 0 on success, a negative error code otherwise. > + */ > +static int spinand_parameter_page_read(struct spinand_device *spinand, > + u8 page, void *buf, unsigned int len) > +{ > + struct spi_mem_op pread_op = SPINAND_PAGE_READ_OP(page); > + struct spi_mem_op pread_cache_op = > + SPINAND_PAGE_READ_FROM_CACHE_OP(false, > + 0, > + 1, > + buf, > + len); That's ok if you cross the 80 characters boundary here. You may put "0, 1," on the first line and "buf, len);" on the second. > + u8 feature; > + u8 status; > + int ret; > + > + if (len && !buf) > + return -EINVAL; > + > + ret = spinand_read_reg_op(spinand, REG_CFG, > + &feature); > + if (ret) > + return ret; > + > + /* CFG_OTP_ENABLE is used to enable parameter page access */ > + feature |= CFG_OTP_ENABLE; > + > + spinand_write_reg_op(spinand, REG_CFG, feature); > + > + ret = spi_mem_exec_op(spinand->spimem, &pread_op); > + if (ret) > + return ret; > + > + ret = spinand_wait(spinand, &status); > + if (ret < 0) > + return ret; > + > + ret = spi_mem_exec_op(spinand->spimem, &pread_cache_op); > + if (ret) > + return ret; > + > + ret = spinand_read_reg_op(spinand, REG_CFG, > + &feature); > + if (ret) > + return ret; > + > + feature &= ~CFG_OTP_ENABLE; > + > + spinand_write_reg_op(spinand, REG_CFG, feature); > + > + return 0; > +} > + Add the kernel doc please Change the below function so that it returns 1 if the page was detected, 0 if it did not, an negative error code otherwise. > +static int spinand_param_page_detect(struct spinand_device *spinand) > +{ > + struct mtd_info *mtd = spinand_to_mtd(spinand); > + struct nand_memory_organization *memorg; > + struct nand_onfi_params *p; > + struct nand_device *base = spinand_to_nand(spinand); > + int i, ret; > + > + memorg = nanddev_get_memorg(base); > + > + /* Allocate buffer to hold parameter page */ > + p = kzalloc((sizeof(*p) * 3), GFP_KERNEL); > + if (!p) > + return -ENOMEM; > + > + ret = spinand_parameter_page_read(spinand, 0x01, p, sizeof(*p) * 3); > + if (ret) { > + ret = 0; No, you should return the error in case of error. You will later handle the fact that there is no parameter page. > + goto free_param_page; > + } > + > + for (i = 0; i < 3; i++) { > + if (onfi_crc16(ONFI_CRC_BASE, (u8 *)&p[i], 254) == ^ If you force the parameter page to be 254 bytes long it means you limit yourself to ONFI standard. That's not a problem, but then you should mention it in the function name. > + le16_to_cpu(p->crc)) { > + if (i) > + memcpy(p, &p[i], sizeof(*p)); > + break; > + } > + } > + > + if (i == 3) { > + const void *srcbufs[3] = {p, p + 1, p + 2}; > + > + pr_warn("Could not find a valid ONFI parameter page, trying bit-wise majority to recover it\n"); > + nand_bit_wise_majority(srcbufs, ARRAY_SIZE(srcbufs), p, > + sizeof(*p)); > + > + if (onfi_crc16(ONFI_CRC_BASE, (u8 *)p, 254) != > + le16_to_cpu(p->crc)) { > + pr_err("ONFI parameter recovery failed, aborting\n"); > + goto free_param_page; > + } > + } The whole for-loop and the if (i==3) condition is exactly the same as for raw NANDs and must be extracted in a generic function: 1/ extract the function from nand/raw/nand_onfi.c and put it in nand/onfi.c. 2/ then use it in this patch. > + > + parse_onfi_params(memorg, p); > + > + mtd->writesize = memorg->pagesize; > + mtd->erasesize = memorg->pages_per_eraseblock * memorg->pagesize; > + mtd->oobsize = memorg->oobsize; This will be handled by nanddev_init, should be removed. > + > + /* Manufacturers may interpret the parameter page differently */ > + if (spinand->manufacturer->ops->fixup_param_page) > + spinand->manufacturer->ops->fixup_param_page(spinand, p); The whole "manufacturer fixup" should be done separately. > + > + /* Identification done, free the full parameter page and exit */ > + ret = 1; > + > +free_param_page: > + kfree(p); > + > + return ret; > +} > + > static int spinand_check_ecc_status(struct spinand_device *spinand, u8 status) > { > struct nand_device *nand = spinand_to_nand(spinand); > @@ -911,6 +1036,15 @@ static int spinand_detect(struct spinand_device *spinand) > return ret; > } > > + if (!spinand->base.memorg.pagesize) { > + ret = spinand_param_page_detect(spinand); > + if (ret <= 0) { > + dev_err(dev, "no parameter page for %*phN\n", Not sure at this stage dev will give something meaningful. Anyway I don't think we should scream at the user if his NAND is not an ONFI one so please return an error only if ret < 0. If ret == 0 or ret == 1, don't warn the user. > + SPINAND_MAX_ID_LEN, spinand->id.data); > + return -ENODEV; > + } > + } > + > if (nand->memorg.ntargets > 1 && !spinand->select_target) { > dev_err(dev, > "SPI NANDs with more than one die must implement ->select_target()\n"); > diff --git a/include/linux/mtd/spinand.h b/include/linux/mtd/spinand.h > index 4ea558bd3c46..fea820a20bc9 100644 > --- a/include/linux/mtd/spinand.h > +++ b/include/linux/mtd/spinand.h > @@ -15,6 +15,7 @@ > #include > #include > #include > +#include > > /** > * Standard SPI NAND flash operations > @@ -209,6 +210,8 @@ struct spinand_manufacturer_ops { > int (*detect)(struct spinand_device *spinand); > int (*init)(struct spinand_device *spinand); > void (*cleanup)(struct spinand_device *spinand); > + void (*fixup_param_page)(struct spinand_device *spinand, > + struct nand_onfi_params *p); Please do this in a separate patch. > }; > > /** Thanks, Miquèl