From mboxrd@z Thu Jan 1 00:00:00 1970 From: Eugeniy Paltsev To: "linux-mtd@lists.infradead.org" CC: "linux-kernel@vger.kernel.org" , "linux-snps-arc@lists.infradead.org" , Alexey Brodkin , "boris.brezillon@bootlin.com" , Vineet Gupta , "dwmw2@infradead.org" , "computersforpeace@gmail.com" , "marek.vasut@gmail.com" , "richard@nod.at" Subject: Re: [PATCH v2 1/2] mtd: spi-nor: Add support of sst26wf* flash ICs protection ops Date: Mon, 15 Oct 2018 14:21:18 +0000 Message-ID: <1539613276.4199.9.camel@synopsys.com> References: <20180910114628.19156-1-Eugeniy.Paltsev@synopsys.com> <20180910114628.19156-2-Eugeniy.Paltsev@synopsys.com> In-Reply-To: <20180910114628.19156-2-Eugeniy.Paltsev@synopsys.com> Content-Language: en-US Content-Type: text/plain; charset="utf-8" Content-ID: <7EE5D155E9B4ED44BE31EB3F3303CC6F@internal.synopsys.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , SGkhDQoNCk1heWJlIHlvdSBoYXZlIGFueSBjb21tZW50cyBvciByZW1hcmtzIGFib3V0IHRoaXMg cGF0Y2g/DQpBbmQgaWYgeW91IGRvbid0IGNvdWxkIHlvdSBwbGVhc2UgYXBwbHkgaXQuIFRoYW5r cyENCg0KT24gTW9uLCAyMDE4LTA5LTEwIGF0IDE0OjQ2ICswMzAwLCBFdWdlbml5IFBhbHRzZXYg d3JvdGU6DQo+IHNzdDI2d2YgZmxhc2ggc2VyaWVzIGJsb2NrIHByb3RlY3Rpb24gaW1wbGVtZW50 YXRpb24gZGlmZmVycw0KPiBmcm9tIG90aGVyIFNTVCBzZXJpZXMsIHNvIGFkZCBzcGVjaWZpYyBp bXBsZW1lbnRhdGlvbg0KPiBmbGFzaF9sb2NrL2ZsYXNoX3VubG9jay9mbGFzaF9pc19sb2NrZWQg ZnVuY3Rpb25zIGZvciBzc3QyNndmDQo+IGZsYXNoIElDcy4NCj4gDQo+IE5PVEU6DQo+IHRoaXMg cGF0Y2ggaXMgYmFzaWNhbGx5IGZvbGxvd2luZyBtaW5lIHUtYm9vdCBjb21taXQgcG9ydDoNCj4g aHR0cDovL2dpdC5kZW54LmRlLz9wPXUtYm9vdC5naXQ7YT1jb21taXRkaWZmO2g9M2Q0ZmVkODdh NWZhM2ZmZWRmNjRmZjI4MTFjZDk1YzVhYzQ1MDNhYw0KPiANCj4gU2lnbmVkLW9mZi1ieTogRXVn ZW5peSBQYWx0c2V2IDxFdWdlbml5LlBhbHRzZXZAc3lub3BzeXMuY29tPg0KPiAtLS0NCj4gQ2hh bmdlcyB2MS0+djI6DQo+ICAqIENoZWNrIHJldHVybiB2YWx1ZSBvZiB7cmVhZCB8IHdyaXRlfV9y ZWcgY2FsbGJhY2tzLg0KPiANCj4gIGRyaXZlcnMvbXRkL3NwaS1ub3Ivc3BpLW5vci5jIHwgMTc3 ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKw0KPiAgaW5jbHVkZS9s aW51eC9tdGQvc3BpLW5vci5oICAgfCAgIDQgKw0KPiAgMiBmaWxlcyBjaGFuZ2VkLCAxODEgaW5z ZXJ0aW9ucygrKQ0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL3NwaS1ub3Ivc3BpLW5v ci5jIGIvZHJpdmVycy9tdGQvc3BpLW5vci9zcGktbm9yLmMNCj4gaW5kZXggZDljMzY4YzQ0MTk0 Li5kMGU3Yzg1YjYwMDIgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvbXRkL3NwaS1ub3Ivc3BpLW5v ci5jDQo+ICsrKyBiL2RyaXZlcnMvbXRkL3NwaS1ub3Ivc3BpLW5vci5jDQo+IEBAIC01OTgsNiAr NTk4LDE3NyBAQCBzdGF0aWMgaW50IHdyaXRlX3NyX2FuZF9jaGVjayhzdHJ1Y3Qgc3BpX25vciAq bm9yLCB1OCBzdGF0dXNfbmV3LCB1OCBtYXNrKQ0KPiAgCXJldHVybiAoKHJldCAmIG1hc2spICE9 IChzdGF0dXNfbmV3ICYgbWFzaykpID8gLUVJTyA6IDA7DQo+ICB9DQo+ICANCj4gKy8qDQo+ICsg KiBzc3QyNndmMDE2L3NzdDI2d2YwMzIvc3N0MjZ3ZjA2NCBoYXZlIG5leHQgYmxvY2sgcHJvdGVj dGlvbjoNCj4gKyAqIDR4ICAgLSA4ICBLQnl0ZSBibG9ja3MgLSByZWFkICYgd3JpdGUgcHJvdGVj dGlvbiBiaXRzIC0gdXBwZXIgYWRkcmVzc2VzDQo+ICsgKiAxeCAgIC0gMzIgS0J5dGUgYmxvY2tz IC0gd3JpdGUgcHJvdGVjdGlvbiBiaXRzDQo+ICsgKiByZXN0IC0gNjQgS0J5dGUgYmxvY2tzIC0g d3JpdGUgcHJvdGVjdGlvbiBiaXRzDQo+ICsgKiAxeCAgIC0gMzIgS0J5dGUgYmxvY2tzIC0gd3Jp dGUgcHJvdGVjdGlvbiBiaXRzDQo+ICsgKiA0eCAgIC0gOCAgS0J5dGUgYmxvY2tzIC0gcmVhZCAm IHdyaXRlIHByb3RlY3Rpb24gYml0cyAtIGxvd2VyIGFkZHJlc3Nlcw0KPiArICoNCj4gKyAqIFdl J2xsIHN1cHBvcnQgb25seSBwZXIgNjRrIGxvY2svdW5sb2NrIHNvIGxvd2VyIGFuZCB1cHBlciA2 NCBLQnl0ZSByZWdpb24NCj4gKyAqIHdpbGwgYmUgdHJlYXRlZCBhcyBzaW5nbGUgYmxvY2suDQo+ ICsgKi8NCj4gKyNkZWZpbmUgU1NUMjZfQlBSXzhLX05VTQkJNA0KPiArI2RlZmluZSBTU1QyNl9N QVhfQlBSX1JFR19MRU4JCSgxOCArIDEpDQo+ICsjZGVmaW5lIFNTVDI2X0JPVU5EX1JFR19TSVpF CQkoKDMyICsgU1NUMjZfQlBSXzhLX05VTSAqIDgpICogU1pfMUspDQo+ICsNCj4gK2VudW0gbG9j a19jdGwgew0KPiArCVNTVDI2X0NUTF9MT0NLLA0KPiArCVNTVDI2X0NUTF9VTkxPQ0ssDQo+ICsJ U1NUMjZfQ1RMX0NIRUNLDQo+ICt9Ow0KPiArDQo+ICtzdGF0aWMgYm9vbCBzc3QyNl9wcm9jZXNz X2Jwcih1MzIgYnByX3NpemUsIHU4ICpjbWQsIHUzMiBiaXQsIGVudW0gbG9ja19jdGwgY3RsKQ0K PiArew0KPiArCXN3aXRjaCAoY3RsKSB7DQo+ICsJY2FzZSBTU1QyNl9DVExfTE9DSzoNCj4gKwkJ Y21kW2Jwcl9zaXplIC0gKGJpdCAvIDgpIC0gMV0gfD0gQklUKGJpdCAlIDgpOw0KPiArCQlicmVh azsNCj4gKwljYXNlIFNTVDI2X0NUTF9VTkxPQ0s6DQo+ICsJCWNtZFticHJfc2l6ZSAtIChiaXQg LyA4KSAtIDFdICY9IH5CSVQoYml0ICUgOCk7DQo+ICsJCWJyZWFrOw0KPiArCWNhc2UgU1NUMjZf Q1RMX0NIRUNLOg0KPiArCQlyZXR1cm4gISEoY21kW2Jwcl9zaXplIC0gKGJpdCAvIDgpIC0gMV0g JiBCSVQoYml0ICUgOCkpOw0KPiArCX0NCj4gKw0KPiArCXJldHVybiBmYWxzZTsNCj4gK30NCj4g Kw0KPiArLyoNCj4gKyAqIExvY2ssIHVubG9jayBvciBjaGVjayBsb2NrIHN0YXR1cyBvZiB0aGUg Zmxhc2ggcmVnaW9uIG9mIHRoZSBmbGFzaCAoZGVwZW5kaW5nDQo+ICsgKiBvbiB0aGUgbG9ja19j dGwgdmFsdWUpDQo+ICsgKi8NCj4gK3N0YXRpYyBpbnQgc3N0MjZfbG9ja19jdGwoc3RydWN0IHNw aV9ub3IgKm5vciwgbG9mZl90IG9mcywgdWludDY0X3QgbGVuLCBlbnVtIGxvY2tfY3RsIGN0bCkN Cj4gK3sNCj4gKwlzdHJ1Y3QgbXRkX2luZm8gKm10ZCA9ICZub3ItPm10ZDsNCj4gKwl1MzIgaSwg YnByX3B0ciwgcnB0cl82NGssIGxwdHJfNjRrLCBicHJfc2l6ZTsNCj4gKwlib29sIGxvd2VyXzY0 ayA9IGZhbHNlLCB1cHBlcl82NGsgPSBmYWxzZTsNCj4gKwl1OCBicHJfYnVmZltTU1QyNl9NQVhf QlBSX1JFR19MRU5dID0ge307DQo+ICsJaW50IHJldDsNCj4gKw0KPiArCS8qIENoZWNrIGxlbmd0 aCBhbmQgb2Zmc2V0IGZvciA2NGsgYWxpZ25tZW50ICovDQo+ICsJaWYgKChvZnMgJiAoU1pfNjRL IC0gMSkpIHx8IChsZW4gJiAoU1pfNjRLIC0gMSkpKSB7DQo+ICsJCWRldl9lcnIobm9yLT5kZXYs ICJsZW5ndGggb3Igb2Zmc2V0IGlzIG5vdCA2NEtpQiBhbGxpZ2huZWRcbiIpOw0KPiArCQlyZXR1 cm4gLUVJTlZBTDsNCj4gKwl9DQo+ICsNCj4gKwlpZiAob2ZzICsgbGVuID4gbXRkLT5zaXplKSB7 DQo+ICsJCWRldl9lcnIobm9yLT5kZXYsICJyYW5nZSBpcyBtb3JlIHRoYW4gZGV2aWNlIHNpemU6 ICUjbGx4ICsgJSNsbHggPiAlI2xseFxuIiwNCj4gKwkJCW9mcywgbGVuLCBtdGQtPnNpemUpOw0K PiArCQlyZXR1cm4gLUVJTlZBTDsNCj4gKwl9DQo+ICsNCj4gKwkvKiBTU1QyNiBmYW1pbHkgaGFz IG9ubHkgMTYgTWJpdCwgMzIgTWJpdCBhbmQgNjQgTWJpdCBJQyAqLw0KPiArCWlmIChtdGQtPnNp emUgIT0gU1pfMk0gJiYNCj4gKwkgICAgbXRkLT5zaXplICE9IFNaXzRNICYmDQo+ICsJICAgIG10 ZC0+c2l6ZSAhPSBTWl84TSkNCj4gKwkJcmV0dXJuIC1FSU5WQUw7DQo+ICsNCj4gKwlicHJfc2l6 ZSA9IDIgKyAobXRkLT5zaXplIC8gU1pfNjRLIC8gOCk7DQo+ICsNCj4gKwlyZXQgPSBub3ItPnJl YWRfcmVnKG5vciwgU1BJTk9SX09QX1JFQURfQlBSLCBicHJfYnVmZiwgYnByX3NpemUpOw0KPiAr CWlmIChyZXQgPCAwKSB7DQo+ICsJCWRldl9lcnIobm9yLT5kZXYsICJmYWlsIHRvIHJlYWQgYmxv Y2stcHJvdGVjdGlvbiByZWdpc3RlclxuIik7DQo+ICsJCXJldHVybiByZXQ7DQo+ICsJfQ0KPiAr DQo+ICsJcnB0cl82NGsgPSBtaW5fdCh1MzIsIG9mcyArIGxlbiwgbXRkLT5zaXplIC0gU1NUMjZf Qk9VTkRfUkVHX1NJWkUpOw0KPiArCWxwdHJfNjRrID0gbWF4X3QodTMyLCBvZnMsIFNTVDI2X0JP VU5EX1JFR19TSVpFKTsNCj4gKw0KPiArCXVwcGVyXzY0ayA9ICgob2ZzICsgbGVuKSA+IChtdGQt PnNpemUgLSBTU1QyNl9CT1VORF9SRUdfU0laRSkpOw0KPiArCWxvd2VyXzY0ayA9IChvZnMgPCBT U1QyNl9CT1VORF9SRUdfU0laRSk7DQo+ICsNCj4gKwkvKiBMb3dlciBiaXRzIGluIGJsb2NrLXBy b3RlY3Rpb24gcmVnaXN0ZXIgYXJlIGFib3V0IDY0ayByZWdpb24gKi8NCj4gKwlicHJfcHRyID0g bHB0cl82NGsgLyBTWl82NEsgLSAxOw0KPiArDQo+ICsJLyogUHJvY2VzcyA2NEsgYmxvY2tzIHJl Z2lvbiAqLw0KPiArCXdoaWxlIChscHRyXzY0ayA8IHJwdHJfNjRrKSB7DQo+ICsJCWlmIChzc3Qy Nl9wcm9jZXNzX2JwcihicHJfc2l6ZSwgYnByX2J1ZmYsIGJwcl9wdHIsIGN0bCkpDQo+ICsJCQly ZXR1cm4gRUFDQ0VTOw0KPiArDQo+ICsJCWJwcl9wdHIrKzsNCj4gKwkJbHB0cl82NGsgKz0gU1pf NjRLOw0KPiArCX0NCj4gKw0KPiArCS8qIDMySyBhbmQgOEsgcmVnaW9uIGJpdHMgaW4gQlBSIGFy ZSBhZnRlciA2NGsgcmVnaW9uIGJpdHMgKi8NCj4gKwlicHJfcHRyID0gKG10ZC0+c2l6ZSAtIDIg KiBTU1QyNl9CT1VORF9SRUdfU0laRSkgLyBTWl82NEs7DQo+ICsNCj4gKwkvKiBQcm9jZXNzIGxv d2VyIDMySyBibG9jayByZWdpb24gKi8NCj4gKwlpZiAobG93ZXJfNjRrKQ0KPiArCQlpZiAoc3N0 MjZfcHJvY2Vzc19icHIoYnByX3NpemUsIGJwcl9idWZmLCBicHJfcHRyLCBjdGwpKQ0KPiArCQkJ cmV0dXJuIEVBQ0NFUzsNCj4gKw0KPiArCWJwcl9wdHIrKzsNCj4gKw0KPiArCS8qIFByb2Nlc3Mg dXBwZXIgMzJLIGJsb2NrIHJlZ2lvbiAqLw0KPiArCWlmICh1cHBlcl82NGspDQo+ICsJCWlmIChz c3QyNl9wcm9jZXNzX2JwcihicHJfc2l6ZSwgYnByX2J1ZmYsIGJwcl9wdHIsIGN0bCkpDQo+ICsJ CQlyZXR1cm4gRUFDQ0VTOw0KPiArDQo+ICsJYnByX3B0cisrOw0KPiArDQo+ICsJLyogUHJvY2Vz cyBsb3dlciA4SyBibG9jayByZWdpb25zICovDQo+ICsJZm9yIChpID0gMDsgaSA8IFNTVDI2X0JQ Ul84S19OVU07IGkrKykgew0KPiArCQlpZiAobG93ZXJfNjRrKQ0KPiArCQkJaWYgKHNzdDI2X3By b2Nlc3NfYnByKGJwcl9zaXplLCBicHJfYnVmZiwgYnByX3B0ciwgY3RsKSkNCj4gKwkJCQlyZXR1 cm4gRUFDQ0VTOw0KPiArDQo+ICsJCS8qIEluIDhLIGFyZWEgQlBSIGhhcyBib3RoIHJlYWQgYW5k IHdyaXRlIHByb3RlY3Rpb24gYml0cyAqLw0KPiArCQlicHJfcHRyICs9IDI7DQo+ICsJfQ0KPiAr DQo+ICsJLyogUHJvY2VzcyB1cHBlciA4SyBibG9jayByZWdpb25zICovDQo+ICsJZm9yIChpID0g MDsgaSA8IFNTVDI2X0JQUl84S19OVU07IGkrKykgew0KPiArCQlpZiAodXBwZXJfNjRrKQ0KPiAr CQkJaWYgKHNzdDI2X3Byb2Nlc3NfYnByKGJwcl9zaXplLCBicHJfYnVmZiwgYnByX3B0ciwgY3Rs KSkNCj4gKwkJCQlyZXR1cm4gRUFDQ0VTOw0KPiArDQo+ICsJCS8qIEluIDhLIGFyZWEgQlBSIGhh cyBib3RoIHJlYWQgYW5kIHdyaXRlIHByb3RlY3Rpb24gYml0cyAqLw0KPiArCQlicHJfcHRyICs9 IDI7DQo+ICsJfQ0KPiArDQo+ICsJLyogSWYgd2UgY2hlY2sgcmVnaW9uIHN0YXR1cyB3ZSBkb24n dCBuZWVkIHRvIHdyaXRlIEJQUiBiYWNrICovDQo+ICsJaWYgKGN0bCA9PSBTU1QyNl9DVExfQ0hF Q0spDQo+ICsJCXJldHVybiAwOw0KPiArDQo+ICsJcmV0ID0gbm9yLT53cml0ZV9yZWcobm9yLCBT UElOT1JfT1BfV1JJVEVfQlBSLCBicHJfYnVmZiwgYnByX3NpemUpOw0KPiArCWlmIChyZXQgPCAw KSB7DQo+ICsJCWRldl9lcnIobm9yLT5kZXYsICJmYWlsIHRvIHdyaXRlIGJsb2NrLXByb3RlY3Rp b24gcmVnaXN0ZXJcbiIpOw0KPiArCQlyZXR1cm4gcmV0Ow0KPiArCX0NCj4gKw0KPiArCXJldHVy biAwOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgaW50IHNzdDI2X3VubG9jayhzdHJ1Y3Qgc3BpX25v ciAqbm9yLCBsb2ZmX3Qgb2ZzLCB1aW50NjRfdCBsZW4pDQo+ICt7DQo+ICsJcmV0dXJuIHNzdDI2 X2xvY2tfY3RsKG5vciwgb2ZzLCBsZW4sIFNTVDI2X0NUTF9VTkxPQ0spOw0KPiArfQ0KPiArDQo+ ICtzdGF0aWMgaW50IHNzdDI2X2xvY2soc3RydWN0IHNwaV9ub3IgKm5vciwgbG9mZl90IG9mcywg dWludDY0X3QgbGVuKQ0KPiArew0KPiArCXJldHVybiBzc3QyNl9sb2NrX2N0bChub3IsIG9mcywg bGVuLCBTU1QyNl9DVExfTE9DSyk7DQo+ICt9DQo+ICsNCj4gKy8qDQo+ICsgKiBSZXR1cm5zIEVB Q0NFUyAocG9zaXRpdmUgdmFsdWUpIGlmIHJlZ2lvbiBpcyBsb2NrZWQsIDAgaWYgcmVnaW9uIGlz IHVubG9ja2VkLA0KPiArICogYW5kIG5lZ2F0aXZlIG9uIGVycm9ycy4NCj4gKyAqLw0KPiArc3Rh dGljIGludCBzc3QyNl9pc19sb2NrZWQoc3RydWN0IHNwaV9ub3IgKm5vciwgbG9mZl90IG9mcywg dWludDY0X3QgbGVuKQ0KPiArew0KPiArCS8qDQo+ICsJICogaXNfbG9ja2VkIGZ1bmN0aW9uIGlz IHVzZWQgZm9yIGNoZWNrIGJlZm9yZSByZWFkaW5nIG9yIGVyYXNpbmcgZmxhc2gNCj4gKwkgKiBy ZWdpb24sIHNvIG9mZnNldCBhbmQgbGVuZ3RoIG1pZ2h0IGJlIG5vdCA2NGsgYWxsaWdobmVkLCBz byBhZGp1c3QNCj4gKwkgKiB0aGVtIHRvIGJlIDY0ayBhbGxpZ2huZWQgYXMgc3N0MjZfbG9ja19j dGwgd29ya3Mgb25seSB3aXRoIDY0aw0KPiArCSAqIGFsbGlnaG5lZCByZWdpb25zLg0KPiArCSAq Lw0KPiArCW9mcyAtPSBvZnMgJiAoU1pfNjRLIC0gMSk7DQo+ICsJbGVuID0gbGVuICYgKFNaXzY0 SyAtIDEpID8gKGxlbiAmIH4oU1pfNjRLIC0gMSkpICsgU1pfNjRLIDogbGVuOw0KPiArDQo+ICsJ cmV0dXJuIHNzdDI2X2xvY2tfY3RsKG5vciwgb2ZzLCBsZW4sIFNTVDI2X0NUTF9DSEVDSyk7DQo+ ICt9DQo+ICsNCj4gIHN0YXRpYyB2b2lkIHN0bV9nZXRfbG9ja2VkX3JhbmdlKHN0cnVjdCBzcGlf bm9yICpub3IsIHU4IHNyLCBsb2ZmX3QgKm9mcywNCj4gIAkJCQkgdWludDY0X3QgKmxlbikNCj4g IHsNCj4gQEAgLTI4NzIsNiArMzA0MywxMiBAQCBpbnQgc3BpX25vcl9zY2FuKHN0cnVjdCBzcGlf bm9yICpub3IsIGNvbnN0IGNoYXIgKm5hbWUsDQo+ICAJCW5vci0+Zmxhc2hfaXNfbG9ja2VkID0g c3RtX2lzX2xvY2tlZDsNCj4gIAl9DQo+ICANCj4gKwlpZiAoSkVERUNfTUZSKGluZm8pID09IFNO T1JfTUZSX1NTVCAmJiBpbmZvLT5pZFsxXSA9PSAweDI2KSB7DQo+ICsJCW5vci0+Zmxhc2hfbG9j ayA9IHNzdDI2X2xvY2s7DQo+ICsJCW5vci0+Zmxhc2hfdW5sb2NrID0gc3N0MjZfdW5sb2NrOw0K PiArCQlub3ItPmZsYXNoX2lzX2xvY2tlZCA9IHNzdDI2X2lzX2xvY2tlZDsNCj4gKwl9DQo+ICsN Cj4gIAlpZiAobm9yLT5mbGFzaF9sb2NrICYmIG5vci0+Zmxhc2hfdW5sb2NrICYmIG5vci0+Zmxh c2hfaXNfbG9ja2VkKSB7DQo+ICAJCW10ZC0+X2xvY2sgPSBzcGlfbm9yX2xvY2s7DQo+ICAJCW10 ZC0+X3VubG9jayA9IHNwaV9ub3JfdW5sb2NrOw0KPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9tdGQvc3BpLW5vci5oIGIvaW5jbHVkZS9saW51eC9tdGQvc3BpLW5vci5oDQo+IGluZGV4IGU2 MGRhMGQzNGNjMS4uMjQ2MDE0YTczZjgzIDEwMDY0NA0KPiAtLS0gYS9pbmNsdWRlL2xpbnV4L210 ZC9zcGktbm9yLmgNCj4gKysrIGIvaW5jbHVkZS9saW51eC9tdGQvc3BpLW5vci5oDQo+IEBAIC05 Myw2ICs5MywxMCBAQA0KPiAgI2RlZmluZSBTUElOT1JfT1BfV1JESQkJMHgwNAkvKiBXcml0ZSBk aXNhYmxlICovDQo+ICAjZGVmaW5lIFNQSU5PUl9PUF9BQUlfV1AJMHhhZAkvKiBBdXRvIGFkZHJl c3MgaW5jcmVtZW50IHdvcmQgcHJvZ3JhbSAqLw0KPiAgDQo+ICsvKiBVc2VkIGZvciBTU1QyNiog Zmxhc2hlcyBvbmx5LiAqLw0KPiArI2RlZmluZSBTUElOT1JfT1BfUkVBRF9CUFIJMHg3MgkvKiBS ZWFkIGJsb2NrIHByb3RlY3Rpb24gcmVnaXN0ZXIgKi8NCj4gKyNkZWZpbmUgU1BJTk9SX09QX1dS SVRFX0JQUgkweDQyCS8qIFdyaXRlIGJsb2NrIHByb3RlY3Rpb24gcmVnaXN0ZXIgKi8NCj4gKw0K PiAgLyogVXNlZCBmb3IgUzNBTiBmbGFzaGVzIG9ubHkgKi8NCj4gICNkZWZpbmUgU1BJTk9SX09Q X1hTRQkJMHg1MAkvKiBTZWN0b3IgZXJhc2UgKi8NCj4gICNkZWZpbmUgU1BJTk9SX09QX1hQUAkJ MHg4MgkvKiBQYWdlIHByb2dyYW0gKi8NCi0tIA0KIEV1Z2VuaXkgUGFsdHNldg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: eugeniy.paltsev@synopsys.com (Eugeniy Paltsev) Date: Mon, 15 Oct 2018 14:21:18 +0000 Subject: [PATCH v2 1/2] mtd: spi-nor: Add support of sst26wf* flash ICs protection ops In-Reply-To: <20180910114628.19156-2-Eugeniy.Paltsev@synopsys.com> References: <20180910114628.19156-1-Eugeniy.Paltsev@synopsys.com> <20180910114628.19156-2-Eugeniy.Paltsev@synopsys.com> List-ID: Message-ID: <1539613276.4199.9.camel@synopsys.com> To: linux-snps-arc@lists.infradead.org Hi! Maybe you have any comments or remarks about this patch? And if you don't could you please apply it. Thanks! On Mon, 2018-09-10@14:46 +0300, Eugeniy Paltsev wrote: > sst26wf flash series block protection implementation differs > from other SST series, so add specific implementation > flash_lock/flash_unlock/flash_is_locked functions for sst26wf > flash ICs. > > NOTE: > this patch is basically following mine u-boot commit port: > http://git.denx.de/?p=u-boot.git;a=commitdiff;h=3d4fed87a5fa3ffedf64ff2811cd95c5ac4503ac > > Signed-off-by: Eugeniy Paltsev > --- > Changes v1->v2: > * Check return value of {read | write}_reg callbacks. > > drivers/mtd/spi-nor/spi-nor.c | 177 ++++++++++++++++++++++++++++++++++++++++++ > include/linux/mtd/spi-nor.h | 4 + > 2 files changed, 181 insertions(+) > > diff --git a/drivers/mtd/spi-nor/spi-nor.c b/drivers/mtd/spi-nor/spi-nor.c > index d9c368c44194..d0e7c85b6002 100644 > --- a/drivers/mtd/spi-nor/spi-nor.c > +++ b/drivers/mtd/spi-nor/spi-nor.c > @@ -598,6 +598,177 @@ static int write_sr_and_check(struct spi_nor *nor, u8 status_new, u8 mask) > return ((ret & mask) != (status_new & mask)) ? -EIO : 0; > } > > +/* > + * sst26wf016/sst26wf032/sst26wf064 have next block protection: > + * 4x - 8 KByte blocks - read & write protection bits - upper addresses > + * 1x - 32 KByte blocks - write protection bits > + * rest - 64 KByte blocks - write protection bits > + * 1x - 32 KByte blocks - write protection bits > + * 4x - 8 KByte blocks - read & write protection bits - lower addresses > + * > + * We'll support only per 64k lock/unlock so lower and upper 64 KByte region > + * will be treated as single block. > + */ > +#define SST26_BPR_8K_NUM 4 > +#define SST26_MAX_BPR_REG_LEN (18 + 1) > +#define SST26_BOUND_REG_SIZE ((32 + SST26_BPR_8K_NUM * 8) * SZ_1K) > + > +enum lock_ctl { > + SST26_CTL_LOCK, > + SST26_CTL_UNLOCK, > + SST26_CTL_CHECK > +}; > + > +static bool sst26_process_bpr(u32 bpr_size, u8 *cmd, u32 bit, enum lock_ctl ctl) > +{ > + switch (ctl) { > + case SST26_CTL_LOCK: > + cmd[bpr_size - (bit / 8) - 1] |= BIT(bit % 8); > + break; > + case SST26_CTL_UNLOCK: > + cmd[bpr_size - (bit / 8) - 1] &= ~BIT(bit % 8); > + break; > + case SST26_CTL_CHECK: > + return !!(cmd[bpr_size - (bit / 8) - 1] & BIT(bit % 8)); > + } > + > + return false; > +} > + > +/* > + * Lock, unlock or check lock status of the flash region of the flash (depending > + * on the lock_ctl value) > + */ > +static int sst26_lock_ctl(struct spi_nor *nor, loff_t ofs, uint64_t len, enum lock_ctl ctl) > +{ > + struct mtd_info *mtd = &nor->mtd; > + u32 i, bpr_ptr, rptr_64k, lptr_64k, bpr_size; > + bool lower_64k = false, upper_64k = false; > + u8 bpr_buff[SST26_MAX_BPR_REG_LEN] = {}; > + int ret; > + > + /* Check length and offset for 64k alignment */ > + if ((ofs & (SZ_64K - 1)) || (len & (SZ_64K - 1))) { > + dev_err(nor->dev, "length or offset is not 64KiB allighned\n"); > + return -EINVAL; > + } > + > + if (ofs + len > mtd->size) { > + dev_err(nor->dev, "range is more than device size: %#llx + %#llx > %#llx\n", > + ofs, len, mtd->size); > + return -EINVAL; > + } > + > + /* SST26 family has only 16 Mbit, 32 Mbit and 64 Mbit IC */ > + if (mtd->size != SZ_2M && > + mtd->size != SZ_4M && > + mtd->size != SZ_8M) > + return -EINVAL; > + > + bpr_size = 2 + (mtd->size / SZ_64K / 8); > + > + ret = nor->read_reg(nor, SPINOR_OP_READ_BPR, bpr_buff, bpr_size); > + if (ret < 0) { > + dev_err(nor->dev, "fail to read block-protection register\n"); > + return ret; > + } > + > + rptr_64k = min_t(u32, ofs + len, mtd->size - SST26_BOUND_REG_SIZE); > + lptr_64k = max_t(u32, ofs, SST26_BOUND_REG_SIZE); > + > + upper_64k = ((ofs + len) > (mtd->size - SST26_BOUND_REG_SIZE)); > + lower_64k = (ofs < SST26_BOUND_REG_SIZE); > + > + /* Lower bits in block-protection register are about 64k region */ > + bpr_ptr = lptr_64k / SZ_64K - 1; > + > + /* Process 64K blocks region */ > + while (lptr_64k < rptr_64k) { > + if (sst26_process_bpr(bpr_size, bpr_buff, bpr_ptr, ctl)) > + return EACCES; > + > + bpr_ptr++; > + lptr_64k += SZ_64K; > + } > + > + /* 32K and 8K region bits in BPR are after 64k region bits */ > + bpr_ptr = (mtd->size - 2 * SST26_BOUND_REG_SIZE) / SZ_64K; > + > + /* Process lower 32K block region */ > + if (lower_64k) > + if (sst26_process_bpr(bpr_size, bpr_buff, bpr_ptr, ctl)) > + return EACCES; > + > + bpr_ptr++; > + > + /* Process upper 32K block region */ > + if (upper_64k) > + if (sst26_process_bpr(bpr_size, bpr_buff, bpr_ptr, ctl)) > + return EACCES; > + > + bpr_ptr++; > + > + /* Process lower 8K block regions */ > + for (i = 0; i < SST26_BPR_8K_NUM; i++) { > + if (lower_64k) > + if (sst26_process_bpr(bpr_size, bpr_buff, bpr_ptr, ctl)) > + return EACCES; > + > + /* In 8K area BPR has both read and write protection bits */ > + bpr_ptr += 2; > + } > + > + /* Process upper 8K block regions */ > + for (i = 0; i < SST26_BPR_8K_NUM; i++) { > + if (upper_64k) > + if (sst26_process_bpr(bpr_size, bpr_buff, bpr_ptr, ctl)) > + return EACCES; > + > + /* In 8K area BPR has both read and write protection bits */ > + bpr_ptr += 2; > + } > + > + /* If we check region status we don't need to write BPR back */ > + if (ctl == SST26_CTL_CHECK) > + return 0; > + > + ret = nor->write_reg(nor, SPINOR_OP_WRITE_BPR, bpr_buff, bpr_size); > + if (ret < 0) { > + dev_err(nor->dev, "fail to write block-protection register\n"); > + return ret; > + } > + > + return 0; > +} > + > +static int sst26_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len) > +{ > + return sst26_lock_ctl(nor, ofs, len, SST26_CTL_UNLOCK); > +} > + > +static int sst26_lock(struct spi_nor *nor, loff_t ofs, uint64_t len) > +{ > + return sst26_lock_ctl(nor, ofs, len, SST26_CTL_LOCK); > +} > + > +/* > + * Returns EACCES (positive value) if region is locked, 0 if region is unlocked, > + * and negative on errors. > + */ > +static int sst26_is_locked(struct spi_nor *nor, loff_t ofs, uint64_t len) > +{ > + /* > + * is_locked function is used for check before reading or erasing flash > + * region, so offset and length might be not 64k allighned, so adjust > + * them to be 64k allighned as sst26_lock_ctl works only with 64k > + * allighned regions. > + */ > + ofs -= ofs & (SZ_64K - 1); > + len = len & (SZ_64K - 1) ? (len & ~(SZ_64K - 1)) + SZ_64K : len; > + > + return sst26_lock_ctl(nor, ofs, len, SST26_CTL_CHECK); > +} > + > static void stm_get_locked_range(struct spi_nor *nor, u8 sr, loff_t *ofs, > uint64_t *len) > { > @@ -2872,6 +3043,12 @@ int spi_nor_scan(struct spi_nor *nor, const char *name, > nor->flash_is_locked = stm_is_locked; > } > > + if (JEDEC_MFR(info) == SNOR_MFR_SST && info->id[1] == 0x26) { > + nor->flash_lock = sst26_lock; > + nor->flash_unlock = sst26_unlock; > + nor->flash_is_locked = sst26_is_locked; > + } > + > if (nor->flash_lock && nor->flash_unlock && nor->flash_is_locked) { > mtd->_lock = spi_nor_lock; > mtd->_unlock = spi_nor_unlock; > diff --git a/include/linux/mtd/spi-nor.h b/include/linux/mtd/spi-nor.h > index e60da0d34cc1..246014a73f83 100644 > --- a/include/linux/mtd/spi-nor.h > +++ b/include/linux/mtd/spi-nor.h > @@ -93,6 +93,10 @@ > #define SPINOR_OP_WRDI 0x04 /* Write disable */ > #define SPINOR_OP_AAI_WP 0xad /* Auto address increment word program */ > > +/* Used for SST26* flashes only. */ > +#define SPINOR_OP_READ_BPR 0x72 /* Read block protection register */ > +#define SPINOR_OP_WRITE_BPR 0x42 /* Write block protection register */ > + > /* Used for S3AN flashes only */ > #define SPINOR_OP_XSE 0x50 /* Sector erase */ > #define SPINOR_OP_XPP 0x82 /* Page program */ -- Eugeniy Paltsev