From mboxrd@z Thu Jan 1 00:00:00 1970 From: Heiko Schocher Date: Thu, 12 Jun 2014 09:39:16 +0000 Subject: Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor Message-Id: <53997544.5090106@denx.de> List-Id: References: <1402468095-14678-1-git-send-email-hs@denx.de> <53988DC1.7000203@roeck-us.net> In-Reply-To: <53988DC1.7000203@roeck-us.net> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: Guenter Roeck Cc: lm-sensors@lm-sensors.org, Jean Delvare , linux-kernel@vger.kernel.org SGVsbG8gR3VlbnRlciwKCkFtIDExLjA2LjIwMTQgMTk6MTEsIHNjaHJpZWIgR3VlbnRlciBSb2Vj azoKPiBPbiAwNi8xMC8yMDE0IDExOjI4IFBNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPj4gRHJp dmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+Pgo+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWlsYXIgdG8g dGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4gYnkgaGF2aW5nIG9ubHkg OCBiaXQgcmVnaXN0ZXJzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hlciA8aHNA ZGVueC5kZT4KPj4gQ2M6IEplYW4gRGVsdmFyZSA8a2hhbGlAbGludXgtZnIub3JnPgo+PiBDYzog R3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0Pgo+PiBDYzogbGludXgta2VybmVsQHZn ZXIua2VybmVsLm9yZwo+Cj4gSGkgSGVpa28sCj4KPiBZb3UgZG9uJ3QgbmVlZCB0aG9zZSBDYzog aW4gdGhlIGhlYWRlci4KCk9rLCBJIHJlbW92ZSB0aGVtLgoKPiBXaHkgcGF0Y2ggMDkvMTMgPyBJ J2QgZXhwZWN0IHRvIHNlZSAxMiBtb3JlIHBhdGNoZXMgaW4gdGhpcyBzZXJpZXMsCgpIdXBzLCBz b3JyeSwgbXkgbWlzdGFrZSwgdGhlcmUgaXMganVzdCB0aGlzIHBhdGNoLi4uCgo+IGJ1dCB0aGVy ZSBpcyBvbmx5IG9uZSAoZXZlbiBvbiBrZXJuZWwub3JnKS4gSWYgeW91IHNlbnQgdGhvc2UKPiBv dGhlciBwYXRjaGVzIHRvIHZhcmlvdXMgb3RoZXIgbWFpbGluZyBsaXN0cywgZXZlcnlvbmUgd2ls bCB3b25kZXIKPiB3aGVyZSB0aGUgcmVtYWluaW5nIHBhdGNoZXMgYXJlLiBJZiB0aGVyZSBpcyBq dXN0IG9uZSBwYXRjaCwKPiBpdCBpcyBqdXN0IGNvbmZ1c2luZy4KPgo+PiAtLS0KPj4gRG9jdW1l bnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMyB8IDMwICsrKwo+PiBkcml2 ZXJzL2h3bW9uL0tjb25maWcgfCAxMCArCj4+IGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgfCAxICsK Pj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDI4MSArKysrKysrKysrKysrKysrKysrKysrKysr Cj4+IDQgZmlsZXMgY2hhbmdlZCwgMzIyIGluc2VydGlvbnMoKykKPj4gY3JlYXRlIG1vZGUgMTAw NjQ0IERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9od21vbi90bXAxMDMKPj4gY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4KPj4gZGlmZiAtLWdpdCBh L0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9od21vbi90bXAxMDMgYi9Eb2N1bWVu dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4+IG5ldyBmaWxlIG1vZGUg MTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjM2ZDdiMzYKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysg Yi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4KPiBTaG91 bGQgYmUgRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMuCgpIbW0uLiBJIGRpZCB0aGlzIGZpcnN0 IHRoZXJlLCBidXQgInNjcmlwdHMvY2hlY2twYXRjaC5wbCIKd2FybnMgKGlmIHVzaW5nIGEgRFQg YmFzZWQgYm9hcmQgd2l0aCBjb21wYXRpYmxlID0gInRpLHRtcDEwMyIpOgoKV0FSTklORzogRFQg Y29tcGF0aWJsZSBzdHJpbmcgInRpLHRtcDEwMyIgYXBwZWFycyB1bi1kb2N1bWVudGVkIC0tIGNo ZWNrIC4vRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzLwojMzI0OiBGSUxFOiBhcmNo L2FybS9ib290L2R0cy9pbXg2cWRsLWFyaXN0YWluZXRvcy5kdHNpOjEwNzoKKyAgICAgICAgICAg ICAgIGNvbXBhdGlibGUgPSAidGksdG1wMTAzIjsKCj4+IEBAIC0wLDAgKzEsMzAgQEAKPj4gK0tl cm5lbCBkcml2ZXIgdG1wMTAzCj4+ICs9PT09PT09PT09PT09PT09PT09PQo+PiArCj4+ICtTdXBw b3J0ZWQgY2hpcHM6Cj4+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKPj4gKyBQcmVmaXg6 ICd0bXAxMDMnCj4+ICsgQWRkcmVzc2VzIHNjYW5uZWQ6IG5vbmUKPj4gKyBQcm9kdWN0IGluZm8g YW5kIGRhdGFzaGVldDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPj4gKwo+PiAr QXV0aG9yOgo+PiArIEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+PiArCj4+ICtEZXNjcmlw dGlvbgo+PiArLS0tLS0tLS0tLS0KPj4gKwo+PiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0 cHV0IHRlbXBlcmF0dXJlIHNlbnNvciBpbiBhIGZvdXItYmFsbAo+PiArd2FmZXIgY2hpcC1zY2Fs ZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRNUDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPj4gK3Rl bXBlcmF0dXJlcyB0byBhIHJlc29sdXRpb24gb2YgMcKwQy4gVGhlIFRNUDEwMyBpcyBzcGVjaWZp ZWQgZm9yCj4+ICtvcGVyYXRpb24gb3ZlciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBD IHRvICsxMjXCsEMuCj4+ICsKPj4gK1Jlc29sdXRpb246IDggQml0cwo+PiArQWNjdXJhY3k6IMKx McKwQyBUeXAgKOKAkzEwwrBDIHRvICsxMDDCsEMpCj4+ICsKPj4gK1RoZSBkcml2ZXIgcHJvdmlk ZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRlcmZhY2UgZm9yIHRlbXBlcmF0dXJlcyAoc2VlCj4+ICtE b2N1bWVudGF0aW9uL2h3bW9uL3N5c2ZzLWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+ PiArCj4+ICtSZXF1aXJlZCBub2RlIHByb3BlcnRpZXM6Cj4+ICstIGNvbXBhdGlibGU6IG1hbnVm YWN0dXJlciBhbmQgY2hpcCBuYW1lCj4+ICsgInRpLHRtcDEwMyIKPj4gKy0gcmVnOiBJMkMgYnVz IGFkZHJlc3Mgb2YgdGhlIGRldmljZQo+Cj4gWW91IGRvbid0IG5lZWQgdGhpcyBwYXJ0LCBhbmQg aXQgaXMgbm90IHJlYWxseSBjb3JyZWN0ICh0aGVyZSBhcmUKPiBvdGhlciB3YXlzIHRvIGluc3Rh bnRpYXRlIHRoZSBkZXZpY2UsIGRldmljZXRyZWUgaXMganVzdCBvbmUgb2YgdGhlbSkuCgpPay4K Cj4gSSB3b3VsZCBzdWdnZXN0IHRvIHJlZmVyIHRvIERvY3VtZW50YXRpb24vaTJjL2luc3RhbnRp YXRpbmctZGV2aWNlcwo+IGluc3RlYWQuIEl0IG1pZ2h0IGFsc28gbWFrZSBzZW5zZSB0byB1cGRh dGUKPiBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNl cy50eHQuCgpBaCwgb2ssIGdvb2QgaWRlYSwgdGhpcyByZW1vdmVzIGFsc28gdGhlIGNoZWNrcGF0 Y2ggd2FybmluZywgdGhhbmtzIQpDaGFuZ2VkLgoKPiBBbHNvLCB3aGVuZXZlciB5b3UgdG91Y2gg YW55IG9mIHRoZSB0aGUgZHQgZmlsZXMsIHlvdSBuZWVkIHRvIGNvcHkKPiB0aGUgRFQgbWFpbnRh aW5lcnMuIHNjcmlwdHMvZ2V0X21haW50YWluZXIucGwgd2lsbCB0ZWxsIHlvdSB3aG8gbmVlZHMK PiB0byBiZSBjb3BpZWQuCgpPay4KClsuLi5dCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9u L01ha2VmaWxlIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+PiBpbmRleCAxMTc5OGFkLi44ZTJm NmEyIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+ICsrKyBiL2RyaXZl cnMvaHdtb24vTWFrZWZpbGUKPj4gQEAgLTEzNCw2ICsxMzQsNyBAQCBvYmotJChDT05GSUdfU0VO U09SU19TTVNDNDdNMTkyKSs9IHNtc2M0N20xOTIubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19B TUM2ODIxKSArPSBhbWM2ODIxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVEhNQzUwKSArPSB0 aG1jNTAubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpICs9IHRtcDEwMi5vCj4+ICtv YmotJChDT05GSUdfU0VOU09SU19UTVAxMDMpICs9IHRtcDEwMy5vCj4+IG9iai0kKENPTkZJR19T RU5TT1JTX1RNUDQwMSkgKz0gdG1wNDAxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIx KSArPSB0bXA0MjEubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UV0w0MDMwX01BREMpKz0gdHds NDAzMC1tYWRjLWh3bW9uLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMg Yi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4 IDAwMDAwMDAuLjBiZDMzZDYKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2h3bW9u L3RtcDEwMy5jCj4+IEBAIC0wLDAgKzEsMjgxIEBACj4+ICsvKgo+PiArICogVGV4YXMgSW5zdHJ1 bWVudHMgVE1QMTAzIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPj4gKyAqIENvcHly aWdodCAoQykgMjAxNCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPj4gKyAqCj4+ICsgKiBC YXNlZCBvbjoKPj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0ZW1wZXJhdHVy ZSBzZW5zb3IgZHJpdmVyCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBL aW5nIDxzZmtpbmdAZmR3ZGMuY29tPgo+PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4+ICsgKiBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieQo+PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZl cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCj4+ICsgKgo+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+ICsgKiBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+PiArICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhl Cj4+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+PiAr ICoKPj4gKyAqLwo+PiArCj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsjaW5jbHVk ZSA8bGludXgvaW5pdC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRl IDxsaW51eC9pMmMuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgo+PiArI2luY2x1ZGUg PGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5j bHVkZSA8bGludXgvbXV0ZXguaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPj4gKyNp bmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+Cj4+ICsKPj4gKyNkZWZpbmUgRFJJVkVSX05BTUUgInRt cDEwMyIKPj4gKwo+PiArI2RlZmluZSBUTVAxMDNfVEVNUF9SRUcgMHgwMAo+PiArI2RlZmluZSBU TVAxMDNfQ09ORl9SRUcgMHgwMQo+PiArI2RlZmluZSBUTVAxMDNfVExPV19SRUcgMHgwMgo+PiAr I2RlZmluZSBUTVAxMDNfVEhJR0hfUkVHIDB4MDMKPj4gKwo+PiArI2RlZmluZSBUTVAxMDNfQ09O Rl9NMCAweDAxCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX00xIDB4MDIKPj4gKyNkZWZpbmUgVE1Q MTAzX0NPTkZfTEMgMHgwNAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GTCAweDA4Cj4+ICsjZGVm aW5lIFRNUDEwM19DT05GX0ZIIDB4MTAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwIDB4MjAK Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IxIDB4NDAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZf SUQgMHg4MAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRCAoVE1QMTAzX0NPTkZfTTAgfCBUTVAx MDNfQ09ORl9NMSkKPj4gKwo+PiArc3RydWN0IHRtcDEwMyB7Cj4+ICsgc3RydWN0IGRldmljZSAq aHdtb25fZGV2Owo+PiArIHN0cnVjdCBtdXRleCBsb2NrOwo+PiArIHUxNiBjb25maWdfb3JpZzsK Pj4gKyB1bnNpZ25lZCBsb25nIGxhc3RfdXBkYXRlOwo+PiArIGludCB0ZW1wWzNdOwo+PiArfTsK Pj4gKwo+PiArc3RhdGljIGlubGluZSBpbnQgdG1wMTAzX3JlZ190b19tQyhzOCB2YWwpCj4+ICt7 Cj4+ICsgcmV0dXJuIHZhbCAqIDEwMDA7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpbmxpbmUgdTgg dG1wMTAzX21DX3RvX3JlZyhpbnQgdmFsKQo+PiArewo+PiArIHJldHVybiB2YWwgLyAxMDAwOwo+ Cj4gRElWX1JPVU5EX0NMT1NFU1QoKSA/Cj4KPiBObyBjYW1lbENhc2UsIHBsZWFzZS4KCk9rIC4u LiBobW0sIHdvbmRlcmluZyB0aGF0IGNoZWNrcGF0Y2gucGwgbm90IGNsYWltZWQgdGhpcy4KcmVt b3ZlZC4KCj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBjb25zdCB1OCB0bXAxMDNfcmVnW10gPSB7Cj4+ ICsgVE1QMTAzX1RFTVBfUkVHLAo+PiArIFRNUDEwM19UTE9XX1JFRywKPj4gKyBUTVAxMDNfVEhJ R0hfUkVHLAo+PiArfTsKPj4gKwo+PiArc3RhdGljIHN0cnVjdCB0bXAxMDMgKnRtcDEwM191cGRh dGVfZGV2aWNlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4+ICt7Cj4+ICsgc3RydWN0IHRt cDEwMyAqdG1wMTAzID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Cj4+ICsKPj4gKyBtdXRl eF9sb2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIGlmICh0aW1lX2FmdGVyKGppZmZpZXMsIHRtcDEw My0+bGFzdF91cGRhdGUgKyBIWiAvIDMpKSB7Cj4+ICsgaW50IGk7Cj4+ICsKPj4gKyBmb3IgKGkg PSAwOyBpIDwgQVJSQVlfU0laRSh0bXAxMDMtPnRlbXApOyArK2kpIHsKPj4gKyBpbnQgc3RhdHVz ID0gaTJjX3NtYnVzX3JlYWRfYnl0ZV9kYXRhKGNsaWVudCwKPj4gKyB0bXAxMDNfcmVnW2ldKTsK Pj4gKyBpZiAoc3RhdHVzID4gLTEpCj4+ICsgdG1wMTAzLT50ZW1wW2ldID0gdG1wMTAzX3JlZ190 b19tQyhzdGF0dXMpOwo+Cj4gSSB1bmRlcnN0YW5kIHRoaXMgaXMgZnJvbSB0aGUgdG1wMTAyIGRy aXZlciwgYnV0IGl0IGlzIGtpbmQgb2YgdW51c3VhbAo+IGJlY2F1c2UgaXQgZG9lcyBub3QgcmVw b3J0IHRoZSBlcnJvciBiYWNrIHRvIHRoZSB1c2VyLiBQbGVhc2UgY29uc2lkZXIKPiBkb2luZyB0 aGF0LCBpZSByZXR1cm4gUFRSX0VSUihzdGF0dXMpIG9uIGVycm9yIGFuZCBjaGVjay9yZXR1cm4g dGhlIGVycm9yCj4gZnJvbSB0aGUgY2FsbGluZyBmdW5jdGlvbnMuIElycmVsZXZhbnQgaWYgeW91 IHVzZSByZWdtYXAgKHNlZSBiZWxvdykuCgp5b3UgbWVhbiBFUlJfUFRSKCkgPwpPaywgYWRkIHRo aXMuCgo+PiArIH0KPj4gKyB0bXAxMDMtPmxhc3RfdXBkYXRlID0gamlmZmllczsKPj4gKyB9Cj4+ ICsgbXV0ZXhfdW5sb2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIHJldHVybiB0bXAxMDM7Cj4+ICt9 Cj4KPiBPdmVyYWxsIHlvdSBtaWdodCBjb25zaWRlciBkcm9wcGluZyB0aGUgdXBkYXRlIGZ1bmN0 aW9uIGFuZCB1c2luZyByZWdtYXAgaW5zdGVhZC4KPiBJdCB3b3VsZCBiZSBhbiBleGNlbGxlbnQg Zml0IGZvciB0aGlzIGRyaXZlcjsgd2hpbGUgaXQgZG9lc24ndCBkbyB0aW1lZCBjYWNoaW5nCj4g aXQgc3VwcG9ydHMgcGVyLXJlZ2lzdGVyIGNhY2hpbmcgd2hpY2ggaXMgdWx0aW1hdGVseSBtb3Jl IHVzZWZ1bCBhbnl3YXkuCj4gU29tZSBvZiB0aGUgZHJpdmVycyBpbiB0aGUgaHdtb24gZGlyZWN0 b3J5IHVzZSBpdCwgc28geW91IGNvdWxkIHVzZSB0aGF0Cj4gYXMgZXhhbXBsZS4gTm90IG1hbmRh dG9yeSwgdGhvdWdoOyBqdXN0IGEgc3VnZ2VzdGlvbi4KCkNvdWxkIHlvdSBnaXZlIG1lIGFuIGV4 YW1wbGU/Cgo+PiArCj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2hvd190ZW1wKHN0cnVjdCBk ZXZpY2UgKmRldiwKPj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPj4gKyBjaGFy ICpidWYpCj4+ICt7Cj4+ICsgc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0 b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4+ICsgc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gdG1w MTAzX3VwZGF0ZV9kZXZpY2UodG9faTJjX2NsaWVudChkZXYpKTsKPj4gKwo+PiArIHJldHVybiBz cHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDMtPnRlbXBbc2RhLT5pbmRleF0pOwo+PiArfQo+PiAr Cj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAo+ PiArIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+PiArIGNvbnN0IGNoYXIgKmJ1Ziwg c2l6ZV90IGNvdW50KQo+PiArewo+PiArIHN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAq c2RhID0gdG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpOwo+PiArIHN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7Cj4+ICsgc3RydWN0IHRtcDEwMyAqdG1wMTAzID0g aTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Cj4+ICsgbG9uZyB2YWw7Cj4+ICsgaW50IHN0YXR1 czsKPj4gKwo+PiArIGlmIChrc3RydG9sKGJ1ZiwgMTAsICZ2YWwpIDwgMCkKPj4gKyByZXR1cm4g LUVJTlZBTDsKPj4gKyB2YWwgPSBjbGFtcF92YWwodmFsLCAtNTUwMDAsIDEyODAwMCk7Cj4KPiBN YXggc2hvdWxkIGJlIDEyNzAwMC4KCk9rLCBjaGFuZ2UgdGhpcy4KCj4+ICsKPj4gKyBtdXRleF9s b2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIHRtcDEwMy0+dGVtcFtzZGEtPmluZGV4XSA9IHZhbDsK Pgo+IFlvdSBjYW4gbm90IGRvIHRoYXQgc2luY2UgaXQgaXMgdGhlIG5vbi1yb3VuZGVkIHZhbHVl LiBZb3UgaGF2ZSB0byBjb252ZXJ0IHRvCj4gdGhlIHJlZ2lzdGVyIHZhbHVlLCB0aGVuIGNvbnZl cnQgYmFjayB0byB0aGUgZGlzcGxheSB2YWx1ZS4KPgo+IElmIHlvdSB1c2UgcmVnbWFwLCB0aGUg cHJvYmxlbSBnb2VzIGF3YXksIHNpbmNlIHlvdSB3b3VsZCBub3QgY2FjaGUgY29udmVydGVkCj4g ZGF0YSBidXQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5jdGlvbi4gQWx0ZXJuYXRpdmVseSwgeW91 IGNvdWxkIHN0b3JlIHJlZ2lzdGVyCj4gdmFsdWVzIGFuZCBjb252ZXJ0IGluIHRoZSBzaG93IGZ1 bmN0aW9uLgoKSSB0YWtlIGEgbG9vayBhdCB0aGlzLgoKPj4gKyBzdGF0dXMgPSBpMmNfc21idXNf d3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgdG1wMTAzX3JlZ1tzZGEtPmluZGV4XSwKPj4gKyB0bXAx MDNfbUNfdG9fcmVnKHZhbCkpOwo+Cj4gUGxlYXNlIG1ha2Ugc3VyZSB0aGF0IGNvbnRpbnVhdGlv biBsaW5lcyBtYXRjaCB0aGUgJygnIGluIHRoZSBsaW5lIGFib3ZlLgo+IEFsaWdubWVudHMgYXJl IGluY29uc2lzdGVudCwgb3RoZXJ3aXNlIEkgd291bGQgbm90IG1lbnRpb24gaXQuCj4gY2hlY2tw YXRjaCAtLXN0cmljdCB0ZWxscyB5b3Ugd2hpY2ggb25lcyBhcmUgbWlzYWxpZ25lZC4KCkFoLCBk aWQgYSBjaGVja3BhdGNoIGJ1dCB3aXRob3V0IHRoZSAiLS1zdHJpY3QiIG9wdGlvbiAhCgpJIGZp eCB0aGlzIGdsb2JhbGx5LgoKPj4gKyBtdXRleF91bmxvY2soJnRtcDEwMy0+bG9jayk7Cj4+ICsg cmV0dXJuIHN0YXR1cyA/IDogY291bnQ7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBTRU5TT1JfREVW SUNFX0FUVFIodGVtcDFfaW5wdXQsIFNfSVJVR08sIHRtcDEwM19zaG93X3RlbXAsIE5VTEwgLCAw KTsKPj4gKwo+IElmIHlvdSB1c2UgcmVnbWFwIHlvdSBjYW4gc3RvcmUgdGhlIHJlZ2lzdGVyIGRp cmVjdGx5IGhlcmUgYW5kIHlvdSB3b3VsZCBub3QKPiBuZWVkIHRtcDEwM19yZWdbXS4KCk9rLgoK Pj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4X2h5c3QsIFNfSVdVU1IgfCBT X0lSVUdPLCB0bXAxMDNfc2hvd190ZW1wLAo+PiArIHRtcDEwM19zZXRfdGVtcCwgMSk7Cj4+ICsK PiBQZXIgdGhlIGRhdGFzaGVldCB0aGlzIHNob3VsZCBiZSB0ZW1wMV9taW4uIFRoZSByZWdpc3Rl ciBkZWZpbml0aW9uIGlzIGRpZmZlcmVudCB0byBUTVAxMDIuCgpjaGFuZ2VkLgoKPj4gK3N0YXRp YyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAz X3Nob3dfdGVtcCwKPj4gKyB0bXAxMDNfc2V0X3RlbXAsIDIpOwo+PiArCj4+ICtzdGF0aWMgc3Ry dWN0IGF0dHJpYnV0ZSAqdG1wMTAzX2F0dHJpYnV0ZXNbXSA9IHsKPj4gKyAmc2Vuc29yX2Rldl9h dHRyX3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIsCj4+ICsgJnNlbnNvcl9kZXZfYXR0cl90ZW1w MV9tYXhfaHlzdC5kZXZfYXR0ci5hdHRyLAo+PiArICZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfbWF4 LmRldl9hdHRyLmF0dHIsCj4KPiBZb3UgbWlnaHQgYWxzbyBjb25zaWRlciBhZGRpbmcgdGVtcDFf bWluX2FsYXJtIGFuZCB0ZW1wMV9tYXhfYWxhcm0gdG8gaW5mb3JtCj4gdXNlciBzcGFjZSBpZiBs aW1pdHMgYXJlIGV4Y2VlZGVkLiBUaGUgc3RhdHVzIGlzIHJlcG9ydGVkIHdpdGggdGhlIEZMIGFu ZCBGSAo+IGJpdHMgaW4gdGhlIGNvbmZpZ3VyYXRpb24gcmVnaXN0ZXIuCgpBZGQgdGhpcyBpZiBJ IGZpbmQgdGltZSwgb3IgaW4gYW4gYW5vdGhlciBwYXRjaC4uLgoKPj4gKyBOVUxMCj4+ICt9Owo+ PiArCj4+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCB0bXAxMDNfYXR0cl9n cm91cCA9IHsKPj4gKyAuYXR0cnMgPSB0bXAxMDNfYXR0cmlidXRlcywKPj4gK307Cj4+ICsKPiBQ bGVhc2UgdXNlIHRoZSBBVFRSSUJVVEVfR1JPVVBTKCkgbWFjcm8uCgpPay4KCj4+ICsjZGVmaW5l IFRNUDEwM19DT05GSUcgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQo+PiArI2Rl ZmluZSBUTVAxMDNfQ09ORklHX1JEX09OTFkgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05G X00xKQo+Cj4gTGF0dGVyIGRlZmluZSBpcyBub3QgdXNlZCBhcyBmYXIgYXMgSSBjYW4gc2VlLiBT aW5jZSBpdCBpcyB0aGUgc2FtZQo+IGl0IGlzIHVubmVjZXNzYXJ5IGFueXdheS4KCnJlbW92ZWQu Cgo+PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xp ZW50LAo+PiArIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPj4gK3sKPj4gKyBzdHJ1 Y3QgdG1wMTAzICp0bXAxMDM7Cj4+ICsgaW50IHN0YXR1czsKPj4gKwo+PiArIGlmICghaTJjX2No ZWNrX2Z1bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+PiArIEkyQ19GVU5DX1NNQlVTX1dP UkRfREFUQSkpIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwKPj4gKyAiYWRhcHRlciBkb2Vz bid0IHN1cHBvcnQgU01CdXMgd29yZCB0cmFuc2FjdGlvbnNcbiIpOwo+Cj4gR29vZCB0aGF0IHRo ZSBjaGlwIGRvZXNuJ3Qgc3VwcG9ydCBhbnkgOy0pLiBDaGVjayBmb3IgYnl0ZSB0cmFuc2FjdGlv bnMgaW5zdGVhZC4KCkhlaC4uLiBjaGFuZ2VkLgoKPj4gKyByZXR1cm4gLUVOT0RFVjsKPj4gKyB9 Cj4+ICsKPj4gKyB0bXAxMDMgPSBkZXZtX2t6YWxsb2MoJmNsaWVudC0+ZGV2LCBzaXplb2YoKnRt cDEwMyksIEdGUF9LRVJORUwpOwo+PiArIGlmICghdG1wMTAzKQo+PiArIHJldHVybiAtRU5PTUVN Owo+PiArCj4+ICsgaTJjX3NldF9jbGllbnRkYXRhKGNsaWVudCwgdG1wMTAzKTsKPj4gKwo+PiAr IHN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRNUDEwM19DT05GX1JF Ryk7Cj4+ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwgImVy cm9yIHJlYWRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyByZXR1cm4gc3RhdHVzOwo+PiAr IH0KPj4gKyB0bXAxMDMtPmNvbmZpZ19vcmlnID0gc3RhdHVzOwo+Cj4gWW91IGRvbid0IHVzZSBj b25maWdfb3JpZyBvdXRzaWRlIHRoZSBwcm9iZSBmdW5jdGlvbiwKPiBzbyBzdG9yaW5nIGl0IGlu IHByaXZhdGUgZGF0YSBkb2Vzbid0IGFkZCBhbnkgdmFsdWUuCj4gQWx0ZXJuYXRpdmVseSwgeW91 IGNvdWxkIHJlc3RvcmUgdGhlIG9yaWdpbmFsIGNvbmZpZ3VyYXRpb24gb24gZXhpdC4KCkkgYWRk ICJyZXN0b3JpbmcgaXQgb24gZXhpdC4iCgo+PiArIHN0YXR1cyA9IGkyY19zbWJ1c193cml0ZV9i eXRlX2RhdGEoY2xpZW50LCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgVE1QMTAzX0NPTkZJRyk7Cj4+ ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwgImVycm9yIHdy aXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyBnb3RvIGZhaWxfcmVzdG9yZV9jb25maWc7 Cj4+ICsgfQo+PiArIHN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRN UDEwM19DT05GX1JFRyk7Cj4+ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGll bnQtPmRldiwgImVycm9yIHJlYWRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyBnb3RvIGZh aWxfcmVzdG9yZV9jb25maWc7Cj4+ICsgfQo+PiArIGlmIChzdGF0dXMgIT0gVE1QMTAzX0NPTkZJ Rykgewo+PiArIGRldl9lcnIoJmNsaWVudC0+ZGV2LCAiY29uZmlnIHNldHRpbmdzIGRpZCBub3Qg c3RpY2tcbiIpOwo+PiArIHN0YXR1cyA9IC1FTk9ERVY7Cj4+ICsgZ290byBmYWlsX3Jlc3RvcmVf Y29uZmlnOwo+PiArIH0KPj4gKyB0bXAxMDMtPmxhc3RfdXBkYXRlID0gamlmZmllcyAtIEhaOwo+ PiArIG11dGV4X2luaXQoJnRtcDEwMy0+bG9jayk7Cj4+ICsKPj4gKyBzdGF0dXMgPSBzeXNmc19j cmVhdGVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICsg aWYgKHN0YXR1cykgewo+PiArIGRldl9kYmcoJmNsaWVudC0+ZGV2LCAiY291bGQgbm90IGNyZWF0 ZSBzeXNmcyBmaWxlc1xuIik7Cj4+ICsgZ290byBmYWlsX3Jlc3RvcmVfY29uZmlnOwo+PiArIH0K Pj4gKyB0bXAxMDMtPmh3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3RlcigmY2xpZW50LT5k ZXYpOwo+PiArIGlmIChJU19FUlIodG1wMTAzLT5od21vbl9kZXYpKSB7Cj4+ICsgZGV2X2RiZygm Y2xpZW50LT5kZXYsICJ1bmFibGUgdG8gcmVnaXN0ZXIgaHdtb24gZGV2aWNlXG4iKTsKPj4gKyBz dGF0dXMgPSBQVFJfRVJSKHRtcDEwMy0+aHdtb25fZGV2KTsKPj4gKyBnb3RvIGZhaWxfcmVtb3Zl X3N5c2ZzOwo+PiArIH0KPgo+IFBsZWFzZSB1c2UgZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJf d2l0aF9ncm91cHMoKS4KCk9rLgoKPj4gKwo+PiArIGRldl9pbmZvKCZjbGllbnQtPmRldiwgImlu aXRpYWxpemVkXG4iKTsKPgo+IFBsZWFzZSBkcm9wIHRoaXMgbWVzc2FnZS4KCk9rLgoKPj4gKwo+ PiArIHJldHVybiAwOwo+PiArCj4+ICtmYWlsX3JlbW92ZV9zeXNmczoKPj4gKyBzeXNmc19yZW1v dmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICtmYWls X3Jlc3RvcmVfY29uZmlnOgo+PiArIGkyY19zbWJ1c193cml0ZV93b3JkX3N3YXBwZWQoY2xpZW50 LCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgdG1wMTAzLT5jb25maWdfb3JpZyk7Cj4KPiBpMmNfc21i dXNfd3JpdGVfYnl0ZV9kYXRhKCkgPwoKWWVzLCBjaGFuZ2VkIQoKPj4gKyByZXR1cm4gc3RhdHVz Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19yZW1vdmUoc3RydWN0IGkyY19jbGll bnQgKmNsaWVudCkKPj4gK3sKPj4gKyBzdHJ1Y3QgdG1wMTAzICp0bXAxMDMgPSBpMmNfZ2V0X2Ns aWVudGRhdGEoY2xpZW50KTsKPj4gKwo+PiArIGh3bW9uX2RldmljZV91bnJlZ2lzdGVyKHRtcDEw My0+aHdtb25fZGV2KTsKPj4gKyBzeXNmc19yZW1vdmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmos ICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICsKPj4gKyByZXR1cm4gMDsKPj4gK30KPj4gKwo+PiAr I2lmZGVmIENPTkZJR19QTQo+PiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2 aWNlICpkZXYpCj4+ICt7Cj4+ICsgc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19j bGllbnQoZGV2KTsKPj4gKyBpbnQgY29uZmlnOwo+PiArCj4+ICsgY29uZmlnID0gaTJjX3NtYnVz X3JlYWRfd29yZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKPgo+IGJ5dGUKPgo+ PiArIGlmIChjb25maWcgPCAwKQo+PiArIHJldHVybiBjb25maWc7Cj4+ICsKPj4gKyBjb25maWcg Jj0gflRNUDEwM19DT05GX1NEOwo+PiArIHJldHVybiBpMmNfc21idXNfd3JpdGVfd29yZF9zd2Fw cGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLCBjb25maWcpOwo+Cj4gYnl0ZQo+Cj4+ICt9Cj4+ ICsKPj4gK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICt7 Cj4+ICsgc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19jbGllbnQoZGV2KTsKPj4g KyBpbnQgY29uZmlnOwo+PiArCj4+ICsgY29uZmlnID0gaTJjX3NtYnVzX3JlYWRfd29yZF9zd2Fw cGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKPgo+IGJ5dGUKPgo+PiArIGlmIChjb25maWcg PCAwKQo+PiArIHJldHVybiBjb25maWc7Cj4+ICsKPj4gKyBjb25maWcgfD0gVE1QMTAzX0NPTkZf U0Q7Cj4+ICsgcmV0dXJuIGkyY19zbWJ1c193cml0ZV93b3JkX3N3YXBwZWQoY2xpZW50LCBUTVAx MDNfQ09ORl9SRUcsIGNvbmZpZyk7Cj4KPiBieXRlCgpjaGFuZ2VkLgoKPj4gK30KPj4gKwo+PiAr c3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+PiAr IC5zdXNwZW5kID0gdG1wMTAzX3N1c3BlbmQsCj4+ICsgLnJlc3VtZSA9IHRtcDEwM19yZXN1bWUs Cj4+ICt9Owo+PiArCj4+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9w bV9vcHMpCj4+ICsjZWxzZQo+PiArI2RlZmluZSBUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4+ICsj ZW5kaWYgLyogQ09ORklHX1BNICovCj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2Rl dmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKPj4gKyB7IERSSVZFUl9OQU1FLCAwIH0sCj4+ICsgeyB9 Cj4+ICt9Owo+PiArTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4+ICsKPj4g K3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciB0bXAxMDNfZHJpdmVyID0gewo+PiArIC5kcml2ZXIu bmFtZSA9IERSSVZFUl9OQU1FLAo+PiArIC5kcml2ZXIucG0gPSBUTVAxMDNfREVWX1BNX09QUywK Pgo+IC5kcml2ZXIgPSB7Cj4gLm5hbWUgPSBEUklWRVJfTkFNRSwKPiAucG0gPSBUTVAxMDNfREVW X1BNX09QUywKPiB9LAo+Cj4gd291bGQgYmUgYSBiaXQgbmljZXIuIEkgd29uJ3QgbWFuZGF0ZSBp dCwgdGhvdWdoLgoKY2hhbmdlZC4KCj4+ICsgLnByb2JlID0gdG1wMTAzX3Byb2JlLAo+PiArIC5y ZW1vdmUgPSB0bXAxMDNfcmVtb3ZlLAo+PiArIC5pZF90YWJsZSA9IHRtcDEwM19pZCwKPj4gK307 Cj4+ICsKPj4gK21vZHVsZV9pMmNfZHJpdmVyKHRtcDEwM19kcml2ZXIpOwo+PiArCj4+ICtNT0RV TEVfQVVUSE9SKCJIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4iKTsKPj4gK01PRFVMRV9ERVND UklQVElPTigiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2 ZXIiKTsKPj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKClRoYW5rcyBmb3IgdGhpcyBncmVhdCBy ZXZpZXchCgpieWUsCkhlaWtvCi0tIApERU5YIFNvZnR3YXJlIEVuZ2luZWVyaW5nIEdtYkgsICAg ICBNRDogV29sZmdhbmcgRGVuayAmIERldGxldiBadW5kZWwKSFJCIDE2NTIzNSBNdW5pY2gsIE9m ZmljZTogS2lyY2hlbnN0ci41LCBELTgyMTk0IEdyb2ViZW56ZWxsLCBHZXJtYW55CgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxp bmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3Jz Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933039AbaFLJtg (ORCPT ); Thu, 12 Jun 2014 05:49:36 -0400 Received: from submit1.sa.ew.hu ([212.108.200.71]:40365 "EHLO submit1.sa.ew.hu" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932784AbaFLJte (ORCPT ); Thu, 12 Jun 2014 05:49:34 -0400 X-Greylist: delayed 609 seconds by postgrey-1.27 at vger.kernel.org; Thu, 12 Jun 2014 05:49:33 EDT Message-ID: <53997544.5090106@denx.de> Date: Thu, 12 Jun 2014 11:39:16 +0200 From: Heiko Schocher Reply-To: hs@denx.de Organization: DENX Software Engineering User-Agent: Mozilla/5.0 (X11; Linux i686; rv:12.0) Gecko/20120421 Thunderbird/12.0 MIME-Version: 1.0 To: Guenter Roeck CC: lm-sensors@lm-sensors.org, Jean Delvare , linux-kernel@vger.kernel.org Subject: Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor References: <1402468095-14678-1-git-send-email-hs@denx.de> <53988DC1.7000203@roeck-us.net> In-Reply-To: <53988DC1.7000203@roeck-us.net> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-PMX-Spam: Gauge=XXIIIIIIII, Probability=28%, Report=' SXL_IP_DYNAMIC 3, MULTIPLE_RCPTS 0.1, HTML_00_01 0.05, HTML_00_10 0.05, BODY_SIZE_10000_PLUS 0, RDNS_GENERIC_POOLED 0, RDNS_SUSP 0, RDNS_SUSP_GENERIC 0, __ANY_URI 0, __BOUNCE_CHALLENGE_SUBJ 0, __BOUNCE_NDR_SUBJ_EXEMPT 0, __CP_URI_IN_BODY 0, __CT 0, __CTE 0, __CT_TEXT_PLAIN 0, __FORWARDED_MSG 0, __FW_1LN_BOT_MSGID 0, __HAS_FROM 0, __HAS_MSGID 0, __HAS_REPLYTO 0, __HIGHBITS 0, __IN_REP_TO 0, __MIME_TEXT_ONLY 0, __MIME_VERSION 0, __MOZILLA_MSGID 0, __MOZILLA_USER_AGENT 0, __MULTIPLE_RCPTS_CC_X2 0, __REPLYTO_SAMEAS_FROM_ACC 0, __REPLYTO_SAMEAS_FROM_ADDY 0, __REPLYTO_SAMEAS_FROM_DOMAIN 0, __SANE_MSGID 0, __SUBJ_ALPHA_END 0, __SUBJ_ALPHA_NEGATE 0, __TO_MALFORMED_2 0, __URI_NS , __USER_AGENT 0' Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hello Guenter, Am 11.06.2014 19:11, schrieb Guenter Roeck: > On 06/10/2014 11:28 PM, Heiko Schocher wrote: >> Driver for the TI TMP103. >> >> The TI TMP103 is similar to the TMP102. It differs from the TMP102 >> by having only 8 bit registers. >> >> Signed-off-by: Heiko Schocher >> Cc: Jean Delvare >> Cc: Guenter Roeck >> Cc: linux-kernel@vger.kernel.org > > Hi Heiko, > > You don't need those Cc: in the header. Ok, I remove them. > Why patch 09/13 ? I'd expect to see 12 more patches in this series, Hups, sorry, my mistake, there is just this patch... > but there is only one (even on kernel.org). If you sent those > other patches to various other mailing lists, everyone will wonder > where the remaining patches are. If there is just one patch, > it is just confusing. > >> --- >> Documentation/devicetree/bindings/hwmon/tmp103 | 30 +++ >> drivers/hwmon/Kconfig | 10 + >> drivers/hwmon/Makefile | 1 + >> drivers/hwmon/tmp103.c | 281 +++++++++++++++++++++++++ >> 4 files changed, 322 insertions(+) >> create mode 100644 Documentation/devicetree/bindings/hwmon/tmp103 >> create mode 100644 drivers/hwmon/tmp103.c >> >> diff --git a/Documentation/devicetree/bindings/hwmon/tmp103 b/Documentation/devicetree/bindings/hwmon/tmp103 >> new file mode 100644 >> index 0000000..36d7b36 >> --- /dev/null >> +++ b/Documentation/devicetree/bindings/hwmon/tmp103 > > Should be Documentation/hwmon/tmp103. Hmm.. I did this first there, but "scripts/checkpatch.pl" warns (if using a DT based board with compatible = "ti,tmp103"): WARNING: DT compatible string "ti,tmp103" appears un-documented -- check ./Documentation/devicetree/bindings/ #324: FILE: arch/arm/boot/dts/imx6qdl-aristainetos.dtsi:107: + compatible = "ti,tmp103"; >> @@ -0,0 +1,30 @@ >> +Kernel driver tmp103 >> +==================== >> + >> +Supported chips: >> + * Texas Instruments TMP103 >> + Prefix: 'tmp103' >> + Addresses scanned: none >> + Product info and datasheet: http://www.ti.com/product/tmp103 >> + >> +Author: >> + Heiko Schocher >> + >> +Description >> +----------- >> + >> +The TMP103 is a digital output temperature sensor in a four-ball >> +wafer chip-scale package (WCSP). The TMP103 is capable of reading >> +temperatures to a resolution of 1°C. The TMP103 is specified for >> +operation over a temperature range of –40°C to +125°C. >> + >> +Resolution: 8 Bits >> +Accuracy: ±1°C Typ (–10°C to +100°C) >> + >> +The driver provides the common sysfs-interface for temperatures (see >> +Documentation/hwmon/sysfs-interface under Temperatures). >> + >> +Required node properties: >> +- compatible: manufacturer and chip name >> + "ti,tmp103" >> +- reg: I2C bus address of the device > > You don't need this part, and it is not really correct (there are > other ways to instantiate the device, devicetree is just one of them). Ok. > I would suggest to refer to Documentation/i2c/instantiating-devices > instead. It might also make sense to update > Documentation/devicetree/bindings/i2c/trivial-devices.txt. Ah, ok, good idea, this removes also the checkpatch warning, thanks! Changed. > Also, whenever you touch any of the the dt files, you need to copy > the DT maintainers. scripts/get_maintainer.pl will tell you who needs > to be copied. Ok. [...] >> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile >> index 11798ad..8e2f6a2 100644 >> --- a/drivers/hwmon/Makefile >> +++ b/drivers/hwmon/Makefile >> @@ -134,6 +134,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o >> obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o >> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o >> obj-$(CONFIG_SENSORS_TMP102) += tmp102.o >> +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o >> obj-$(CONFIG_SENSORS_TMP401) += tmp401.o >> obj-$(CONFIG_SENSORS_TMP421) += tmp421.o >> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o >> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c >> new file mode 100644 >> index 0000000..0bd33d6 >> --- /dev/null >> +++ b/drivers/hwmon/tmp103.c >> @@ -0,0 +1,281 @@ >> +/* >> + * Texas Instruments TMP103 SMBus temperature sensor driver >> + * Copyright (C) 2014 Heiko Schocher >> + * >> + * Based on: >> + * Texas Instruments TMP102 SMBus temperature sensor driver >> + * >> + * Copyright (C) 2010 Steven King >> + * >> + * 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. >> + * >> + * This program is distributed in the hope that it will be useful, >> + * but WITHOUT ANY WARRANTY; without even the implied warranty of >> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> + * GNU General Public License for more details. >> + * >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> + >> +#define DRIVER_NAME "tmp103" >> + >> +#define TMP103_TEMP_REG 0x00 >> +#define TMP103_CONF_REG 0x01 >> +#define TMP103_TLOW_REG 0x02 >> +#define TMP103_THIGH_REG 0x03 >> + >> +#define TMP103_CONF_M0 0x01 >> +#define TMP103_CONF_M1 0x02 >> +#define TMP103_CONF_LC 0x04 >> +#define TMP103_CONF_FL 0x08 >> +#define TMP103_CONF_FH 0x10 >> +#define TMP103_CONF_CR0 0x20 >> +#define TMP103_CONF_CR1 0x40 >> +#define TMP103_CONF_ID 0x80 >> +#define TMP103_CONF_SD (TMP103_CONF_M0 | TMP103_CONF_M1) >> + >> +struct tmp103 { >> + struct device *hwmon_dev; >> + struct mutex lock; >> + u16 config_orig; >> + unsigned long last_update; >> + int temp[3]; >> +}; >> + >> +static inline int tmp103_reg_to_mC(s8 val) >> +{ >> + return val * 1000; >> +} >> + >> +static inline u8 tmp103_mC_to_reg(int val) >> +{ >> + return val / 1000; > > DIV_ROUND_CLOSEST() ? > > No camelCase, please. Ok ... hmm, wondering that checkpatch.pl not claimed this. removed. >> +} >> + >> +static const u8 tmp103_reg[] = { >> + TMP103_TEMP_REG, >> + TMP103_TLOW_REG, >> + TMP103_THIGH_REG, >> +}; >> + >> +static struct tmp103 *tmp103_update_device(struct i2c_client *client) >> +{ >> + struct tmp103 *tmp103 = i2c_get_clientdata(client); >> + >> + mutex_lock(&tmp103->lock); >> + if (time_after(jiffies, tmp103->last_update + HZ / 3)) { >> + int i; >> + >> + for (i = 0; i < ARRAY_SIZE(tmp103->temp); ++i) { >> + int status = i2c_smbus_read_byte_data(client, >> + tmp103_reg[i]); >> + if (status > -1) >> + tmp103->temp[i] = tmp103_reg_to_mC(status); > > I understand this is from the tmp102 driver, but it is kind of unusual > because it does not report the error back to the user. Please consider > doing that, ie return PTR_ERR(status) on error and check/return the error > from the calling functions. Irrelevant if you use regmap (see below). you mean ERR_PTR() ? Ok, add this. >> + } >> + tmp103->last_update = jiffies; >> + } >> + mutex_unlock(&tmp103->lock); >> + return tmp103; >> +} > > Overall you might consider dropping the update function and using regmap instead. > It would be an excellent fit for this driver; while it doesn't do timed caching > it supports per-register caching which is ultimately more useful anyway. > Some of the drivers in the hwmon directory use it, so you could use that > as example. Not mandatory, though; just a suggestion. Could you give me an example? >> + >> +static ssize_t tmp103_show_temp(struct device *dev, >> + struct device_attribute *attr, >> + char *buf) >> +{ >> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >> + struct tmp103 *tmp103 = tmp103_update_device(to_i2c_client(dev)); >> + >> + return sprintf(buf, "%d\n", tmp103->temp[sda->index]); >> +} >> + >> +static ssize_t tmp103_set_temp(struct device *dev, >> + struct device_attribute *attr, >> + const char *buf, size_t count) >> +{ >> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >> + struct i2c_client *client = to_i2c_client(dev); >> + struct tmp103 *tmp103 = i2c_get_clientdata(client); >> + long val; >> + int status; >> + >> + if (kstrtol(buf, 10, &val) < 0) >> + return -EINVAL; >> + val = clamp_val(val, -55000, 128000); > > Max should be 127000. Ok, change this. >> + >> + mutex_lock(&tmp103->lock); >> + tmp103->temp[sda->index] = val; > > You can not do that since it is the non-rounded value. You have to convert to > the register value, then convert back to the display value. > > If you use regmap, the problem goes away, since you would not cache converted > data but convert in the show function. Alternatively, you could store register > values and convert in the show function. I take a look at this. >> + status = i2c_smbus_write_byte_data(client, tmp103_reg[sda->index], >> + tmp103_mC_to_reg(val)); > > Please make sure that continuation lines match the '(' in the line above. > Alignments are inconsistent, otherwise I would not mention it. > checkpatch --strict tells you which ones are misaligned. Ah, did a checkpatch but without the "--strict" option ! I fix this globally. >> + mutex_unlock(&tmp103->lock); >> + return status ? : count; >> +} >> + >> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , 0); >> + > If you use regmap you can store the register directly here and you would not > need tmp103_reg[]. Ok. >> +static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, 1); >> + > Per the datasheet this should be temp1_min. The register definition is different to TMP102. changed. >> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, 2); >> + >> +static struct attribute *tmp103_attributes[] = { >> + &sensor_dev_attr_temp1_input.dev_attr.attr, >> + &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, >> + &sensor_dev_attr_temp1_max.dev_attr.attr, > > You might also consider adding temp1_min_alarm and temp1_max_alarm to inform > user space if limits are exceeded. The status is reported with the FL and FH > bits in the configuration register. Add this if I find time, or in an another patch... >> + NULL >> +}; >> + >> +static const struct attribute_group tmp103_attr_group = { >> + .attrs = tmp103_attributes, >> +}; >> + > Please use the ATTRIBUTE_GROUPS() macro. Ok. >> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) >> +#define TMP103_CONFIG_RD_ONLY (TMP103_CONF_CR1 | TMP103_CONF_M1) > > Latter define is not used as far as I can see. Since it is the same > it is unnecessary anyway. removed. >> + >> +static int tmp103_probe(struct i2c_client *client, >> + const struct i2c_device_id *id) >> +{ >> + struct tmp103 *tmp103; >> + int status; >> + >> + if (!i2c_check_functionality(client->adapter, >> + I2C_FUNC_SMBUS_WORD_DATA)) { >> + dev_err(&client->dev, >> + "adapter doesn't support SMBus word transactions\n"); > > Good that the chip doesn't support any ;-). Check for byte transactions instead. Heh... changed. >> + return -ENODEV; >> + } >> + >> + tmp103 = devm_kzalloc(&client->dev, sizeof(*tmp103), GFP_KERNEL); >> + if (!tmp103) >> + return -ENOMEM; >> + >> + i2c_set_clientdata(client, tmp103); >> + >> + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); >> + if (status < 0) { >> + dev_err(&client->dev, "error reading config register\n"); >> + return status; >> + } >> + tmp103->config_orig = status; > > You don't use config_orig outside the probe function, > so storing it in private data doesn't add any value. > Alternatively, you could restore the original configuration on exit. I add "restoring it on exit." >> + status = i2c_smbus_write_byte_data(client, TMP103_CONF_REG, >> + TMP103_CONFIG); >> + if (status < 0) { >> + dev_err(&client->dev, "error writing config register\n"); >> + goto fail_restore_config; >> + } >> + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); >> + if (status < 0) { >> + dev_err(&client->dev, "error reading config register\n"); >> + goto fail_restore_config; >> + } >> + if (status != TMP103_CONFIG) { >> + dev_err(&client->dev, "config settings did not stick\n"); >> + status = -ENODEV; >> + goto fail_restore_config; >> + } >> + tmp103->last_update = jiffies - HZ; >> + mutex_init(&tmp103->lock); >> + >> + status = sysfs_create_group(&client->dev.kobj, &tmp103_attr_group); >> + if (status) { >> + dev_dbg(&client->dev, "could not create sysfs files\n"); >> + goto fail_restore_config; >> + } >> + tmp103->hwmon_dev = hwmon_device_register(&client->dev); >> + if (IS_ERR(tmp103->hwmon_dev)) { >> + dev_dbg(&client->dev, "unable to register hwmon device\n"); >> + status = PTR_ERR(tmp103->hwmon_dev); >> + goto fail_remove_sysfs; >> + } > > Please use devm_hwmon_device_register_with_groups(). Ok. >> + >> + dev_info(&client->dev, "initialized\n"); > > Please drop this message. Ok. >> + >> + return 0; >> + >> +fail_remove_sysfs: >> + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); >> +fail_restore_config: >> + i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, >> + tmp103->config_orig); > > i2c_smbus_write_byte_data() ? Yes, changed! >> + return status; >> +} >> + >> +static int tmp103_remove(struct i2c_client *client) >> +{ >> + struct tmp103 *tmp103 = i2c_get_clientdata(client); >> + >> + hwmon_device_unregister(tmp103->hwmon_dev); >> + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); >> + >> + return 0; >> +} >> + >> +#ifdef CONFIG_PM >> +static int tmp103_suspend(struct device *dev) >> +{ >> + struct i2c_client *client = to_i2c_client(dev); >> + int config; >> + >> + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); > > byte > >> + if (config < 0) >> + return config; >> + >> + config &= ~TMP103_CONF_SD; >> + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); > > byte > >> +} >> + >> +static int tmp103_resume(struct device *dev) >> +{ >> + struct i2c_client *client = to_i2c_client(dev); >> + int config; >> + >> + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); > > byte > >> + if (config < 0) >> + return config; >> + >> + config |= TMP103_CONF_SD; >> + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); > > byte changed. >> +} >> + >> +static const struct dev_pm_ops tmp103_dev_pm_ops = { >> + .suspend = tmp103_suspend, >> + .resume = tmp103_resume, >> +}; >> + >> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) >> +#else >> +#define TMP103_DEV_PM_OPS NULL >> +#endif /* CONFIG_PM */ >> + >> +static const struct i2c_device_id tmp103_id[] = { >> + { DRIVER_NAME, 0 }, >> + { } >> +}; >> +MODULE_DEVICE_TABLE(i2c, tmp103_id); >> + >> +static struct i2c_driver tmp103_driver = { >> + .driver.name = DRIVER_NAME, >> + .driver.pm = TMP103_DEV_PM_OPS, > > .driver = { > .name = DRIVER_NAME, > .pm = TMP103_DEV_PM_OPS, > }, > > would be a bit nicer. I won't mandate it, though. changed. >> + .probe = tmp103_probe, >> + .remove = tmp103_remove, >> + .id_table = tmp103_id, >> +}; >> + >> +module_i2c_driver(tmp103_driver); >> + >> +MODULE_AUTHOR("Heiko Schocher "); >> +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); >> +MODULE_LICENSE("GPL"); Thanks for this great review! bye, Heiko -- DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany