From mboxrd@z Thu Jan 1 00:00:00 1970 From: Eduardo Valentin Subject: Re: [PATCH v3 08/23] thermal: armada: use the resource managed registration helper alternative Date: Thu, 26 Jul 2018 14:37:38 -0700 Message-ID: <20180726213737.GB15690@localhost.localdomain> References: <20180716144206.30985-1-miquel.raynal@bootlin.com> <20180716144206.30985-9-miquel.raynal@bootlin.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20180716144206.30985-9-miquel.raynal@bootlin.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: Miquel Raynal Cc: Mark Rutland , Andrew Lunn , Jason Cooper , devicetree@vger.kernel.org, Antoine Tenart , Catalin Marinas , Gregory Clement , linux-pm@vger.kernel.org, Will Deacon , Maxime Chevallier , Nadav Haklai , David Sniatkiwicz , Rob Herring , Thomas Petazzoni , Zhang Rui , linux-arm-kernel@lists.infradead.org, Sebastian Hesselbarth List-Id: devicetree@vger.kernel.org SGV5LAoKT24gTW9uLCBKdWwgMTYsIDIwMTggYXQgMDQ6NDE6NTFQTSArMDIwMCwgTWlxdWVsIFJh eW5hbCB3cm90ZToKPiBDdXJyZW50IHVzZSBvZiB0aGVybWFsX3pvbmVfZGV2aWNlX3JlZ2lzdGVy KCkgdHJpZ2dlcnMgYSB3YXJuaW5nIGF0IGJvb3QKPiBhbmQgc2hvdWxkIGJlIHJlcGxhY2VkIGJ5 IGRldm1fdGhlcm1hbF96b25lX29mX3NlbnNvcl9yZWdpc3RlcigpLiBUaGlzCj4gYWxsb3dzIGJl dHRlciBoYW5kbGluZyBvZiBtdWx0aXBsZSB0aGVybWFsIHpvbmVzIGZvciBsYXRlciBtdWx0aS1z ZW5zb3JzCj4gc3VwcG9ydC4KPiAKPiBBbHNvIGNoYW5nZSB0aGUgZHJpdmVyIGRhdGEgdG8gZW1i ZWQgYSBuZXcgc3RydWN0dXJlIHRvIG1ha2UgdGhlCj4gZGlmZmVyZW5jZSBiZXR3ZWVuIGxlZ2Fj eSBkYXRhICh3aGljaCBuZWVkcyB0byBiZSBjbGVhbmVkKSBhbmQKPiBzeXNjb24tcmVsYXRlZCBk YXRhLgo+IAo+IFNpZ25lZC1vZmYtYnk6IE1pcXVlbCBSYXluYWwgPG1pcXVlbC5yYXluYWxAYm9v dGxpbi5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvdGhlcm1hbC9hcm1hZGFfdGhlcm1hbC5jIHwgMTIz ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLQo+ICAxIGZpbGUgY2hhbmdl ZCwgMTAxIGluc2VydGlvbnMoKyksIDIyIGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL3RoZXJtYWwvYXJtYWRhX3RoZXJtYWwuYyBiL2RyaXZlcnMvdGhlcm1hbC9hcm1hZGFf dGhlcm1hbC5jCj4gaW5kZXggYmUzNDZjNmFmZGUyLi5kZDg5NDMxMmRlZGYgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy90aGVybWFsL2FybWFkYV90aGVybWFsLmMKPiArKysgYi9kcml2ZXJzL3RoZXJt YWwvYXJtYWRhX3RoZXJtYWwuYwo+IEBAIC02NCw2ICs2NCw3IEBAIHN0cnVjdCBhcm1hZGFfdGhl cm1hbF9kYXRhOwo+ICAKPiAgLyogTWFydmVsbCBFQlUgVGhlcm1hbCBTZW5zb3IgRGV2IFN0cnVj dHVyZSAqLwo+ICBzdHJ1Y3QgYXJtYWRhX3RoZXJtYWxfcHJpdiB7Cj4gKwlzdHJ1Y3QgZGV2aWNl ICpkZXY7Cj4gIAlzdHJ1Y3QgcmVnbWFwICpzeXNjb247Cj4gIAljaGFyIHpvbmVfbmFtZVtUSEVS TUFMX05BTUVfTEVOR1RIXTsKPiAgCXN0cnVjdCBhcm1hZGFfdGhlcm1hbF9kYXRhICpkYXRhOwo+ IEBAIC05NSw2ICs5NiwyNiBAQCBzdHJ1Y3QgYXJtYWRhX3RoZXJtYWxfZGF0YSB7Cj4gIAl1bnNp Z25lZCBpbnQgc3lzY29uX3N0YXR1c19vZmY7Cj4gIH07Cj4gIAo+ICtzdHJ1Y3QgYXJtYWRhX2Ry dmRhdGEgewo+ICsJZW51bSBkcnZ0eXBlIHsKPiArCQlMRUdBQ1ksCj4gKwkJU1lTQ09OCj4gKwl9 IHR5cGU7Cj4gKwl1bmlvbiB7Cj4gKwkJc3RydWN0IGFybWFkYV90aGVybWFsX3ByaXYgKnByaXY7 Cj4gKwkJc3RydWN0IHRoZXJtYWxfem9uZV9kZXZpY2UgKnR6Owo+ICsJfSBkYXRhOwo+ICt9Owo+ ICsKPiArLyoKPiArICogc3RydWN0IGFybWFkYV90aGVybWFsX3NlbnNvciAtIGhvbGQgdGhlIGlu Zm9ybWF0aW9uIG9mIG9uZSB0aGVybWFsIHNlbnNvcgo+ICsgKiBAdGhlcm1hbDogcG9pbnRlciB0 byB0aGUgbG9jYWwgcHJpdmF0ZSBzdHJ1Y3R1cmUKPiArICogQHR6ZDogcG9pbnRlciB0byB0aGUg dGhlcm1hbCB6b25lIGRldmljZQo+ICsgKi8KPiArc3RydWN0IGFybWFkYV90aGVybWFsX3NlbnNv ciB7Cj4gKwlzdHJ1Y3QgYXJtYWRhX3RoZXJtYWxfcHJpdiAqcHJpdjsKPiArfTsKPiArCj4gIHN0 YXRpYyB2b2lkIGFybWFkYXhwX2luaXQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKPiAg CQkJICBzdHJ1Y3QgYXJtYWRhX3RoZXJtYWxfcHJpdiAqcHJpdikKPiAgewo+IEBAIC0yNDMsMTYg KzI2NCwxNCBAQCBzdGF0aWMgYm9vbCBhcm1hZGFfaXNfdmFsaWQoc3RydWN0IGFybWFkYV90aGVy bWFsX3ByaXYgKnByaXYpCj4gIAlyZXR1cm4gcmVnICYgcHJpdi0+ZGF0YS0+aXNfdmFsaWRfYml0 Owo+ICB9Cj4gIAo+IC1zdGF0aWMgaW50IGFybWFkYV9nZXRfdGVtcChzdHJ1Y3QgdGhlcm1hbF96 b25lX2RldmljZSAqdGhlcm1hbCwKPiAtCQkJICAgaW50ICp0ZW1wKQo+ICtzdGF0aWMgaW50IGFy bWFkYV9yZWFkX3NlbnNvcihzdHJ1Y3QgYXJtYWRhX3RoZXJtYWxfcHJpdiAqcHJpdiwgaW50ICp0 ZW1wKQo+ICB7Cj4gLQlzdHJ1Y3QgYXJtYWRhX3RoZXJtYWxfcHJpdiAqcHJpdiA9IHRoZXJtYWwt PmRldmRhdGE7Cj4gIAl1MzIgcmVnLCBkaXY7Cj4gIAlzNjQgc2FtcGxlLCBiLCBtOwo+ICAKPiAg CS8qIFZhbGlkIGNoZWNrICovCj4gIAlpZiAocHJpdi0+ZGF0YS0+aXNfdmFsaWQgJiYgIXByaXYt PmRhdGEtPmlzX3ZhbGlkKHByaXYpKSB7Cj4gLQkJZGV2X2VycigmdGhlcm1hbC0+ZGV2aWNlLAo+ ICsJCWRldl9lcnIocHJpdi0+ZGV2LAo+ICAJCQkiVGVtcGVyYXR1cmUgc2Vuc29yIHJlYWRpbmcg bm90IHZhbGlkXG4iKTsKPiAgCQlyZXR1cm4gLUVJTzsKPiAgCX0KPiBAQCAtMjc4LDcgKzI5Nywz MyBAQCBzdGF0aWMgaW50IGFybWFkYV9nZXRfdGVtcChzdHJ1Y3QgdGhlcm1hbF96b25lX2Rldmlj ZSAqdGhlcm1hbCwKPiAgCXJldHVybiAwOwo+ICB9Cj4gIAo+IC1zdGF0aWMgc3RydWN0IHRoZXJt YWxfem9uZV9kZXZpY2Vfb3BzIG9wcyA9IHsKPiArc3RhdGljIGludCBhcm1hZGFfZ2V0X3RlbXBf bGVnYWN5KHN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNlICp0aGVybWFsLAo+ICsJCQkJICBpbnQg KnRlbXApCj4gK3sKPiArCXN0cnVjdCBhcm1hZGFfdGhlcm1hbF9wcml2ICpwcml2ID0gdGhlcm1h bC0+ZGV2ZGF0YTsKPiArCWludCByZXQ7Cj4gKwo+ICsJLyogRG8gdGhlIGFjdHVhbCByZWFkaW5n ICovCj4gKwlyZXQgPSBhcm1hZGFfcmVhZF9zZW5zb3IocHJpdiwgdGVtcCk7Cj4gKwo+ICsJcmV0 dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNlX29w cyBsZWdhY3lfb3BzID0gewo+ICsJLmdldF90ZW1wID0gYXJtYWRhX2dldF90ZW1wX2xlZ2FjeSwK PiArfTsKPiArCj4gK3N0YXRpYyBpbnQgYXJtYWRhX2dldF90ZW1wKHZvaWQgKl9zZW5zb3IsIGlu dCAqdGVtcCkKPiArewo+ICsJc3RydWN0IGFybWFkYV90aGVybWFsX3NlbnNvciAqc2Vuc29yID0g X3NlbnNvcjsKPiArCXN0cnVjdCBhcm1hZGFfdGhlcm1hbF9wcml2ICpwcml2ID0gc2Vuc29yLT5w cml2Owo+ICsJaW50IHJldDsKCgpUaGUgYWJvdmUgdmFyaWFibGU6CmRyaXZlcnMvdGhlcm1hbC9h cm1hZGFfdGhlcm1hbC5jOjMyMDo2OiB3YXJuaW5nOiB1bnVzZWQgdmFyaWFibGUg4oCYcmV04oCZ IFstV3VudXNlZC12YXJpYWJsZV0KICBpbnQgcmV0OwogICAgICBefn4KY2MxOiBzb21lIHdhcm5p bmdzIGJlaW5nIHRyZWF0ZWQgYXMgZXJyb3JzCnNjcmlwdHMvTWFrZWZpbGUuYnVpbGQ6MzIzOiBy ZWNpcGUgZm9yIHRhcmdldCAnZHJpdmVycy90aGVybWFsL2FybWFkYV90aGVybWFsLm8nIGZhaWxl ZAoKCj4gKwo+ICsJLyogRG8gdGhlIGFjdHVhbCByZWFkaW5nICovCj4gKwlyZXR1cm4gYXJtYWRh X3JlYWRfc2Vuc29yKHByaXYsICZ0ZW1wKTsKCkkgdGhpbmsgeW91IG1lYW50IAoKKwlyZXR1cm4g YXJtYWRhX3JlYWRfc2Vuc29yKHByaXYsIHRlbXApOwoKaGVyZSByaWdodD8KCgpJIG9idmlvdXNs eSBnZXQ6CgogIENDIFtNXSAgZHJpdmVycy90aGVybWFsL2FybWFkYV90aGVybWFsLm8KZHJpdmVy cy90aGVybWFsL2FybWFkYV90aGVybWFsLmM6IEluIGZ1bmN0aW9uIOKAmGFybWFkYV9nZXRfdGVt cOKAmToKZHJpdmVycy90aGVybWFsL2FybWFkYV90aGVybWFsLmM6MzIzOjM0OiBlcnJvcjogcGFz c2luZyBhcmd1bWVudCAyIG9mIOKAmGFybWFkYV9yZWFkX3NlbnNvcuKAmSBmcm9tIGluY29tcGF0 aWJsZSBwb2ludGVyIHR5cGUgWy1XZXJyb3I9aW5jb21wYXRpYmxlLXBvaW50ZXItdHlwZXNdCiAg cmV0dXJuIGFybWFkYV9yZWFkX3NlbnNvcihwcml2LCAmdGVtcCk7CiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBeCmRyaXZlcnMvdGhlcm1hbC9hcm1hZGFfdGhlcm1hbC5jOjI2Nzox Mjogbm90ZTogZXhwZWN0ZWQg4oCYaW50ICrigJkgYnV0IGFyZ3VtZW50IGlzIG9mIHR5cGUg4oCY aW50ICoq4oCZCiBzdGF0aWMgaW50IGFybWFkYV9yZWFkX3NlbnNvcihzdHJ1Y3QgYXJtYWRhX3Ro ZXJtYWxfcHJpdiAqcHJpdiwgaW50ICp0ZW1wKQogICAgICAgICAgICBefn5+fn5+fn5+fn5+fn5+ fn4KCgo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHRoZXJtYWxfem9uZV9vZl9kZXZpY2Vfb3Bz IG9mX29wcyA9IHsKPiAgCS5nZXRfdGVtcCA9IGFybWFkYV9nZXRfdGVtcCwKPiAgfTsKPiAgCj4g QEAgLTQ4MCw3ICs1MjUsOSBAQCBzdGF0aWMgdm9pZCBhcm1hZGFfc2V0X3NhbmVfbmFtZShzdHJ1 Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAo+ICAKPiAgc3RhdGljIGludCBhcm1hZGFfdGhlcm1h bF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICB7Cj4gLQlzdHJ1Y3QgdGhl cm1hbF96b25lX2RldmljZSAqdGhlcm1hbDsKPiArCXN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNl ICp0ejsKPiArCXN0cnVjdCBhcm1hZGFfdGhlcm1hbF9zZW5zb3IgKnNlbnNvcnM7Cj4gKwlzdHJ1 Y3QgYXJtYWRhX2RydmRhdGEgKmRydmRhdGE7Cj4gIAljb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lk ICptYXRjaDsKPiAgCXN0cnVjdCBhcm1hZGFfdGhlcm1hbF9wcml2ICpwcml2Owo+ICAJaW50IHJl dDsKPiBAQCAtNDkzLDExICs1NDAsMTMgQEAgc3RhdGljIGludCBhcm1hZGFfdGhlcm1hbF9wcm9i ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICAJaWYgKCFwcml2KQo+ICAJCXJldHVy biAtRU5PTUVNOwo+ICAKPiArCWRydmRhdGEgPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6 ZW9mKCpkcnZkYXRhKSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIXByaXYpCj4gKwkJcmV0dXJuIC1F Tk9NRU07Cj4gKwo+ICsJcHJpdi0+ZGV2ID0gJnBkZXYtPmRldjsKPiAgCXByaXYtPmRhdGEgPSAo c3RydWN0IGFybWFkYV90aGVybWFsX2RhdGEgKiltYXRjaC0+ZGF0YTsKPiAgCj4gLQkvKiBFbnN1 cmUgZGV2aWNlIG5hbWUgaXMgY29ycmVjdCBmb3IgdGhlIHRoZXJtYWwgY29yZSAqLwo+IC0JYXJt YWRhX3NldF9zYW5lX25hbWUocGRldiwgcHJpdik7Cj4gLQo+ICAJLyoKPiAgCSAqIExlZ2FjeSBE VCBiaW5kaW5ncyBvbmx5IGRlc2NyaWJlZCAiY29udHJvbDEiIHJlZ2lzdGVyIChhbHNvIHJlZmVy cmVkCj4gIAkgKiBhcyAiY29udHJvbCBNU0IiIG9uIG9sZCBkb2N1bWVudGF0aW9uKS4gVGhlbiwg YmluZGluZ3MgbW92ZWQgdG8gY292ZXIKPiBAQCAtNTEwLDM1ICs1NTksNjUgQEAgc3RhdGljIGlu dCBhcm1hZGFfdGhlcm1hbF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICAJ ICogaXMgdG8gZGVmaW5lIGFuIG92ZXJhbGwgc3lzdGVtIGNvbnRyb2xsZXIgYW5kIHB1dCB0aGUg dGhlcm1hbCBub2RlCj4gIAkgKiBpbnRvIGl0LCB3aGljaCByZXF1aXJlcyB0aGUgdXNlIG9mIHJl Z21hcHMgYWNyb3NzIGFsbCB0aGUgZHJpdmVyLgo+ICAJICovCj4gLQlpZiAoSVNfRVJSKHN5c2Nv bl9ub2RlX3RvX3JlZ21hcChwZGV2LT5kZXYucGFyZW50LT5vZl9ub2RlKSkpCj4gKwlpZiAoSVNf RVJSKHN5c2Nvbl9ub2RlX3RvX3JlZ21hcChwZGV2LT5kZXYucGFyZW50LT5vZl9ub2RlKSkpIHsK PiArCQkvKiBFbnN1cmUgZGV2aWNlIG5hbWUgaXMgY29ycmVjdCBmb3IgdGhlIHRoZXJtYWwgY29y ZSAqLwo+ICsJCWFybWFkYV9zZXRfc2FuZV9uYW1lKHBkZXYsIHByaXYpOwo+ICsKPiAgCQlyZXQg PSBhcm1hZGFfdGhlcm1hbF9wcm9iZV9sZWdhY3kocGRldiwgcHJpdik7Cj4gLQllbHNlCj4gLQkJ cmV0ID0gYXJtYWRhX3RoZXJtYWxfcHJvYmVfc3lzY29uKHBkZXYsIHByaXYpOwo+ICsJCWlmIChy ZXQpCj4gKwkJCXJldHVybiByZXQ7Cj4gIAo+ICsJCXByaXYtPmRhdGEtPmluaXQocGRldiwgcHJp dik7Cj4gKwo+ICsJCXR6ID0gdGhlcm1hbF96b25lX2RldmljZV9yZWdpc3Rlcihwcml2LT56b25l X25hbWUsIDAsIDAsIHByaXYsCj4gKwkJCQkJCSAgJmxlZ2FjeV9vcHMsIE5VTEwsIDAsIDApOwo+ ICsJCWlmIChJU19FUlIodHopKSB7Cj4gKwkJCWRldl9lcnIoJnBkZXYtPmRldiwKPiArCQkJCSJG YWlsZWQgdG8gcmVnaXN0ZXIgdGhlcm1hbCB6b25lIGRldmljZVxuIik7Cj4gKwkJCXJldHVybiBQ VFJfRVJSKHR6KTsKPiArCQl9Cj4gKwo+ICsJCWRydmRhdGEtPnR5cGUgPSBMRUdBQ1k7Cj4gKwkJ ZHJ2ZGF0YS0+ZGF0YS50eiA9IHR6Owo+ICsJCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGRy dmRhdGEpOwo+ICsKPiArCQlyZXR1cm4gMDsKPiArCX0KPiArCj4gKwlyZXQgPSBhcm1hZGFfdGhl cm1hbF9wcm9iZV9zeXNjb24ocGRldiwgcHJpdik7Cj4gIAlpZiAocmV0KQo+ICAJCXJldHVybiBy ZXQ7Cj4gIAo+ICAJcHJpdi0+ZGF0YS0+aW5pdChwZGV2LCBwcml2KTsKPiArCWRydmRhdGEtPnR5 cGUgPSBTWVNDT047Cj4gKwlkcnZkYXRhLT5kYXRhLnByaXYgPSBwcml2Owo+ICsJcGxhdGZvcm1f c2V0X2RydmRhdGEocGRldiwgZHJ2ZGF0YSk7Cj4gIAo+IC0JdGhlcm1hbCA9IHRoZXJtYWxfem9u ZV9kZXZpY2VfcmVnaXN0ZXIocHJpdi0+em9uZV9uYW1lLCAwLCAwLCBwcml2LAo+IC0JCQkJCSAg ICAgICAmb3BzLCBOVUxMLCAwLCAwKTsKPiAtCWlmIChJU19FUlIodGhlcm1hbCkpIHsKPiArCXNl bnNvcnMgPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKHN0cnVjdCBhcm1hZGFfdGhl cm1hbF9zZW5zb3IpLAo+ICsJCQkgICAgICAgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIXNlbnNvcnMp Cj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJc2Vuc29ycy0+cHJpdiA9IHByaXY7Cj4gKwo+ ICsJdHogPSBkZXZtX3RoZXJtYWxfem9uZV9vZl9zZW5zb3JfcmVnaXN0ZXIoJnBkZXYtPmRldiwg MCwgc2Vuc29ycywKPiArCQkJCQkJICAmb2Zfb3BzKTsKPiArCWlmIChJU19FUlIodHopKSB7Cj4g IAkJZGV2X2VycigmcGRldi0+ZGV2LAo+IC0JCQkiRmFpbGVkIHRvIHJlZ2lzdGVyIHRoZXJtYWwg em9uZSBkZXZpY2VcbiIpOwo+IC0JCXJldHVybiBQVFJfRVJSKHRoZXJtYWwpOwo+ICsJCQkiRmFp bGVkIHRvIHJlZ2lzdGVyIHRoZXJtYWwgc2Vuc29yIChlcnI6ICVsZClcbiIsCj4gKwkJCVBUUl9F UlIodHopKTsKPiArCQlyZXR1cm4gUFRSX0VSUih0eik7Cj4gIAl9Cj4gIAo+IC0JcGxhdGZvcm1f c2V0X2RydmRhdGEocGRldiwgdGhlcm1hbCk7Cj4gLQo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAgCj4g IHN0YXRpYyBpbnQgYXJtYWRhX3RoZXJtYWxfZXhpdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpw ZGV2KQo+ICB7Cj4gLQlzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZSAqYXJtYWRhX3RoZXJtYWwg PQo+IC0JCXBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwo+ICsJc3RydWN0IGFybWFkYV9kcnZk YXRhICpkcnZkYXRhID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7Cj4gIAo+IC0JdGhlcm1h bF96b25lX2RldmljZV91bnJlZ2lzdGVyKGFybWFkYV90aGVybWFsKTsKPiArCWlmIChkcnZkYXRh LT50eXBlID09IExFR0FDWSkKPiArCQl0aGVybWFsX3pvbmVfZGV2aWNlX3VucmVnaXN0ZXIoZHJ2 ZGF0YS0+ZGF0YS50eik7Cj4gIAo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAtLSAKPiAyLjE0LjEKPiAK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFy bS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9y ZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1r ZXJuZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: edubezval@gmail.com (Eduardo Valentin) Date: Thu, 26 Jul 2018 14:37:38 -0700 Subject: [PATCH v3 08/23] thermal: armada: use the resource managed registration helper alternative In-Reply-To: <20180716144206.30985-9-miquel.raynal@bootlin.com> References: <20180716144206.30985-1-miquel.raynal@bootlin.com> <20180716144206.30985-9-miquel.raynal@bootlin.com> Message-ID: <20180726213737.GB15690@localhost.localdomain> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Hey, On Mon, Jul 16, 2018 at 04:41:51PM +0200, Miquel Raynal wrote: > Current use of thermal_zone_device_register() triggers a warning at boot > and should be replaced by devm_thermal_zone_of_sensor_register(). This > allows better handling of multiple thermal zones for later multi-sensors > support. > > Also change the driver data to embed a new structure to make the > difference between legacy data (which needs to be cleaned) and > syscon-related data. > > Signed-off-by: Miquel Raynal > --- > drivers/thermal/armada_thermal.c | 123 ++++++++++++++++++++++++++++++++------- > 1 file changed, 101 insertions(+), 22 deletions(-) > > diff --git a/drivers/thermal/armada_thermal.c b/drivers/thermal/armada_thermal.c > index be346c6afde2..dd894312dedf 100644 > --- a/drivers/thermal/armada_thermal.c > +++ b/drivers/thermal/armada_thermal.c > @@ -64,6 +64,7 @@ struct armada_thermal_data; > > /* Marvell EBU Thermal Sensor Dev Structure */ > struct armada_thermal_priv { > + struct device *dev; > struct regmap *syscon; > char zone_name[THERMAL_NAME_LENGTH]; > struct armada_thermal_data *data; > @@ -95,6 +96,26 @@ struct armada_thermal_data { > unsigned int syscon_status_off; > }; > > +struct armada_drvdata { > + enum drvtype { > + LEGACY, > + SYSCON > + } type; > + union { > + struct armada_thermal_priv *priv; > + struct thermal_zone_device *tz; > + } data; > +}; > + > +/* > + * struct armada_thermal_sensor - hold the information of one thermal sensor > + * @thermal: pointer to the local private structure > + * @tzd: pointer to the thermal zone device > + */ > +struct armada_thermal_sensor { > + struct armada_thermal_priv *priv; > +}; > + > static void armadaxp_init(struct platform_device *pdev, > struct armada_thermal_priv *priv) > { > @@ -243,16 +264,14 @@ static bool armada_is_valid(struct armada_thermal_priv *priv) > return reg & priv->data->is_valid_bit; > } > > -static int armada_get_temp(struct thermal_zone_device *thermal, > - int *temp) > +static int armada_read_sensor(struct armada_thermal_priv *priv, int *temp) > { > - struct armada_thermal_priv *priv = thermal->devdata; > u32 reg, div; > s64 sample, b, m; > > /* Valid check */ > if (priv->data->is_valid && !priv->data->is_valid(priv)) { > - dev_err(&thermal->device, > + dev_err(priv->dev, > "Temperature sensor reading not valid\n"); > return -EIO; > } > @@ -278,7 +297,33 @@ static int armada_get_temp(struct thermal_zone_device *thermal, > return 0; > } > > -static struct thermal_zone_device_ops ops = { > +static int armada_get_temp_legacy(struct thermal_zone_device *thermal, > + int *temp) > +{ > + struct armada_thermal_priv *priv = thermal->devdata; > + int ret; > + > + /* Do the actual reading */ > + ret = armada_read_sensor(priv, temp); > + > + return ret; > +} > + > +static struct thermal_zone_device_ops legacy_ops = { > + .get_temp = armada_get_temp_legacy, > +}; > + > +static int armada_get_temp(void *_sensor, int *temp) > +{ > + struct armada_thermal_sensor *sensor = _sensor; > + struct armada_thermal_priv *priv = sensor->priv; > + int ret; The above variable: drivers/thermal/armada_thermal.c:320:6: warning: unused variable ?ret? [-Wunused-variable] int ret; ^~~ cc1: some warnings being treated as errors scripts/Makefile.build:323: recipe for target 'drivers/thermal/armada_thermal.o' failed > + > + /* Do the actual reading */ > + return armada_read_sensor(priv, &temp); I think you meant + return armada_read_sensor(priv, temp); here right? I obviously get: CC [M] drivers/thermal/armada_thermal.o drivers/thermal/armada_thermal.c: In function ?armada_get_temp?: drivers/thermal/armada_thermal.c:323:34: error: passing argument 2 of ?armada_read_sensor? from incompatible pointer type [-Werror=incompatible-pointer-types] return armada_read_sensor(priv, &temp); ^ drivers/thermal/armada_thermal.c:267:12: note: expected ?int *? but argument is of type ?int **? static int armada_read_sensor(struct armada_thermal_priv *priv, int *temp) ^~~~~~~~~~~~~~~~~~ > +} > + > +static struct thermal_zone_of_device_ops of_ops = { > .get_temp = armada_get_temp, > }; > > @@ -480,7 +525,9 @@ static void armada_set_sane_name(struct platform_device *pdev, > > static int armada_thermal_probe(struct platform_device *pdev) > { > - struct thermal_zone_device *thermal; > + struct thermal_zone_device *tz; > + struct armada_thermal_sensor *sensors; > + struct armada_drvdata *drvdata; > const struct of_device_id *match; > struct armada_thermal_priv *priv; > int ret; > @@ -493,11 +540,13 @@ static int armada_thermal_probe(struct platform_device *pdev) > if (!priv) > return -ENOMEM; > > + drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); > + if (!priv) > + return -ENOMEM; > + > + priv->dev = &pdev->dev; > priv->data = (struct armada_thermal_data *)match->data; > > - /* Ensure device name is correct for the thermal core */ > - armada_set_sane_name(pdev, priv); > - > /* > * Legacy DT bindings only described "control1" register (also referred > * as "control MSB" on old documentation). Then, bindings moved to cover > @@ -510,35 +559,65 @@ static int armada_thermal_probe(struct platform_device *pdev) > * is to define an overall system controller and put the thermal node > * into it, which requires the use of regmaps across all the driver. > */ > - if (IS_ERR(syscon_node_to_regmap(pdev->dev.parent->of_node))) > + if (IS_ERR(syscon_node_to_regmap(pdev->dev.parent->of_node))) { > + /* Ensure device name is correct for the thermal core */ > + armada_set_sane_name(pdev, priv); > + > ret = armada_thermal_probe_legacy(pdev, priv); > - else > - ret = armada_thermal_probe_syscon(pdev, priv); > + if (ret) > + return ret; > > + priv->data->init(pdev, priv); > + > + tz = thermal_zone_device_register(priv->zone_name, 0, 0, priv, > + &legacy_ops, NULL, 0, 0); > + if (IS_ERR(tz)) { > + dev_err(&pdev->dev, > + "Failed to register thermal zone device\n"); > + return PTR_ERR(tz); > + } > + > + drvdata->type = LEGACY; > + drvdata->data.tz = tz; > + platform_set_drvdata(pdev, drvdata); > + > + return 0; > + } > + > + ret = armada_thermal_probe_syscon(pdev, priv); > if (ret) > return ret; > > priv->data->init(pdev, priv); > + drvdata->type = SYSCON; > + drvdata->data.priv = priv; > + platform_set_drvdata(pdev, drvdata); > > - thermal = thermal_zone_device_register(priv->zone_name, 0, 0, priv, > - &ops, NULL, 0, 0); > - if (IS_ERR(thermal)) { > + sensors = devm_kzalloc(&pdev->dev, sizeof(struct armada_thermal_sensor), > + GFP_KERNEL); > + if (!sensors) > + return -ENOMEM; > + > + sensors->priv = priv; > + > + tz = devm_thermal_zone_of_sensor_register(&pdev->dev, 0, sensors, > + &of_ops); > + if (IS_ERR(tz)) { > dev_err(&pdev->dev, > - "Failed to register thermal zone device\n"); > - return PTR_ERR(thermal); > + "Failed to register thermal sensor (err: %ld)\n", > + PTR_ERR(tz)); > + return PTR_ERR(tz); > } > > - platform_set_drvdata(pdev, thermal); > - > return 0; > } > > static int armada_thermal_exit(struct platform_device *pdev) > { > - struct thermal_zone_device *armada_thermal = > - platform_get_drvdata(pdev); > + struct armada_drvdata *drvdata = platform_get_drvdata(pdev); > > - thermal_zone_device_unregister(armada_thermal); > + if (drvdata->type == LEGACY) > + thermal_zone_device_unregister(drvdata->data.tz); > > return 0; > } > -- > 2.14.1 >