From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B6D3CC433FE for ; Tue, 28 Dec 2021 15:38:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235294AbhL1Pi0 (ORCPT ); Tue, 28 Dec 2021 10:38:26 -0500 Received: from mswedge1.sunplus.com ([60.248.182.113]:33290 "EHLO mg.sunplus.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S235256AbhL1PiZ (ORCPT ); Tue, 28 Dec 2021 10:38:25 -0500 X-MailGates: (flag:3,DYNAMIC,RELAY,NOHOST:PASS)(compute_score:DELIVER,40 ,3) Received: from 172.17.9.202 by mg01.sunplus.com with MailGates ESMTP Server V5.0(4603:0:AUTH_RELAY) (envelope-from ); Tue, 28 Dec 2021 23:38:33 +0800 (CST) Received: from sphcmbx02.sunplus.com.tw (172.17.9.112) by sphcmbx01.sunplus.com.tw (172.17.9.202) with Microsoft SMTP Server (TLS) id 15.0.1497.26; Tue, 28 Dec 2021 23:38:28 +0800 Received: from sphcmbx02.sunplus.com.tw ([fe80::fd3d:ad1a:de2a:18bd]) by sphcmbx02.sunplus.com.tw ([fe80::fd3d:ad1a:de2a:18bd%14]) with mapi id 15.00.1497.026; Tue, 28 Dec 2021 23:38:28 +0800 From: =?utf-8?B?V2VsbHMgTHUg5ZGC6Iqz6aiw?= To: Andy Shevchenko , Wells Lu CC: Linus Walleij , "open list:GPIO SUBSYSTEM" , Linux Kernel Mailing List , Rob Herring , devicetree , linux-arm Mailing List , "dvorkin@tibbo.com" Subject: RE: [PATCH v5 2/2] pinctrl: Add driver for Sunplus SP7021 Thread-Topic: [PATCH v5 2/2] pinctrl: Add driver for Sunplus SP7021 Thread-Index: AQHX+JsJQRl6kRXEwk+dQHdfPj/+4axC0feAgAMwBYA= Date: Tue, 28 Dec 2021 15:38:28 +0000 Message-ID: References: <1640331779-18277-1-git-send-email-wellslutw@gmail.com> <1640331779-18277-3-git-send-email-wellslutw@gmail.com> In-Reply-To: Accept-Language: zh-TW, en-US Content-Language: zh-TW X-MS-Has-Attach: X-MS-TNEF-Correlator: x-ms-exchange-transport-fromentityheader: Hosted x-originating-ip: [172.25.108.39] Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org SGkgQW5keSwNCg0KVGhhbmtzIGEgbG90IGZvciB5b3VyIHJldmlldy4NCg0KDQpQbGVhc2Ugc2Vl IG15IGFuc3dlcnMgYmVsb3c6DQoNCg0KPiA+DQo+ID4gQWRkIGRyaXZlciBmb3IgU3VucGx1cyBT UDcwMjEgU29DLg0KPiANCj4gVGhhbmtzIGZvciBhbiB1cGRhdGUsIG15IGNvbW1lbnRzIGJlbG93 Lg0KPiANCj4gLi4uDQo+IA0KPiA+ICtjb25maWcgUElOQ1RSTF9TUFBDVEwNCj4gPiArICAgICAg IGJvb2wgIlN1bnBsdXMgU1A3MDIxIFBpbk11eCBhbmQgR1BJTyBkcml2ZXIiDQo+IA0KPiBXaHkg Ym9vbCBhbmQgbm90IHRyaXN0YXRlPw0KDQpQaW5jdHJsIGRyaXZlciBpcyBzZWxlY3RlZCBieSBt YW55IGRyaXZlcnMgaW4gU1A3MDIxIHBsYXRmb3JtLg0KV2UgbmV2ZXIgYnVpbGQgaXQgYXMgYSBt b2R1bGUsIGJ1dCBidWlsZC1pbiB0byBrZXJuZWwuDQpTbyB3ZSB1c2UgImJvb2wiLg0KDQpTaG91 bGQgd2Ugc2V0IGl0IHRvIHRyaXN0YXRlPw0KDQoNCj4gDQo+ID4gKyAgICAgICBkZXBlbmRzIG9u IFNPQ19TUDcwMjENCj4gPiArICAgICAgIGRlcGVuZHMgb24gT0YgJiYgSEFTX0lPTUVNDQo+IA0K PiAuLi4NCj4gDQo+ID4gKyNpbmNsdWRlIDxsaW51eC9vZi5oPg0KPiA+ICsjaW5jbHVkZSA8bGlu dXgvb2ZfZGV2aWNlLmg+DQo+IA0KPiA+ICsjaW5jbHVkZSA8bGludXgvcGluY3RybC9waW5jb25m Lmg+DQo+ID4gKyNpbmNsdWRlIDxsaW51eC9waW5jdHJsL3BpbmNvbmYtZ2VuZXJpYy5oPiAjaW5j bHVkZQ0KPiA+ICs8bGludXgvcGluY3RybC9waW5tdXguaD4NCj4gDQo+IENhbiB5b3UgbW92ZSB0 aGlzIGdyb3VwLi4uDQo+IA0KPiA+ICsjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+ DQo+ID4gKyNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPg0KPiA+ICsjaW5jbHVkZSA8bGludXgv c2xhYi5oPg0KPiANCj4gLi4udG8gYmUgc29tZXdoZXJlIGhlcmU/DQoNClllcywgSSdsbCBtb3Zl IGl0IG5leHQgcGF0Y2guDQoNCg0KPiA+ICsjaW5jbHVkZSA8ZHQtYmluZGluZ3MvcGluY3RybC9z cHBjdGwtc3A3MDIxLmg+DQo+IA0KPiAuLi4NCj4gDQo+ID4gKy8qIGlubGluZSBmdW5jdGlvbnMg Ki8NCj4gDQo+IFVzZWxlc3MuDQoNCkknbGwgcmVtb3ZlIGFsbCB0aGlzIGtpbmQgb2YgY29tbWVu dHMgbmV4dCBwYXRjaC4NCg0KDQo+IC4uLg0KPiANCj4gPiArICAgICAgIG1hc2sgPSBHRU5NQVNL KGJpdF9zeiAtIDEsIDApIDw8IChiaXRfb2ZmICsgU1BQQ1RMX0dST1VQX1BJTk1VWF9NQVNLX1NI SUZUKTsNCj4gPiArICAgICAgIHJlZyA9IG1hc2sgfCAodmFsIDw8IGJpdF9vZmYpOw0KPiANCj4g Tm93IHlvdSBtYXkgZG8gb25lIHN0ZXAgZm9yd2FyZDoNCj4gDQo+ICAgICAgICBtYXNrID0gR0VO TUFTSyhiaXRfc3ogLSAxLCAwKSA8PCBTUFBDVExfR1JPVVBfUElOTVVYX01BU0tfU0hJRlQ7DQo+ ICAgICAgICByZWcgPSAodmFsIHwgbWFzaykgPDwgYml0X29mZjsNCg0KSSdsbCByZXZpc2UgdGhl c2Ugc3RhdGVtZW50cyBhcyBjb2RlIHlvdSd2ZSBzaGFyZWQuDQoNCg0KPiAuLi4NCj4gDQo+ID4g K3N0YXRpYyB2b2lkIHNwcGN0bF9maXJzdF9tYXN0ZXJfc2V0KHN0cnVjdCBncGlvX2NoaXAgKmNo aXAsIHVuc2lnbmVkIGludCBvZmZzZXQsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZW51bSBtdXhfZmlyc3RfcmVnIGZpcnN0LCBlbnVtDQo+ID4gK211eF9tYXN0ZXJf cmVnIG1hc3Rlcikgew0KPiA+ICsgICAgICAgc3RydWN0IHNwcGN0bF9ncGlvX2NoaXAgKnNwcF9n Y2hpcCA9IGdwaW9jaGlwX2dldF9kYXRhKGNoaXApOw0KPiA+ICsgICAgICAgdTMyIHJlZ19vZmYs IGJpdF9vZmYsIHJlZzsNCj4gPiArICAgICAgIGludCB2YWw7DQo+ID4gKw0KPiA+ICsgICAgICAg LyogRklSU1QgcmVnaXN0ZXIgKi8NCj4gPiArICAgICAgIGlmIChmaXJzdCAhPSBtdXhfZl9rZWVw KSB7DQo+ID4gKyAgICAgICAgICAgICAgIC8qDQo+ID4gKyAgICAgICAgICAgICAgICAqIFJlZmVy IHRvIGRlc2NyaXB0aW9ucyBvZiBmdW5jdGlvbiBzcHBjdGxfZmlyc3RfZ2V0KCkNCj4gPiArICAg ICAgICAgICAgICAgICogZm9yIHVzYWdlIG9mIEZJUlNUIHJlZ2lzdGVycy4NCj4gPiArICAgICAg ICAgICAgICAgICovDQo+ID4gKyAgICAgICAgICAgICAgIHJlZ19vZmYgPSAob2Zmc2V0IC8gMzIp ICogNDsNCj4gPiArICAgICAgICAgICAgICAgYml0X29mZiA9IG9mZnNldCAlIDMyOw0KPiA+ICsN Cj4gPiArICAgICAgICAgICAgICAgcmVnID0gc3BwY3RsX2ZpcnN0X3JlYWRsKHNwcF9nY2hpcCwg cmVnX29mZik7DQo+ID4gKyAgICAgICAgICAgICAgIHZhbCA9IChyZWcgJiBCSVQoYml0X29mZikp ID8gMSA6IDA7DQo+IA0KPiA+ICsgICAgICAgICAgICAgICBpZiAoZmlyc3QgIT0gdmFsKSB7DQo+ IA0KPiBmaXJzdCBpcyBlbnVtLCB2YWwgaXMgaW50LCBhcmUgeW91IHN1cmUgaXQncyBnb29kIHRv IGNvbXBhcmUgbGlrZSB0aGlzPw0KDQpObywgaXQgaXMgYWx3YXlzIG5vdCBnb29kIHRvIGNvbXBh cmUgZGlmZmVyZW50IHR5cGUgb2YgdGhpbmdzLg0KSSdsbCBtb2RpZnkgY29kZSBhcyBzaG93biBi ZWxvdzoNCg0KCWVudW0gbXV4X2ZpcnN0X3JlZyB2YWw7DQoJCToNCgkJOg0KCXZhbCA9IChyZWcg JiBCSVQoYml0X29mZikpID8gbXV4X2ZfZ3BpbyA6IG11eF9mX211eDsNCg0KDQo+ID4gKyAgICAg ICAgICAgICAgICAgICAgICAgaWYgKGZpcnN0ID09IG11eF9mX2dwaW8pDQo+ID4gKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICByZWcgfD0gQklUKGJpdF9vZmYpOw0KPiA+ICsgICAgICAg ICAgICAgICAgICAgICAgIGVsc2UNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJlZyAmPSB+QklUKGJpdF9vZmYpOw0KPiANCj4gDQo+IFNpbmNlIHlvdSBvcGVyYXRlIGFnYWlu c3QgZW51bXMgaXQncyBiZXR0ZXIgdG8gdXNlIHN3aXRjaC1jYXNlLg0KDQpJJ2xsIG1vZGlmeSBj b2RlIGFzIHNob3duIGJlbG93Og0KDQoJCQlpZiAoZmlyc3QgIT0gdmFsKQ0KCQkJCXN3aXRjaCAo Zmlyc3QpIHsNCgkJCQljYXNlIG11eF9mX2dwaW86DQoJCQkJCXJlZyB8PSBCSVQoYml0X29mZik7 DQoJCQkJCXNwcGN0bF9maXJzdF93cml0ZWwoc3BwX2djaGlwLCByZWcsIHJlZ19vZmYpOw0KCQkJ CQlicmVhazsNCg0KCQkJCWNhc2UgbXV4X2ZfbXV4Og0KCQkJCQlyZWcgJj0gfkJJVChiaXRfb2Zm KTsNCgkJCQkJc3BwY3RsX2ZpcnN0X3dyaXRlbChzcHBfZ2NoaXAsIHJlZywgcmVnX29mZik7DQoJ CQkJCWJyZWFrOw0KDQoJCQkJY2FzZSBtdXhfZl9rZWVwOg0KCQkJCQlicmVhazsNCgkJCQl9DQoN Cg0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgIHNwcGN0bF9maXJzdF93cml0ZWwoc3BwX2dj aGlwLCByZWcsIHJlZ19vZmYpOw0KPiA+ICsgICAgICAgICAgICAgICB9DQo+ID4gKyAgICAgICB9 DQo+ID4gKw0KPiA+ICsgICAgICAgLyogTUFTVEVSIHJlZ2lzdGVyICovDQo+ID4gKyAgICAgICBp ZiAobWFzdGVyICE9IG11eF9tX2tlZXApIHsNCj4gPiArICAgICAgICAgICAgICAgLyoNCj4gPiAr ICAgICAgICAgICAgICAgICogUmVmZXIgdG8gZGVzY3JpcHRpb25zIG9mIGZ1bmN0aW9uIHNwcGN0 bF9tYXN0ZXJfZ2V0KCkNCj4gPiArICAgICAgICAgICAgICAgICogZm9yIHVzYWdlIG9mIE1BU1RF UiByZWdpc3RlcnMuDQo+ID4gKyAgICAgICAgICAgICAgICAqLw0KPiA+ICsgICAgICAgICAgICAg ICByZWdfb2ZmID0gKG9mZnNldCAvIDE2KSAqIDQ7DQo+ID4gKyAgICAgICAgICAgICAgIGJpdF9v ZmYgPSBvZmZzZXQgJSAxNjsNCj4gPiArDQo+ID4gKyAgICAgICAgICAgICAgIHJlZyA9IEJJVChi aXRfb2ZmKSA8PCBTUFBDVExfTUFTVEVSX01BU0tfU0hJRlQ7DQo+ID4gKyAgICAgICAgICAgICAg IGlmIChtYXN0ZXIgPT0gbXV4X21fZ3BpbykNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICBy ZWcgfD0gQklUKGJpdF9vZmYpOw0KPiA+ICsgICAgICAgICAgICAgICBzcHBjdGxfZ3Bpb19tYXN0 ZXJfd3JpdGVsKHNwcF9nY2hpcCwgcmVnLCByZWdfb2ZmKTsNCj4gPiArICAgICAgIH0NCj4gPiAr fQ0KPiANCj4gLi4uDQo+IA0KPiA+ICsgICAgICAgcmVnID0gQklUKGJpdF9vZmYgKyBTUFBDVExf R1BJT19NQVNLX1NISUZUKSB8IEJJVChiaXRfb2ZmKTsNCj4gDQo+ID4gKyAgICAgICByZWcgPSBC SVQoYml0X29mZiArIFNQUENUTF9HUElPX01BU0tfU0hJRlQpIHwgQklUKGJpdF9vZmYpOw0KPiAN Cj4gUGVyaGFwcyBhIG1hY3JvIHdpdGggZGVmaW5pdGl2ZSBuYW1lPw0KDQpJJ2xsIGRlZmluZSB0 d28gbmV3IG1hY3JvczoNCg0KI2RlZmluZSBTUFBDVExfTU9PTl9SRUdfTUFTS19TSElGVAkJMTYN CiNkZWZpbmUgU1BQQ1RMX1NFVF9NT09OX1JFR19CSVQoYml0KQkJKEJJVChiaXQgKyBTUFBDVExf TU9PTl9SRUdfTUFTS19TSElGVCkgfCBCSVQoYml0KSkNCiNkZWZpbmUgU1BQQ1RMX0NMUl9NT09O X1JFR19CSVQoYml0KQkJQklUKGJpdCArIFNQUENUTF9NT09OX1JFR19NQVNLX1NISUZUKQ0KDQpB bmQgbW9kaWZ5IGNvZGUgYXMgc2hvd24gYmVsb3c6DQoNCg0KCQkJcmVnID0gU1BQQ1RMX1NFVF9N T09OX1JFR19CSVQoYml0X29mZik7DQoNCg0KPiAuLi4NCj4gDQo+ID4gKyAgICAgICByZWcgPSBC SVQoYml0X29mZiArIFNQUENUTF9HUElPX01BU0tfU0hJRlQpOw0KPiA+ICsgICAgICAgaWYgKHZh bCkNCj4gPiArICAgICAgICAgICAgICAgcmVnIHw9IEJJVChiaXRfb2ZmKTsNCj4gDQo+IFlvdSBj YW4gdXNlIGl0IGV2ZW4gaGVyZToNCj4gDQo+IGlmICh2YWwpDQo+ICAgcmVnID0gTVlfTUFDUk8o Yml0X29mZikNCj4gZWxzZQ0KPiAgIHJlZyA9IEJJVCguLi4pIC8vIHBlcmhhcHMgYW5vdGhlciBt YWNybw0KDQpJJ2xsIG1vZGlmeSBjb2RlIGFzIHNob3duIGJlbG93Og0KDQoJaWYgKHZhbCkNCgkJ cmVnID0gU1BQQ1RMX1NFVF9NT09OX1JFR19CSVQoYml0X29mZik7DQoJZWxzZQ0KCQlyZWcgPSBT UFBDVExfQ0xSX01PT05fUkVHX0JJVChiaXRfb2ZmKTsNCg0KDQo+IC4uLg0KPiANCj4gPiArICAg ICAgIHJlZyA9IEJJVChiaXRfb2ZmICsgU1BQQ1RMX0dQSU9fTUFTS19TSElGVCk7DQo+IA0KPiBE aXR0by4NCg0KSSdsbCBtb2RpZnkgY29kZSBhcyBzaG93biBiZWxvdzoNCgkJDQoJCQlyZWcgPSBT UFBDVExfQ0xSX01PT05fUkVHX0JJVChiaXRfb2ZmKTsNCg0KDQo+IC4uLg0KPiANCj4gPiArICAg ICAgIHJlZyA9IEJJVChiaXRfb2ZmICsgU1BQQ1RMX0dQSU9fTUFTS19TSElGVCkgfCBCSVQoYml0 X29mZik7DQo+IA0KPiBEaXR0by4NCg0KSSdsbCBtb2RpZnkgY29kZSBhcyBzaG93biBzaG93biBi ZWxvdzoNCg0KCQkJcmVnID0gU1BQQ1RMX1NFVF9NT09OX1JFR19CSVQoYml0X29mZik7DQoNCj4g Li4uDQo+IA0KPiA+ICsgICAgICAgcmVnID0gQklUKGJpdF9vZmYgKyBTUFBDVExfR1BJT19NQVNL X1NISUZUKTsNCj4gPiArICAgICAgIGlmICh2YWwpDQo+ID4gKyAgICAgICAgICAgICAgIHJlZyB8 PSBCSVQoYml0X29mZik7DQo+IA0KPiBEaXR0by4NCg0KSSdsbCBtb2RpZnkgY29kZSBhcyBzaG93 biBiZWxvdzoNCg0KCWlmICh2YWwpDQoJCXJlZyA9IFNQUENUTF9TRVRfTU9PTl9SRUdfQklUKGJp dF9vZmYpOw0KCWVsc2UNCgkJcmVnID0gU1BQQ1RMX0NMUl9NT09OX1JFR19CSVQoYml0X29mZik7 DQoNCg0KPiAuLi4NCj4gDQo+ID4gKyAgICAgICByZWcgPSBCSVQoYml0X29mZiArIFNQUENUTF9H UElPX01BU0tfU0hJRlQpOw0KPiA+ICsgICAgICAgaWYgKHZhbCkNCj4gPiArICAgICAgICAgICAg ICAgcmVnIHw9IEJJVChiaXRfb2ZmKTsNCj4gDQo+IERpdHRvLg0KDQpJJ2xsIG1vZGlmeSBjb2Rl IGFzIHNob3duIGluIGFib3ZlIGNhc2UuDQoNCg0KPiBBbmQgbG9va2luZyBpbnRvIHJlcGV0aXRp b24sIHlvdSBtYXkgZXZlbiBoYXZlIGEgaGVscGVyIHdoaWNoIGRvZXMgdGhpcyBjb25kaXRpb25h bA0KPiANCj4gc3RhdGljIGlubGluZSB1MzIgc3BwY3RsXy4uLigpDQo+IHsNCj4gICAuLi4NCj4g ICByZXR1cm4gcmVnOw0KPiB9DQoNCkknbGwgYWRkIGFuIGlubGluZSBmdW5jdGlvbiBhcyBzaG93 biBiZWxvdzoNCg0Kc3RhdGljIGlubGluZSB1MzIgc3BwY3RsX3ByZXBfbW9vbl9yZWcodTMyIGJp dF9vZmYsIGludCB2YWwpDQp7DQoJaWYgKHZhbCkNCgkJcmV0dXJuIFNQUENUTF9TRVRfTU9PTl9S RUdfQklUKGJpdF9vZmYpOw0KCWVsc2UNCgkJcmV0dXJuIFNQUENUTF9DTFJfTU9PTl9SRUdfQklU KGJpdF9vZmYpOw0KfQ0KDQpBbmQgcmVwbGFjZSBhbGwgImlmICh2YWwpIC4uLiAiIHdpdGggdGhl IGlubGluZSBmdW5jdGlvbi4NCg0KDQo+IC4uLg0KPiANCj4gPiArICAgICAgIGludCByZXQgPSAw Ow0KPiANCj4gUmVkdW5kYW50IHZhcmlhYmxlLCByZXR1cm4gZGlyZWN0bHkuDQoNCkknbGwgcmVt b3ZlIHRoZSByZWR1bmRhbnQgdmFyaWFibGUuDQoNCg0KPiA+ICsgICAgICAgc3dpdGNoIChwYXJh bSkgew0KPiA+ICsgICAgICAgY2FzZSBQSU5fQ09ORklHX0RSSVZFX09QRU5fRFJBSU46DQo+ID4g KyAgICAgICAgICAgICAgIC8qDQo+ID4gKyAgICAgICAgICAgICAgICAqIFVwcGVyIDE2LWJpdCB3 b3JkIGlzIG1hc2suIExvd2VyIDE2LWJpdCB3b3JkIGlzIHZhbHVlLg0KPiA+ICsgICAgICAgICAg ICAgICAgKiBSZWZlciB0byBkZXNjcmlwdGlvbnMgb2YgZnVuY3Rpb24gc3BwY3RsX21hc3Rlcl9n ZXQoKS4NCj4gPiArICAgICAgICAgICAgICAgICovDQo+ID4gKyAgICAgICAgICAgICAgIHJlZ19v ZmYgPSAob2Zmc2V0IC8gMTYpICogNDsNCj4gPiArICAgICAgICAgICAgICAgYml0X29mZiA9IG9m ZnNldCAlIDE2Ow0KPiA+ICsgICAgICAgICAgICAgICByZWcgPSBCSVQoYml0X29mZiArIFNQUENU TF9HUElPX01BU0tfU0hJRlQpIHwNCj4gPiArIEJJVChiaXRfb2ZmKTsNCj4gDQo+IEFzIEkgY29t bWVudGVkIGFib3ZlIHVzZSBoZWxwZXIgZnVuY3Rpb24gd2hpY2ggdGFrZXMgb2Zmc2V0IGFzIGlu cHV0IGFuZCByZXR1cm5zIHlvdSByZWcNCj4gYW5kIHJlZ19vZmYuDQoNCkknbGwgbW9kaWZ5IGNv ZGUgYXMgc2hvd24gYmVsb3c6DQoNCgkJcmVnID0gU1BQQ1RMX1NFVF9NT09OX1JFR19CSVQoYml0 X29mZik7DQoNClNvcnJ5LCBJIGRvbid0IHVuZGVyc3RhbmQgeW91ciBtZWFuaW5nICJyZXR1cm5z IHlvdSByZWcgYW5kIHJlZ19vZmYiLg0KVGhlIGhlbHBlciBtYWNybyB3aWxsIHJldHVybiByZWcg YnV0IG5vdCByZWdfb2ZmLCByaWdodD8NCg0KDQo+ID4gKyAgICAgICAgICAgICAgIHNwcGN0bF9n cGlvX29kX3dyaXRlbChzcHBfZ2NoaXAsIHJlZywgcmVnX29mZik7DQo+ID4gKyAgICAgICAgICAg ICAgIGJyZWFrOw0KPiA+ICsNCj4gPiArICAgICAgIGNhc2UgUElOX0NPTkZJR19JTlBVVF9FTkFC TEU6DQo+ID4gKyAgICAgICAgICAgICAgIGJyZWFrOw0KPiA+ICsNCj4gPiArICAgICAgIGNhc2Ug UElOX0NPTkZJR19PVVRQVVQ6DQo+ID4gKyAgICAgICAgICAgICAgIHJldCA9IHNwcGN0bF9ncGlv X2RpcmVjdGlvbl9vdXRwdXQoY2hpcCwgb2Zmc2V0LCAwKTsNCj4gPiArICAgICAgICAgICAgICAg YnJlYWs7DQo+ID4gKw0KPiA+ICsgICAgICAgY2FzZSBQSU5fQ09ORklHX1BFUlNJU1RfU1RBVEU6 DQo+ID4gKyAgICAgICAgICAgICAgIHJldCA9IC1FTk9UU1VQUDsNCj4gPiArICAgICAgICAgICAg ICAgYnJlYWs7DQo+ID4gKw0KPiA+ICsgICAgICAgZGVmYXVsdDoNCj4gPiArICAgICAgICAgICAg ICAgcmV0ID0gLUVJTlZBTDsNCj4gPiArICAgICAgICAgICAgICAgYnJlYWs7DQo+ID4gKyAgICAg ICB9DQo+ID4gKw0KPiA+ICsgICAgICAgcmV0dXJuIHJldDsNCj4gPiArfQ0KPiANCj4gLi4uDQo+ IA0KPiA+ICsgICAgICAgaWYgKCFvZl9maW5kX3Byb3BlcnR5KHBkZXYtPmRldi5vZl9ub2RlLCAi Z3Bpby1jb250cm9sbGVyIiwgTlVMTCkpDQo+ID4gKyAgICAgICAgICAgICAgIHJldHVybiBkZXZf ZXJyX3Byb2JlKCZwZGV2LT5kZXYsIC1FSU5WQUwsICJOb3QgYQ0KPiA+ICsgZ3Bpby1jb250cm9s bGVyIVxuIik7DQo+IA0KPiBXaHkgZG8geW91IG5lZWQgdGhpcyBjaGVjayBmb3I/DQoNCkJ5IHJl ZmVycmluZyB0byBvdGhlciBwaW5jdHJsIGRyaXZlciwgd2UgY2hlY2sgaWYgcHJvcGVydHkgImdw aW8tY29udHJvbGxlciIgZXhpc3RzPw0KV2lsbCBjb3JlIGhlbHAgdXMgY2hlY2sgdGhpcz8NCklz IHRoaXMgcmVkdW5kYW50Pw0KDQoNCj4gLi4uDQo+IA0KPiA+ICsgICAgICAgZ2NoaXAtPmNhbl9z bGVlcCAgICAgICAgPSAwOw0KPiANCj4gQmVzaWRlcyB0aGF0IGl0J3MgYWxyZWFkeSBjbGVhcmVk LCB0aGUgdHlwZSBoZXJlIGlzIGJvb2xlYW4uDQoNCkknbGwgcmVtb3ZlIHRoZSB1bm5lY2Vzc2Fy eSBhc3NpZ25tZW50IGFzIHRoZSB3aG9sZSBzdHJ1Y3R1cmUgaXMgaW5pdGlhbGl6ZWQgdG8gMC4N ClNob3VsZCBJIGFsc28gcmVtb3ZlIHRoZSBhc3NpZ25tZW50Og0KDQoJCWdjaGlwLT5iYXNlIAkJ PSAwOw0KDQoNCj4gLi4uDQo+IA0KPiA+ICsvKiBwaW5jb25mIG9wZXJhdGlvbnMgKi8NCj4gDQo+ IEFueSB2YWx1ZSBvZiB0aGlzIGNvbW1lbnQ/DQoNCkknbGwgcmVtb3ZlIGl0Lg0KDQoNCj4gPiAr c3RhdGljIGludCBzcHBjdGxfcGluX2NvbmZpZ19nZXQoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3Rs ZGV2LCB1bnNpZ25lZCBpbnQgcGluLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHVuc2lnbmVkIGxvbmcgKmNvbmZpZykgew0KPiA+ICsgICAgICAgc3RydWN0IHNwcGN0bF9w ZGF0YSAqcGN0bCA9IHBpbmN0cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOw0KPiA+ICsgICAg ICAgdW5zaWduZWQgaW50IHBhcmFtID0gcGluY29uZl90b19jb25maWdfcGFyYW0oKmNvbmZpZyk7 DQo+IA0KPiA+ICsgICAgICAgdW5zaWduZWQgaW50IGFyZyA9IDA7DQo+IA0KPiBNb3ZlIGFzc2ln bm1lbnQgdG8gd2hlcmUgaXQgYWN0dWFsbHkgbWFrZXMgc2Vuc2UuDQoNCkknbGwgbW92ZSBpdCBh cyBzaG93biBiZWxvdzoNCg0KCQljYXNlIFBJTl9DT05GSUdfRFJJVkVfT1BFTl9EUkFJTjoNCgkJ CWlmICghc3BwY3RsX2dwaW9fb3V0cHV0X29kX2dldCgmcGN0bC0+c3BwX2djaGlwLT5jaGlwLCBw aW4pKQ0KCQkJCXJldHVybiAtRUlOVkFMOw0KCQkJYXJnID0gMDsNCgkJCWJyZWFrOw0KDQoNCj4g PiArICAgICAgIHN3aXRjaCAocGFyYW0pIHsNCj4gPiArICAgICAgIGNhc2UgUElOX0NPTkZJR19E UklWRV9PUEVOX0RSQUlOOg0KPiA+ICsgICAgICAgICAgICAgICBpZiAoIXNwcGN0bF9ncGlvX291 dHB1dF9vZF9nZXQoJnBjdGwtPnNwcF9nY2hpcC0+Y2hpcCwgcGluKSkNCj4gPiArICAgICAgICAg ICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsNCj4gPiArICAgICAgICAgICAgICAgYnJlYWs7 DQo+ID4gKw0KPiA+ICsgICAgICAgY2FzZSBQSU5fQ09ORklHX09VVFBVVDoNCj4gPiArICAgICAg ICAgICAgICAgaWYgKCFzcHBjdGxfZmlyc3RfZ2V0KCZwY3RsLT5zcHBfZ2NoaXAtPmNoaXAsIHBp bikpDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7DQo+ID4gKyAg ICAgICAgICAgICAgIGlmICghc3BwY3RsX21hc3Rlcl9nZXQoJnBjdGwtPnNwcF9nY2hpcC0+Y2hp cCwgcGluKSkNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsNCj4g PiArICAgICAgICAgICAgICAgaWYgKHNwcGN0bF9ncGlvX2dldF9kaXJlY3Rpb24oJnBjdGwtPnNw cF9nY2hpcC0+Y2hpcCwgcGluKSkNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g LUVJTlZBTDsNCj4gPiArICAgICAgICAgICAgICAgYXJnID0gc3BwY3RsX2dwaW9fZ2V0KCZwY3Rs LT5zcHBfZ2NoaXAtPmNoaXAsIHBpbik7DQo+ID4gKyAgICAgICAgICAgICAgIGJyZWFrOw0KPiA+ ICsNCj4gPiArICAgICAgIGRlZmF1bHQ6DQo+ID4gKyAgICAgICAgICAgICAgIHJldHVybiAtRU9Q Tk9UU1VQUDsNCj4gPiArICAgICAgIH0NCj4gPiArICAgICAgICpjb25maWcgPSBwaW5jb25mX3Rv X2NvbmZpZ19wYWNrZWQocGFyYW0sIGFyZyk7DQo+ID4gKw0KPiA+ICsgICAgICAgcmV0dXJuIDA7 DQo+ID4gK30NCj4gDQo+IC4uLg0KPiANCj4gPiArICAgICAgIHN3aXRjaCAoZi0+dHlwZSkgew0K PiA+ICsgICAgICAgY2FzZSBwaW5tdXhfdHlwZV9mcG14OiAgLyogZnVsbHktcGlubXV4ICovDQo+ IA0KPiBXaHkgZG8geW91IG5lZWQgdGhlc2UgY29tbWVudHM/DQo+IFNob3VsZG4ndCB5b3UgcmF0 aGVyIHRvIGtlcm5lbCBkb2MgeW91ciBlbnVtIGVudHJpZXM/DQoNCkknbGwgcmVtb3ZlIHRoZSBj b21tZW50cy4NCkNvdWxkIHlvdSBwbGVhc2UgdGVsbCBtZSB3aGVyZSBJIHNob3VsZCB3cml0ZSBh bmQgcHV0IG15IGtlcm5lbCBkb2M/DQpJcyB0aGVyZSBhbnkgZXhhbXBsZXMgSSBjYW4gcmVmZXIg dG8/DQoNCg0KPiA+ICsgICAgICAgICAgICAgICAqbnVtX2dyb3VwcyA9IHNwcGN0bF9wbXV4X2xp c3Rfc3o7DQo+ID4gKyAgICAgICAgICAgICAgICpncm91cHMgPSBzcHBjdGxfcG11eF9saXN0X3M7 DQo+ID4gKyAgICAgICAgICAgICAgIGJyZWFrOw0KPiA+ICsNCj4gPiArICAgICAgIGNhc2UgcGlu bXV4X3R5cGVfZ3JwOiAgIC8qIGdyb3VwLXBpbm11eCAqLw0KPiA+ICsgICAgICAgICAgICAgICBp ZiAoIWYtPmdycHMpDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7DQo+ID4gKw0K PiA+ICsgICAgICAgICAgICAgICAqbnVtX2dyb3VwcyA9IGYtPmdudW07DQo+ID4gKyAgICAgICAg ICAgICAgIGZvciAoaSA9IDA7IGkgPCBwY3RsLT51bnFfZ3Jwc19zejsgaSsrKQ0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgIGlmIChwY3RsLT5nMmZwX21hcHNbaV0uZl9pZHggPT0gc2VsZWN0 b3IpDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBicmVhazsNCj4gPiArICAg ICAgICAgICAgICAgKmdyb3VwcyA9ICZwY3RsLT51bnFfZ3Jwc1tpXTsNCj4gPiArICAgICAgICAg ICAgICAgYnJlYWs7DQo+IA0KPiA+ICsgICAgICAgfQ0KPiANCj4gPiArLyoqIHNwcGN0bF9mdWxs eV9waW5tdXhfY29udiAtIENvbnZlcnQgR1BJTyMgdG8gZnVsbHktcGlubXV4DQo+ID4gK2NvbnRy b2wtZmllbGQgc2V0dGluZw0KPiA+ICsgKg0KPiA+ICsgKiBFYWNoIGZ1bGx5LXBpbm11eCBmdW5j dGlvbiBjYW4gYmUgbWFwcGVkIHRvIGFueSBvZiBHUElPIDggfiA3MSBieQ0KPiA+ICsgKiBzZXR0 aW5ncyBpdHMgY29udHJvbC1maWVsZC4gUmVmZXIgdG8gZm9sbG93aW5nIHRhYmxlOg0KPiA+ICsg Kg0KPiA+ICsgKiBjb250cm9sLWZpZWxkIHwgIEdQSU8NCj4gPiArICogLS0tLS0tLS0tLS0tLS0r LS0tLS0tLS0NCj4gPiArICogICAgICAgIDAgICAgICB8ICBObyBtYXANCj4gPiArICogICAgICAg IDEgICAgICB8ICAgIDgNCj4gPiArICogICAgICAgIDIgICAgICB8ICAgIDkNCj4gPiArICogICAg ICAgIDMgICAgICB8ICAgMTANCj4gPiArICogICAgICAgIDogICAgICB8ICAgIDoNCj4gPiArICog ICAgICAgNjUgICAgICB8ICAgNzENCj4gPiArICovDQo+ID4gK3N0YXRpYyBpbmxpbmUgaW50IHNw cGN0bF9mdWxseV9waW5tdXhfY29udih1bnNpZ25lZCBpbnQgb2Zmc2V0KSB7DQo+ID4gKyAgICAg ICByZXR1cm4gKG9mZnNldCA8IDgpID8gMCA6IG9mZnNldCAtIDc7IH0NCj4gDQo+IC4uLg0KPiAN Cj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCBwaW5tdXhfb3BzIHNwcGN0bF9waW5tdXhfb3BzID0g ew0KPiA+ICsgICAgICAgLmdldF9mdW5jdGlvbnNfY291bnQgPSBzcHBjdGxfZ2V0X2Z1bmN0aW9u c19jb3VudCwNCj4gPiArICAgICAgIC5nZXRfZnVuY3Rpb25fbmFtZSAgID0gc3BwY3RsX2dldF9m dW5jdGlvbl9uYW1lLA0KPiA+ICsgICAgICAgLmdldF9mdW5jdGlvbl9ncm91cHMgPSBzcHBjdGxf Z2V0X2Z1bmN0aW9uX2dyb3VwcywNCj4gPiArICAgICAgIC5zZXRfbXV4ICAgICAgICAgICAgID0g c3BwY3RsX3NldF9tdXgsDQo+ID4gKyAgICAgICAuZ3Bpb19yZXF1ZXN0X2VuYWJsZSA9IHNwcGN0 bF9ncGlvX3JlcXVlc3RfZW5hYmxlLA0KPiANCj4gPiArICAgICAgIC5zdHJpY3QgICAgICAgICAg ICAgID0gdHJ1ZQ0KPiANCj4gKyBDb21tYS4NCg0KSSdsbCBhZGQgYSBjb21tYSByaWdodCBhZnRl ciAndHJ1ZScuDQoNCg0KPiA+ICt9Ow0KPiANCj4gLi4uDQo+IA0KPiA+ICtzdGF0aWMgaW50IHNw cGN0bF9kdF9ub2RlX3RvX21hcChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsIHN0cnVjdCBk ZXZpY2Vfbm9kZQ0KPiAqbnBfY29uZmlnLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHN0cnVjdCBwaW5jdHJsX21hcCAqKm1hcCwgdW5zaWduZWQNCj4gPiAraW50ICpudW1f bWFwcykgew0KPiA+ICsgICAgICAgc3RydWN0IHNwcGN0bF9wZGF0YSAqcGN0bCA9IHBpbmN0cmxf ZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOw0KPiA+ICsgICAgICAgaW50IG5tRyA9IG9mX3Byb3Bl cnR5X2NvdW50X3N0cmluZ3MobnBfY29uZmlnLCAiZ3JvdXBzIik7DQo+ID4gKyAgICAgICBjb25z dCBzdHJ1Y3Qgc3BwY3RsX2Z1bmMgKmYgPSBOVUxMOw0KPiA+ICsgICAgICAgdTggcGluX251bSwg cGluX3R5cGUsIHBpbl9mdW5jOw0KPiA+ICsgICAgICAgc3RydWN0IGRldmljZV9ub2RlICpwYXJl bnQ7DQo+ID4gKyAgICAgICB1bnNpZ25lZCBsb25nICpjb25maWdzOw0KPiA+ICsgICAgICAgc3Ry dWN0IHByb3BlcnR5ICpwcm9wOw0KPiA+ICsgICAgICAgY29uc3QgY2hhciAqc19mLCAqc19nOw0K PiA+ICsNCj4gPiArICAgICAgIGNvbnN0IF9fYmUzMiAqbGlzdDsNCj4gPiArICAgICAgIHUzMiBk dF9waW4sIGR0X2Z1bjsNCj4gPiArICAgICAgIGludCBpLCBzaXplID0gMDsNCj4gPiArDQo+ID4g KyAgICAgICBsaXN0ID0gb2ZfZ2V0X3Byb3BlcnR5KG5wX2NvbmZpZywgInN1bnBsdXMscGlucyIs ICZzaXplKTsNCj4gPiArDQo+ID4gKyAgICAgICBpZiAobm1HIDw9IDApDQo+ID4gKyAgICAgICAg ICAgICAgIG5tRyA9IDA7DQo+ID4gKw0KPiA+ICsgICAgICAgcGFyZW50ID0gb2ZfZ2V0X3BhcmVu dChucF9jb25maWcpOw0KPiA+ICsgICAgICAgKm51bV9tYXBzID0gc2l6ZSAvIHNpemVvZigqbGlz dCk7DQo+ID4gKw0KPiA+ICsgICAgICAgLyoNCj4gPiArICAgICAgICAqIFByb2Nlc3MgcHJvcGVy dHk6DQo+ID4gKyAgICAgICAgKiAgICAgc3VucGx1cyxwaW5zID0gPCB1MzIgdTMyIHUzMiAuLi4g PjsNCj4gPiArICAgICAgICAqDQo+ID4gKyAgICAgICAgKiBFYWNoIDMyLWJpdCBpbnRlZ2VyIGRl ZmluZXMgYSBpbmRpdmlkdWFsIHBpbiBpbiB3aGljaDoNCj4gPiArICAgICAgICAqDQo+ID4gKyAg ICAgICAgKiAgIEJpdCAzMn4yNDogZGVmaW5lcyBHUElPIHBpbiBudW1iZXIuIEl0cyByYW5nZSBp cyAwIH4gOTguDQo+ID4gKyAgICAgICAgKiAgIEJpdCAyM34xNjogZGVmaW5lcyB0eXBlczogKDEp IGZ1bGx5LXBpbm11eCBwaW5zDQo+ID4gKyAgICAgICAgKiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgKDIpIElPIHByb2Nlc3NvciBwaW5zDQo+ID4gKyAgICAgICAgKiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgKDMpIGRpZ2l0YWwgR1BJTyBwaW5zDQo+ID4gKyAgICAgICAgKiAgIEJp dCAxNX44OiAgZGVmaW5lcyBwaW5zIG9mIHBlcmlwaGVyYWxzICh3aGljaCBhcmUgZGVmaW5lZCBp bg0KPiA+ICsgICAgICAgICogICAgICAgICAgICAgICdpbmNsdWRlL2R0LWJpbmdpbmcvcGluY3Ry bC9zcHBjdGwuaCcpLg0KPiA+ICsgICAgICAgICogICBCaXQgN34wOiAgIGRlZmluZXMgdHlwZXMg b3IgaW5pdGlhbC1zdGF0ZSBvZiBkaWdpdGFsIEdQSU8gcGlucy4NCj4gPiArICAgICAgICAqLw0K PiA+ICsgICAgICAgZm9yIChpID0gMDsgaSA8ICgqbnVtX21hcHMpOyBpKyspIHsNCj4gPiArICAg ICAgICAgICAgICAgZHRfcGluID0gYmUzMl90b19jcHUobGlzdFtpXSk7DQo+ID4gKyAgICAgICAg ICAgICAgIHBpbl9udW0gPSBGSUVMRF9HRVQoR0VOTUFTSygzMSwgMjQpLCBkdF9waW4pOw0KPiA+ ICsNCj4gPiArICAgICAgICAgICAgICAgLyogQ2hlY2sgaWYgb3V0IG9mIHJhbmdlPyAqLw0KPiA+ ICsgICAgICAgICAgICAgICBpZiAocGluX251bSA+PSBzcHBjdGxfcGluc19hbGxfc3opIHsNCj4g PiArICAgICAgICAgICAgICAgICAgICAgICBkZXZfZXJyKHBjdGxkZXYtPmRldiwgIkludmFsaWQg cGluIHByb3BlcnR5IGF0IGluZGV4ICVkDQo+ICgweCUwOHgpXG4iLA0KPiA+ICsgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgaSwgZHRfcGluKTsNCj4gPiArICAgICAgICAgICAgICAgICAg ICAgICByZXR1cm4gLUVJTlZBTDsNCj4gPiArICAgICAgICAgICAgICAgfQ0KPiA+ICsgICAgICAg fQ0KPiA+ICsNCj4gPiArICAgICAgICptYXAgPSBrY2FsbG9jKCpudW1fbWFwcyArIG5tRywgc2l6 ZW9mKCoqbWFwKSwgR0ZQX0tFUk5FTCk7DQo+ID4gKyAgICAgICBmb3IgKGkgPSAwOyBpIDwgKCpu dW1fbWFwcyk7IGkrKykgew0KPiA+ICsgICAgICAgICAgICAgICBkdF9waW4gPSBiZTMyX3RvX2Nw dShsaXN0W2ldKTsNCj4gPiArICAgICAgICAgICAgICAgcGluX251bSA9IEZJRUxEX0dFVChHRU5N QVNLKDMxLCAyNCksIGR0X3Bpbik7DQo+ID4gKyAgICAgICAgICAgICAgIHBpbl90eXBlID0gRklF TERfR0VUKEdFTk1BU0soMjMsIDE2KSwgZHRfcGluKTsNCj4gPiArICAgICAgICAgICAgICAgcGlu X2Z1bmMgPSBGSUVMRF9HRVQoR0VOTUFTSygxNSwgOCksIGR0X3Bpbik7DQo+ID4gKyAgICAgICAg ICAgICAgICgqbWFwKVtpXS5uYW1lID0gcGFyZW50LT5uYW1lOw0KPiA+ICsNCj4gPiArICAgICAg ICAgICAgICAgaWYgKHBpbl90eXBlID09IFNQUENUTF9QQ1RMX0dfR1BJTykgew0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgIC8qIEEgZGlnaXRhbCBHUElPIHBpbiAqLw0KPiA+ICsgICAgICAg ICAgICAgICAgICAgICAgICgqbWFwKVtpXS50eXBlID0gUElOX01BUF9UWVBFX0NPTkZJR1NfUElO Ow0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICgqbWFwKVtpXS5kYXRhLmNvbmZpZ3MubnVt X2NvbmZpZ3MgPSAxOw0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICgqbWFwKVtpXS5kYXRh LmNvbmZpZ3MuZ3JvdXBfb3JfcGluID0gcGluX2dldF9uYW1lKHBjdGxkZXYsDQo+IHBpbl9udW0p Ow0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgIGNvbmZpZ3MgPSBrbWFsbG9jKHNpemVvZigq Y29uZmlncyksIEdGUF9LRVJORUwpOw0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICpjb25m aWdzID0gRklFTERfR0VUKEdFTk1BU0soNywgMCksIGR0X3Bpbik7DQo+ID4gKyAgICAgICAgICAg ICAgICAgICAgICAgKCptYXApW2ldLmRhdGEuY29uZmlncy5jb25maWdzID0gY29uZmlnczsNCj4g PiArDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgZGV2X2RiZyhwY3RsZGV2LT5kZXYsICIl czogR1BJTyAoJXMpXG4iLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCpt YXApW2ldLmRhdGEuY29uZmlncy5ncm91cF9vcl9waW4sDQo+ID4gKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAoKmNvbmZpZ3MgJiAoU1BQQ1RMX1BDVExfTF9PVVQgfCBTUFBDVExfUENU TF9MX09VMSkpID8NCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJPVVQiIDog IklOIik7DQo+ID4gKyAgICAgICAgICAgICAgIH0gZWxzZSBpZiAocGluX3R5cGUgPT0gU1BQQ1RM X1BDVExfR19JT1BQKSB7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgLyogQSBJTyBQcm9j ZXNzb3IgKElPUCkgcGluICovDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgKCptYXApW2ld LnR5cGUgPSBQSU5fTUFQX1RZUEVfQ09ORklHU19QSU47DQo+ID4gKyAgICAgICAgICAgICAgICAg ICAgICAgKCptYXApW2ldLmRhdGEuY29uZmlncy5udW1fY29uZmlncyA9IDE7DQo+ID4gKyAgICAg ICAgICAgICAgICAgICAgICAgKCptYXApW2ldLmRhdGEuY29uZmlncy5ncm91cF9vcl9waW4gPSBw aW5fZ2V0X25hbWUocGN0bGRldiwNCj4gcGluX251bSk7DQo+ID4gKyAgICAgICAgICAgICAgICAg ICAgICAgY29uZmlncyA9IGttYWxsb2Moc2l6ZW9mKCpjb25maWdzKSwgR0ZQX0tFUk5FTCk7DQo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICAgKmNvbmZpZ3MgPSBTUFBDVExfSU9QX0NPTkZJR1M7 DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgKCptYXApW2ldLmRhdGEuY29uZmlncy5jb25m aWdzID0gY29uZmlnczsNCj4gPiArDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgZGV2X2Ri ZyhwY3RsZGV2LT5kZXYsICIlczogSU9QXG4iLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgKCptYXApW2ldLmRhdGEuY29uZmlncy5ncm91cF9vcl9waW4pOw0KPiA+ICsgICAg ICAgICAgICAgICB9IGVsc2Ugew0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgIC8qIEEgZnVs bHktcGlubXV4IHBpbiAqLw0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICgqbWFwKVtpXS50 eXBlID0gUElOX01BUF9UWVBFX01VWF9HUk9VUDsNCj4gPiArICAgICAgICAgICAgICAgICAgICAg ICAoKm1hcClbaV0uZGF0YS5tdXguZnVuY3Rpb24gPSBzcHBjdGxfbGlzdF9mdW5jc1twaW5fZnVu Y10ubmFtZTsNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAoKm1hcClbaV0uZGF0YS5tdXgu Z3JvdXAgPQ0KPiA+ICsgcGluX2dldF9uYW1lKHBjdGxkZXYsIHBpbl9udW0pOw0KPiA+ICsNCj4g PiArICAgICAgICAgICAgICAgICAgICAgICBkZXZfZGJnKHBjdGxkZXYtPmRldiwgIiVzOiAlc1xu IiwgKCptYXApW2ldLmRhdGEubXV4Lmdyb3VwLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgKCptYXApW2ldLmRhdGEubXV4LmZ1bmN0aW9uKTsNCj4gPiArICAgICAgICAgICAg ICAgfQ0KPiA+ICsgICAgICAgfQ0KPiA+ICsNCj4gPiArICAgICAgIC8qDQo+ID4gKyAgICAgICAg KiBQcm9jZXNzIHByb3BlcnRpZXM6DQo+ID4gKyAgICAgICAgKiAgICAgZnVuY3Rpb24gPSAieHh4 IjsNCj4gPiArICAgICAgICAqICAgICBncm91cHMgPSAieXl5IjsNCj4gPiArICAgICAgICAqLw0K PiA+ICsgICAgICAgaWYgKG5tRyA+IDAgJiYgb2ZfcHJvcGVydHlfcmVhZF9zdHJpbmcobnBfY29u ZmlnLCAiZnVuY3Rpb24iLCAmc19mKSA9PSAwKSB7DQo+ID4gKyAgICAgICAgICAgICAgIG9mX3By b3BlcnR5X2Zvcl9lYWNoX3N0cmluZyhucF9jb25maWcsICJncm91cHMiLCBwcm9wLCBzX2cpIHsN Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAoKm1hcClbKm51bV9tYXBzXS50eXBlID0gUElO X01BUF9UWVBFX01VWF9HUk9VUDsNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAoKm1hcClb Km51bV9tYXBzXS5kYXRhLm11eC5mdW5jdGlvbiA9IHNfZjsNCj4gPiArICAgICAgICAgICAgICAg ICAgICAgICAoKm1hcClbKm51bV9tYXBzXS5kYXRhLm11eC5ncm91cCA9IHNfZzsNCj4gPiArICAg ICAgICAgICAgICAgICAgICAgICAoKm51bV9tYXBzKSsrOw0KPiA+ICsNCj4gPiArICAgICAgICAg ICAgICAgICAgICAgICBkZXZfZGJnKHBjdGxkZXYtPmRldiwgIiVzOiAlc1xuIiwgc19mLCBzX2cp Ow0KPiA+ICsgICAgICAgICAgICAgICB9DQo+ID4gKyAgICAgICB9DQo+ID4gKw0KPiA+ICsgICAg ICAgLyoNCj4gPiArICAgICAgICAqIFByb2Nlc3MgcHJvcGVydHk6DQo+ID4gKyAgICAgICAgKiAg ICAgc3VucGx1cyx6ZXJvX2Z1bmMgPSA8IHUzMiB1MzIgdTMyIC4uLj4NCj4gPiArICAgICAgICAq Lw0KPiA+ICsgICAgICAgbGlzdCA9IG9mX2dldF9wcm9wZXJ0eShucF9jb25maWcsICJzdW5wbHVz LHplcm9fZnVuYyIsICZzaXplKTsNCj4gPiArICAgICAgIGlmIChsaXN0KSB7DQo+ID4gKyAgICAg ICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCAoc2l6ZSAvIHNpemVvZigqbGlzdCkpOyBpKyspIHsN Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICBkdF9mdW4gPSBiZTMyX3RvX2NwdShsaXN0W2ld KTsNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICBpZiAoZHRfZnVuID49IHNwcGN0bF9saXN0 X2Z1bmNzX3N6KSB7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkZXZfZXJy KHBjdGxkZXYtPmRldiwgIlplcm8tZnVuYyAlZCBvdXQgb2YgcmFuZ2UhXG4iLA0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkdF9mdW4pOw0KPiA+ICsgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgY29udGludWU7DQo+ID4gKyAgICAgICAgICAgICAgICAg ICAgICAgfQ0KPiA+ICsNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICBmID0gJnNwcGN0bF9s aXN0X2Z1bmNzW2R0X2Z1bl07DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgc3dpdGNoIChm LT50eXBlKSB7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgY2FzZSBwaW5tdXhfdHlwZV9m cG14Og0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3BwY3RsX2Z1bmNfc2V0 KHBjdGwsIGR0X2Z1biwgMCk7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBk ZXZfZGJnKHBjdGxkZXYtPmRldiwgIiVzOiBObyBtYXBcbiIsIGYtPm5hbWUpOw0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7DQo+ID4gKw0KPiA+ICsgICAgICAgICAg ICAgICAgICAgICAgIGNhc2UgcGlubXV4X3R5cGVfZ3JwOg0KPiA+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgc3BwY3RsX2dteF9zZXQocGN0bCwgZi0+cm9mZiwgZi0+Ym9mZiwgZi0+ YmxlbiwgMCk7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkZXZfZGJnKHBj dGxkZXYtPmRldiwgIiVzOiBObyBtYXBcbiIsIGYtPm5hbWUpOw0KPiA+ICsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgYnJlYWs7DQo+ID4gKw0KPiA+ICsgICAgICAgICAgICAgICAgICAg ICAgIGRlZmF1bHQ6DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkZXZfZXJy KHBjdGxkZXYtPmRldiwgIldyb25nIHplcm8tZ3JvdXA6ICVkICglcylcbiIsDQo+ID4gKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGR0X2Z1biwgZi0+bmFtZSk7DQo+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBicmVhazsNCj4gPiArICAgICAgICAgICAg ICAgICAgICAgICB9DQo+ID4gKyAgICAgICAgICAgICAgIH0NCj4gPiArICAgICAgIH0NCj4gPiAr DQo+ID4gKyAgICAgICBvZl9ub2RlX3B1dChwYXJlbnQpOw0KPiA+ICsgICAgICAgZGV2X2RiZyhw Y3RsZGV2LT5kZXYsICIlZCBwaW5zIG1hcHBlZFxuIiwgKm51bV9tYXBzKTsNCj4gPiArICAgICAg IHJldHVybiAwOw0KPiA+ICt9DQo+IA0KPiAuLi4NCj4gDQo+ID4gKyAgICAgICBzcHBjdGwtPmcy ZnBfbWFwcyA9IGRldm1fa2NhbGxvYygmcGRldi0+ZGV2LCBzcHBjdGwtPnVucV9ncnBzX3N6ICsg MSwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNpemVvZigq c3BwY3RsLT5nMmZwX21hcHMpLCBHRlBfS0VSTkVMKTsNCj4gPiArICAgICAgIGlmICghc3BwY3Rs LT5nMmZwX21hcHMpDQo+ID4gKyAgICAgICAgICAgICAgIHJldHVybiAtRU5PTUVNOw0KPiANCj4g PiArICAgICAgIC8qDQo+ID4gKyAgICAgICAgKiBDaGVjayBvbmx5IHByb2R1Y3Qgb2YgbiBhbmQg c2l6ZSBvZiB0aGUgc2Vjb25kIGRldm1fa2NhbGxvYygpDQo+ID4gKyAgICAgICAgKiBiZWNhdXNl IGl0cyBzaXplIGlzIHRoZSBsYXJnZXN0IG9mIHRoZSB0d28uDQo+ID4gKyAgICAgICAgKi8NCj4g PiArICAgICAgIGlmICh1bmxpa2VseShjaGVja19tdWxfb3ZlcmZsb3coc3BwY3RsLT51bnFfZ3Jw c19zeiArIDEsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNp emVvZigqc3BwY3RsLT5nMmZwX21hcHMpLCAmcHJvZCkpKQ0KPiA+ICsgICAgICAgICAgICAgICBy ZXR1cm4gLUVJTlZBTDsNCj4gDQo+IFdoYXQgdGhlIHBvaW50IHRvIGNoZWNrIGl0IGFmdGVyPyBX aGF0IHRoZSBwb2ludCB0byB1c2UgaXQgd2l0aCBrY2FsbG9jKCk/IFBsZWFzZSwgZG8geW91cg0K PiBob21ld29yaywgaS5lLiByZWFkIHRoZSBjb2RlIHdoaWNoIGltcGxlbWVudHMgdGhhdC4NCg0K SSdsbCByZW1vdmUgdGhlICJpZiAodW5saWtlbHkoY2hlY2tfbXVsX292ZXJmbG93KCkuLi4pIHJl dHVybiAtRUlOVkFMIiBzdGF0ZW1lbnQgbmV4dCBwYXRjaC4NCg0KSSB0aGluayBJIG1pcy11bmRl cnN0b29kIHlvdXIgcHJldmlvdXMgY29tbWVudC4NCkkgdGhvdWdodCBJIHdhcyBhc2tlZCB0byBh ZGQgY2hlY2tfbXVsX292ZXJmbG93KCkgZnVuY3Rpb24gZm9yIGRldm1fa2NhbGxvYyguLi4pLg0K U29ycnkgZm9yIHN0cmFuZ2UgY29kZXMuDQoNCkkgc2hvdWxkIHN0dWR5IGRldm1fa2NhbGxvYygp IGZ1cnRoZXJtb3JlLiBOb3cgSSBrbm93IGRldm1fa2NhbGxvYyguLi4pIGRvZXMgDQptdWx0aXBs aWNhdGlvbiBvdmVyZmxvdyBjaGVjayBmb3IgdXMuIFRoYXQncyB3aHkgd2UgbmVlZCB0byBkZXZt X2t6YWxsb2MoKSB3aXRoDQpkZXZtX2tjYWxsb2MoKS4NCg0KT25lIHF1ZXN0aW9uIGxlZnQgaW4g bXkgbWluZCBpcywgaW4gdGhpcyBjYXNlLCBldmVuIHdlIGhhdmUgMTAsMDAwIHBpbnMsIA0Kd2Ug d2lsbCBuZXZlciBnZXQgb3ZlcmZsb3cuIEl0IGxvb2tzIG5vdCBzbyBuZWNlc3NhcnkuDQoNCg0K PiAuLi4NCj4gDQo+ID4gKyAgICAgICBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wID0gb2Zfbm9kZV9n ZXQocGRldi0+ZGV2Lm9mX25vZGUpOw0KPiANCj4gV2hhdCdzIHRoZSByb2xlIG9mIG9mX25vZGVf Z2V0KCk/DQoNCkknbGwgcmVtb3ZlIHRoZSB1bnVzZWQgY29kZXMuDQpJIHRoaW5rIGl0IHdhcyB1 c2VkIHRvIGNoZWNrIGlmIE9GIG5vZGUgZXhpc3RzLg0KDQoNCj4gLi4uDQo+IA0KPiA+ICsgICAg ICAgLyogSW5pdGlhbGl6ZSBwY3RsX2Rlc2MgKi8NCj4gDQo+IFVzZWxlc3MuIERyb3AgYWxsIHVz ZWxlc3MgY29tbWVudHMgbGlrZSB0aGlzIGZyb20gdGhlIGNvZGUuDQoNCkknbGwgcmVtb3ZlIGFs bCB0aGlzIGtpbmQgb2YgY29tbWVudHMuDQoNCg0KPiAuLi4NCj4gDQo+ID4gKyAgICAgICBkZXZf aW5mbygmcGRldi0+ZGV2LCAiU1A3MDIxIFBpbkN0cmwgYnkgU3VucGx1cy9UaWJibyBUZWNoLiIp Ow0KPiANCj4gSXMgaXQgdXNlZnVsPw0KDQpJIHRoaW5rIHllcy4gSXQgdGVsbHMgdXNlcnMgdGhh dCBQaW5jdHJsIGRyaXZlciBoYXMgcHJvYmVkIHN1Y2Nlc3NmdWxseS4NCklmIG5vIHRoaXMgbWVz c2FnZSwgdXNlcnMgZG9uJ3Qga25vdyBpZiBQaW5jdHJsIGRyaXZlciBoYXMgcHJvYmVkIA0Kc3Vj Y2Vzc2Z1bGx5IG9yIG5vdC4gRm9yIGV4YW1wbGUsIGJlY2F1c2UgdGhhdCBkdHMgbm9kZSBvZiBw aW5jdHJsIGlzIA0KImRpc2FibGVkIiBvciBQaW5jdHJsIGRyaXZlciBpcyBldmVuIG5vdCBlbmFi bGVkLg0KDQpDYW4gSSBrZWVwIHRoaXM/DQoNCg0KPiAuLi4NCj4gDQo+ID4gKyNpZm5kZWYgX19T UFBDVExfSF9fDQo+ID4gKyNkZWZpbmUgX19TUFBDVExfSF9fDQo+ID4gKw0KPiA+ICsjaW5jbHVk ZSA8bGludXgvYml0cy5oPg0KPiA+ICsjaW5jbHVkZSA8bGludXgvZ3Bpby9kcml2ZXIuaD4NCj4g DQo+ID4gKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4NCj4gPiArI2luY2x1ZGUgPGxpbnV4L3Bp bmN0cmwvcGluY3RybC5oPg0KPiA+ICsjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4NCj4gDQo+ IHR5cGVzLmggaXMgbWlzc2VkLg0KDQpJJ2xsIGFkZCB0aGUgaGVhZGVyIGZpbGUgbmV4dCBwYXRj aC4NCg0KDQo+IC4uLg0KPiANCj4gPiArLyoqIGVudW0gbXV4X2ZpcnN0X3JlZyAtIGRlZmluZSBt b2RlcyBvZiBGSVJTVCByZWdpc3RlciBhY2Nlc3Nlcw0KPiANCj4gRml4IHRoZSBtdWx0aS1saW5l IGNvbW1lbnQgc3R5bGUuIFlvdSBtZW50aW9uZWQgeW91IGZpeGVkLCBidXQgc2VlbXMgbm90IChu b3QgaW4gYWxsIHBsYWNlcykuDQoNCkknbGwgZml4IGl0Lg0KDQpTb3JyeSBmb3IgbXkgbWlzdGFr ZS4NCkkgbW9kaWZpZWQgbXVsdGktbGluZSBjb21tZW50cyBmb3IgYWxsLg0KTGF0ZXIsIEkgYWRk ZWQgbW9yZSBjb21tZW50cy4gQnV0IEkgDQpmb3Jnb3QgdG8gc3dpdGNoIGJhY2sgZnJvbSBuZXR3 b3JrIG1vZGUuDQoNCg0KPiA+ICsgKiAgICAtIG11eF9mX211eDogIFNlbGVjdCB0aGUgcGluIHRv IGEgZnVsbHktcGlubXV4IHBpbg0KPiA+ICsgKiAgICAtIG11eF9mX2dwaW86IFNlbGVjdCB0aGUg cGluIHRvIGEgR1BJTyBvciBJT1AgcGluDQo+ID4gKyAqICAgIC0gbXV4X2Zfa2VlcDogRG9uJ3Qg Y2hhbmdlIChrZWVwIGludGFjdCkNCj4gPiArICovDQo+ID4gK2VudW0gbXV4X2ZpcnN0X3JlZyB7 DQo+ID4gKyAgICAgICBtdXhfZl9tdXggPSAwLCAgICAgICAgICAvKiBzZWxlY3QgZnVsbHktcGlu bXV4ICAgICAgICovDQo+ID4gKyAgICAgICBtdXhfZl9ncGlvID0gMSwgICAgICAgICAvKiBzZWxl Y3QgR1BJTyBvciBJT1AgcGlubXV4ICovDQo+ID4gKyAgICAgICBtdXhfZl9rZWVwID0gMiwgICAg ICAgICAvKiBrZWVwIG5vIGNoYW5nZSAgICAgICAgICAgICovDQo+ID4gK307DQo+IA0KPiANCj4g PiArc3RydWN0IHNwcGN0bF9ncGlvX2NoaXAgew0KPiA+ICsgICAgICAgdm9pZCBfX2lvbWVtICpn cGlveHRfYmFzZTsgICAgICAvKiBNQVNURVIsIE9FLCBPVVQsIElOLCBJX0lOViwgT19JTlYsIE9E ICovDQo+ID4gKyAgICAgICB2b2lkIF9faW9tZW0gKmZpcnN0X2Jhc2U7ICAgICAgIC8qIEdQSU9f RklSU1QgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8NCj4gPiArDQo+ID4gKyAgICAgICBz dHJ1Y3QgZ3Bpb19jaGlwIGNoaXA7DQo+ID4gKyAgICAgICBzcGlubG9ja190IGxvY2s7ICAgICAg ICAgICAgICAgIC8qIGxvY2sgZm9yIGFjY2Vzc2luZyBPRSByZWdpc3RlciAgICAgICAgKi8NCj4g PiArfTsNCj4gDQo+IFdoeSBpcyB0aGlzIGluIHRoZSBoZWFkZXI/DQoNCkRvIHlvdSBtZWFuIEkg bmVlZCB0byBtb3ZlIHRoaXMgInN0cnVjdCBzcHBjdGxfZ3Bpb19jaGlwIHsgLi4uIH0iIGRlY2xh cmF0aW9uIA0KdG8gYyBmaWxlIGJlY2F1c2UgaXQgaXMgb25seSB1c2VkIGJ5IHRoZSBjIGZpbGU/ DQoNCg0KPiAuLi4NCj4gDQo+ID4gKy8qIFNQNzAyMSBQaW4gQ29udHJvbGxlciBEcml2ZXIuDQo+ ID4gKyAqIENvcHlyaWdodCAoQykgU3VucGx1cyBUZWNoIC8gVGliYm8gVGVjaC4NCj4gPiArICov DQo+IA0KPiBNdWx0aS1saW5lIGNvbW1lbnRzLg0KDQpJJ2xsIGZpeCBpdC4NClNvcnJ5IGZvciBt aXN0YWtlLiBJIG92ZXJsb29rZWQgdGhlIGZpbGUgaGVhZGVyLg0KDQoNCj4gSSBzdG9wcGVkIGhl cmUsIHBsZWFzZSByZWFkIG15IGNvbW1lbnRzIGZvciBwcmV2aW91cyB2ZXJzaW9ucyBhbmQgaGVy ZSBhbmQgdHJ5IHlvdXIgYmVzdC4NCg0KSSByZWFkIGFsbCB5b3VyIGNvbW1lbnRzIG1hbnkgdGlt ZXMuDQpJJ2xsIGRvIG15IGJlc3QgdG8gYWRkcmVzcyBhbGwgY29tbWVudHMuDQpTb3JyeSBmb3Ig bWlzLXVuZGVyc3RhbmQgc29tZSBjb21tZW50cy4NCg0KDQpZb3VyIHByZXZpb3VzIGNvbW1lbnRz Og0KPiA+ID4gPiArc3RhdGljIGludCBzcHBjdGxfZHRfbm9kZV90b19tYXAoc3RydWN0IHBpbmN0 cmxfZGV2ICpwY3RsZGV2LCBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wX2NvbmZpZywNCj4gPiA+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHBpbmN0cmxfbWFwICoqbWFw LCB1bnNpZ25lZCANCj4gPiA+ID4gK2ludCAqbnVtX21hcHMpIHsNCj4gPiA+DQo+ID4gPiBMb29r aW5nIGludG8gdGhpcyByYXRoZXIgcXVpdGUgYmlnIGZ1bmN0aW9uIHdoeSB5b3UgY2FuJ3QgdXNl IHdoYXQgcGluIGNvbnRyb2wgY29yZSBwcm92aWRlcz8NCj4gPg0KPiA+IE5vLCB3ZSBjYW5ub3Qg dXNlIGZ1bmN0aW9ucyBwaW4tY29udHJvbCBjb3JlIHByb3ZpZGVzLg0KPiA+IFBsZWFzZSByZWZl ciB0byBkdC1iaW5kaW5ncyBkb2N1bWVudCwgInBpbmN0cmwvc3VucGx1cyxzcDcwMjEtcGluY3Ry bC55YW1sIi4NCj4gPiBXZSBoYXZlIG1vcmUgZXhwbGFuYXRpb24gdGhlcmUuDQo+DQo+IEZpbmUs IGNhbiB5b3UgcmV1c2Ugc29tZSBsaWJyYXJ5IGZ1bmN0aW9ucywgZXRjPyBQbGVhc2UsIGNvbnNp ZGVyIHJlZmFjdG9yaW5nIHRvIG1ha2UgaXQgbW9yZSByZWFkYWJsZS4NCg0KQ291bGQgeW91IHBs ZWFzZSBzaGFyZSBtZSB5b3VyIGlkZWEgYWJvdXQgInJlZmFjdG9yaW5nIj8NCk9yIGNvdWxkIHlv dSBnaXZlIG1lIHNvbWUgaGludHM/DQpJIHRoaW5rIG1hbnkgdGltZXMsIGJ1dCBoYXZlIG5vIGlk ZWEgYWJvdXQgcmVmYWN0b3JpbmcuDQoNCg0KPiAtLQ0KPiBXaXRoIEJlc3QgUmVnYXJkcywNCj4g QW5keSBTaGV2Y2hlbmtvDQo= 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 2285BC433F5 for ; Tue, 28 Dec 2021 15:40:45 +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:In-Reply-To:References: Message-ID:Date:Subject:CC:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=XInwpWlnCnnPCZ/c5hbxib56KBb9Cau9iniA553R9Ew=; b=fGiL6Hf5dcVhHS 0TC2zp4WOUez2Er7ISi5wNb45LLfgoEXTsvRVa+4IpKCbi+RrutV/RN8M5W3xLar2vsK7ca0TCvJD awQIJTTdAt1DSzndVRpq4ihZxOoPjM602Zkfm9+um8tr7IQyVj0ZS6q0G8mTUmoTpC97X/iQ9AXPy l3IqwiFZ25KUkBkXqg2ZXKRY40KNh5hkc9xaiiyHt2GTaJj/VVcdaf9ifQhEB0KHoHa2qLIc4bV2E DTQ0h8Ki10XetHxgYPpyqZzSNR9Aeg2oHHAcsev+NFlw9DP23o8R2iFaUSQaaYxpeykjzGgAAT28g 3IVdG3C9EhF3VlitC1rw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1n2EYx-001Rrf-GI; Tue, 28 Dec 2021 15:38:55 +0000 Received: from mswedge1.sunplus.com ([60.248.182.113] helo=mg.sunplus.com) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1n2EYr-001RrC-O4 for linux-arm-kernel@lists.infradead.org; Tue, 28 Dec 2021 15:38:53 +0000 X-MailGates: (flag:3,DYNAMIC,RELAY,NOHOST:PASS)(compute_score:DELIVER,40 ,3) Received: from 172.17.9.202 by mg01.sunplus.com with MailGates ESMTP Server V5.0(4603:0:AUTH_RELAY) (envelope-from ); Tue, 28 Dec 2021 23:38:33 +0800 (CST) Received: from sphcmbx02.sunplus.com.tw (172.17.9.112) by sphcmbx01.sunplus.com.tw (172.17.9.202) with Microsoft SMTP Server (TLS) id 15.0.1497.26; Tue, 28 Dec 2021 23:38:28 +0800 Received: from sphcmbx02.sunplus.com.tw ([fe80::fd3d:ad1a:de2a:18bd]) by sphcmbx02.sunplus.com.tw ([fe80::fd3d:ad1a:de2a:18bd%14]) with mapi id 15.00.1497.026; Tue, 28 Dec 2021 23:38:28 +0800 From: =?utf-8?B?V2VsbHMgTHUg5ZGC6Iqz6aiw?= To: Andy Shevchenko , Wells Lu CC: Linus Walleij , "open list:GPIO SUBSYSTEM" , Linux Kernel Mailing List , Rob Herring , devicetree , linux-arm Mailing List , "dvorkin@tibbo.com" Subject: RE: [PATCH v5 2/2] pinctrl: Add driver for Sunplus SP7021 Thread-Topic: [PATCH v5 2/2] pinctrl: Add driver for Sunplus SP7021 Thread-Index: AQHX+JsJQRl6kRXEwk+dQHdfPj/+4axC0feAgAMwBYA= Date: Tue, 28 Dec 2021 15:38:28 +0000 Message-ID: References: <1640331779-18277-1-git-send-email-wellslutw@gmail.com> <1640331779-18277-3-git-send-email-wellslutw@gmail.com> In-Reply-To: Accept-Language: zh-TW, en-US Content-Language: zh-TW X-MS-Has-Attach: X-MS-TNEF-Correlator: x-ms-exchange-transport-fromentityheader: Hosted x-originating-ip: [172.25.108.39] MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20211228_073850_277965_4E4128D6 X-CRM114-Status: GOOD ( 35.18 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Hi Andy, Thanks a lot for your review. Please see my answers below: > > > > Add driver for Sunplus SP7021 SoC. > > Thanks for an update, my comments below. > > ... > > > +config PINCTRL_SPPCTL > > + bool "Sunplus SP7021 PinMux and GPIO driver" > > Why bool and not tristate? Pinctrl driver is selected by many drivers in SP7021 platform. We never build it as a module, but build-in to kernel. So we use "bool". Should we set it to tristate? > > > + depends on SOC_SP7021 > > + depends on OF && HAS_IOMEM > > ... > > > +#include > > +#include > > > +#include > > +#include #include > > + > > Can you move this group... > > > +#include > > +#include > > +#include > > ...to be somewhere here? Yes, I'll move it next patch. > > +#include > > ... > > > +/* inline functions */ > > Useless. I'll remove all this kind of comments next patch. > ... > > > + mask = GENMASK(bit_sz - 1, 0) << (bit_off + SPPCTL_GROUP_PINMUX_MASK_SHIFT); > > + reg = mask | (val << bit_off); > > Now you may do one step forward: > > mask = GENMASK(bit_sz - 1, 0) << SPPCTL_GROUP_PINMUX_MASK_SHIFT; > reg = (val | mask) << bit_off; I'll revise these statements as code you've shared. > ... > > > +static void sppctl_first_master_set(struct gpio_chip *chip, unsigned int offset, > > + enum mux_first_reg first, enum > > +mux_master_reg master) { > > + struct sppctl_gpio_chip *spp_gchip = gpiochip_get_data(chip); > > + u32 reg_off, bit_off, reg; > > + int val; > > + > > + /* FIRST register */ > > + if (first != mux_f_keep) { > > + /* > > + * Refer to descriptions of function sppctl_first_get() > > + * for usage of FIRST registers. > > + */ > > + reg_off = (offset / 32) * 4; > > + bit_off = offset % 32; > > + > > + reg = sppctl_first_readl(spp_gchip, reg_off); > > + val = (reg & BIT(bit_off)) ? 1 : 0; > > > + if (first != val) { > > first is enum, val is int, are you sure it's good to compare like this? No, it is always not good to compare different type of things. I'll modify code as shown below: enum mux_first_reg val; : : val = (reg & BIT(bit_off)) ? mux_f_gpio : mux_f_mux; > > + if (first == mux_f_gpio) > > + reg |= BIT(bit_off); > > + else > > + reg &= ~BIT(bit_off); > > > Since you operate against enums it's better to use switch-case. I'll modify code as shown below: if (first != val) switch (first) { case mux_f_gpio: reg |= BIT(bit_off); sppctl_first_writel(spp_gchip, reg, reg_off); break; case mux_f_mux: reg &= ~BIT(bit_off); sppctl_first_writel(spp_gchip, reg, reg_off); break; case mux_f_keep: break; } > > + sppctl_first_writel(spp_gchip, reg, reg_off); > > + } > > + } > > + > > + /* MASTER register */ > > + if (master != mux_m_keep) { > > + /* > > + * Refer to descriptions of function sppctl_master_get() > > + * for usage of MASTER registers. > > + */ > > + reg_off = (offset / 16) * 4; > > + bit_off = offset % 16; > > + > > + reg = BIT(bit_off) << SPPCTL_MASTER_MASK_SHIFT; > > + if (master == mux_m_gpio) > > + reg |= BIT(bit_off); > > + sppctl_gpio_master_writel(spp_gchip, reg, reg_off); > > + } > > +} > > ... > > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT) | BIT(bit_off); > > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT) | BIT(bit_off); > > Perhaps a macro with definitive name? I'll define two new macros: #define SPPCTL_MOON_REG_MASK_SHIFT 16 #define SPPCTL_SET_MOON_REG_BIT(bit) (BIT(bit + SPPCTL_MOON_REG_MASK_SHIFT) | BIT(bit)) #define SPPCTL_CLR_MOON_REG_BIT(bit) BIT(bit + SPPCTL_MOON_REG_MASK_SHIFT) And modify code as shown below: reg = SPPCTL_SET_MOON_REG_BIT(bit_off); > ... > > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT); > > + if (val) > > + reg |= BIT(bit_off); > > You can use it even here: > > if (val) > reg = MY_MACRO(bit_off) > else > reg = BIT(...) // perhaps another macro I'll modify code as shown below: if (val) reg = SPPCTL_SET_MOON_REG_BIT(bit_off); else reg = SPPCTL_CLR_MOON_REG_BIT(bit_off); > ... > > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT); > > Ditto. I'll modify code as shown below: reg = SPPCTL_CLR_MOON_REG_BIT(bit_off); > ... > > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT) | BIT(bit_off); > > Ditto. I'll modify code as shown shown below: reg = SPPCTL_SET_MOON_REG_BIT(bit_off); > ... > > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT); > > + if (val) > > + reg |= BIT(bit_off); > > Ditto. I'll modify code as shown below: if (val) reg = SPPCTL_SET_MOON_REG_BIT(bit_off); else reg = SPPCTL_CLR_MOON_REG_BIT(bit_off); > ... > > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT); > > + if (val) > > + reg |= BIT(bit_off); > > Ditto. I'll modify code as shown in above case. > And looking into repetition, you may even have a helper which does this conditional > > static inline u32 sppctl_...() > { > ... > return reg; > } I'll add an inline function as shown below: static inline u32 sppctl_prep_moon_reg(u32 bit_off, int val) { if (val) return SPPCTL_SET_MOON_REG_BIT(bit_off); else return SPPCTL_CLR_MOON_REG_BIT(bit_off); } And replace all "if (val) ... " with the inline function. > ... > > > + int ret = 0; > > Redundant variable, return directly. I'll remove the redundant variable. > > + switch (param) { > > + case PIN_CONFIG_DRIVE_OPEN_DRAIN: > > + /* > > + * Upper 16-bit word is mask. Lower 16-bit word is value. > > + * Refer to descriptions of function sppctl_master_get(). > > + */ > > + reg_off = (offset / 16) * 4; > > + bit_off = offset % 16; > > + reg = BIT(bit_off + SPPCTL_GPIO_MASK_SHIFT) | > > + BIT(bit_off); > > As I commented above use helper function which takes offset as input and returns you reg > and reg_off. I'll modify code as shown below: reg = SPPCTL_SET_MOON_REG_BIT(bit_off); Sorry, I don't understand your meaning "returns you reg and reg_off". The helper macro will return reg but not reg_off, right? > > + sppctl_gpio_od_writel(spp_gchip, reg, reg_off); > > + break; > > + > > + case PIN_CONFIG_INPUT_ENABLE: > > + break; > > + > > + case PIN_CONFIG_OUTPUT: > > + ret = sppctl_gpio_direction_output(chip, offset, 0); > > + break; > > + > > + case PIN_CONFIG_PERSIST_STATE: > > + ret = -ENOTSUPP; > > + break; > > + > > + default: > > + ret = -EINVAL; > > + break; > > + } > > + > > + return ret; > > +} > > ... > > > + if (!of_find_property(pdev->dev.of_node, "gpio-controller", NULL)) > > + return dev_err_probe(&pdev->dev, -EINVAL, "Not a > > + gpio-controller!\n"); > > Why do you need this check for? By referring to other pinctrl driver, we check if property "gpio-controller" exists? Will core help us check this? Is this redundant? > ... > > > + gchip->can_sleep = 0; > > Besides that it's already cleared, the type here is boolean. I'll remove the unnecessary assignment as the whole structure is initialized to 0. Should I also remove the assignment: gchip->base = 0; > ... > > > +/* pinconf operations */ > > Any value of this comment? I'll remove it. > > +static int sppctl_pin_config_get(struct pinctrl_dev *pctldev, unsigned int pin, > > + unsigned long *config) { > > + struct sppctl_pdata *pctl = pinctrl_dev_get_drvdata(pctldev); > > + unsigned int param = pinconf_to_config_param(*config); > > > + unsigned int arg = 0; > > Move assignment to where it actually makes sense. I'll move it as shown below: case PIN_CONFIG_DRIVE_OPEN_DRAIN: if (!sppctl_gpio_output_od_get(&pctl->spp_gchip->chip, pin)) return -EINVAL; arg = 0; break; > > + switch (param) { > > + case PIN_CONFIG_DRIVE_OPEN_DRAIN: > > + if (!sppctl_gpio_output_od_get(&pctl->spp_gchip->chip, pin)) > > + return -EINVAL; > > + break; > > + > > + case PIN_CONFIG_OUTPUT: > > + if (!sppctl_first_get(&pctl->spp_gchip->chip, pin)) > > + return -EINVAL; > > + if (!sppctl_master_get(&pctl->spp_gchip->chip, pin)) > > + return -EINVAL; > > + if (sppctl_gpio_get_direction(&pctl->spp_gchip->chip, pin)) > > + return -EINVAL; > > + arg = sppctl_gpio_get(&pctl->spp_gchip->chip, pin); > > + break; > > + > > + default: > > + return -EOPNOTSUPP; > > + } > > + *config = pinconf_to_config_packed(param, arg); > > + > > + return 0; > > +} > > ... > > > + switch (f->type) { > > + case pinmux_type_fpmx: /* fully-pinmux */ > > Why do you need these comments? > Shouldn't you rather to kernel doc your enum entries? I'll remove the comments. Could you please tell me where I should write and put my kernel doc? Is there any examples I can refer to? > > + *num_groups = sppctl_pmux_list_sz; > > + *groups = sppctl_pmux_list_s; > > + break; > > + > > + case pinmux_type_grp: /* group-pinmux */ > > + if (!f->grps) > > + break; > > + > > + *num_groups = f->gnum; > > + for (i = 0; i < pctl->unq_grps_sz; i++) > > + if (pctl->g2fp_maps[i].f_idx == selector) > > + break; > > + *groups = &pctl->unq_grps[i]; > > + break; > > > + } > > > +/** sppctl_fully_pinmux_conv - Convert GPIO# to fully-pinmux > > +control-field setting > > + * > > + * Each fully-pinmux function can be mapped to any of GPIO 8 ~ 71 by > > + * settings its control-field. Refer to following table: > > + * > > + * control-field | GPIO > > + * --------------+-------- > > + * 0 | No map > > + * 1 | 8 > > + * 2 | 9 > > + * 3 | 10 > > + * : | : > > + * 65 | 71 > > + */ > > +static inline int sppctl_fully_pinmux_conv(unsigned int offset) { > > + return (offset < 8) ? 0 : offset - 7; } > > ... > > > +static const struct pinmux_ops sppctl_pinmux_ops = { > > + .get_functions_count = sppctl_get_functions_count, > > + .get_function_name = sppctl_get_function_name, > > + .get_function_groups = sppctl_get_function_groups, > > + .set_mux = sppctl_set_mux, > > + .gpio_request_enable = sppctl_gpio_request_enable, > > > + .strict = true > > + Comma. I'll add a comma right after 'true'. > > +}; > > ... > > > +static int sppctl_dt_node_to_map(struct pinctrl_dev *pctldev, struct device_node > *np_config, > > + struct pinctrl_map **map, unsigned > > +int *num_maps) { > > + struct sppctl_pdata *pctl = pinctrl_dev_get_drvdata(pctldev); > > + int nmG = of_property_count_strings(np_config, "groups"); > > + const struct sppctl_func *f = NULL; > > + u8 pin_num, pin_type, pin_func; > > + struct device_node *parent; > > + unsigned long *configs; > > + struct property *prop; > > + const char *s_f, *s_g; > > + > > + const __be32 *list; > > + u32 dt_pin, dt_fun; > > + int i, size = 0; > > + > > + list = of_get_property(np_config, "sunplus,pins", &size); > > + > > + if (nmG <= 0) > > + nmG = 0; > > + > > + parent = of_get_parent(np_config); > > + *num_maps = size / sizeof(*list); > > + > > + /* > > + * Process property: > > + * sunplus,pins = < u32 u32 u32 ... >; > > + * > > + * Each 32-bit integer defines a individual pin in which: > > + * > > + * Bit 32~24: defines GPIO pin number. Its range is 0 ~ 98. > > + * Bit 23~16: defines types: (1) fully-pinmux pins > > + * (2) IO processor pins > > + * (3) digital GPIO pins > > + * Bit 15~8: defines pins of peripherals (which are defined in > > + * 'include/dt-binging/pinctrl/sppctl.h'). > > + * Bit 7~0: defines types or initial-state of digital GPIO pins. > > + */ > > + for (i = 0; i < (*num_maps); i++) { > > + dt_pin = be32_to_cpu(list[i]); > > + pin_num = FIELD_GET(GENMASK(31, 24), dt_pin); > > + > > + /* Check if out of range? */ > > + if (pin_num >= sppctl_pins_all_sz) { > > + dev_err(pctldev->dev, "Invalid pin property at index %d > (0x%08x)\n", > > + i, dt_pin); > > + return -EINVAL; > > + } > > + } > > + > > + *map = kcalloc(*num_maps + nmG, sizeof(**map), GFP_KERNEL); > > + for (i = 0; i < (*num_maps); i++) { > > + dt_pin = be32_to_cpu(list[i]); > > + pin_num = FIELD_GET(GENMASK(31, 24), dt_pin); > > + pin_type = FIELD_GET(GENMASK(23, 16), dt_pin); > > + pin_func = FIELD_GET(GENMASK(15, 8), dt_pin); > > + (*map)[i].name = parent->name; > > + > > + if (pin_type == SPPCTL_PCTL_G_GPIO) { > > + /* A digital GPIO pin */ > > + (*map)[i].type = PIN_MAP_TYPE_CONFIGS_PIN; > > + (*map)[i].data.configs.num_configs = 1; > > + (*map)[i].data.configs.group_or_pin = pin_get_name(pctldev, > pin_num); > > + configs = kmalloc(sizeof(*configs), GFP_KERNEL); > > + *configs = FIELD_GET(GENMASK(7, 0), dt_pin); > > + (*map)[i].data.configs.configs = configs; > > + > > + dev_dbg(pctldev->dev, "%s: GPIO (%s)\n", > > + (*map)[i].data.configs.group_or_pin, > > + (*configs & (SPPCTL_PCTL_L_OUT | SPPCTL_PCTL_L_OU1)) ? > > + "OUT" : "IN"); > > + } else if (pin_type == SPPCTL_PCTL_G_IOPP) { > > + /* A IO Processor (IOP) pin */ > > + (*map)[i].type = PIN_MAP_TYPE_CONFIGS_PIN; > > + (*map)[i].data.configs.num_configs = 1; > > + (*map)[i].data.configs.group_or_pin = pin_get_name(pctldev, > pin_num); > > + configs = kmalloc(sizeof(*configs), GFP_KERNEL); > > + *configs = SPPCTL_IOP_CONFIGS; > > + (*map)[i].data.configs.configs = configs; > > + > > + dev_dbg(pctldev->dev, "%s: IOP\n", > > + (*map)[i].data.configs.group_or_pin); > > + } else { > > + /* A fully-pinmux pin */ > > + (*map)[i].type = PIN_MAP_TYPE_MUX_GROUP; > > + (*map)[i].data.mux.function = sppctl_list_funcs[pin_func].name; > > + (*map)[i].data.mux.group = > > + pin_get_name(pctldev, pin_num); > > + > > + dev_dbg(pctldev->dev, "%s: %s\n", (*map)[i].data.mux.group, > > + (*map)[i].data.mux.function); > > + } > > + } > > + > > + /* > > + * Process properties: > > + * function = "xxx"; > > + * groups = "yyy"; > > + */ > > + if (nmG > 0 && of_property_read_string(np_config, "function", &s_f) == 0) { > > + of_property_for_each_string(np_config, "groups", prop, s_g) { > > + (*map)[*num_maps].type = PIN_MAP_TYPE_MUX_GROUP; > > + (*map)[*num_maps].data.mux.function = s_f; > > + (*map)[*num_maps].data.mux.group = s_g; > > + (*num_maps)++; > > + > > + dev_dbg(pctldev->dev, "%s: %s\n", s_f, s_g); > > + } > > + } > > + > > + /* > > + * Process property: > > + * sunplus,zero_func = < u32 u32 u32 ...> > > + */ > > + list = of_get_property(np_config, "sunplus,zero_func", &size); > > + if (list) { > > + for (i = 0; i < (size / sizeof(*list)); i++) { > > + dt_fun = be32_to_cpu(list[i]); > > + if (dt_fun >= sppctl_list_funcs_sz) { > > + dev_err(pctldev->dev, "Zero-func %d out of range!\n", > > + dt_fun); > > + continue; > > + } > > + > > + f = &sppctl_list_funcs[dt_fun]; > > + switch (f->type) { > > + case pinmux_type_fpmx: > > + sppctl_func_set(pctl, dt_fun, 0); > > + dev_dbg(pctldev->dev, "%s: No map\n", f->name); > > + break; > > + > > + case pinmux_type_grp: > > + sppctl_gmx_set(pctl, f->roff, f->boff, f->blen, 0); > > + dev_dbg(pctldev->dev, "%s: No map\n", f->name); > > + break; > > + > > + default: > > + dev_err(pctldev->dev, "Wrong zero-group: %d (%s)\n", > > + dt_fun, f->name); > > + break; > > + } > > + } > > + } > > + > > + of_node_put(parent); > > + dev_dbg(pctldev->dev, "%d pins mapped\n", *num_maps); > > + return 0; > > +} > > ... > > > + sppctl->g2fp_maps = devm_kcalloc(&pdev->dev, sppctl->unq_grps_sz + 1, > > + sizeof(*sppctl->g2fp_maps), GFP_KERNEL); > > + if (!sppctl->g2fp_maps) > > + return -ENOMEM; > > > + /* > > + * Check only product of n and size of the second devm_kcalloc() > > + * because its size is the largest of the two. > > + */ > > + if (unlikely(check_mul_overflow(sppctl->unq_grps_sz + 1, > > + sizeof(*sppctl->g2fp_maps), &prod))) > > + return -EINVAL; > > What the point to check it after? What the point to use it with kcalloc()? Please, do your > homework, i.e. read the code which implements that. I'll remove the "if (unlikely(check_mul_overflow()...) return -EINVAL" statement next patch. I think I mis-understood your previous comment. I thought I was asked to add check_mul_overflow() function for devm_kcalloc(...). Sorry for strange codes. I should study devm_kcalloc() furthermore. Now I know devm_kcalloc(...) does multiplication overflow check for us. That's why we need to devm_kzalloc() with devm_kcalloc(). One question left in my mind is, in this case, even we have 10,000 pins, we will never get overflow. It looks not so necessary. > ... > > > + struct device_node *np = of_node_get(pdev->dev.of_node); > > What's the role of of_node_get()? I'll remove the unused codes. I think it was used to check if OF node exists. > ... > > > + /* Initialize pctl_desc */ > > Useless. Drop all useless comments like this from the code. I'll remove all this kind of comments. > ... > > > + dev_info(&pdev->dev, "SP7021 PinCtrl by Sunplus/Tibbo Tech."); > > Is it useful? I think yes. It tells users that Pinctrl driver has probed successfully. If no this message, users don't know if Pinctrl driver has probed successfully or not. For example, because that dts node of pinctrl is "disabled" or Pinctrl driver is even not enabled. Can I keep this? > ... > > > +#ifndef __SPPCTL_H__ > > +#define __SPPCTL_H__ > > + > > +#include > > +#include > > > +#include > > +#include > > +#include > > types.h is missed. I'll add the header file next patch. > ... > > > +/** enum mux_first_reg - define modes of FIRST register accesses > > Fix the multi-line comment style. You mentioned you fixed, but seems not (not in all places). I'll fix it. Sorry for my mistake. I modified multi-line comments for all. Later, I added more comments. But I forgot to switch back from network mode. > > + * - mux_f_mux: Select the pin to a fully-pinmux pin > > + * - mux_f_gpio: Select the pin to a GPIO or IOP pin > > + * - mux_f_keep: Don't change (keep intact) > > + */ > > +enum mux_first_reg { > > + mux_f_mux = 0, /* select fully-pinmux */ > > + mux_f_gpio = 1, /* select GPIO or IOP pinmux */ > > + mux_f_keep = 2, /* keep no change */ > > +}; > > > > +struct sppctl_gpio_chip { > > + void __iomem *gpioxt_base; /* MASTER, OE, OUT, IN, I_INV, O_INV, OD */ > > + void __iomem *first_base; /* GPIO_FIRST */ > > + > > + struct gpio_chip chip; > > + spinlock_t lock; /* lock for accessing OE register */ > > +}; > > Why is this in the header? Do you mean I need to move this "struct sppctl_gpio_chip { ... }" declaration to c file because it is only used by the c file? > ... > > > +/* SP7021 Pin Controller Driver. > > + * Copyright (C) Sunplus Tech / Tibbo Tech. > > + */ > > Multi-line comments. I'll fix it. Sorry for mistake. I overlooked the file header. > I stopped here, please read my comments for previous versions and here and try your best. I read all your comments many times. I'll do my best to address all comments. Sorry for mis-understand some comments. Your previous comments: > > > > +static int sppctl_dt_node_to_map(struct pinctrl_dev *pctldev, struct device_node *np_config, > > > > + struct pinctrl_map **map, unsigned > > > > +int *num_maps) { > > > > > > Looking into this rather quite big function why you can't use what pin control core provides? > > > > No, we cannot use functions pin-control core provides. > > Please refer to dt-bindings document, "pinctrl/sunplus,sp7021-pinctrl.yaml". > > We have more explanation there. > > Fine, can you reuse some library functions, etc? Please, consider refactoring to make it more readable. Could you please share me your idea about "refactoring"? Or could you give me some hints? I think many times, but have no idea about refactoring. > -- > With Best Regards, > Andy Shevchenko _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel