From mboxrd@z Thu Jan 1 00:00:00 1970 From: Vasant Hegde Subject: Re: [PATCH v5 3/3] leds/powernv: Add driver for PowerNV platform Date: Thu, 16 Jul 2015 12:24:57 +0530 Message-ID: <55A75541.4060008@linux.vnet.ibm.com> References: <1435740638-16259-1-git-send-email-hegdevasant@linux.vnet.ibm.com> <1435740638-16259-4-git-send-email-hegdevasant@linux.vnet.ibm.com> <55A4CFA0.6090306@samsung.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <55A4CFA0.6090306@samsung.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linuxppc-dev-bounces+glppe-linuxppc-embedded-2=m.gmane.org@lists.ozlabs.org Sender: "Linuxppc-dev" To: Jacek Anaszewski Cc: stewart@linux.vnet.ibm.com, arnd@arndb.de, j.anaszewski81@gmail.com, cooloney@gmail.com, rpurdie@rpsys.net, linuxppc-dev@lists.ozlabs.org, linux-leds@vger.kernel.org, khandual@linux.vnet.ibm.com List-Id: linux-leds@vger.kernel.org T24gMDcvMTQvMjAxNSAwMjozMCBQTSwgSmFjZWsgQW5hc3pld3NraSB3cm90ZToKPiBIaSBWYXNh bnQsCgpKYWNlaywKCj4gCj4gVGhhbmtzIGZvciB0aGUgdXBkYXRlLiBJIHRoaW5rIHRoYXQgd2Ug aGF2ZSBzdGlsbCByb29tCj4gZm9yIGltcHJvdmVtZW50cywgcGxlYXNlIGxvb2sgYXQgbXkgY29t bWVudHMgYmVsb3cuCgpUaGFua3MgZm9yIHRoZSBkZXRhaWxlZCByZXZpZXcuCgoKLi4uLy4uLgoK Pj4gQEAgLTAsMCArMSwyNCBAQAo+PiArRGV2aWNlIFRyZWUgYmluZGluZyBmb3IgTEVEcyBvbiBJ Qk0gUG93ZXIgU3lzdGVtcwo+PiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQo+PiArCj4gCj4gUGxlYXNlIHN0YXJ0IHdpdGg6Cj4gCj4gLS0tLS0tLS0t Cj4gCj4gUmVxdWlyZWQgcHJvcGVydGllczoKPiAtIGNvbXBhdGlibGUgOiBTaG91bGQgYmUgImli bSxvcGFsLXYzLWxlZCIuCj4gCj4gRWFjaCBsb2NhdGlvbiBjb2RlIG9mIEZSVS9FbmNsb3N1cmUg bXVzdCBiZSBleHByZXNzZWQgaW4gdGhlCj4gZm9ybSBvZiBhIHN1Yi1ub2RlLgo+IAo+IFJlcXVp cmVkIHByb3BlcnRpZXMgZm9yIHRoZSBzdWIgbm9kZXM6Cj4gLSBsZWQtdHlwZXMgOiBTdXBwb3J0 ZWQgTEVEIHR5cGVzIChhdHRlbnRpb24vaWRlbnRpZnkvZmF1bHQpIHByb3ZpZGVkCj4gICAgICAg ICAgIGluIHRoZSBmb3JtIG9mIHN0cmluZyBhcnJheS4KPiAKPiAtLS0tLS0tLS0KPiAKPiBvciBz b21ldGhpbmcgb2YgdGhpcyBmbGF2b3VyLiBUaGUgZXhhbXBsZSBzaG91bGQgYmUgYXQgdGhlIGVu ZC4KPiAKCkZpeGVkLgoKPiAKPiAKPj4gK1RoZSAnbGVkcycgbm9kZSB1bmRlciAnL2libSxvcGFs JyBsaXN0cyBzZXJ2aWNlIGluZGljYXRvcnMgYXZhaWxhYmxlIGluIHRoZQo+PiArc3lzdGVtIGFu ZCB0aGVpciBjYXBhYmlsaXRpZXMuCj4+ICsKPj4gK2xlZHMgewo+PiArICAgIGNvbXBhdGlibGUg PSAiaWJtLG9wYWwtdjMtbGVkIjsKPj4gKyAgICBsZWQtbW9kZSA9ICJsaWdodHBhdGgiOwo+IAo+ IFdoYXQgYWJvdXQgbGVkLW1vZGUgcHJvcGVydHk/IElmIGl0IGlzIGdlbmVyYXRlZCBieSBmaXJt d2FyZSBJIHRoaW5rLAo+IHRoYXQgdGhpcyBzaG91bGQgYmUgbWVudGlvbmVkIHNvbWVob3cuCgpZ ZXMuLiBJdHMgZ2VuZXJhdGVkIGJ5IGZpcm13YXJlLiBBZGRlZCB0aGlzIHByb3BlcnR5IHRvIGRv Y3VtZW50YXRpb24gZmlsZS4KCj4gCj4+ICsKPj4gKyAgICBVNzhDOS4wMDEuUlNUMDAyNy1QMS1D MSB7Cj4+ICsgICAgICAgIGxlZC10eXBlcyA9ICJpZGVudGlmeSIsICJmYXVsdCI7Cj4+ICsgICAg fTsKPj4gKyAgICAuLi4KPj4gKyAgICAuLi4KPj4gK307Cj4+ICsKPj4gK0VhY2ggbm9kZSB1bmRl ciAnbGVkcycgbm9kZSBkZXNjcmliZXMgbG9jYXRpb24gY29kZSBvZiBGUlUvRW5jbG9zdXJlLgo+ PiArCj4+ICtjb21wYXRpYmxlIDogc2hvdWxkIGJlIDogImlibSxvcGFsLXYzLWxlZCIuCj4gCj4g U2Vjb25kIGNvbG9uIHdhcyByZWR1bmRhbnQgaGVyZS4KPiAKCkkgaGF2ZSBhZGRlZCBhcwotICBj b21wYXRpYmxlIDogImlibSxvcGFsLXYzLWxlZCIuCgoKPj4gKwo+PiArVGhlIHByb3BlcnRpZXMg dW5kZXIgZWFjaCBub2RlOgo+PiArCj4+ICsgIGxlZC10eXBlcyA6IFN1cHBvcnRlZCBMRUQgdHlw ZXMgKGF0dGVudGlvbi9pZGVudGlmeS9mYXVsdCkuCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2xl ZHMvS2NvbmZpZyBiL2RyaXZlcnMvbGVkcy9LY29uZmlnCj4+IGluZGV4IDQxOTE2MTQuLjRmNTZj N2EgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvbGVkcy9LY29uZmlnCj4+ICsrKyBiL2RyaXZlcnMv bGVkcy9LY29uZmlnCj4+IEBAIC01MDUsNiArNTA1LDE3IEBAIGNvbmZpZyBMRURTX0JMSU5LTQo+ PiAgICAgICAgIFRoaXMgb3B0aW9uIGVuYWJsZXMgc3VwcG9ydCBmb3IgdGhlIEJsaW5rTSBSR0Ig TEVEIGNvbm5lY3RlZAo+PiAgICAgICAgIHRocm91Z2ggSTJDLiBTYXkgWSB0byBlbmFibGUgc3Vw cG9ydCBmb3IgdGhlIEJsaW5rTSBMRUQuCj4+Cj4+ICtjb25maWcgTEVEU19QT1dFUk5WCj4+ICsg ICAgdHJpc3RhdGUgIkxFRCBzdXBwb3J0IGZvciBQb3dlck5WIFBsYXRmb3JtIgo+PiArICAgIGRl cGVuZHMgb24gTEVEU19DTEFTUwo+PiArICAgIGRlcGVuZHMgb24gUFBDX1BPV0VSTlYKPj4gKyAg ICBkZXBlbmRzIG9uIE9GCj4+ICsgICAgaGVscAo+PiArICAgICAgVGhpcyBvcHRpb24gZW5hYmxl cyBzdXBwb3J0IGZvciB0aGUgc3lzdGVtIExFRHMgcHJlc2VudCBvbgo+PiArICAgICAgUG93ZXJO ViBwbGF0Zm9ybXMuIFNheSAneScgdG8gZW5hYmxlIHRoaXMgc3VwcG9ydCBpbiBrZXJuZWwuCj4+ ICsgICAgICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgJ20nIGhl cmU6IHRoZSBtb2R1bGUKPj4gKyAgICAgIHdpbGwgYmUgY2FsbGVkIGxlZHMtcG93ZXJudi4KPj4g Kwo+PiAgIGNvbmZpZyBMRURTX1NZU0NPTgo+PiAgICAgICBib29sICJMRUQgc3VwcG9ydCBmb3Ig TEVEcyBvbiBzeXN0ZW0gY29udHJvbGxlcnMiCj4+ICAgICAgIGRlcGVuZHMgb24gTEVEU19DTEFT Uz15Cj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2xlZHMvTWFrZWZpbGUgYi9kcml2ZXJzL2xlZHMv TWFrZWZpbGUKPj4gaW5kZXggYmY0NjA5My4uNDgwODE0YSAxMDA2NDQKPj4gLS0tIGEvZHJpdmVy cy9sZWRzL01ha2VmaWxlCj4+ICsrKyBiL2RyaXZlcnMvbGVkcy9NYWtlZmlsZQo+PiBAQCAtNTks NiArNTksNyBAQCBvYmotJChDT05GSUdfTEVEU19TWVNDT04pICAgICAgICArPSBsZWRzLXN5c2Nv bi5vCj4+ICAgb2JqLSQoQ09ORklHX0xFRFNfVkVSU0FUSUxFKSAgICAgICAgKz0gbGVkcy12ZXJz YXRpbGUubwo+PiAgIG9iai0kKENPTkZJR19MRURTX01FTkYyMUJNQykgICAgICAgICs9IGxlZHMt bWVuZjIxYm1jLm8KPj4gICBvYmotJChDT05GSUdfTEVEU19QTTg5NDFfV0xFRCkgICAgICAgICs9 IGxlZHMtcG04OTQxLXdsZWQubwo+PiArb2JqLSQoQ09ORklHX0xFRFNfUE9XRVJOVikgICAgICAg ICs9IGxlZHMtcG93ZXJudi5vCj4+Cj4+ICAgIyBMRUQgU1BJIERyaXZlcnMKPj4gICBvYmotJChD T05GSUdfTEVEU19EQUMxMjRTMDg1KSAgICAgICAgKz0gbGVkcy1kYWMxMjRzMDg1Lm8KPj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbGVkcy9sZWRzLXBvd2VybnYuYyBiL2RyaXZlcnMvbGVkcy9sZWRz LXBvd2VybnYuYwo+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+PiBpbmRleCAwMDAwMDAwLi5iNWEz MDdjCj4+IC0tLSAvZGV2L251bGwKPj4gKysrIGIvZHJpdmVycy9sZWRzL2xlZHMtcG93ZXJudi5j Cj4+IEBAIC0wLDAgKzEsNDYzIEBACj4+ICsvKgo+PiArICogUG93ZXJOViBMRUQgRHJpdmVyCj4+ ICsgKgo+PiArICogQ29weXJpZ2h0IElCTSBDb3JwLiAyMDE1Cj4+ICsgKgo+PiArICogQXV0aG9y OiBWYXNhbnQgSGVnZGUgPGhlZ2RldmFzYW50QGxpbnV4LnZuZXQuaWJtLmNvbT4KPj4gKyAqIEF1 dGhvcjogQW5zaHVtYW4gS2hhbmR1YWwgPGtoYW5kdWFsQGxpbnV4LnZuZXQuaWJtLmNvbT4KPj4g KyAqCj4+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCj4+ICsgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQo+PiArICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uCj4+ICsgKiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgo+PiArICovCj4+ICsK Pj4gKyNpbmNsdWRlIDxsaW51eC9sZWRzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ Cj4+ICsjaW5jbHVkZSA8bGludXgvb2YuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9k ZXZpY2UuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgv dHlwZXMuaD4KPj4gKwo+PiArI2luY2x1ZGUgPGFzbS9vcGFsLmg+Cj4+ICsKPj4gKy8qCj4+ICsg KiBCeSBkZWZhdWx0IHVubG9hZCBwYXRoIHJlc2V0cyBhbGwgdGhlIExFRHMuIEJ1dCBvbiBQb3dl ck5WIHBsYXRmb3JtCj4+ICsgKiB3ZSB3YW50IHRvIHJldGFpbiBMRUQgc3RhdGUgYWNyb3NzIHJl Ym9vdCBhcyB0aGVzZSBhcmUgY29udHJvbGxlZCBieQo+PiArICogZmlybXdhcmUuIEFsc28gc2Vy dmljZSBwcm9jZXNzb3IgY2FuIG1vZGlmeSB0aGUgTEVEcyBpbmRlcGVuZGVudCBvZgo+PiArICog T1MuIEhlbmNlIGF2b2lkIHJlc2V0dGluZyBMRURzIGluIHVubG9hZCBwYXRoLgo+PiArICovCj4+ ICtzdGF0aWMgYm9vbCBsZWRfZGlzYWJsZWQ7Cj4+ICsKPj4gKy8qIE1hcCBMRUQgdHlwZSB0byBk ZXNjcmlwdGlvbi4gKi8KPj4gK3N0cnVjdCBsZWRfdHlwZV9tYXAgewo+PiArICAgIGNvbnN0IGlu dCAgICB0eXBlOwo+PiArICAgIGNvbnN0IGNoYXIgICAgKmRlc2M7Cj4+ICt9Owo+PiArc3RhdGlj IGNvbnN0IHN0cnVjdCBsZWRfdHlwZV9tYXAgbGVkX3R5cGVfbWFwW10gPSB7Cj4+ICsgICAge09Q QUxfU0xPVF9MRURfVFlQRV9JRCwgICAgICAgIFBPV0VSTlZfTEVEX1RZUEVfSURFTlRJRll9LAo+ PiArICAgIHtPUEFMX1NMT1RfTEVEX1RZUEVfRkFVTFQsICAgIFBPV0VSTlZfTEVEX1RZUEVfRkFV TFR9LAo+PiArICAgIHtPUEFMX1NMT1RfTEVEX1RZUEVfQVRUTiwgICAgUE9XRVJOVl9MRURfVFlQ RV9BVFRFTlRJT059LAo+PiArICAgIHstMSwgICAgICAgICAgICAgICAgTlVMTH0sCj4+ICt9Owo+ PiArCj4+ICsvKgo+PiArICogTEVEIHNldCByb3V0aW5lcyBoYXZlIGJlZW4gaW1wbGVtZW50ZWQg YXMgd29yayBxdWV1ZSB0YXNrcyBzY2hlZHVsZWQKPj4gKyAqIG9uIHRoZSBnbG9iYWwgd29yayBx dWV1ZS4gSW5kaXZpZHVhbCB0YXNrIGNhbGxzIE9QQUwgaW50ZXJmYWNlIHRvIHNldAo+PiArICog dGhlIExFRCBzdGF0ZSB3aGljaCBtaWdodCBzbGVlcCBmb3Igc29tZSB0aW1lLgo+PiArICovCj4+ ICtzdHJ1Y3QgcG93ZXJudl9sZWRfZGF0YSB7Cj4+ICsgICAgc3RydWN0IGxlZF9jbGFzc2RldiAg ICBjZGV2Owo+PiArICAgIGVudW0gbGVkX2JyaWdodG5lc3MgICAgdmFsdWU7ICAgICAvKiBCcmln aHRuZXNzIHZhbHVlICovCj4+ICsgICAgc3RydWN0IG11dGV4ICAgICAgICBsb2NrOwo+PiArICAg IHN0cnVjdCB3b3JrX3N0cnVjdCAgICB3b3JrX2xlZDsgLyogTEVEIHVwZGF0ZSB3b3JrcXVldWUg Ki8KPj4gK307Cj4+ICsKPj4gK3N0cnVjdCBwb3dlcm52X2xlZHNfcHJpdiB7Cj4+ICsgICAgaW50 IG51bV9sZWRzOwo+PiArICAgIHN0cnVjdCBwb3dlcm52X2xlZF9kYXRhIHBvd2VybnZfbGVkc1td Owo+PiArfTsKPj4gKwo+PiArCj4+ICtzdGF0aWMgaW5saW5lIGludCBzaXplb2ZfcG93ZXJudl9s ZWRzX3ByaXYoaW50IG51bV9sZWRzKQo+PiArewo+PiArICAgIHJldHVybiBzaXplb2Yoc3RydWN0 IHBvd2VybnZfbGVkc19wcml2KSArCj4+ICsgICAgICAgIChzaXplb2Yoc3RydWN0IHBvd2VybnZf bGVkX2RhdGEpICogbnVtX2xlZHMpOwo+PiArfQo+PiArCj4+ICsvKiBSZXR1cm5zIE9QQUxfU0xP VF9MRURfVFlQRV8qIGZvciBnaXZlbiBsZWQgdHlwZSBzdHJpbmcgKi8KPj4gK3N0YXRpYyBpbnQg cG93ZXJudl9nZXRfbGVkX3R5cGUoc3RydWN0IGxlZF9jbGFzc2RldiAqbGVkX2NkZXYpCj4+ICt7 Cj4+ICsgICAgY2hhciAqZGVzYzsKPj4gKyAgICBpbnQgaTsKPj4gKwo+PiArICAgIGRlc2MgPSBz dHJzdHIobGVkX2NkZXYtPm5hbWUsICI6Iik7Cj4+ICsgICAgaWYgKCFkZXNjKQo+PiArICAgICAg ICByZXR1cm4gLTE7Cj4+ICsgICAgZGVzYysrOwo+PiArICAgIGlmICghZGVzYykKPj4gKyAgICAg ICAgcmV0dXJuIC0xOwo+PiArCj4+ICsgICAgZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUobGVk X3R5cGVfbWFwKTsgaSsrKQo+PiArICAgICAgICBpZiAoIXN0cmNtcChsZWRfdHlwZV9tYXBbaV0u ZGVzYywgZGVzYykpCj4+ICsgICAgICAgICAgICByZXR1cm4gbGVkX3R5cGVfbWFwW2ldLnR5cGU7 Cj4+ICsKPj4gKyAgICByZXR1cm4gLTE7Cj4+ICt9Cj4+ICsKPj4gKy8qIFRoaXMgZnVuY3Rpb24g Z2V0cyBMRUQgbG9jYXRpb24gY29kZSBmb3IgZ2l2ZW4gTEVEIGNsYXNzZGV2ICovCj4+ICtzdGF0 aWMgY2hhciAqcG93ZXJudl9nZXRfbG9jYXRpb25fY29kZShzdHJ1Y3QgbGVkX2NsYXNzZGV2ICps ZWRfY2RldikKPj4gK3sKPj4gKyAgICBjaGFyICpsb2NfY29kZTsKPj4gKyAgICBjaGFyICpjb2xv bjsKPj4gKwo+PiArICAgIC8qIExvY2F0aW9uIGNvZGUgb2YgdGhlIExFRCAqLwo+PiArICAgIGxv Y19jb2RlID0ga2FzcHJpbnRmKEdGUF9LRVJORUwsICIlcyIsIGxlZF9jZGV2LT5uYW1lKTsKPj4g KyAgICBpZiAoIWxvY19jb2RlKSB7Cj4+ICsgICAgICAgIGRldl9lcnIobGVkX2NkZXYtPmRldiwK Pj4gKyAgICAgICAgICAgICIlczogTWVtb3J5IGFsbG9jYXRpb24gZmFpbGVkXG4iLCBfX2Z1bmNf Xyk7Cj4+ICsgICAgICAgIHJldHVybiBOVUxMOwo+PiArICAgIH0KPj4gKwo+PiArICAgIGNvbG9u ID0gc3Ryc3RyKGxvY19jb2RlLCAiOiIpOwo+PiArICAgIGlmICghY29sb24pIHsKPj4gKyAgICAg ICAga2ZyZWUobG9jX2NvZGUpOwo+PiArICAgICAgICByZXR1cm4gTlVMTDsKPj4gKyAgICB9Cj4+ ICsKPj4gKyAgICAqY29sb24gPSAnXDAnOwo+PiArICAgIHJldHVybiBsb2NfY29kZTsKPj4gK30K Pj4gKwo+PiArLyoKPj4gKyAqIFRoaXMgY29tbWl0cyB0aGUgc3RhdGUgY2hhbmdlIG9mIHRoZSBy ZXF1ZXN0ZWQgTEVEIHRocm91Z2ggYW4gT1BBTCBjYWxsLgo+PiArICogVGhpcyBmdW5jdGlvbiBp cyBjYWxsZWQgZnJvbSB3b3JrIHF1ZXVlIHRhc2sgY29udGV4dCB3aGVuIGV2ZXIgaXQgZ2V0cwo+ PiArICogc2NoZWR1bGVkLiBUaGlzIGZ1bmN0aW9uIGNhbiBzbGVlcCBhdCBvcGFsX2FzeW5jX3dh aXRfcmVzcG9uc2UgY2FsbC4KPj4gKyAqLwo+PiArc3RhdGljIHZvaWQgcG93ZXJudl9sZWRfc2V0 KHN0cnVjdCBsZWRfY2xhc3NkZXYgKmxlZF9jZGV2LAo+PiArICAgICAgICAgICAgICAgIGVudW0g bGVkX2JyaWdodG5lc3MgdmFsdWUpCj4+ICt7Cj4+ICsgICAgY2hhciAqbG9jX2NvZGU7Cj4+ICsg ICAgaW50IHJjLCB0b2tlbiwgbGVkX3R5cGU7Cj4+ICsgICAgdTY0IGxlZF9tYXNrLCBsZWRfdmFs dWUgPSAwOwo+PiArICAgIF9fYmU2NCBtYXhfbGVkX3R5cGU7Cj4+ICsgICAgc3RydWN0IG9wYWxf bXNnIG1zZzsKPj4gKwo+PiArICAgIGxlZF90eXBlID0gcG93ZXJudl9nZXRfbGVkX3R5cGUobGVk X2NkZXYpOwo+PiArICAgIGlmIChsZWRfdHlwZSA9PSAtMSkKPj4gKyAgICAgICAgcmV0dXJuOwo+ IAo+IFBsZWFzZSBwYXJzZSB0aGUgbGVkIHR5cGUgb25jZSB1cG9uIGluaXRpYWxpemF0aW9uIGFu ZCBhZGQgcmVsYXRlZAo+IHByb3BlcnR5IHRvIHRoZSBzdHJ1Y3QgcG93ZXJudl9sZWRfZGF0YSB0 aGF0IHdpbGwgaG9sZCB0aGUgdmFsdWUuCgpJIHRob3VnaHQgd2UgY2FuIGdldCBsb2NhdGlvbiBj b2RlIGFuZCB0eXBlIHVzaW5nIGNsYXNzIGRldiBuYW1lIGl0c2VsZi4gSGVuY2UgSQpkaWRuJ3Qg YWRkIHRoZXNlIHR3byBwcm9wZXJ0aWVzIHRvIHN0cnVjdHVyZS4uCgpEbyB5b3Ugd2FudCBtZSB0 byBhZGQgdGhlbSB0byBzdHJ1Y3R1cmUgaXRzZWxmPwoKPiAKPj4gKyAgICBsb2NfY29kZSA9IHBv d2VybnZfZ2V0X2xvY2F0aW9uX2NvZGUobGVkX2NkZXYpOwo+PiArICAgIGlmICghbG9jX2NvZGUp Cj4+ICsgICAgICAgIHJldHVybjsKPiAKPiBUaGUgc2FtZSBzaXR1YXRpb24gYXMgaW4gY2FzZSBv ZiBsZWQgdHlwZS4KPiAKPj4gKyAgICAvKiBQcmVwYXJlIGZvciB0aGUgT1BBTCBjYWxsICovCj4+ ICsgICAgbWF4X2xlZF90eXBlID0gY3B1X3RvX2JlNjQoT1BBTF9TTE9UX0xFRF9UWVBFX01BWCk7 Cj4gCj4gVGhpcyB2YWx1ZSBjb3VsZCBiZSBhbHNvIGNhbGN1bGF0ZWQgb25seSBvbmNlLgoKWWVh aC4gTWF5IGJlIEkgY2FuIG1vdmUgdGhpcyB0byBwb3dlcm52X2xlZHNfcHJpdiBzdHJ1Y3R1cmUu Cgo+IAo+PiArICAgIGxlZF9tYXNrID0gT1BBTF9TTE9UX0xFRF9TVEFURV9PTiA8PCBsZWRfdHlw ZTsKPj4gKyAgICBpZiAodmFsdWUpCj4+ICsgICAgICAgIGxlZF92YWx1ZSA9IGxlZF9tYXNrOwo+ PiArCj4+ICsgICAgLyogT1BBTCBhc3luYyBjYWxsICovCj4+ICsgICAgdG9rZW4gPSBvcGFsX2Fz eW5jX2dldF90b2tlbl9pbnRlcnJ1cHRpYmxlKCk7Cj4+ICsgICAgaWYgKHRva2VuIDwgMCkgewo+ PiArICAgICAgICBpZiAodG9rZW4gIT0gLUVSRVNUQVJUU1lTKQo+PiArICAgICAgICAgICAgZGV2 X2VycihsZWRfY2Rldi0+ZGV2LAo+PiArICAgICAgICAgICAgICAgICIlczogQ291bGRuJ3QgZ2V0 IE9QQUwgYXN5bmMgdG9rZW5cbiIsCj4+ICsgICAgICAgICAgICAgICAgX19mdW5jX18pOwo+PiAr ICAgICAgICBnb3RvIG91dF9sb2M7Cj4+ICsgICAgfQo+PiArCj4+ICsgICAgcmMgPSBvcGFsX2xl ZHNfc2V0X2luZCh0b2tlbiwgbG9jX2NvZGUsCj4+ICsgICAgICAgICAgICAgICAgICAgbGVkX21h c2ssIGxlZF92YWx1ZSwgJm1heF9sZWRfdHlwZSk7Cj4+ICsgICAgaWYgKHJjICE9IE9QQUxfQVNZ TkNfQ09NUExFVElPTikgewo+PiArICAgICAgICBkZXZfZXJyKGxlZF9jZGV2LT5kZXYsCj4+ICsg ICAgICAgICAgICAiJXM6IE9QQUwgc2V0IExFRCBjYWxsIGZhaWxlZCBmb3IgJXMgW3JjPSVkXVxu IiwKPj4gKyAgICAgICAgICAgIF9fZnVuY19fLCBsb2NfY29kZSwgcmMpOwo+PiArICAgICAgICBn b3RvIG91dF90b2tlbjsKPj4gKyAgICB9Cj4+ICsKPj4gKyAgICByYyA9IG9wYWxfYXN5bmNfd2Fp dF9yZXNwb25zZSh0b2tlbiwgJm1zZyk7Cj4+ICsgICAgaWYgKHJjKSB7Cj4+ICsgICAgICAgIGRl dl9lcnIobGVkX2NkZXYtPmRldiwKPj4gKyAgICAgICAgICAgICIlczogRmFpbGVkIHRvIHdhaXQg Zm9yIHRoZSBhc3luYyByZXNwb25zZSBbcmM9JWRdXG4iLAo+PiArICAgICAgICAgICAgX19mdW5j X18sIHJjKTsKPj4gKyAgICAgICAgZ290byBvdXRfdG9rZW47Cj4+ICsgICAgfQo+PiArCj4+ICsg ICAgcmMgPSBiZTY0X3RvX2NwdShtc2cucGFyYW1zWzFdKTsKPj4gKyAgICBpZiAocmMgIT0gT1BB TF9TVUNDRVNTKQo+PiArICAgICAgICBkZXZfZXJyKGxlZF9jZGV2LT5kZXYsCj4+ICsgICAgICAg ICAgICAiJXMgOiBPQVBMIGFzeW5jIGNhbGwgcmV0dXJuZWQgZmFpbGVkIFtyYz0lZF1cbiIsCj4+ ICsgICAgICAgICAgICBfX2Z1bmNfXywgcmMpOwo+PiArCj4+ICtvdXRfdG9rZW46Cj4+ICsgICAg b3BhbF9hc3luY19yZWxlYXNlX3Rva2VuKHRva2VuKTsKPj4gKwo+PiArb3V0X2xvYzoKPj4gKyAg ICBrZnJlZShsb2NfY29kZSk7Cj4+ICt9Cj4+ICsKPj4gKy8qCj4+ICsgKiBUaGlzIGZ1bmN0aW9u IGZldGNoZXMgdGhlIExFRCBzdGF0ZSBmb3IgYSBnaXZlbiBMRUQgdHlwZSBmb3IKPj4gKyAqIG1l bnRpb25lZCBMRUQgY2xhc3NkZXYgc3RydWN0dXJlLgo+PiArICovCj4+ICtzdGF0aWMgZW51bSBs ZWRfYnJpZ2h0bmVzcyBwb3dlcm52X2xlZF9nZXQoc3RydWN0IGxlZF9jbGFzc2RldiAqbGVkX2Nk ZXYpCj4+ICt7Cj4+ICsgICAgY2hhciAqbG9jX2NvZGU7Cj4+ICsgICAgaW50IHJjLCBsZWRfdHlw ZTsKPj4gKyAgICBfX2JlNjQgbGVkX21hc2ssIGxlZF92YWx1ZSwgbWF4X2xlZF90eXBlOwo+PiAr Cj4+ICsgICAgbGVkX3R5cGUgPSBwb3dlcm52X2dldF9sZWRfdHlwZShsZWRfY2Rldik7Cj4+ICsg ICAgaWYgKGxlZF90eXBlID09IC0xKQo+PiArICAgICAgICByZXR1cm4gTEVEX09GRjsKPj4gKwo+ PiArICAgIGxvY19jb2RlID0gcG93ZXJudl9nZXRfbG9jYXRpb25fY29kZShsZWRfY2Rldik7Cj4+ ICsgICAgaWYgKCFsb2NfY29kZSkKPj4gKyAgICAgICAgcmV0dXJuIExFRF9PRkY7Cj4+ICsKPj4g KyAgICAvKiBGZXRjaCBhbGwgTEVEIHN0YXR1cyAqLwo+PiArICAgIGxlZF9tYXNrID0gY3B1X3Rv X2JlNjQoMCk7Cj4+ICsgICAgbGVkX3ZhbHVlID0gY3B1X3RvX2JlNjQoMCk7Cj4+ICsgICAgbWF4 X2xlZF90eXBlID0gY3B1X3RvX2JlNjQoT1BBTF9TTE9UX0xFRF9UWVBFX01BWCk7Cj4+ICsKPj4g KyAgICByYyA9IG9wYWxfbGVkc19nZXRfaW5kKGxvY19jb2RlLCAmbGVkX21hc2ssICZsZWRfdmFs dWUsICZtYXhfbGVkX3R5cGUpOwo+PiArICAgIGlmIChyYyAhPSBPUEFMX1NVQ0NFU1MgJiYgcmMg IT0gT1BBTF9QQVJUSUFMKSB7Cj4+ICsgICAgICAgIGRldl9lcnIobGVkX2NkZXYtPmRldiwKPj4g KyAgICAgICAgICAgICIlczogT1BBTCBnZXQgbGVkIGNhbGwgZmFpbGVkIFtyYz0lZF1cbiIsCj4+ ICsgICAgICAgICAgICBfX2Z1bmNfXywgcmMpOwo+PiArICAgICAgICBnb3RvIGxlZF9mYWlsOwo+ PiArICAgIH0KPj4gKwo+PiArICAgIGxlZF9tYXNrID0gYmU2NF90b19jcHUobGVkX21hc2spOwo+ PiArICAgIGxlZF92YWx1ZSA9IGJlNjRfdG9fY3B1KGxlZF92YWx1ZSk7Cj4gCj4gYmU2NF90b19j cHUgcmVzdWx0IHNob3VsZCBiZSBhc3NpZ25lZCB0byB0aGUgdmFyaWFibGUgb2YgdTY0L3M2NCB0 eXBlLgoKUG93ZXJOViBwbGF0Zm9ybSBpcyBjYXBhYmxlIG9mIHJ1bm5pbmcgYm90aCBiaWcvbGl0 dGxlIGVuZGlhbiBtb2RlLi4gQnV0CnByZXNlbnRseSBvdXIgZmlybXdhcmUgaXMgYmlnIGVuZGlh bi4gVGhlc2UgdmFyaWFibGUgY29udGFpbnMgYmlnIGVuZGlhbiB2YWx1ZXMuCkhlbmNlIEkgaGF2 ZSBjcmVhdGVkIGFzIF9fYmU2NCAuLiAoVGhpcyBpcyB0aGUgY29udmVudGlvbiB3ZSBmb2xsb3cg aW4gb3RoZXIKcGxhY2VzIGFzIHdlbGwpLgoKPiAKPj4gKyAgICAvKiBMRUQgc3RhdHVzIGF2YWls YWJsZSAqLwo+PiArICAgIGlmICghKChsZWRfbWFzayA+PiBsZWRfdHlwZSkgJiBPUEFMX1NMT1Rf TEVEX1NUQVRFX09OKSkgewo+PiArICAgICAgICBkZXZfZXJyKGxlZF9jZGV2LT5kZXYsCj4+ICsg ICAgICAgICAgICAiJXM6IExFRCBzdGF0dXMgbm90IGF2YWlsYWJsZSBmb3IgJXNcbiIsCj4+ICsg ICAgICAgICAgICBfX2Z1bmNfXywgbGVkX2NkZXYtPm5hbWUpOwo+PiArICAgICAgICBnb3RvIGxl ZF9mYWlsOwo+PiArICAgIH0KPj4gKwo+PiArICAgIC8qIExFRCBzdGF0dXMgdmFsdWUgKi8KPj4g KyAgICBpZiAoKGxlZF92YWx1ZSA+PiBsZWRfdHlwZSkgJiBPUEFMX1NMT1RfTEVEX1NUQVRFX09O KSB7Cj4+ICsgICAgICAgIGtmcmVlKGxvY19jb2RlKTsKPj4gKyAgICAgICAgcmV0dXJuIExFRF9G VUxMOwo+PiArICAgIH0KPj4gKwo+PiArbGVkX2ZhaWw6Cj4+ICsgICAga2ZyZWUobG9jX2NvZGUp Owo+PiArICAgIHJldHVybiBMRURfT0ZGOwo+PiArfQo+PiArCj4+ICsvKiBFeGVjdXRlIExFRCBz ZXQgdGFzayBmb3IgZ2l2ZW4gbGVkIGNsYXNzZGV2ICovCj4+ICtzdGF0aWMgdm9pZCBwb3dlcm52 X2RlZmVycmVkX2xlZF9zZXQoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQo+PiArewo+PiArICAg IHN0cnVjdCBwb3dlcm52X2xlZF9kYXRhICpwb3dlcm52X2xlZCA9Cj4+ICsgICAgICAgIGNvbnRh aW5lcl9vZih3b3JrLCBzdHJ1Y3QgcG93ZXJudl9sZWRfZGF0YSwgd29ya19sZWQpOwo+PiArCj4+ ICsgICAgbXV0ZXhfbG9jaygmcG93ZXJudl9sZWQtPmxvY2spOwo+PiArICAgIHBvd2VybnZfbGVk X3NldCgmcG93ZXJudl9sZWQtPmNkZXYsIHBvd2VybnZfbGVkLT52YWx1ZSk7Cj4+ICsgICAgbXV0 ZXhfdW5sb2NrKCZwb3dlcm52X2xlZC0+bG9jayk7Cj4+ICt9Cj4+ICsKPj4gKy8qCj4+ICsgKiBM RUQgY2xhc3NkZXYgJ2JyaWdodG5lc3NfZ2V0JyBmdW5jdGlvbi4gVGhpcyBzY2hlZHVsZXMgd29y awo+PiArICogdG8gdXBkYXRlIExFRCBzdGF0ZS4KPj4gKyAqLwo+PiArc3RhdGljIHZvaWQgcG93 ZXJudl9icmlnaHRuZXNzX3NldChzdHJ1Y3QgbGVkX2NsYXNzZGV2ICpsZWRfY2RldiwKPj4gKyAg ICAgICAgICAgICAgICAgICBlbnVtIGxlZF9icmlnaHRuZXNzIHZhbHVlKQo+PiArewo+PiArICAg IHN0cnVjdCBwb3dlcm52X2xlZF9kYXRhICpwb3dlcm52X2xlZCA9Cj4+ICsgICAgICAgIGNvbnRh aW5lcl9vZihsZWRfY2Rldiwgc3RydWN0IHBvd2VybnZfbGVkX2RhdGEsIGNkZXYpOwo+PiArCj4+ ICsgICAgLyogRG8gbm90IG1vZGlmeSBMRUQgaW4gdW5sb2FkIHBhdGggKi8KPj4gKyAgICBpZiAo bGVkX2Rpc2FibGVkKQo+PiArICAgICAgICByZXR1cm47Cj4+ICsKPj4gKyAgICAvKiBQcmVwYXJl IHRoZSByZXF1ZXN0ICovCj4+ICsgICAgcG93ZXJudl9sZWQtPnZhbHVlID0gdmFsdWU7Cj4+ICsK Pj4gKyAgICAvKiBTY2hlZHVsZSB0aGUgbmV3IHRhc2sgKi8KPj4gKyAgICBzY2hlZHVsZV93b3Jr KCZwb3dlcm52X2xlZC0+d29ya19sZWQpOwo+PiArfQo+PiArCj4+ICsvKiBMRUQgY2xhc3NkZXYg J2JyaWdodG5lc3NfZ2V0JyBmdW5jdGlvbiAqLwo+PiArc3RhdGljIGVudW0gbGVkX2JyaWdodG5l c3MKPj4gK3Bvd2VybnZfYnJpZ2h0bmVzc19nZXQoc3RydWN0IGxlZF9jbGFzc2RldiAqbGVkX2Nk ZXYpCj4+ICt7Cj4+ICsgICAgcmV0dXJuIHBvd2VybnZfbGVkX2dldChsZWRfY2Rldik7Cj4+ICt9 Cj4+ICsKPj4gKwo+PiArLyoKPj4gKyAqIFRoaXMgZnVuY3Rpb24gcmVnaXN0ZXJzIGNsYXNzZGV2 IHN0cnVjdHVyZSBmb3IgYW55IGdpdmVuIHR5cGUgb2YgTEVEIG9uCj4+ICsgKiBhIGdpdmVuIGNo aWxkIExFRCBkZXZpY2Ugbm9kZS4KPj4gKyAqLwo+PiArc3RhdGljIGludCBwb3dlcm52X2xlZF9j cmVhdGUoc3RydWN0IGRldmljZSAqZGV2LAo+PiArICAgICAgICAgICAgICAgICAgc3RydWN0IHBv d2VybnZfbGVkX2RhdGEgKnBvd2VybnZfbGVkLAo+PiArICAgICAgICAgICAgICAgICAgY29uc3Qg Y2hhciAqbGVkX25hbWUsIGNvbnN0IGNoYXIgKmxlZF90eXBlX2Rlc2MpCj4+ICt7Cj4+ICsgICAg aW50IHJjOwo+PiArCj4+ICsgICAgLyogQ3JlYXRlIHRoZSBuYW1lIGZvciBjbGFzc2RldiAqLwo+ PiArICAgIHBvd2VybnZfbGVkLT5jZGV2Lm5hbWUgPSBrYXNwcmludGYoR0ZQX0tFUk5FTCwgIiVz OiVzIiwKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgbGVkX25hbWUsIGxlZF90eXBlX2Rlc2Mp Owo+IAo+IFBsZWFzZSB1c2UgZGV2bV9rYXNwcmludGYuCgpEb25lLgoKPiAKPj4gKyAgICBpZiAo IXBvd2VybnZfbGVkLT5jZGV2Lm5hbWUpIHsKPj4gKyAgICAgICAgZGV2X2VycihkZXYsCj4+ICsg ICAgICAgICAgICAiJXM6IE1lbW9yeSBhbGxvY2F0aW9uIGZhaWxlZCBmb3IgY2xhc3NkZXYgbmFt ZVxuIiwKPj4gKyAgICAgICAgICAgIF9fZnVuY19fKTsKPj4gKyAgICAgICAgcmV0dXJuIC1FTk9N RU07Cj4+ICsgICAgfQo+PiArCj4+ICsgICAgLyogTWFrZSBzdXJlIExFRCB0eXBlIGlzIHN1cHBv cnRlZCAqLwo+PiArICAgIGlmIChwb3dlcm52X2dldF9sZWRfdHlwZSgmcG93ZXJudl9sZWQtPmNk ZXYpID09IC0xKSB7Cj4+ICsgICAgICAgIGtmcmVlKHBvd2VybnZfbGVkLT5jZGV2Lm5hbWUpOwo+ PiArICAgICAgICByZXR1cm4gLUVJTlZBTDsKPj4gKyAgICB9Cj4+ICsKPj4gKyAgICBwb3dlcm52 X2xlZC0+Y2Rldi5icmlnaHRuZXNzX3NldCA9IHBvd2VybnZfYnJpZ2h0bmVzc19zZXQ7Cj4+ICsg ICAgcG93ZXJudl9sZWQtPmNkZXYuYnJpZ2h0bmVzc19nZXQgPSBwb3dlcm52X2JyaWdodG5lc3Nf Z2V0Owo+PiArICAgIHBvd2VybnZfbGVkLT5jZGV2LmJyaWdodG5lc3MgPSBMRURfT0ZGOwo+PiAr ICAgIHBvd2VybnZfbGVkLT5jZGV2Lm1heF9icmlnaHRuZXNzID0gTEVEX0ZVTEw7Cj4+ICsKPj4g KyAgICBtdXRleF9pbml0KCZwb3dlcm52X2xlZC0+bG9jayk7Cj4+ICsgICAgSU5JVF9XT1JLKCZw b3dlcm52X2xlZC0+d29ya19sZWQsIHBvd2VybnZfZGVmZXJyZWRfbGVkX3NldCk7Cj4+ICsKPj4g KyAgICAvKiBSZWdpc3RlciB0aGUgY2xhc3NkZXYgKi8KPj4gKyAgICByYyA9IGxlZF9jbGFzc2Rl dl9yZWdpc3RlcihkZXYsICZwb3dlcm52X2xlZC0+Y2Rldik7Cj4gCj4gZGV2bV9sZWRfY2xhc3Nk ZXZfcmVnaXN0ZXIgaXMgYWxzbyBhdmFpbGFibGUuCgpMb29rcyBsaWtlIG1vc3Qgb2YgdGhlIGV4 aXN0aW5nIGRyaXZlcnMgYXJlIHVzaW5nIGxlZF9jbGFzc2Rldl9yZWdpc3RlciBmdW5jdGlvbi4u CldoaWNoIG9uZSBpcyBwcmVmZXJyZWQgaGVyZT8KCj4gCj4+ICsgICAgaWYgKHJjKSB7Cj4+ICsg ICAgICAgIGRldl9lcnIoZGV2LCAiJXM6IENsYXNzZGV2IHJlZ2lzdHJhdGlvbiBmYWlsZWQgZm9y ICVzXG4iLAo+PiArICAgICAgICAgICAgX19mdW5jX18sIHBvd2VybnZfbGVkLT5jZGV2Lm5hbWUp Owo+PiArICAgICAgICBrZnJlZShwb3dlcm52X2xlZC0+Y2Rldi5uYW1lKTsKPj4gKyAgICB9Cj4+ ICsKPj4gKyAgICByZXR1cm4gcmM7Cj4+ICt9Cj4+ICsKPj4gKy8qIFVucmVnaXN0ZXIgY2xhc3Nk ZXYgc3RydWN0dXJlIGZvciBhbnkgZ2l2ZW4gTEVEICovCj4+ICtzdGF0aWMgdm9pZCBwb3dlcm52 X2xlZF9kZWxldGUoc3RydWN0IHBvd2VybnZfbGVkX2RhdGEgKnBvd2VybnZfbGVkKQo+PiArewo+ PiArICAgIGxlZF9jbGFzc2Rldl91bnJlZ2lzdGVyKCZwb3dlcm52X2xlZC0+Y2Rldik7Cj4+ICt9 Cj4gCj4gVGhpcyBmdW5jdGlvbiBpcyByZWR1bmRhbnQuCgpMaWtlIHBvd2VybnZfbGVkX2NyZWF0 ZSwgSSBqdXN0IGFkZGVkIHRoaXMgZnVuY3Rpb24gLi4uIGhvcGluZyB0aGlzIHdpbGwgaW1wcm92 ZQpjb2RlIHJlYWRhYmlsaXR5LgpXaWxsIHJlbW92ZSB0aGlzIGZ1bmN0aW9uLgoKPiAKPj4gKy8q IEdvIHRocm91Z2ggTEVEIGRldmljZSB0cmVlIG5vZGUgYW5kIHJlZ2lzdGVyIExFRCBjbGFzc2Rl diBzdHJ1Y3R1cmUgKi8KPj4gK3N0YXRpYyBpbnQgcG93ZXJudl9sZWRfY2xhc3NkZXYoc3RydWN0 IHBsYXRmb3JtX2RldmljZSAqcGRldiwKPj4gKyAgICAgICAgICAgICAgICBzdHJ1Y3QgZGV2aWNl X25vZGUgKmxlZF9ub2RlLAo+PiArICAgICAgICAgICAgICAgIHN0cnVjdCBwb3dlcm52X2xlZHNf cHJpdiAqcHJpdiwgaW50IG51bV9sZWRzKQo+PiArewo+PiArICAgIGNvbnN0IGNoYXIgKmN1ciA9 IE5VTEw7Cj4+ICsgICAgaW50IGksIHJjID0gLTE7Cj4+ICsgICAgc3RydWN0IHByb3BlcnR5ICpw Owo+PiArICAgIHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7Cj4+ICsgICAgc3RydWN0IHBvd2VybnZf bGVkX2RhdGEgKnBvd2VybnZfbGVkOwo+PiArICAgIHN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2 LT5kZXY7Cj4+ICsKPj4gKyAgICBmb3JfZWFjaF9jaGlsZF9vZl9ub2RlKGxlZF9ub2RlLCBucCkg ewo+PiArICAgICAgICBwID0gb2ZfZmluZF9wcm9wZXJ0eShucCwgImxlZC10eXBlcyIsIE5VTEwp Owo+PiArICAgICAgICBpZiAoIXApCj4+ICsgICAgICAgICAgICBjb250aW51ZTsKPj4gKwo+PiAr ICAgICAgICB3aGlsZSAoKGN1ciA9IG9mX3Byb3BfbmV4dF9zdHJpbmcocCwgY3VyKSkgIT0gTlVM TCkgewo+PiArICAgICAgICAgICAgcG93ZXJudl9sZWQgPSAmcHJpdi0+cG93ZXJudl9sZWRzW3By aXYtPm51bV9sZWRzKytdOwo+PiArICAgICAgICAgICAgaWYgKHByaXYtPm51bV9sZWRzID4gbnVt X2xlZHMpIHsKPj4gKyAgICAgICAgICAgICAgICByYyA9IC1FTk9NRU07Cj4+ICsgICAgICAgICAg ICAgICAgZ290byBjbGFzc2Rldl9mYWlsOwo+PiArICAgICAgICAgICAgfQo+PiArICAgICAgICAg ICAgcmMgPSBwb3dlcm52X2xlZF9jcmVhdGUoZGV2LAo+PiArICAgICAgICAgICAgICAgICAgICAg ICAgcG93ZXJudl9sZWQsIG5wLT5uYW1lLCBjdXIpOwo+PiArICAgICAgICAgICAgaWYgKHJjKQo+ PiArICAgICAgICAgICAgICAgIGdvdG8gY2xhc3NkZXZfZmFpbDsKPj4gKyAgICAgICAgfSAvKiB3 aGlsZSBlbmQgKi8KPj4gKyAgICB9Cj4+ICsKPj4gKyAgICBwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShw ZGV2LCBwcml2KTsKPj4gKyAgICByZXR1cm4gcmM7Cj4+ICsKPj4gK2NsYXNzZGV2X2ZhaWw6Cj4+ ICsgICAgZm9yIChpID0gcHJpdi0+bnVtX2xlZHMgLSAyOyBpID4gMDsgaS0tKQo+IAo+IFdoeSBk byB5b3UgbGVhdmUgZWxlbWVudCB3aXRoIGlkID09IDAgdW5yZWxlYXNlZD8KCkl0IHdhcyBteSBt aXN0YWtlLiBGaXhlZC4KCj4gCj4+ICsgICAgICAgIHBvd2VybnZfbGVkX2RlbGV0ZSgmcHJpdi0+ cG93ZXJudl9sZWRzW2ldKTsKPj4gKwo+PiArICAgIHJldHVybiByYzsKPj4gK30KPj4gKwo+PiAr LyoKPj4gKyAqIFdlIHdhbnQgdG8gcG9wdWxhdGUgTEVEIGRldmljZSBmb3IgZWFjaCBMRUQgdHlw ZS4gSGVuY2Ugd2UKPj4gKyAqIGhhdmUgdG8gY2FsY3VsYXRlIGNvdW50IGV4cGxpY2l0bHkuCj4+ ICsgKi8KPj4gK3N0YXRpYyBpbnQgcG93ZXJudl9sZWRzX2NvdW50KHN0cnVjdCBkZXZpY2Vfbm9k ZSAqbGVkX25vZGUpCj4+ICt7Cj4+ICsgICAgY29uc3QgY2hhciAqY3VyID0gTlVMTDsKPj4gKyAg ICBpbnQgbnVtX2xlZHMgPSAwOwo+PiArICAgIHN0cnVjdCBwcm9wZXJ0eSAqcDsKPj4gKyAgICBz dHJ1Y3QgZGV2aWNlX25vZGUgKm5wOwo+PiArCj4+ICsgICAgZm9yX2VhY2hfY2hpbGRfb2Zfbm9k ZShsZWRfbm9kZSwgbnApIHsKPj4gKyAgICAgICAgcCA9IG9mX2ZpbmRfcHJvcGVydHkobnAsICJs ZWQtdHlwZXMiLCBOVUxMKTsKPj4gKyAgICAgICAgaWYgKCFwKQo+PiArICAgICAgICAgICAgY29u dGludWU7Cj4+ICsKPj4gKyAgICAgICAgd2hpbGUgKChjdXIgPSBvZl9wcm9wX25leHRfc3RyaW5n KHAsIGN1cikpICE9IE5VTEwpCj4+ICsgICAgICAgICAgICBudW1fbGVkcysrOwo+PiArICAgIH0K Pj4gKwo+PiArICAgIHJldHVybiBudW1fbGVkczsKPj4gK30KPiAKPiBEb2VzIGl0IG1lYW4gdGhh dCBpZiB0aGUgbm9kZSBleGlzdHMgYnV0IGRvZXMndCBoYXZlIGxlZC10eXBlcwo+IHByb3BlcnR5 IHdlIGFyZSBub3QgZ29pbmcgdG8gcmVnaXN0ZXIgaXQ/CgpZZXMuLiAgTm8gcG9pbnQgaW4gcmVn aXN0ZXJpbmcgbG9jYXRpb24gY29kZSAuLndoaWNoIGRvZXNuJ3QgaGF2ZSBsZWQtdHlwZXMKcHJv cGVydHkuCgoKPiBJIGFzc3VtZSB0aGF0IHRoaXMgaXMKPiBmaXJtd2FyZSB3aGljaCBnZW5lcmF0 ZXMgdGhlIG5vZGVzLCBvdGhlcndpc2UgaXQgd291bGQgbWFrZQo+IG5vIHNlbnNlIHRvIGhhdmUg dGhlIG5vZGUsIGFtIEkgcmlnaHQ/CgpUaGF0IGNvcnJlY3QuIE91ciBmaXJtd2FyZSBnZW5lcmF0 ZXMgdGhpcyBwcm9wZXJ0eS4KCj4gCj4+ICsvKiBQbGF0Zm9ybSBkcml2ZXIgcHJvYmUgKi8KPj4g K3N0YXRpYyBpbnQgcG93ZXJudl9sZWRfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRl dikKPj4gK3sKPj4gKyAgICBpbnQgbnVtX2xlZHM7Cj4+ICsgICAgc3RydWN0IGRldmljZV9ub2Rl ICpsZWRfbm9kZTsKPj4gKyAgICBzdHJ1Y3QgcG93ZXJudl9sZWRzX3ByaXYgKnByaXY7Cj4+ICsK Pj4gKyAgICBsZWRfbm9kZSA9IG9mX2ZpbmRfbm9kZV9ieV9wYXRoKCIvaWJtLG9wYWwvbGVkcyIp Owo+PiArICAgIGlmICghbGVkX25vZGUpIHsKPj4gKyAgICAgICAgZGV2X2VycigmcGRldi0+ZGV2 LAo+PiArICAgICAgICAgICAgIiVzOiBMRUQgcGFyZW50IGRldmljZSBub2RlIG5vdCBmb3VuZFxu IiwgX19mdW5jX18pOwo+PiArICAgICAgICByZXR1cm4gLUVJTlZBTDsKPj4gKyAgICB9Cj4+ICsK Pj4gKyAgICBudW1fbGVkcyA9IHBvd2VybnZfbGVkc19jb3VudChsZWRfbm9kZSk7Cj4+ICsgICAg aWYgKG51bV9sZWRzIDw9IDApIHsKPj4gKyAgICAgICAgZGV2X2VycigmcGRldi0+ZGV2LAo+PiAr ICAgICAgICAgICAgIiVzOiBObyBsb2NhdGlvbiBjb2RlIGZvdW5kIHVuZGVyIExFRCBub2RlXG4i LAo+PiArICAgICAgICAgICAgX19mdW5jX18pOwo+PiArICAgICAgICByZXR1cm4gLUVJTlZBTDsK Pj4gKyAgICB9Cj4+ICsKPj4gKyAgICBwcml2ID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsCj4+ ICsgICAgICAgICAgICAgICAgc2l6ZW9mX3Bvd2VybnZfbGVkc19wcml2KG51bV9sZWRzKSwKPj4g KyAgICAgICAgICAgICAgICBHRlBfS0VSTkVMKTsKPj4gKyAgICBpZiAoIXByaXYpCj4+ICsgICAg ICAgIHJldHVybiAtRU5PTUVNOwo+PiArCj4+ICsgICAgcmV0dXJuIHBvd2VybnZfbGVkX2NsYXNz ZGV2KHBkZXYsIGxlZF9ub2RlLCBwcml2LCBudW1fbGVkcyk7Cj4+ICt9Cj4+ICsKPj4gKy8qIFBs YXRmb3JtIGRyaXZlciByZW1vdmUgKi8KPj4gK3N0YXRpYyBpbnQgcG93ZXJudl9sZWRfcmVtb3Zl KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4+ICt7Cj4+ICsgICAgaW50IGk7Cj4+ICsg ICAgc3RydWN0IHBvd2VybnZfbGVkX2RhdGEgKnBvd2VybnZfbGVkOwo+PiArICAgIHN0cnVjdCBw b3dlcm52X2xlZHNfcHJpdiAqcHJpdjsKPj4gKwo+PiArICAgIC8qIERpc2FibGUgTEVEIG9wZXJh dGlvbiAqLwo+PiArICAgIGxlZF9kaXNhYmxlZCA9IHRydWU7Cj4+ICsKPj4gKyAgICBwcml2ID0g cGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7Cj4+ICsKPj4gKyAgICBmb3IgKGkgPSAwOyBpIDwg cHJpdi0+bnVtX2xlZHM7IGkrKykgewo+PiArICAgICAgICBwb3dlcm52X2xlZCA9ICZwcml2LT5w b3dlcm52X2xlZHNbaV07Cj4+ICsgICAgICAgIHBvd2VybnZfbGVkX2RlbGV0ZShwb3dlcm52X2xl ZCk7Cj4+ICsgICAgICAgIGZsdXNoX3dvcmsoJnBvd2VybnZfbGVkLT53b3JrX2xlZCk7Cj4+ICsg ICAgfQo+IAo+IFlvdSBhcmUgbWlzc2luZyBtdXRleF9kZXN0cm95IGhlcmUuCgpPaCB5ZWFoLi4g SSBtaXNzZWQgaXQuIEZpeGVkLgoKLVZhc2FudAoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KTGludXhwcGMtZGV2IG1haWxpbmcgbGlzdApMaW51eHBwYy1k ZXZAbGlzdHMub3psYWJzLm9yZwpodHRwczovL2xpc3RzLm96bGFicy5vcmcvbGlzdGluZm8vbGlu dXhwcGMtZGV2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from e28smtp02.in.ibm.com (e28smtp02.in.ibm.com [122.248.162.2]) (using TLSv1 with cipher CAMELLIA256-SHA (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id AE6831A0727 for ; Thu, 16 Jul 2015 16:55:35 +1000 (AEST) Received: from /spool/local by e28smtp02.in.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Thu, 16 Jul 2015 12:25:31 +0530 Received: from d28relay02.in.ibm.com (d28relay02.in.ibm.com [9.184.220.59]) by d28dlp01.in.ibm.com (Postfix) with ESMTP id 3CAA7E0057 for ; Thu, 16 Jul 2015 12:29:24 +0530 (IST) Received: from d28av03.in.ibm.com (d28av03.in.ibm.com [9.184.220.65]) by d28relay02.in.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id t6G6t4Bs16121948 for ; Thu, 16 Jul 2015 12:25:05 +0530 Received: from d28av03.in.ibm.com (localhost [127.0.0.1]) by d28av03.in.ibm.com (8.14.4/8.14.4/NCO v10.0 AVout) with ESMTP id t6G5ehg3010683 for ; Thu, 16 Jul 2015 11:10:43 +0530 Message-ID: <55A75541.4060008@linux.vnet.ibm.com> Date: Thu, 16 Jul 2015 12:24:57 +0530 From: Vasant Hegde MIME-Version: 1.0 To: Jacek Anaszewski CC: stewart@linux.vnet.ibm.com, arnd@arndb.de, j.anaszewski81@gmail.com, cooloney@gmail.com, rpurdie@rpsys.net, linuxppc-dev@lists.ozlabs.org, linux-leds@vger.kernel.org, khandual@linux.vnet.ibm.com Subject: Re: [PATCH v5 3/3] leds/powernv: Add driver for PowerNV platform References: <1435740638-16259-1-git-send-email-hegdevasant@linux.vnet.ibm.com> <1435740638-16259-4-git-send-email-hegdevasant@linux.vnet.ibm.com> <55A4CFA0.6090306@samsung.com> In-Reply-To: <55A4CFA0.6090306@samsung.com> Content-Type: text/plain; charset=utf-8 List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , On 07/14/2015 02:30 PM, Jacek Anaszewski wrote: > Hi Vasant, Jacek, > > Thanks for the update. I think that we have still room > for improvements, please look at my comments below. Thanks for the detailed review. .../... >> @@ -0,0 +1,24 @@ >> +Device Tree binding for LEDs on IBM Power Systems >> +------------------------------------------------- >> + > > Please start with: > > --------- > > Required properties: > - compatible : Should be "ibm,opal-v3-led". > > Each location code of FRU/Enclosure must be expressed in the > form of a sub-node. > > Required properties for the sub nodes: > - led-types : Supported LED types (attention/identify/fault) provided > in the form of string array. > > --------- > > or something of this flavour. The example should be at the end. > Fixed. > > >> +The 'leds' node under '/ibm,opal' lists service indicators available in the >> +system and their capabilities. >> + >> +leds { >> + compatible = "ibm,opal-v3-led"; >> + led-mode = "lightpath"; > > What about led-mode property? If it is generated by firmware I think, > that this should be mentioned somehow. Yes.. Its generated by firmware. Added this property to documentation file. > >> + >> + U78C9.001.RST0027-P1-C1 { >> + led-types = "identify", "fault"; >> + }; >> + ... >> + ... >> +}; >> + >> +Each node under 'leds' node describes location code of FRU/Enclosure. >> + >> +compatible : should be : "ibm,opal-v3-led". > > Second colon was redundant here. > I have added as - compatible : "ibm,opal-v3-led". >> + >> +The properties under each node: >> + >> + led-types : Supported LED types (attention/identify/fault). >> diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig >> index 4191614..4f56c7a 100644 >> --- a/drivers/leds/Kconfig >> +++ b/drivers/leds/Kconfig >> @@ -505,6 +505,17 @@ config LEDS_BLINKM >> This option enables support for the BlinkM RGB LED connected >> through I2C. Say Y to enable support for the BlinkM LED. >> >> +config LEDS_POWERNV >> + tristate "LED support for PowerNV Platform" >> + depends on LEDS_CLASS >> + depends on PPC_POWERNV >> + depends on OF >> + help >> + This option enables support for the system LEDs present on >> + PowerNV platforms. Say 'y' to enable this support in kernel. >> + To compile this driver as a module, choose 'm' here: the module >> + will be called leds-powernv. >> + >> config LEDS_SYSCON >> bool "LED support for LEDs on system controllers" >> depends on LEDS_CLASS=y >> diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile >> index bf46093..480814a 100644 >> --- a/drivers/leds/Makefile >> +++ b/drivers/leds/Makefile >> @@ -59,6 +59,7 @@ obj-$(CONFIG_LEDS_SYSCON) += leds-syscon.o >> obj-$(CONFIG_LEDS_VERSATILE) += leds-versatile.o >> obj-$(CONFIG_LEDS_MENF21BMC) += leds-menf21bmc.o >> obj-$(CONFIG_LEDS_PM8941_WLED) += leds-pm8941-wled.o >> +obj-$(CONFIG_LEDS_POWERNV) += leds-powernv.o >> >> # LED SPI Drivers >> obj-$(CONFIG_LEDS_DAC124S085) += leds-dac124s085.o >> diff --git a/drivers/leds/leds-powernv.c b/drivers/leds/leds-powernv.c >> new file mode 100644 >> index 0000000..b5a307c >> --- /dev/null >> +++ b/drivers/leds/leds-powernv.c >> @@ -0,0 +1,463 @@ >> +/* >> + * PowerNV LED Driver >> + * >> + * Copyright IBM Corp. 2015 >> + * >> + * Author: Vasant Hegde >> + * Author: Anshuman Khandual >> + * >> + * This program is free software; you can redistribute it and/or >> + * modify it under the terms of the GNU General Public License >> + * as published by the Free Software Foundation; either version >> + * 2 of the License, or (at your option) any later version. >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> + >> +#include >> + >> +/* >> + * By default unload path resets all the LEDs. But on PowerNV platform >> + * we want to retain LED state across reboot as these are controlled by >> + * firmware. Also service processor can modify the LEDs independent of >> + * OS. Hence avoid resetting LEDs in unload path. >> + */ >> +static bool led_disabled; >> + >> +/* Map LED type to description. */ >> +struct led_type_map { >> + const int type; >> + const char *desc; >> +}; >> +static const struct led_type_map led_type_map[] = { >> + {OPAL_SLOT_LED_TYPE_ID, POWERNV_LED_TYPE_IDENTIFY}, >> + {OPAL_SLOT_LED_TYPE_FAULT, POWERNV_LED_TYPE_FAULT}, >> + {OPAL_SLOT_LED_TYPE_ATTN, POWERNV_LED_TYPE_ATTENTION}, >> + {-1, NULL}, >> +}; >> + >> +/* >> + * LED set routines have been implemented as work queue tasks scheduled >> + * on the global work queue. Individual task calls OPAL interface to set >> + * the LED state which might sleep for some time. >> + */ >> +struct powernv_led_data { >> + struct led_classdev cdev; >> + enum led_brightness value; /* Brightness value */ >> + struct mutex lock; >> + struct work_struct work_led; /* LED update workqueue */ >> +}; >> + >> +struct powernv_leds_priv { >> + int num_leds; >> + struct powernv_led_data powernv_leds[]; >> +}; >> + >> + >> +static inline int sizeof_powernv_leds_priv(int num_leds) >> +{ >> + return sizeof(struct powernv_leds_priv) + >> + (sizeof(struct powernv_led_data) * num_leds); >> +} >> + >> +/* Returns OPAL_SLOT_LED_TYPE_* for given led type string */ >> +static int powernv_get_led_type(struct led_classdev *led_cdev) >> +{ >> + char *desc; >> + int i; >> + >> + desc = strstr(led_cdev->name, ":"); >> + if (!desc) >> + return -1; >> + desc++; >> + if (!desc) >> + return -1; >> + >> + for (i = 0; i < ARRAY_SIZE(led_type_map); i++) >> + if (!strcmp(led_type_map[i].desc, desc)) >> + return led_type_map[i].type; >> + >> + return -1; >> +} >> + >> +/* This function gets LED location code for given LED classdev */ >> +static char *powernv_get_location_code(struct led_classdev *led_cdev) >> +{ >> + char *loc_code; >> + char *colon; >> + >> + /* Location code of the LED */ >> + loc_code = kasprintf(GFP_KERNEL, "%s", led_cdev->name); >> + if (!loc_code) { >> + dev_err(led_cdev->dev, >> + "%s: Memory allocation failed\n", __func__); >> + return NULL; >> + } >> + >> + colon = strstr(loc_code, ":"); >> + if (!colon) { >> + kfree(loc_code); >> + return NULL; >> + } >> + >> + *colon = '\0'; >> + return loc_code; >> +} >> + >> +/* >> + * This commits the state change of the requested LED through an OPAL call. >> + * This function is called from work queue task context when ever it gets >> + * scheduled. This function can sleep at opal_async_wait_response call. >> + */ >> +static void powernv_led_set(struct led_classdev *led_cdev, >> + enum led_brightness value) >> +{ >> + char *loc_code; >> + int rc, token, led_type; >> + u64 led_mask, led_value = 0; >> + __be64 max_led_type; >> + struct opal_msg msg; >> + >> + led_type = powernv_get_led_type(led_cdev); >> + if (led_type == -1) >> + return; > > Please parse the led type once upon initialization and add related > property to the struct powernv_led_data that will hold the value. I thought we can get location code and type using class dev name itself. Hence I didn't add these two properties to structure.. Do you want me to add them to structure itself? > >> + loc_code = powernv_get_location_code(led_cdev); >> + if (!loc_code) >> + return; > > The same situation as in case of led type. > >> + /* Prepare for the OPAL call */ >> + max_led_type = cpu_to_be64(OPAL_SLOT_LED_TYPE_MAX); > > This value could be also calculated only once. Yeah. May be I can move this to powernv_leds_priv structure. > >> + led_mask = OPAL_SLOT_LED_STATE_ON << led_type; >> + if (value) >> + led_value = led_mask; >> + >> + /* OPAL async call */ >> + token = opal_async_get_token_interruptible(); >> + if (token < 0) { >> + if (token != -ERESTARTSYS) >> + dev_err(led_cdev->dev, >> + "%s: Couldn't get OPAL async token\n", >> + __func__); >> + goto out_loc; >> + } >> + >> + rc = opal_leds_set_ind(token, loc_code, >> + led_mask, led_value, &max_led_type); >> + if (rc != OPAL_ASYNC_COMPLETION) { >> + dev_err(led_cdev->dev, >> + "%s: OPAL set LED call failed for %s [rc=%d]\n", >> + __func__, loc_code, rc); >> + goto out_token; >> + } >> + >> + rc = opal_async_wait_response(token, &msg); >> + if (rc) { >> + dev_err(led_cdev->dev, >> + "%s: Failed to wait for the async response [rc=%d]\n", >> + __func__, rc); >> + goto out_token; >> + } >> + >> + rc = be64_to_cpu(msg.params[1]); >> + if (rc != OPAL_SUCCESS) >> + dev_err(led_cdev->dev, >> + "%s : OAPL async call returned failed [rc=%d]\n", >> + __func__, rc); >> + >> +out_token: >> + opal_async_release_token(token); >> + >> +out_loc: >> + kfree(loc_code); >> +} >> + >> +/* >> + * This function fetches the LED state for a given LED type for >> + * mentioned LED classdev structure. >> + */ >> +static enum led_brightness powernv_led_get(struct led_classdev *led_cdev) >> +{ >> + char *loc_code; >> + int rc, led_type; >> + __be64 led_mask, led_value, max_led_type; >> + >> + led_type = powernv_get_led_type(led_cdev); >> + if (led_type == -1) >> + return LED_OFF; >> + >> + loc_code = powernv_get_location_code(led_cdev); >> + if (!loc_code) >> + return LED_OFF; >> + >> + /* Fetch all LED status */ >> + led_mask = cpu_to_be64(0); >> + led_value = cpu_to_be64(0); >> + max_led_type = cpu_to_be64(OPAL_SLOT_LED_TYPE_MAX); >> + >> + rc = opal_leds_get_ind(loc_code, &led_mask, &led_value, &max_led_type); >> + if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL) { >> + dev_err(led_cdev->dev, >> + "%s: OPAL get led call failed [rc=%d]\n", >> + __func__, rc); >> + goto led_fail; >> + } >> + >> + led_mask = be64_to_cpu(led_mask); >> + led_value = be64_to_cpu(led_value); > > be64_to_cpu result should be assigned to the variable of u64/s64 type. PowerNV platform is capable of running both big/little endian mode.. But presently our firmware is big endian. These variable contains big endian values. Hence I have created as __be64 .. (This is the convention we follow in other places as well). > >> + /* LED status available */ >> + if (!((led_mask >> led_type) & OPAL_SLOT_LED_STATE_ON)) { >> + dev_err(led_cdev->dev, >> + "%s: LED status not available for %s\n", >> + __func__, led_cdev->name); >> + goto led_fail; >> + } >> + >> + /* LED status value */ >> + if ((led_value >> led_type) & OPAL_SLOT_LED_STATE_ON) { >> + kfree(loc_code); >> + return LED_FULL; >> + } >> + >> +led_fail: >> + kfree(loc_code); >> + return LED_OFF; >> +} >> + >> +/* Execute LED set task for given led classdev */ >> +static void powernv_deferred_led_set(struct work_struct *work) >> +{ >> + struct powernv_led_data *powernv_led = >> + container_of(work, struct powernv_led_data, work_led); >> + >> + mutex_lock(&powernv_led->lock); >> + powernv_led_set(&powernv_led->cdev, powernv_led->value); >> + mutex_unlock(&powernv_led->lock); >> +} >> + >> +/* >> + * LED classdev 'brightness_get' function. This schedules work >> + * to update LED state. >> + */ >> +static void powernv_brightness_set(struct led_classdev *led_cdev, >> + enum led_brightness value) >> +{ >> + struct powernv_led_data *powernv_led = >> + container_of(led_cdev, struct powernv_led_data, cdev); >> + >> + /* Do not modify LED in unload path */ >> + if (led_disabled) >> + return; >> + >> + /* Prepare the request */ >> + powernv_led->value = value; >> + >> + /* Schedule the new task */ >> + schedule_work(&powernv_led->work_led); >> +} >> + >> +/* LED classdev 'brightness_get' function */ >> +static enum led_brightness >> +powernv_brightness_get(struct led_classdev *led_cdev) >> +{ >> + return powernv_led_get(led_cdev); >> +} >> + >> + >> +/* >> + * This function registers classdev structure for any given type of LED on >> + * a given child LED device node. >> + */ >> +static int powernv_led_create(struct device *dev, >> + struct powernv_led_data *powernv_led, >> + const char *led_name, const char *led_type_desc) >> +{ >> + int rc; >> + >> + /* Create the name for classdev */ >> + powernv_led->cdev.name = kasprintf(GFP_KERNEL, "%s:%s", >> + led_name, led_type_desc); > > Please use devm_kasprintf. Done. > >> + if (!powernv_led->cdev.name) { >> + dev_err(dev, >> + "%s: Memory allocation failed for classdev name\n", >> + __func__); >> + return -ENOMEM; >> + } >> + >> + /* Make sure LED type is supported */ >> + if (powernv_get_led_type(&powernv_led->cdev) == -1) { >> + kfree(powernv_led->cdev.name); >> + return -EINVAL; >> + } >> + >> + powernv_led->cdev.brightness_set = powernv_brightness_set; >> + powernv_led->cdev.brightness_get = powernv_brightness_get; >> + powernv_led->cdev.brightness = LED_OFF; >> + powernv_led->cdev.max_brightness = LED_FULL; >> + >> + mutex_init(&powernv_led->lock); >> + INIT_WORK(&powernv_led->work_led, powernv_deferred_led_set); >> + >> + /* Register the classdev */ >> + rc = led_classdev_register(dev, &powernv_led->cdev); > > devm_led_classdev_register is also available. Looks like most of the existing drivers are using led_classdev_register function.. Which one is preferred here? > >> + if (rc) { >> + dev_err(dev, "%s: Classdev registration failed for %s\n", >> + __func__, powernv_led->cdev.name); >> + kfree(powernv_led->cdev.name); >> + } >> + >> + return rc; >> +} >> + >> +/* Unregister classdev structure for any given LED */ >> +static void powernv_led_delete(struct powernv_led_data *powernv_led) >> +{ >> + led_classdev_unregister(&powernv_led->cdev); >> +} > > This function is redundant. Like powernv_led_create, I just added this function ... hoping this will improve code readability. Will remove this function. > >> +/* Go through LED device tree node and register LED classdev structure */ >> +static int powernv_led_classdev(struct platform_device *pdev, >> + struct device_node *led_node, >> + struct powernv_leds_priv *priv, int num_leds) >> +{ >> + const char *cur = NULL; >> + int i, rc = -1; >> + struct property *p; >> + struct device_node *np; >> + struct powernv_led_data *powernv_led; >> + struct device *dev = &pdev->dev; >> + >> + for_each_child_of_node(led_node, np) { >> + p = of_find_property(np, "led-types", NULL); >> + if (!p) >> + continue; >> + >> + while ((cur = of_prop_next_string(p, cur)) != NULL) { >> + powernv_led = &priv->powernv_leds[priv->num_leds++]; >> + if (priv->num_leds > num_leds) { >> + rc = -ENOMEM; >> + goto classdev_fail; >> + } >> + rc = powernv_led_create(dev, >> + powernv_led, np->name, cur); >> + if (rc) >> + goto classdev_fail; >> + } /* while end */ >> + } >> + >> + platform_set_drvdata(pdev, priv); >> + return rc; >> + >> +classdev_fail: >> + for (i = priv->num_leds - 2; i > 0; i--) > > Why do you leave element with id == 0 unreleased? It was my mistake. Fixed. > >> + powernv_led_delete(&priv->powernv_leds[i]); >> + >> + return rc; >> +} >> + >> +/* >> + * We want to populate LED device for each LED type. Hence we >> + * have to calculate count explicitly. >> + */ >> +static int powernv_leds_count(struct device_node *led_node) >> +{ >> + const char *cur = NULL; >> + int num_leds = 0; >> + struct property *p; >> + struct device_node *np; >> + >> + for_each_child_of_node(led_node, np) { >> + p = of_find_property(np, "led-types", NULL); >> + if (!p) >> + continue; >> + >> + while ((cur = of_prop_next_string(p, cur)) != NULL) >> + num_leds++; >> + } >> + >> + return num_leds; >> +} > > Does it mean that if the node exists but does't have led-types > property we are not going to register it? Yes.. No point in registering location code ..which doesn't have led-types property. > I assume that this is > firmware which generates the nodes, otherwise it would make > no sense to have the node, am I right? That correct. Our firmware generates this property. > >> +/* Platform driver probe */ >> +static int powernv_led_probe(struct platform_device *pdev) >> +{ >> + int num_leds; >> + struct device_node *led_node; >> + struct powernv_leds_priv *priv; >> + >> + led_node = of_find_node_by_path("/ibm,opal/leds"); >> + if (!led_node) { >> + dev_err(&pdev->dev, >> + "%s: LED parent device node not found\n", __func__); >> + return -EINVAL; >> + } >> + >> + num_leds = powernv_leds_count(led_node); >> + if (num_leds <= 0) { >> + dev_err(&pdev->dev, >> + "%s: No location code found under LED node\n", >> + __func__); >> + return -EINVAL; >> + } >> + >> + priv = devm_kzalloc(&pdev->dev, >> + sizeof_powernv_leds_priv(num_leds), >> + GFP_KERNEL); >> + if (!priv) >> + return -ENOMEM; >> + >> + return powernv_led_classdev(pdev, led_node, priv, num_leds); >> +} >> + >> +/* Platform driver remove */ >> +static int powernv_led_remove(struct platform_device *pdev) >> +{ >> + int i; >> + struct powernv_led_data *powernv_led; >> + struct powernv_leds_priv *priv; >> + >> + /* Disable LED operation */ >> + led_disabled = true; >> + >> + priv = platform_get_drvdata(pdev); >> + >> + for (i = 0; i < priv->num_leds; i++) { >> + powernv_led = &priv->powernv_leds[i]; >> + powernv_led_delete(powernv_led); >> + flush_work(&powernv_led->work_led); >> + } > > You are missing mutex_destroy here. Oh yeah.. I missed it. Fixed. -Vasant