diff for duplicates of <53988DC1.7000203@roeck-us.net> diff --git a/a/1.txt b/N1/1.txt index c9522c9..c382ede 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,262 +1,489 @@ -T24gMDYvMTAvMjAxNCAxMToyOCBQTSwgSGVpa28gU2Nob2NoZXIgd3JvdGU6Cj4gRHJpdmVyIGZv -ciB0aGUgVEkgVE1QMTAzLgo+Cj4gVGhlIFRJIFRNUDEwMyBpcyBzaW1pbGFyIHRvIHRoZSBUTVAx -MDIuICBJdCBkaWZmZXJzIGZyb20gdGhlIFRNUDEwMgo+IGJ5IGhhdmluZyBvbmx5IDggYml0IHJl -Z2lzdGVycy4KPgo+IFNpZ25lZC1vZmYtYnk6IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ -IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4KPiBDYzogR3VlbnRlciBSb2Vj -ayA8bGludXhAcm9lY2stdXMubmV0Pgo+IENjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3Jn -CgpIaSBIZWlrbywKCllvdSBkb24ndCBuZWVkIHRob3NlIENjOiBpbiB0aGUgaGVhZGVyLgoKV2h5 -IHBhdGNoIDA5LzEzID8gSSdkIGV4cGVjdCB0byBzZWUgMTIgbW9yZSBwYXRjaGVzIGluIHRoaXMg -c2VyaWVzLApidXQgdGhlcmUgaXMgb25seSBvbmUgKGV2ZW4gb24ga2VybmVsLm9yZykuIElmIHlv -dSBzZW50IHRob3NlCm90aGVyIHBhdGNoZXMgdG8gdmFyaW91cyBvdGhlciBtYWlsaW5nIGxpc3Rz -LCBldmVyeW9uZSB3aWxsIHdvbmRlcgp3aGVyZSB0aGUgcmVtYWluaW5nIHBhdGNoZXMgYXJlLiBJ -ZiB0aGVyZSBpcyBqdXN0IG9uZSBwYXRjaCwKaXQgaXMganVzdCBjb25mdXNpbmcuCgo+IC0tLQo+ -ICAgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMyB8ICAzMCAr -KysKPiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg -MTAgKwo+ICAgZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICB8 -ICAgMSArCj4gICBkcml2ZXJzL2h3bW9uL3RtcDEwMy5jICAgICAgICAgICAgICAgICAgICAgICAg -IHwgMjgxICsrKysrKysrKysrKysrKysrKysrKysrKysKPiAgIDQgZmlsZXMgY2hhbmdlZCwgMzIy -IGluc2VydGlvbnMoKykKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2Rldmlj -ZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy -cy9od21vbi90bXAxMDMuYwo+Cj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJl -ZS9iaW5kaW5ncy9od21vbi90bXAxMDMgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGlu -Z3MvaHdtb24vdG1wMTAzCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwLi4z -NmQ3YjM2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i -aW5kaW5ncy9od21vbi90bXAxMDMKClNob3VsZCBiZSBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw -My4KCj4gQEAgLTAsMCArMSwzMCBAQAo+ICtLZXJuZWwgZHJpdmVyIHRtcDEwMwo+ICs9PT09PT09 -PT09PT09PT09PT09PQo+ICsKPiArU3VwcG9ydGVkIGNoaXBzOgo+ICsgICogVGV4YXMgSW5zdHJ1 -bWVudHMgVE1QMTAzCj4gKyAgICBQcmVmaXg6ICd0bXAxMDMnCj4gKyAgICBBZGRyZXNzZXMgc2Nh -bm5lZDogbm9uZQo+ICsgICAgUHJvZHVjdCBpbmZvIGFuZCBkYXRhc2hlZXQ6IGh0dHA6Ly93d3cu -dGkuY29tL3Byb2R1Y3QvdG1wMTAzCj4gKwo+ICtBdXRob3I6Cj4gKwlIZWlrbyBTY2hvY2hlciA8 -aHNAZGVueC5kZT4KPiArCj4gK0Rlc2NyaXB0aW9uCj4gKy0tLS0tLS0tLS0tCj4gKwo+ICtUaGUg -VE1QMTAzIGlzIGEgZGlnaXRhbCBvdXRwdXQgdGVtcGVyYXR1cmUgc2Vuc29yIGluIGEgZm91ci1i -YWxsCj4gK3dhZmVyIGNoaXAtc2NhbGUgcGFja2FnZSAoV0NTUCkuIFRoZSBUTVAxMDMgaXMgY2Fw -YWJsZSBvZiByZWFkaW5nCj4gK3RlbXBlcmF0dXJlcyB0byBhIHJlc29sdXRpb24gb2YgMcKwQy4g -VGhlIFRNUDEwMyBpcyBzcGVjaWZpZWQgZm9yCj4gK29wZXJhdGlvbiBvdmVyIGEgdGVtcGVyYXR1 -cmUgcmFuZ2Ugb2Yg4oCTNDDCsEMgdG8gKzEyNcKwQy4KPiArCj4gK1Jlc29sdXRpb246IDggQml0 -cwo+ICtBY2N1cmFjeTogwrExwrBDIFR5cCAo4oCTMTDCsEMgdG8gKzEwMMKwQykKPiArCj4gK1Ro -ZSBkcml2ZXIgcHJvdmlkZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRlcmZhY2UgZm9yIHRlbXBlcmF0 -dXJlcyAoc2VlCj4gK0RvY3VtZW50YXRpb24vaHdtb24vc3lzZnMtaW50ZXJmYWNlIHVuZGVyIFRl -bXBlcmF0dXJlcykuCj4gKwo+ICtSZXF1aXJlZCBub2RlIHByb3BlcnRpZXM6Cj4gKy0gY29tcGF0 -aWJsZTogbWFudWZhY3R1cmVyIGFuZCBjaGlwIG5hbWUKPiArCQkidGksdG1wMTAzIgo+ICstIHJl -ZzogSTJDIGJ1cyBhZGRyZXNzIG9mIHRoZSBkZXZpY2UKCllvdSBkb24ndCBuZWVkIHRoaXMgcGFy -dCwgYW5kIGl0IGlzIG5vdCByZWFsbHkgY29ycmVjdCAodGhlcmUgYXJlCm90aGVyIHdheXMgdG8g -aW5zdGFudGlhdGUgdGhlIGRldmljZSwgZGV2aWNldHJlZSBpcyBqdXN0IG9uZSBvZiB0aGVtKS4K -Ckkgd291bGQgc3VnZ2VzdCB0byByZWZlciB0byBEb2N1bWVudGF0aW9uL2kyYy9pbnN0YW50aWF0 -aW5nLWRldmljZXMKaW5zdGVhZC4gSXQgbWlnaHQgYWxzbyBtYWtlIHNlbnNlIHRvIHVwZGF0ZQpE -b2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQu -CgpBbHNvLCB3aGVuZXZlciB5b3UgdG91Y2ggYW55IG9mIHRoZSB0aGUgZHQgZmlsZXMsIHlvdSBu -ZWVkIHRvIGNvcHkKdGhlIERUIG1haW50YWluZXJzLiBzY3JpcHRzL2dldF9tYWludGFpbmVyLnBs -IHdpbGwgdGVsbCB5b3Ugd2hvIG5lZWRzCnRvIGJlIGNvcGllZC4KCj4gZGlmZiAtLWdpdCBhL2Ry -aXZlcnMvaHdtb24vS2NvbmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IDAwMzQz -MTYuLjBmNDRkYmIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIv -ZHJpdmVycy9od21vbi9LY29uZmlnCj4gQEAgLTEzODEsNiArMTM4MSwxNiBAQCBjb25maWcgU0VO -U09SU19UTVAxMDIKPiAgIAkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9k -dWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKPiAgIAkgIHdpbGwgYmUgY2FsbGVkIHRtcDEwMi4KPgo+ -ICtjb25maWcgU0VOU09SU19UTVAxMDMKPiArCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBU -TVAxMDMiCj4gKwlkZXBlbmRzIG9uIEkyQwo+ICsJaGVscAo+ICsJICBJZiB5b3Ugc2F5IHllcyBo -ZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4gKwkgIHNl -bnNvciBjaGlwcy4KPiArCj4gKwkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEg -bW9kdWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+ -ICsKPiAgIGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+ICAgCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVt -ZW50cyBUTVA0MDEgYW5kIGNvbXBhdGlibGVzIgo+ICAgCWRlcGVuZHMgb24gSTJDCj4gZGlmZiAt -LWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4g -aW5kZXggMTE3OThhZC4uOGUyZjZhMiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2Vm -aWxlCj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+IEBAIC0xMzQsNiArMTM0LDcgQEAg -b2JqLSQoQ09ORklHX1NFTlNPUlNfU01TQzQ3TTE5MikrPSBzbXNjNDdtMTkyLm8KPiAgIG9iai0k -KENPTkZJR19TRU5TT1JTX0FNQzY4MjEpCSs9IGFtYzY4MjEubwo+ICAgb2JqLSQoQ09ORklHX1NF -TlNPUlNfVEhNQzUwKQkrPSB0aG1jNTAubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QMTAy -KQkrPSB0bXAxMDIubwo+ICtvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDMpCSs9IHRtcDEwMy5v -Cj4gICBvYmotJChDT05GSUdfU0VOU09SU19UTVA0MDEpCSs9IHRtcDQwMS5vCj4gICBvYmotJChD -T05GSUdfU0VOU09SU19UTVA0MjEpCSs9IHRtcDQyMS5vCj4gICBvYmotJChDT05GSUdfU0VOU09S -U19UV0w0MDMwX01BREMpKz0gdHdsNDAzMC1tYWRjLWh3bW9uLm8KPiBkaWZmIC0tZ2l0IGEvZHJp -dmVycy9od21vbi90bXAxMDMuYyBiL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMKPiBuZXcgZmlsZSBt -b2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjBiZDMzZDYKPiAtLS0gL2Rldi9udWxsCj4gKysr -IGIvZHJpdmVycy9od21vbi90bXAxMDMuYwo+IEBAIC0wLDAgKzEsMjgxIEBACj4gKy8qCj4gKyAq -IFRleGFzIEluc3RydW1lbnRzIFRNUDEwMyBTTUJ1cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVy -Cj4gKyAqIENvcHlyaWdodCAoQykgMjAxNCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPiAr -ICoKPiArICogQmFzZWQgb246Cj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0 -ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyCj4gKyAqCj4gKyAqIENvcHlyaWdodCAoQykgMjAxMCBT -dGV2ZW4gS2luZyA8c2ZraW5nQGZkd2RjLmNvbT4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlz -IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKPiAr -ICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBh -cyBwdWJsaXNoZWQgYnkKPiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy -IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPiArICogKGF0IHlvdXIgb3B0aW9uKSBhbnkg -bGF0ZXIgdmVyc2lvbi4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu -IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4gKyAqIGJ1dCBXSVRIT1VUIEFOWSBX -QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCj4gKyAqIE1FUkNI -QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUK -PiArICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICoK -PiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51 -eC9pbml0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9p -MmMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9od21v -bi1zeXNmcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9t -dXRleC5oPgo+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9q -aWZmaWVzLmg+Cj4gKwo+ICsjZGVmaW5lCURSSVZFUl9OQU1FICJ0bXAxMDMiCj4gKwo+ICsjZGVm -aW5lCVRNUDEwM19URU1QX1JFRwkJCTB4MDAKPiArI2RlZmluZQlUTVAxMDNfQ09ORl9SRUcJCQkw -eDAxCj4gKyNkZWZpbmUJVE1QMTAzX1RMT1dfUkVHCQkJMHgwMgo+ICsjZGVmaW5lCVRNUDEwM19U -SElHSF9SRUcJCTB4MDMKPiArCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX00wCQkweDAxCj4gKyNk -ZWZpbmUJCVRNUDEwM19DT05GX00xCQkweDAyCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0xDCQkw -eDA0Cj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0ZMCQkweDA4Cj4gKyNkZWZpbmUJCVRNUDEwM19D -T05GX0ZICQkweDEwCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0NSMAkJMHgyMAo+ICsjZGVmaW5l -CQlUTVAxMDNfQ09ORl9DUjEJCTB4NDAKPiArI2RlZmluZQkJVE1QMTAzX0NPTkZfSUQJCTB4ODAK -PiArI2RlZmluZQkJVE1QMTAzX0NPTkZfU0QJCShUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05G -X00xKQo+ICsKPiArc3RydWN0IHRtcDEwMyB7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7 -Cj4gKwlzdHJ1Y3QgbXV0ZXggbG9jazsKPiArCXUxNiBjb25maWdfb3JpZzsKPiArCXVuc2lnbmVk -IGxvbmcgbGFzdF91cGRhdGU7Cj4gKwlpbnQgdGVtcFszXTsKPiArfTsKPiArCj4gK3N0YXRpYyBp -bmxpbmUgaW50IHRtcDEwM19yZWdfdG9fbUMoczggdmFsKQo+ICt7Cj4gKwlyZXR1cm4gdmFsICog -MTAwMDsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB1OCB0bXAxMDNfbUNfdG9fcmVnKGludCB2 -YWwpCj4gK3sKPiArCXJldHVybiB2YWwgLyAxMDAwOwoKRElWX1JPVU5EX0NMT1NFU1QoKSA/CgpO -byBjYW1lbENhc2UsIHBsZWFzZS4KCj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCB1OCB0bXAxMDNf -cmVnW10gPSB7Cj4gKwlUTVAxMDNfVEVNUF9SRUcsCj4gKwlUTVAxMDNfVExPV19SRUcsCj4gKwlU -TVAxMDNfVEhJR0hfUkVHLAo+ICt9Owo+ICsKPiArc3RhdGljIHN0cnVjdCB0bXAxMDMgKnRtcDEw -M191cGRhdGVfZGV2aWNlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVj -dCB0bXAxMDMgKnRtcDEwMyA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOwo+ICsKPiArCW11 -dGV4X2xvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0bXAx -MDMtPmxhc3RfdXBkYXRlICsgSFogLyAzKSkgewo+ICsJCWludCBpOwo+ICsKPiArCQlmb3IgKGkg -PSAwOyBpIDwgQVJSQVlfU0laRSh0bXAxMDMtPnRlbXApOyArK2kpIHsKPiArCQkJaW50IHN0YXR1 -cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsCj4gKwkJCQkJCQkgdG1wMTAzX3Jl -Z1tpXSk7Cj4gKwkJCWlmIChzdGF0dXMgPiAtMSkKPiArCQkJCXRtcDEwMy0+dGVtcFtpXSA9IHRt -cDEwM19yZWdfdG9fbUMoc3RhdHVzKTsKCkkgdW5kZXJzdGFuZCB0aGlzIGlzIGZyb20gdGhlIHRt -cDEwMiBkcml2ZXIsIGJ1dCBpdCBpcyBraW5kIG9mIHVudXN1YWwKYmVjYXVzZSBpdCBkb2VzIG5v -dCByZXBvcnQgdGhlIGVycm9yIGJhY2sgdG8gdGhlIHVzZXIuIFBsZWFzZSBjb25zaWRlcgpkb2lu -ZyB0aGF0LCBpZSByZXR1cm4gUFRSX0VSUihzdGF0dXMpIG9uIGVycm9yIGFuZCBjaGVjay9yZXR1 -cm4gdGhlIGVycm9yCmZyb20gdGhlIGNhbGxpbmcgZnVuY3Rpb25zLiBJcnJlbGV2YW50IGlmIHlv -dSB1c2UgcmVnbWFwIChzZWUgYmVsb3cpLgoKPiArCQl9Cj4gKwkJdG1wMTAzLT5sYXN0X3VwZGF0 -ZSA9IGppZmZpZXM7Cj4gKwl9Cj4gKwltdXRleF91bmxvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwly -ZXR1cm4gdG1wMTAzOwo+ICt9CgpPdmVyYWxsIHlvdSBtaWdodCBjb25zaWRlciBkcm9wcGluZyB0 -aGUgdXBkYXRlIGZ1bmN0aW9uIGFuZCB1c2luZyByZWdtYXAgaW5zdGVhZC4KSXQgd291bGQgYmUg -YW4gZXhjZWxsZW50IGZpdCBmb3IgdGhpcyBkcml2ZXI7IHdoaWxlIGl0IGRvZXNuJ3QgZG8gdGlt -ZWQgY2FjaGluZwppdCBzdXBwb3J0cyBwZXItcmVnaXN0ZXIgY2FjaGluZyB3aGljaCBpcyB1bHRp -bWF0ZWx5IG1vcmUgdXNlZnVsIGFueXdheS4KU29tZSBvZiB0aGUgZHJpdmVycyBpbiB0aGUgaHdt -b24gZGlyZWN0b3J5IHVzZSBpdCwgc28geW91IGNvdWxkIHVzZSB0aGF0CmFzIGV4YW1wbGUuIE5v -dCBtYW5kYXRvcnksIHRob3VnaDsganVzdCBhIHN1Z2dlc3Rpb24uCgo+ICsKPiArc3RhdGljIHNz -aXplX3QgdG1wMTAzX3Nob3dfdGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQlzdHJ1Y3Qg -ZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCWNoYXIgKmJ1ZikKPiArewo+ICsJc3RydWN0 -IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7 -Cj4gKwlzdHJ1Y3QgdG1wMTAzICp0bXAxMDMgPSB0bXAxMDNfdXBkYXRlX2RldmljZSh0b19pMmNf -Y2xpZW50KGRldikpOwo+ICsKPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDMt -PnRlbXBbc2RhLT5pbmRleF0pOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0 -X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAo+ICsJCQkgICAgICAgc3RydWN0IGRldmljZV9hdHRy -aWJ1dGUgKmF0dHIsCj4gKwkJCSAgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkK -PiArewo+ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3Jf -ZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdG9faTJjX2Ns -aWVudChkZXYpOwo+ICsJc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gaTJjX2dldF9jbGllbnRkYXRh -KGNsaWVudCk7Cj4gKwlsb25nIHZhbDsKPiArCWludCBzdGF0dXM7Cj4gKwo+ICsJaWYgKGtzdHJ0 -b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJdmFsID0gY2xh -bXBfdmFsKHZhbCwgLTU1MDAwLCAxMjgwMDApOwoKTWF4IHNob3VsZCBiZSAxMjcwMDAuCgo+ICsK -PiArCW11dGV4X2xvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwl0bXAxMDMtPnRlbXBbc2RhLT5pbmRl -eF0gPSB2YWw7CgpZb3UgY2FuIG5vdCBkbyB0aGF0IHNpbmNlIGl0IGlzIHRoZSBub24tcm91bmRl -ZCB2YWx1ZS4gWW91IGhhdmUgdG8gY29udmVydCB0bwp0aGUgcmVnaXN0ZXIgdmFsdWUsIHRoZW4g -Y29udmVydCBiYWNrIHRvIHRoZSBkaXNwbGF5IHZhbHVlLgoKSWYgeW91IHVzZSByZWdtYXAsIHRo -ZSBwcm9ibGVtIGdvZXMgYXdheSwgc2luY2UgeW91IHdvdWxkIG5vdCBjYWNoZSBjb252ZXJ0ZWQK -ZGF0YSBidXQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5jdGlvbi4gQWx0ZXJuYXRpdmVseSwgeW91 -IGNvdWxkIHN0b3JlIHJlZ2lzdGVyCnZhbHVlcyBhbmQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5j -dGlvbi4KCj4gKwlzdGF0dXMgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgdG1w -MTAzX3JlZ1tzZGEtPmluZGV4XSwKPiArCQkJCQkgICAgICB0bXAxMDNfbUNfdG9fcmVnKHZhbCkp -OwoKUGxlYXNlIG1ha2Ugc3VyZSB0aGF0IGNvbnRpbnVhdGlvbiBsaW5lcyBtYXRjaCB0aGUgJygn -IGluIHRoZSBsaW5lIGFib3ZlLgpBbGlnbm1lbnRzIGFyZSBpbmNvbnNpc3RlbnQsIG90aGVyd2lz -ZSBJIHdvdWxkIG5vdCBtZW50aW9uIGl0LgpjaGVja3BhdGNoIC0tc3RyaWN0IHRlbGxzIHlvdSB3 -aGljaCBvbmVzIGFyZSBtaXNhbGlnbmVkLgoKPiArCW11dGV4X3VubG9jaygmdG1wMTAzLT5sb2Nr -KTsKPiArCXJldHVybiBzdGF0dXMgPyA6IGNvdW50Owo+ICt9Cj4gKwo+ICtzdGF0aWMgU0VOU09S -X0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAxMDNfc2hvd190ZW1wLCBOVUxM -ICwgMCk7Cj4gKwpJZiB5b3UgdXNlIHJlZ21hcCB5b3UgY2FuIHN0b3JlIHRoZSByZWdpc3RlciBk -aXJlY3RseSBoZXJlIGFuZCB5b3Ugd291bGQgbm90Cm5lZWQgdG1wMTAzX3JlZ1tdLgoKPiArc3Rh -dGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9tYXhfaHlzdCwgU19JV1VTUiB8IFNfSVJVR08s -IHRtcDEwM19zaG93X3RlbXAsCj4gKwkJCSAgdG1wMTAzX3NldF90ZW1wLCAxKTsKPiArClBlciB0 -aGUgZGF0YXNoZWV0IHRoaXMgc2hvdWxkIGJlIHRlbXAxX21pbi4gVGhlIHJlZ2lzdGVyIGRlZmlu -aXRpb24gaXMgZGlmZmVyZW50IHRvIFRNUDEwMi4KCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FU -VFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPiArCQkJ -ICB0bXAxMDNfc2V0X3RlbXAsIDIpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRt -cDEwM19hdHRyaWJ1dGVzW10gPSB7Cj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2lucHV0LmRl -dl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heF9oeXN0LmRldl9hdHRy -LmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAoKWW91 -IG1pZ2h0IGFsc28gY29uc2lkZXIgYWRkaW5nIHRlbXAxX21pbl9hbGFybSBhbmQgdGVtcDFfbWF4 -X2FsYXJtIHRvIGluZm9ybQp1c2VyIHNwYWNlIGlmIGxpbWl0cyBhcmUgZXhjZWVkZWQuIFRoZSBz -dGF0dXMgaXMgcmVwb3J0ZWQgd2l0aCB0aGUgRkwgYW5kIEZICmJpdHMgaW4gdGhlIGNvbmZpZ3Vy -YXRpb24gcmVnaXN0ZXIuCgo+ICsJTlVMTAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVj -dCBhdHRyaWJ1dGVfZ3JvdXAgdG1wMTAzX2F0dHJfZ3JvdXAgPSB7Cj4gKwkuYXR0cnMgPSB0bXAx -MDNfYXR0cmlidXRlcywKPiArfTsKPiArClBsZWFzZSB1c2UgdGhlIEFUVFJJQlVURV9HUk9VUFMo -KSBtYWNyby4KCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJRwkJKFRNUDEwM19DT05GX0NSMSB8IFRN -UDEwM19DT05GX00xKQo+ICsjZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQkoVE1QMTAzX0NP -TkZfQ1IxIHwgVE1QMTAzX0NPTkZfTTEpCgpMYXR0ZXIgZGVmaW5lIGlzIG5vdCB1c2VkIGFzIGZh -ciBhcyBJIGNhbiBzZWUuIFNpbmNlIGl0IGlzIHRoZSBzYW1lCml0IGlzIHVubmVjZXNzYXJ5IGFu -eXdheS4KCj4gKwo+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAq -Y2xpZW50LAo+ICsJCQkJICBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCj4gK3sKPiAr -CXN0cnVjdCB0bXAxMDMgKnRtcDEwMzsKPiArCWludCBzdGF0dXM7Cj4gKwo+ICsJaWYgKCFpMmNf -Y2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0ZXIsCj4gKwkJCQkgICAgIEkyQ19GVU5D -X1NNQlVTX1dPUkRfREFUQSkpIHsKPiArCQlkZXZfZXJyKCZjbGllbnQtPmRldiwKPiArCQkJImFk -YXB0ZXIgZG9lc24ndCBzdXBwb3J0IFNNQnVzIHdvcmQgdHJhbnNhY3Rpb25zXG4iKTsKCkdvb2Qg -dGhhdCB0aGUgY2hpcCBkb2Vzbid0IHN1cHBvcnQgYW55IDstKS4gQ2hlY2sgZm9yIGJ5dGUgdHJh -bnNhY3Rpb25zIGluc3RlYWQuCgo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJfQo+ICsKPiArCXRt -cDEwMyA9IGRldm1fa3phbGxvYygmY2xpZW50LT5kZXYsIHNpemVvZigqdG1wMTAzKSwgR0ZQX0tF -Uk5FTCk7Cj4gKwlpZiAoIXRtcDEwMykKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlpMmNf -c2V0X2NsaWVudGRhdGEoY2xpZW50LCB0bXAxMDMpOwo+ICsKPiArCXN0YXR1cyA9IGkyY19zbWJ1 -c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRNUDEwM19DT05GX1JFRyk7Cj4gKwlpZiAoc3RhdHVz -IDwgMCkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiZXJyb3IgcmVhZGluZyBjb25maWcg -cmVnaXN0ZXJcbiIpOwo+ICsJCXJldHVybiBzdGF0dXM7Cj4gKwl9Cj4gKwl0bXAxMDMtPmNvbmZp -Z19vcmlnID0gc3RhdHVzOwoKWW91IGRvbid0IHVzZSBjb25maWdfb3JpZyBvdXRzaWRlIHRoZSBw -cm9iZSBmdW5jdGlvbiwKc28gc3RvcmluZyBpdCBpbiBwcml2YXRlIGRhdGEgZG9lc24ndCBhZGQg -YW55IHZhbHVlLgpBbHRlcm5hdGl2ZWx5LCB5b3UgY291bGQgcmVzdG9yZSB0aGUgb3JpZ2luYWwg -Y29uZmlndXJhdGlvbiBvbiBleGl0LgoKPiArCXN0YXR1cyA9IGkyY19zbWJ1c193cml0ZV9ieXRl -X2RhdGEoY2xpZW50LCBUTVAxMDNfQ09ORl9SRUcsCj4gKwkJCQkJICAgICAgVE1QMTAzX0NPTkZJ -Ryk7Cj4gKwlpZiAoc3RhdHVzIDwgMCkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiZXJy -b3Igd3JpdGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+ICsJCWdvdG8gZmFpbF9yZXN0b3JlX2Nv -bmZpZzsKPiArCX0KPiArCXN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQs -IFRNUDEwM19DT05GX1JFRyk7Cj4gKwlpZiAoc3RhdHVzIDwgMCkgewo+ICsJCWRldl9lcnIoJmNs -aWVudC0+ZGV2LCAiZXJyb3IgcmVhZGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+ICsJCWdvdG8g -ZmFpbF9yZXN0b3JlX2NvbmZpZzsKPiArCX0KPiArCWlmIChzdGF0dXMgIT0gVE1QMTAzX0NPTkZJ -Rykgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiY29uZmlnIHNldHRpbmdzIGRpZCBub3Qg -c3RpY2tcbiIpOwo+ICsJCXN0YXR1cyA9IC1FTk9ERVY7Cj4gKwkJZ290byBmYWlsX3Jlc3RvcmVf -Y29uZmlnOwo+ICsJfQo+ICsJdG1wMTAzLT5sYXN0X3VwZGF0ZSA9IGppZmZpZXMgLSBIWjsKPiAr -CW11dGV4X2luaXQoJnRtcDEwMy0+bG9jayk7Cj4gKwo+ICsJc3RhdHVzID0gc3lzZnNfY3JlYXRl -X2dyb3VwKCZjbGllbnQtPmRldi5rb2JqLCAmdG1wMTAzX2F0dHJfZ3JvdXApOwo+ICsJaWYgKHN0 -YXR1cykgewo+ICsJCWRldl9kYmcoJmNsaWVudC0+ZGV2LCAiY291bGQgbm90IGNyZWF0ZSBzeXNm -cyBmaWxlc1xuIik7Cj4gKwkJZ290byBmYWlsX3Jlc3RvcmVfY29uZmlnOwo+ICsJfQo+ICsJdG1w -MTAzLT5od21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXIoJmNsaWVudC0+ZGV2KTsKPiAr -CWlmIChJU19FUlIodG1wMTAzLT5od21vbl9kZXYpKSB7Cj4gKwkJZGV2X2RiZygmY2xpZW50LT5k -ZXYsICJ1bmFibGUgdG8gcmVnaXN0ZXIgaHdtb24gZGV2aWNlXG4iKTsKPiArCQlzdGF0dXMgPSBQ -VFJfRVJSKHRtcDEwMy0+aHdtb25fZGV2KTsKPiArCQlnb3RvIGZhaWxfcmVtb3ZlX3N5c2ZzOwo+ -ICsJfQoKUGxlYXNlIHVzZSBkZXZtX2h3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dyb3Vwcygp -LgoKPiArCj4gKwlkZXZfaW5mbygmY2xpZW50LT5kZXYsICJpbml0aWFsaXplZFxuIik7CgpQbGVh -c2UgZHJvcCB0aGlzIG1lc3NhZ2UuCgo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZmFpbF9yZW1v -dmVfc3lzZnM6Cj4gKwlzeXNmc19yZW1vdmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAx -MDNfYXR0cl9ncm91cCk7Cj4gK2ZhaWxfcmVzdG9yZV9jb25maWc6Cj4gKwlpMmNfc21idXNfd3Jp -dGVfd29yZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLAo+ICsJCQkJICAgICB0bXAx -MDMtPmNvbmZpZ19vcmlnKTsKCmkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoKSA/Cgo+ICsJcmV0 -dXJuIHN0YXR1czsKPiArfQo+ICsKPiArc3RhdGljIGludCB0bXAxMDNfcmVtb3ZlKHN0cnVjdCBp -MmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVjdCB0bXAxMDMgKnRtcDEwMyA9IGkyY19n -ZXRfY2xpZW50ZGF0YShjbGllbnQpOwo+ICsKPiArCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKHRt -cDEwMy0+aHdtb25fZGV2KTsKPiArCXN5c2ZzX3JlbW92ZV9ncm91cCgmY2xpZW50LT5kZXYua29i -aiwgJnRtcDEwM19hdHRyX2dyb3VwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArI2lm -ZGVmIENPTkZJR19QTQo+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0cnVjdCBkZXZpY2Ug -KmRldikKPiArewo+ICsJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19jbGllbnQo -ZGV2KTsKPiArCWludCBjb25maWc7Cj4gKwo+ICsJY29uZmlnID0gaTJjX3NtYnVzX3JlYWRfd29y -ZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKCmJ5dGUKCj4gKwlpZiAoY29uZmln -IDwgMCkKPiArCQlyZXR1cm4gY29uZmlnOwo+ICsKPiArCWNvbmZpZyAmPSB+VE1QMTAzX0NPTkZf -U0Q7Cj4gKwlyZXR1cm4gaTJjX3NtYnVzX3dyaXRlX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEw -M19DT05GX1JFRywgY29uZmlnKTsKCmJ5dGUKCj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdG1wMTAz -X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCBpMmNfY2xpZW50ICpj -bGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7Cj4gKwlpbnQgY29uZmlnOwo+ICsKPiArCWNvbmZp -ZyA9IGkyY19zbWJ1c19yZWFkX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05GX1JFRyk7 -CgpieXRlCgo+ICsJaWYgKGNvbmZpZyA8IDApCj4gKwkJcmV0dXJuIGNvbmZpZzsKPiArCj4gKwlj -b25maWcgfD0gVE1QMTAzX0NPTkZfU0Q7Cj4gKwlyZXR1cm4gaTJjX3NtYnVzX3dyaXRlX3dvcmRf -c3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05GX1JFRywgY29uZmlnKTsKCmJ5dGUKCj4gK30KPiAr -Cj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyB0bXAxMDNfZGV2X3BtX29wcyA9IHsK -PiArCS5zdXNwZW5kCT0gdG1wMTAzX3N1c3BlbmQsCj4gKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1 -bWUsCj4gK307Cj4gKwo+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9w -bV9vcHMpCj4gKyNlbHNlCj4gKyNkZWZpbmUJVE1QMTAzX0RFVl9QTV9PUFMgTlVMTAo+ICsjZW5k -aWYgLyogQ09ORklHX1BNICovCj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2Vf -aWQgdG1wMTAzX2lkW10gPSB7Cj4gKwl7IERSSVZFUl9OQU1FLCAwIH0sCj4gKwl7IH0KPiArfTsK -PiArTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4gKwo+ICtzdGF0aWMgc3Ry -dWN0IGkyY19kcml2ZXIgdG1wMTAzX2RyaXZlciA9IHsKPiArCS5kcml2ZXIubmFtZQk9IERSSVZF -Ul9OQU1FLAo+ICsJLmRyaXZlci5wbQk9IFRNUDEwM19ERVZfUE1fT1BTLAoKCS5kcml2ZXIgPSB7 -CgkJLm5hbWUJPSBEUklWRVJfTkFNRSwKCQkucG0JPSBUTVAxMDNfREVWX1BNX09QUywKCX0sCgp3 -b3VsZCBiZSBhIGJpdCBuaWNlci4gSSB3b24ndCBtYW5kYXRlIGl0LCB0aG91Z2guCgo+ICsJLnBy -b2JlCQk9IHRtcDEwM19wcm9iZSwKPiArCS5yZW1vdmUJCT0gdG1wMTAzX3JlbW92ZSwKPiArCS5p -ZF90YWJsZQk9IHRtcDEwM19pZCwKPiArfTsKPiArCj4gK21vZHVsZV9pMmNfZHJpdmVyKHRtcDEw -M19kcml2ZXIpOwo+ICsKPiArTU9EVUxFX0FVVEhPUigiSGVpa28gU2Nob2NoZXIgPGhzQGRlbngu -ZGU+Iik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIHRl -bXBlcmF0dXJlIHNlbnNvciBkcml2ZXIiKTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo+CgoK -X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbG0tc2Vuc29y -cyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0t -c2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz +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 <hs@denx.de> +> Cc: Jean Delvare <khali@linux-fr.org> +> Cc: Guenter Roeck <linux@roeck-us.net> +> Cc: linux-kernel@vger.kernel.org + +Hi Heiko, + +You don't need those Cc: in the header. + +Why patch 09/13 ? I'd expect to see 12 more patches in this series, +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. + +> @@ -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 <hs@denx.de> +> + +> +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). + +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. + +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. + +> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig +> index 0034316..0f44dbb 100644 +> --- a/drivers/hwmon/Kconfig +> +++ b/drivers/hwmon/Kconfig +> @@ -1381,6 +1381,16 @@ config SENSORS_TMP102 +> This driver can also be built as a module. If so, the module +> will be called tmp102. +> +> +config SENSORS_TMP103 +> + tristate "Texas Instruments TMP103" +> + depends on I2C +> + help +> + If you say yes here you get support for Texas Instruments TMP103 +> + sensor chips. +> + +> + This driver can also be built as a module. If so, the module +> + will be called tmp103. +> + +> config SENSORS_TMP401 +> tristate "Texas Instruments TMP401 and compatibles" +> depends on I2C +> 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 <hs@denx.de> +> + * +> + * Based on: +> + * Texas Instruments TMP102 SMBus temperature sensor driver +> + * +> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> +> + * +> + * 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 <linux/module.h> +> +#include <linux/init.h> +> +#include <linux/slab.h> +> +#include <linux/i2c.h> +> +#include <linux/hwmon.h> +> +#include <linux/hwmon-sysfs.h> +> +#include <linux/err.h> +> +#include <linux/mutex.h> +> +#include <linux/device.h> +> +#include <linux/jiffies.h> +> + +> +#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. + +> +} +> + +> +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). + +> + } +> + 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. + +> + +> +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. + +> + +> + 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. + +> + 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. + +> + 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[]. + +> +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. + +> +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. + +> + NULL +> +}; +> + +> +static const struct attribute_group tmp103_attr_group = { +> + .attrs = tmp103_attributes, +> +}; +> + +Please use the ATTRIBUTE_GROUPS() macro. + +> +#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. + +> + +> +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. + +> + 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. + +> + 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(). + +> + +> + dev_info(&client->dev, "initialized\n"); + +Please drop this message. + +> + +> + 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() ? + +> + 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 + +> +} +> + +> +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. + +> + .probe = tmp103_probe, +> + .remove = tmp103_remove, +> + .id_table = tmp103_id, +> +}; +> + +> +module_i2c_driver(tmp103_driver); +> + +> +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); +> +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); +> +MODULE_LICENSE("GPL"); +> diff --git a/a/content_digest b/N1/content_digest index c720fc6..eb8beee 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -1,274 +1,501 @@ "ref\01402468095-14678-1-git-send-email-hs@denx.de\0" "From\0Guenter Roeck <linux@roeck-us.net>\0" - "Subject\0Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor\0" - "Date\0Wed, 11 Jun 2014 17:11:29 +0000\0" + "Subject\0Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor\0" + "Date\0Wed, 11 Jun 2014 10:11:29 -0700\0" "To\0Heiko Schocher <hs@denx.de>" " lm-sensors@lm-sensors.org\0" "Cc\0Jean Delvare <khali@linux-fr.org>" " linux-kernel@vger.kernel.org\0" "\00:1\0" "b\0" - "T24gMDYvMTAvMjAxNCAxMToyOCBQTSwgSGVpa28gU2Nob2NoZXIgd3JvdGU6Cj4gRHJpdmVyIGZv\n" - "ciB0aGUgVEkgVE1QMTAzLgo+Cj4gVGhlIFRJIFRNUDEwMyBpcyBzaW1pbGFyIHRvIHRoZSBUTVAx\n" - "MDIuICBJdCBkaWZmZXJzIGZyb20gdGhlIFRNUDEwMgo+IGJ5IGhhdmluZyBvbmx5IDggYml0IHJl\n" - "Z2lzdGVycy4KPgo+IFNpZ25lZC1vZmYtYnk6IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+\n" - "IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4KPiBDYzogR3VlbnRlciBSb2Vj\n" - "ayA8bGludXhAcm9lY2stdXMubmV0Pgo+IENjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3Jn\n" - "CgpIaSBIZWlrbywKCllvdSBkb24ndCBuZWVkIHRob3NlIENjOiBpbiB0aGUgaGVhZGVyLgoKV2h5\n" - "IHBhdGNoIDA5LzEzID8gSSdkIGV4cGVjdCB0byBzZWUgMTIgbW9yZSBwYXRjaGVzIGluIHRoaXMg\n" - "c2VyaWVzLApidXQgdGhlcmUgaXMgb25seSBvbmUgKGV2ZW4gb24ga2VybmVsLm9yZykuIElmIHlv\n" - "dSBzZW50IHRob3NlCm90aGVyIHBhdGNoZXMgdG8gdmFyaW91cyBvdGhlciBtYWlsaW5nIGxpc3Rz\n" - "LCBldmVyeW9uZSB3aWxsIHdvbmRlcgp3aGVyZSB0aGUgcmVtYWluaW5nIHBhdGNoZXMgYXJlLiBJ\n" - "ZiB0aGVyZSBpcyBqdXN0IG9uZSBwYXRjaCwKaXQgaXMganVzdCBjb25mdXNpbmcuCgo+IC0tLQo+\n" - "ICAgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMyB8ICAzMCAr\n" - "KysKPiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg\n" - "MTAgKwo+ICAgZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICB8\n" - "ICAgMSArCj4gICBkcml2ZXJzL2h3bW9uL3RtcDEwMy5jICAgICAgICAgICAgICAgICAgICAgICAg\n" - "IHwgMjgxICsrKysrKysrKysrKysrKysrKysrKysrKysKPiAgIDQgZmlsZXMgY2hhbmdlZCwgMzIy\n" - "IGluc2VydGlvbnMoKykKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2Rldmlj\n" - "ZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy\n" - "cy9od21vbi90bXAxMDMuYwo+Cj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJl\n" - "ZS9iaW5kaW5ncy9od21vbi90bXAxMDMgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGlu\n" - "Z3MvaHdtb24vdG1wMTAzCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwLi4z\n" - "NmQ3YjM2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i\n" - "aW5kaW5ncy9od21vbi90bXAxMDMKClNob3VsZCBiZSBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw\n" - "My4KCj4gQEAgLTAsMCArMSwzMCBAQAo+ICtLZXJuZWwgZHJpdmVyIHRtcDEwMwo+ICs9PT09PT09\n" - "PT09PT09PT09PT09PQo+ICsKPiArU3VwcG9ydGVkIGNoaXBzOgo+ICsgICogVGV4YXMgSW5zdHJ1\n" - "bWVudHMgVE1QMTAzCj4gKyAgICBQcmVmaXg6ICd0bXAxMDMnCj4gKyAgICBBZGRyZXNzZXMgc2Nh\n" - "bm5lZDogbm9uZQo+ICsgICAgUHJvZHVjdCBpbmZvIGFuZCBkYXRhc2hlZXQ6IGh0dHA6Ly93d3cu\n" - "dGkuY29tL3Byb2R1Y3QvdG1wMTAzCj4gKwo+ICtBdXRob3I6Cj4gKwlIZWlrbyBTY2hvY2hlciA8\n" - "aHNAZGVueC5kZT4KPiArCj4gK0Rlc2NyaXB0aW9uCj4gKy0tLS0tLS0tLS0tCj4gKwo+ICtUaGUg\n" - "VE1QMTAzIGlzIGEgZGlnaXRhbCBvdXRwdXQgdGVtcGVyYXR1cmUgc2Vuc29yIGluIGEgZm91ci1i\n" - "YWxsCj4gK3dhZmVyIGNoaXAtc2NhbGUgcGFja2FnZSAoV0NTUCkuIFRoZSBUTVAxMDMgaXMgY2Fw\n" - "YWJsZSBvZiByZWFkaW5nCj4gK3RlbXBlcmF0dXJlcyB0byBhIHJlc29sdXRpb24gb2YgMcKwQy4g\n" - "VGhlIFRNUDEwMyBpcyBzcGVjaWZpZWQgZm9yCj4gK29wZXJhdGlvbiBvdmVyIGEgdGVtcGVyYXR1\n" - "cmUgcmFuZ2Ugb2Yg4oCTNDDCsEMgdG8gKzEyNcKwQy4KPiArCj4gK1Jlc29sdXRpb246IDggQml0\n" - "cwo+ICtBY2N1cmFjeTogwrExwrBDIFR5cCAo4oCTMTDCsEMgdG8gKzEwMMKwQykKPiArCj4gK1Ro\n" - "ZSBkcml2ZXIgcHJvdmlkZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRlcmZhY2UgZm9yIHRlbXBlcmF0\n" - "dXJlcyAoc2VlCj4gK0RvY3VtZW50YXRpb24vaHdtb24vc3lzZnMtaW50ZXJmYWNlIHVuZGVyIFRl\n" - "bXBlcmF0dXJlcykuCj4gKwo+ICtSZXF1aXJlZCBub2RlIHByb3BlcnRpZXM6Cj4gKy0gY29tcGF0\n" - "aWJsZTogbWFudWZhY3R1cmVyIGFuZCBjaGlwIG5hbWUKPiArCQkidGksdG1wMTAzIgo+ICstIHJl\n" - "ZzogSTJDIGJ1cyBhZGRyZXNzIG9mIHRoZSBkZXZpY2UKCllvdSBkb24ndCBuZWVkIHRoaXMgcGFy\n" - "dCwgYW5kIGl0IGlzIG5vdCByZWFsbHkgY29ycmVjdCAodGhlcmUgYXJlCm90aGVyIHdheXMgdG8g\n" - "aW5zdGFudGlhdGUgdGhlIGRldmljZSwgZGV2aWNldHJlZSBpcyBqdXN0IG9uZSBvZiB0aGVtKS4K\n" - "Ckkgd291bGQgc3VnZ2VzdCB0byByZWZlciB0byBEb2N1bWVudGF0aW9uL2kyYy9pbnN0YW50aWF0\n" - "aW5nLWRldmljZXMKaW5zdGVhZC4gSXQgbWlnaHQgYWxzbyBtYWtlIHNlbnNlIHRvIHVwZGF0ZQpE\n" - "b2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQu\n" - "CgpBbHNvLCB3aGVuZXZlciB5b3UgdG91Y2ggYW55IG9mIHRoZSB0aGUgZHQgZmlsZXMsIHlvdSBu\n" - "ZWVkIHRvIGNvcHkKdGhlIERUIG1haW50YWluZXJzLiBzY3JpcHRzL2dldF9tYWludGFpbmVyLnBs\n" - "IHdpbGwgdGVsbCB5b3Ugd2hvIG5lZWRzCnRvIGJlIGNvcGllZC4KCj4gZGlmZiAtLWdpdCBhL2Ry\n" - "aXZlcnMvaHdtb24vS2NvbmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IDAwMzQz\n" - "MTYuLjBmNDRkYmIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIv\n" - "ZHJpdmVycy9od21vbi9LY29uZmlnCj4gQEAgLTEzODEsNiArMTM4MSwxNiBAQCBjb25maWcgU0VO\n" - "U09SU19UTVAxMDIKPiAgIAkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9k\n" - "dWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKPiAgIAkgIHdpbGwgYmUgY2FsbGVkIHRtcDEwMi4KPgo+\n" - "ICtjb25maWcgU0VOU09SU19UTVAxMDMKPiArCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBU\n" - "TVAxMDMiCj4gKwlkZXBlbmRzIG9uIEkyQwo+ICsJaGVscAo+ICsJICBJZiB5b3Ugc2F5IHllcyBo\n" - "ZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4gKwkgIHNl\n" - "bnNvciBjaGlwcy4KPiArCj4gKwkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEg\n" - "bW9kdWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+\n" - "ICsKPiAgIGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+ICAgCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVt\n" - "ZW50cyBUTVA0MDEgYW5kIGNvbXBhdGlibGVzIgo+ICAgCWRlcGVuZHMgb24gSTJDCj4gZGlmZiAt\n" - "LWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4g\n" - "aW5kZXggMTE3OThhZC4uOGUyZjZhMiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2Vm\n" - "aWxlCj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+IEBAIC0xMzQsNiArMTM0LDcgQEAg\n" - "b2JqLSQoQ09ORklHX1NFTlNPUlNfU01TQzQ3TTE5MikrPSBzbXNjNDdtMTkyLm8KPiAgIG9iai0k\n" - "KENPTkZJR19TRU5TT1JTX0FNQzY4MjEpCSs9IGFtYzY4MjEubwo+ICAgb2JqLSQoQ09ORklHX1NF\n" - "TlNPUlNfVEhNQzUwKQkrPSB0aG1jNTAubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QMTAy\n" - "KQkrPSB0bXAxMDIubwo+ICtvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDMpCSs9IHRtcDEwMy5v\n" - "Cj4gICBvYmotJChDT05GSUdfU0VOU09SU19UTVA0MDEpCSs9IHRtcDQwMS5vCj4gICBvYmotJChD\n" - "T05GSUdfU0VOU09SU19UTVA0MjEpCSs9IHRtcDQyMS5vCj4gICBvYmotJChDT05GSUdfU0VOU09S\n" - "U19UV0w0MDMwX01BREMpKz0gdHdsNDAzMC1tYWRjLWh3bW9uLm8KPiBkaWZmIC0tZ2l0IGEvZHJp\n" - "dmVycy9od21vbi90bXAxMDMuYyBiL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMKPiBuZXcgZmlsZSBt\n" - "b2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjBiZDMzZDYKPiAtLS0gL2Rldi9udWxsCj4gKysr\n" - "IGIvZHJpdmVycy9od21vbi90bXAxMDMuYwo+IEBAIC0wLDAgKzEsMjgxIEBACj4gKy8qCj4gKyAq\n" - "IFRleGFzIEluc3RydW1lbnRzIFRNUDEwMyBTTUJ1cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVy\n" - "Cj4gKyAqIENvcHlyaWdodCAoQykgMjAxNCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPiAr\n" - "ICoKPiArICogQmFzZWQgb246Cj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0\n" - "ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyCj4gKyAqCj4gKyAqIENvcHlyaWdodCAoQykgMjAxMCBT\n" - "dGV2ZW4gS2luZyA8c2ZraW5nQGZkd2RjLmNvbT4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlz\n" - "IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKPiAr\n" - "ICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBh\n" - "cyBwdWJsaXNoZWQgYnkKPiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy\n" - "IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPiArICogKGF0IHlvdXIgb3B0aW9uKSBhbnkg\n" - "bGF0ZXIgdmVyc2lvbi4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu\n" - "IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4gKyAqIGJ1dCBXSVRIT1VUIEFOWSBX\n" - "QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCj4gKyAqIE1FUkNI\n" - "QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUK\n" - "PiArICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICoK\n" - "PiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51\n" - "eC9pbml0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9p\n" - "MmMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9od21v\n" - "bi1zeXNmcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9t\n" - "dXRleC5oPgo+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9q\n" - "aWZmaWVzLmg+Cj4gKwo+ICsjZGVmaW5lCURSSVZFUl9OQU1FICJ0bXAxMDMiCj4gKwo+ICsjZGVm\n" - "aW5lCVRNUDEwM19URU1QX1JFRwkJCTB4MDAKPiArI2RlZmluZQlUTVAxMDNfQ09ORl9SRUcJCQkw\n" - "eDAxCj4gKyNkZWZpbmUJVE1QMTAzX1RMT1dfUkVHCQkJMHgwMgo+ICsjZGVmaW5lCVRNUDEwM19U\n" - "SElHSF9SRUcJCTB4MDMKPiArCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX00wCQkweDAxCj4gKyNk\n" - "ZWZpbmUJCVRNUDEwM19DT05GX00xCQkweDAyCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0xDCQkw\n" - "eDA0Cj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0ZMCQkweDA4Cj4gKyNkZWZpbmUJCVRNUDEwM19D\n" - "T05GX0ZICQkweDEwCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0NSMAkJMHgyMAo+ICsjZGVmaW5l\n" - "CQlUTVAxMDNfQ09ORl9DUjEJCTB4NDAKPiArI2RlZmluZQkJVE1QMTAzX0NPTkZfSUQJCTB4ODAK\n" - "PiArI2RlZmluZQkJVE1QMTAzX0NPTkZfU0QJCShUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05G\n" - "X00xKQo+ICsKPiArc3RydWN0IHRtcDEwMyB7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7\n" - "Cj4gKwlzdHJ1Y3QgbXV0ZXggbG9jazsKPiArCXUxNiBjb25maWdfb3JpZzsKPiArCXVuc2lnbmVk\n" - "IGxvbmcgbGFzdF91cGRhdGU7Cj4gKwlpbnQgdGVtcFszXTsKPiArfTsKPiArCj4gK3N0YXRpYyBp\n" - "bmxpbmUgaW50IHRtcDEwM19yZWdfdG9fbUMoczggdmFsKQo+ICt7Cj4gKwlyZXR1cm4gdmFsICog\n" - "MTAwMDsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB1OCB0bXAxMDNfbUNfdG9fcmVnKGludCB2\n" - "YWwpCj4gK3sKPiArCXJldHVybiB2YWwgLyAxMDAwOwoKRElWX1JPVU5EX0NMT1NFU1QoKSA/CgpO\n" - "byBjYW1lbENhc2UsIHBsZWFzZS4KCj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCB1OCB0bXAxMDNf\n" - "cmVnW10gPSB7Cj4gKwlUTVAxMDNfVEVNUF9SRUcsCj4gKwlUTVAxMDNfVExPV19SRUcsCj4gKwlU\n" - "TVAxMDNfVEhJR0hfUkVHLAo+ICt9Owo+ICsKPiArc3RhdGljIHN0cnVjdCB0bXAxMDMgKnRtcDEw\n" - "M191cGRhdGVfZGV2aWNlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVj\n" - "dCB0bXAxMDMgKnRtcDEwMyA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOwo+ICsKPiArCW11\n" - "dGV4X2xvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0bXAx\n" - "MDMtPmxhc3RfdXBkYXRlICsgSFogLyAzKSkgewo+ICsJCWludCBpOwo+ICsKPiArCQlmb3IgKGkg\n" - "PSAwOyBpIDwgQVJSQVlfU0laRSh0bXAxMDMtPnRlbXApOyArK2kpIHsKPiArCQkJaW50IHN0YXR1\n" - "cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsCj4gKwkJCQkJCQkgdG1wMTAzX3Jl\n" - "Z1tpXSk7Cj4gKwkJCWlmIChzdGF0dXMgPiAtMSkKPiArCQkJCXRtcDEwMy0+dGVtcFtpXSA9IHRt\n" - "cDEwM19yZWdfdG9fbUMoc3RhdHVzKTsKCkkgdW5kZXJzdGFuZCB0aGlzIGlzIGZyb20gdGhlIHRt\n" - "cDEwMiBkcml2ZXIsIGJ1dCBpdCBpcyBraW5kIG9mIHVudXN1YWwKYmVjYXVzZSBpdCBkb2VzIG5v\n" - "dCByZXBvcnQgdGhlIGVycm9yIGJhY2sgdG8gdGhlIHVzZXIuIFBsZWFzZSBjb25zaWRlcgpkb2lu\n" - "ZyB0aGF0LCBpZSByZXR1cm4gUFRSX0VSUihzdGF0dXMpIG9uIGVycm9yIGFuZCBjaGVjay9yZXR1\n" - "cm4gdGhlIGVycm9yCmZyb20gdGhlIGNhbGxpbmcgZnVuY3Rpb25zLiBJcnJlbGV2YW50IGlmIHlv\n" - "dSB1c2UgcmVnbWFwIChzZWUgYmVsb3cpLgoKPiArCQl9Cj4gKwkJdG1wMTAzLT5sYXN0X3VwZGF0\n" - "ZSA9IGppZmZpZXM7Cj4gKwl9Cj4gKwltdXRleF91bmxvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwly\n" - "ZXR1cm4gdG1wMTAzOwo+ICt9CgpPdmVyYWxsIHlvdSBtaWdodCBjb25zaWRlciBkcm9wcGluZyB0\n" - "aGUgdXBkYXRlIGZ1bmN0aW9uIGFuZCB1c2luZyByZWdtYXAgaW5zdGVhZC4KSXQgd291bGQgYmUg\n" - "YW4gZXhjZWxsZW50IGZpdCBmb3IgdGhpcyBkcml2ZXI7IHdoaWxlIGl0IGRvZXNuJ3QgZG8gdGlt\n" - "ZWQgY2FjaGluZwppdCBzdXBwb3J0cyBwZXItcmVnaXN0ZXIgY2FjaGluZyB3aGljaCBpcyB1bHRp\n" - "bWF0ZWx5IG1vcmUgdXNlZnVsIGFueXdheS4KU29tZSBvZiB0aGUgZHJpdmVycyBpbiB0aGUgaHdt\n" - "b24gZGlyZWN0b3J5IHVzZSBpdCwgc28geW91IGNvdWxkIHVzZSB0aGF0CmFzIGV4YW1wbGUuIE5v\n" - "dCBtYW5kYXRvcnksIHRob3VnaDsganVzdCBhIHN1Z2dlc3Rpb24uCgo+ICsKPiArc3RhdGljIHNz\n" - "aXplX3QgdG1wMTAzX3Nob3dfdGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQlzdHJ1Y3Qg\n" - "ZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCWNoYXIgKmJ1ZikKPiArewo+ICsJc3RydWN0\n" - "IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7\n" - "Cj4gKwlzdHJ1Y3QgdG1wMTAzICp0bXAxMDMgPSB0bXAxMDNfdXBkYXRlX2RldmljZSh0b19pMmNf\n" - "Y2xpZW50KGRldikpOwo+ICsKPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDMt\n" - "PnRlbXBbc2RhLT5pbmRleF0pOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0\n" - "X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAo+ICsJCQkgICAgICAgc3RydWN0IGRldmljZV9hdHRy\n" - "aWJ1dGUgKmF0dHIsCj4gKwkJCSAgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkK\n" - "PiArewo+ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3Jf\n" - "ZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdG9faTJjX2Ns\n" - "aWVudChkZXYpOwo+ICsJc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gaTJjX2dldF9jbGllbnRkYXRh\n" - "KGNsaWVudCk7Cj4gKwlsb25nIHZhbDsKPiArCWludCBzdGF0dXM7Cj4gKwo+ICsJaWYgKGtzdHJ0\n" - "b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJdmFsID0gY2xh\n" - "bXBfdmFsKHZhbCwgLTU1MDAwLCAxMjgwMDApOwoKTWF4IHNob3VsZCBiZSAxMjcwMDAuCgo+ICsK\n" - "PiArCW11dGV4X2xvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwl0bXAxMDMtPnRlbXBbc2RhLT5pbmRl\n" - "eF0gPSB2YWw7CgpZb3UgY2FuIG5vdCBkbyB0aGF0IHNpbmNlIGl0IGlzIHRoZSBub24tcm91bmRl\n" - "ZCB2YWx1ZS4gWW91IGhhdmUgdG8gY29udmVydCB0bwp0aGUgcmVnaXN0ZXIgdmFsdWUsIHRoZW4g\n" - "Y29udmVydCBiYWNrIHRvIHRoZSBkaXNwbGF5IHZhbHVlLgoKSWYgeW91IHVzZSByZWdtYXAsIHRo\n" - "ZSBwcm9ibGVtIGdvZXMgYXdheSwgc2luY2UgeW91IHdvdWxkIG5vdCBjYWNoZSBjb252ZXJ0ZWQK\n" - "ZGF0YSBidXQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5jdGlvbi4gQWx0ZXJuYXRpdmVseSwgeW91\n" - "IGNvdWxkIHN0b3JlIHJlZ2lzdGVyCnZhbHVlcyBhbmQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5j\n" - "dGlvbi4KCj4gKwlzdGF0dXMgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgdG1w\n" - "MTAzX3JlZ1tzZGEtPmluZGV4XSwKPiArCQkJCQkgICAgICB0bXAxMDNfbUNfdG9fcmVnKHZhbCkp\n" - "OwoKUGxlYXNlIG1ha2Ugc3VyZSB0aGF0IGNvbnRpbnVhdGlvbiBsaW5lcyBtYXRjaCB0aGUgJygn\n" - "IGluIHRoZSBsaW5lIGFib3ZlLgpBbGlnbm1lbnRzIGFyZSBpbmNvbnNpc3RlbnQsIG90aGVyd2lz\n" - "ZSBJIHdvdWxkIG5vdCBtZW50aW9uIGl0LgpjaGVja3BhdGNoIC0tc3RyaWN0IHRlbGxzIHlvdSB3\n" - "aGljaCBvbmVzIGFyZSBtaXNhbGlnbmVkLgoKPiArCW11dGV4X3VubG9jaygmdG1wMTAzLT5sb2Nr\n" - "KTsKPiArCXJldHVybiBzdGF0dXMgPyA6IGNvdW50Owo+ICt9Cj4gKwo+ICtzdGF0aWMgU0VOU09S\n" - "X0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAxMDNfc2hvd190ZW1wLCBOVUxM\n" - "ICwgMCk7Cj4gKwpJZiB5b3UgdXNlIHJlZ21hcCB5b3UgY2FuIHN0b3JlIHRoZSByZWdpc3RlciBk\n" - "aXJlY3RseSBoZXJlIGFuZCB5b3Ugd291bGQgbm90Cm5lZWQgdG1wMTAzX3JlZ1tdLgoKPiArc3Rh\n" - "dGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9tYXhfaHlzdCwgU19JV1VTUiB8IFNfSVJVR08s\n" - "IHRtcDEwM19zaG93X3RlbXAsCj4gKwkJCSAgdG1wMTAzX3NldF90ZW1wLCAxKTsKPiArClBlciB0\n" - "aGUgZGF0YXNoZWV0IHRoaXMgc2hvdWxkIGJlIHRlbXAxX21pbi4gVGhlIHJlZ2lzdGVyIGRlZmlu\n" - "aXRpb24gaXMgZGlmZmVyZW50IHRvIFRNUDEwMi4KCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FU\n" - "VFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPiArCQkJ\n" - "ICB0bXAxMDNfc2V0X3RlbXAsIDIpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRt\n" - "cDEwM19hdHRyaWJ1dGVzW10gPSB7Cj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2lucHV0LmRl\n" - "dl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heF9oeXN0LmRldl9hdHRy\n" - "LmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAoKWW91\n" - "IG1pZ2h0IGFsc28gY29uc2lkZXIgYWRkaW5nIHRlbXAxX21pbl9hbGFybSBhbmQgdGVtcDFfbWF4\n" - "X2FsYXJtIHRvIGluZm9ybQp1c2VyIHNwYWNlIGlmIGxpbWl0cyBhcmUgZXhjZWVkZWQuIFRoZSBz\n" - "dGF0dXMgaXMgcmVwb3J0ZWQgd2l0aCB0aGUgRkwgYW5kIEZICmJpdHMgaW4gdGhlIGNvbmZpZ3Vy\n" - "YXRpb24gcmVnaXN0ZXIuCgo+ICsJTlVMTAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVj\n" - "dCBhdHRyaWJ1dGVfZ3JvdXAgdG1wMTAzX2F0dHJfZ3JvdXAgPSB7Cj4gKwkuYXR0cnMgPSB0bXAx\n" - "MDNfYXR0cmlidXRlcywKPiArfTsKPiArClBsZWFzZSB1c2UgdGhlIEFUVFJJQlVURV9HUk9VUFMo\n" - "KSBtYWNyby4KCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJRwkJKFRNUDEwM19DT05GX0NSMSB8IFRN\n" - "UDEwM19DT05GX00xKQo+ICsjZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQkoVE1QMTAzX0NP\n" - "TkZfQ1IxIHwgVE1QMTAzX0NPTkZfTTEpCgpMYXR0ZXIgZGVmaW5lIGlzIG5vdCB1c2VkIGFzIGZh\n" - "ciBhcyBJIGNhbiBzZWUuIFNpbmNlIGl0IGlzIHRoZSBzYW1lCml0IGlzIHVubmVjZXNzYXJ5IGFu\n" - "eXdheS4KCj4gKwo+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAq\n" - "Y2xpZW50LAo+ICsJCQkJICBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCj4gK3sKPiAr\n" - "CXN0cnVjdCB0bXAxMDMgKnRtcDEwMzsKPiArCWludCBzdGF0dXM7Cj4gKwo+ICsJaWYgKCFpMmNf\n" - "Y2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0ZXIsCj4gKwkJCQkgICAgIEkyQ19GVU5D\n" - "X1NNQlVTX1dPUkRfREFUQSkpIHsKPiArCQlkZXZfZXJyKCZjbGllbnQtPmRldiwKPiArCQkJImFk\n" - "YXB0ZXIgZG9lc24ndCBzdXBwb3J0IFNNQnVzIHdvcmQgdHJhbnNhY3Rpb25zXG4iKTsKCkdvb2Qg\n" - "dGhhdCB0aGUgY2hpcCBkb2Vzbid0IHN1cHBvcnQgYW55IDstKS4gQ2hlY2sgZm9yIGJ5dGUgdHJh\n" - "bnNhY3Rpb25zIGluc3RlYWQuCgo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJfQo+ICsKPiArCXRt\n" - "cDEwMyA9IGRldm1fa3phbGxvYygmY2xpZW50LT5kZXYsIHNpemVvZigqdG1wMTAzKSwgR0ZQX0tF\n" - "Uk5FTCk7Cj4gKwlpZiAoIXRtcDEwMykKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlpMmNf\n" - "c2V0X2NsaWVudGRhdGEoY2xpZW50LCB0bXAxMDMpOwo+ICsKPiArCXN0YXR1cyA9IGkyY19zbWJ1\n" - "c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRNUDEwM19DT05GX1JFRyk7Cj4gKwlpZiAoc3RhdHVz\n" - "IDwgMCkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiZXJyb3IgcmVhZGluZyBjb25maWcg\n" - "cmVnaXN0ZXJcbiIpOwo+ICsJCXJldHVybiBzdGF0dXM7Cj4gKwl9Cj4gKwl0bXAxMDMtPmNvbmZp\n" - "Z19vcmlnID0gc3RhdHVzOwoKWW91IGRvbid0IHVzZSBjb25maWdfb3JpZyBvdXRzaWRlIHRoZSBw\n" - "cm9iZSBmdW5jdGlvbiwKc28gc3RvcmluZyBpdCBpbiBwcml2YXRlIGRhdGEgZG9lc24ndCBhZGQg\n" - "YW55IHZhbHVlLgpBbHRlcm5hdGl2ZWx5LCB5b3UgY291bGQgcmVzdG9yZSB0aGUgb3JpZ2luYWwg\n" - "Y29uZmlndXJhdGlvbiBvbiBleGl0LgoKPiArCXN0YXR1cyA9IGkyY19zbWJ1c193cml0ZV9ieXRl\n" - "X2RhdGEoY2xpZW50LCBUTVAxMDNfQ09ORl9SRUcsCj4gKwkJCQkJICAgICAgVE1QMTAzX0NPTkZJ\n" - "Ryk7Cj4gKwlpZiAoc3RhdHVzIDwgMCkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiZXJy\n" - "b3Igd3JpdGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+ICsJCWdvdG8gZmFpbF9yZXN0b3JlX2Nv\n" - "bmZpZzsKPiArCX0KPiArCXN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQs\n" - "IFRNUDEwM19DT05GX1JFRyk7Cj4gKwlpZiAoc3RhdHVzIDwgMCkgewo+ICsJCWRldl9lcnIoJmNs\n" - "aWVudC0+ZGV2LCAiZXJyb3IgcmVhZGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+ICsJCWdvdG8g\n" - "ZmFpbF9yZXN0b3JlX2NvbmZpZzsKPiArCX0KPiArCWlmIChzdGF0dXMgIT0gVE1QMTAzX0NPTkZJ\n" - "Rykgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiY29uZmlnIHNldHRpbmdzIGRpZCBub3Qg\n" - "c3RpY2tcbiIpOwo+ICsJCXN0YXR1cyA9IC1FTk9ERVY7Cj4gKwkJZ290byBmYWlsX3Jlc3RvcmVf\n" - "Y29uZmlnOwo+ICsJfQo+ICsJdG1wMTAzLT5sYXN0X3VwZGF0ZSA9IGppZmZpZXMgLSBIWjsKPiAr\n" - "CW11dGV4X2luaXQoJnRtcDEwMy0+bG9jayk7Cj4gKwo+ICsJc3RhdHVzID0gc3lzZnNfY3JlYXRl\n" - "X2dyb3VwKCZjbGllbnQtPmRldi5rb2JqLCAmdG1wMTAzX2F0dHJfZ3JvdXApOwo+ICsJaWYgKHN0\n" - "YXR1cykgewo+ICsJCWRldl9kYmcoJmNsaWVudC0+ZGV2LCAiY291bGQgbm90IGNyZWF0ZSBzeXNm\n" - "cyBmaWxlc1xuIik7Cj4gKwkJZ290byBmYWlsX3Jlc3RvcmVfY29uZmlnOwo+ICsJfQo+ICsJdG1w\n" - "MTAzLT5od21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXIoJmNsaWVudC0+ZGV2KTsKPiAr\n" - "CWlmIChJU19FUlIodG1wMTAzLT5od21vbl9kZXYpKSB7Cj4gKwkJZGV2X2RiZygmY2xpZW50LT5k\n" - "ZXYsICJ1bmFibGUgdG8gcmVnaXN0ZXIgaHdtb24gZGV2aWNlXG4iKTsKPiArCQlzdGF0dXMgPSBQ\n" - "VFJfRVJSKHRtcDEwMy0+aHdtb25fZGV2KTsKPiArCQlnb3RvIGZhaWxfcmVtb3ZlX3N5c2ZzOwo+\n" - "ICsJfQoKUGxlYXNlIHVzZSBkZXZtX2h3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dyb3Vwcygp\n" - "LgoKPiArCj4gKwlkZXZfaW5mbygmY2xpZW50LT5kZXYsICJpbml0aWFsaXplZFxuIik7CgpQbGVh\n" - "c2UgZHJvcCB0aGlzIG1lc3NhZ2UuCgo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZmFpbF9yZW1v\n" - "dmVfc3lzZnM6Cj4gKwlzeXNmc19yZW1vdmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAx\n" - "MDNfYXR0cl9ncm91cCk7Cj4gK2ZhaWxfcmVzdG9yZV9jb25maWc6Cj4gKwlpMmNfc21idXNfd3Jp\n" - "dGVfd29yZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLAo+ICsJCQkJICAgICB0bXAx\n" - "MDMtPmNvbmZpZ19vcmlnKTsKCmkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoKSA/Cgo+ICsJcmV0\n" - "dXJuIHN0YXR1czsKPiArfQo+ICsKPiArc3RhdGljIGludCB0bXAxMDNfcmVtb3ZlKHN0cnVjdCBp\n" - "MmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVjdCB0bXAxMDMgKnRtcDEwMyA9IGkyY19n\n" - "ZXRfY2xpZW50ZGF0YShjbGllbnQpOwo+ICsKPiArCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKHRt\n" - "cDEwMy0+aHdtb25fZGV2KTsKPiArCXN5c2ZzX3JlbW92ZV9ncm91cCgmY2xpZW50LT5kZXYua29i\n" - "aiwgJnRtcDEwM19hdHRyX2dyb3VwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArI2lm\n" - "ZGVmIENPTkZJR19QTQo+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0cnVjdCBkZXZpY2Ug\n" - "KmRldikKPiArewo+ICsJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19jbGllbnQo\n" - "ZGV2KTsKPiArCWludCBjb25maWc7Cj4gKwo+ICsJY29uZmlnID0gaTJjX3NtYnVzX3JlYWRfd29y\n" - "ZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKCmJ5dGUKCj4gKwlpZiAoY29uZmln\n" - "IDwgMCkKPiArCQlyZXR1cm4gY29uZmlnOwo+ICsKPiArCWNvbmZpZyAmPSB+VE1QMTAzX0NPTkZf\n" - "U0Q7Cj4gKwlyZXR1cm4gaTJjX3NtYnVzX3dyaXRlX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEw\n" - "M19DT05GX1JFRywgY29uZmlnKTsKCmJ5dGUKCj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdG1wMTAz\n" - "X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCBpMmNfY2xpZW50ICpj\n" - "bGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7Cj4gKwlpbnQgY29uZmlnOwo+ICsKPiArCWNvbmZp\n" - "ZyA9IGkyY19zbWJ1c19yZWFkX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05GX1JFRyk7\n" - "CgpieXRlCgo+ICsJaWYgKGNvbmZpZyA8IDApCj4gKwkJcmV0dXJuIGNvbmZpZzsKPiArCj4gKwlj\n" - "b25maWcgfD0gVE1QMTAzX0NPTkZfU0Q7Cj4gKwlyZXR1cm4gaTJjX3NtYnVzX3dyaXRlX3dvcmRf\n" - "c3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05GX1JFRywgY29uZmlnKTsKCmJ5dGUKCj4gK30KPiAr\n" - "Cj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyB0bXAxMDNfZGV2X3BtX29wcyA9IHsK\n" - "PiArCS5zdXNwZW5kCT0gdG1wMTAzX3N1c3BlbmQsCj4gKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1\n" - "bWUsCj4gK307Cj4gKwo+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9w\n" - "bV9vcHMpCj4gKyNlbHNlCj4gKyNkZWZpbmUJVE1QMTAzX0RFVl9QTV9PUFMgTlVMTAo+ICsjZW5k\n" - "aWYgLyogQ09ORklHX1BNICovCj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2Vf\n" - "aWQgdG1wMTAzX2lkW10gPSB7Cj4gKwl7IERSSVZFUl9OQU1FLCAwIH0sCj4gKwl7IH0KPiArfTsK\n" - "PiArTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4gKwo+ICtzdGF0aWMgc3Ry\n" - "dWN0IGkyY19kcml2ZXIgdG1wMTAzX2RyaXZlciA9IHsKPiArCS5kcml2ZXIubmFtZQk9IERSSVZF\n" - "Ul9OQU1FLAo+ICsJLmRyaXZlci5wbQk9IFRNUDEwM19ERVZfUE1fT1BTLAoKCS5kcml2ZXIgPSB7\n" - "CgkJLm5hbWUJPSBEUklWRVJfTkFNRSwKCQkucG0JPSBUTVAxMDNfREVWX1BNX09QUywKCX0sCgp3\n" - "b3VsZCBiZSBhIGJpdCBuaWNlci4gSSB3b24ndCBtYW5kYXRlIGl0LCB0aG91Z2guCgo+ICsJLnBy\n" - "b2JlCQk9IHRtcDEwM19wcm9iZSwKPiArCS5yZW1vdmUJCT0gdG1wMTAzX3JlbW92ZSwKPiArCS5p\n" - "ZF90YWJsZQk9IHRtcDEwM19pZCwKPiArfTsKPiArCj4gK21vZHVsZV9pMmNfZHJpdmVyKHRtcDEw\n" - "M19kcml2ZXIpOwo+ICsKPiArTU9EVUxFX0FVVEhPUigiSGVpa28gU2Nob2NoZXIgPGhzQGRlbngu\n" - "ZGU+Iik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIHRl\n" - "bXBlcmF0dXJlIHNlbnNvciBkcml2ZXIiKTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo+CgoK\n" - "X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbG0tc2Vuc29y\n" - "cyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0t\n" - c2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz + "On 06/10/2014 11:28 PM, Heiko Schocher wrote:\n" + "> Driver for the TI TMP103.\n" + ">\n" + "> The TI TMP103 is similar to the TMP102. It differs from the TMP102\n" + "> by having only 8 bit registers.\n" + ">\n" + "> Signed-off-by: Heiko Schocher <hs@denx.de>\n" + "> Cc: Jean Delvare <khali@linux-fr.org>\n" + "> Cc: Guenter Roeck <linux@roeck-us.net>\n" + "> Cc: linux-kernel@vger.kernel.org\n" + "\n" + "Hi Heiko,\n" + "\n" + "You don't need those Cc: in the header.\n" + "\n" + "Why patch 09/13 ? I'd expect to see 12 more patches in this series,\n" + "but there is only one (even on kernel.org). If you sent those\n" + "other patches to various other mailing lists, everyone will wonder\n" + "where the remaining patches are. If there is just one patch,\n" + "it is just confusing.\n" + "\n" + "> ---\n" + "> Documentation/devicetree/bindings/hwmon/tmp103 | 30 +++\n" + "> drivers/hwmon/Kconfig | 10 +\n" + "> drivers/hwmon/Makefile | 1 +\n" + "> drivers/hwmon/tmp103.c | 281 +++++++++++++++++++++++++\n" + "> 4 files changed, 322 insertions(+)\n" + "> create mode 100644 Documentation/devicetree/bindings/hwmon/tmp103\n" + "> create mode 100644 drivers/hwmon/tmp103.c\n" + ">\n" + "> diff --git a/Documentation/devicetree/bindings/hwmon/tmp103 b/Documentation/devicetree/bindings/hwmon/tmp103\n" + "> new file mode 100644\n" + "> index 0000000..36d7b36\n" + "> --- /dev/null\n" + "> +++ b/Documentation/devicetree/bindings/hwmon/tmp103\n" + "\n" + "Should be Documentation/hwmon/tmp103.\n" + "\n" + "> @@ -0,0 +1,30 @@\n" + "> +Kernel driver tmp103\n" + "> +====================\n" + "> +\n" + "> +Supported chips:\n" + "> + * Texas Instruments TMP103\n" + "> + Prefix: 'tmp103'\n" + "> + Addresses scanned: none\n" + "> + Product info and datasheet: http://www.ti.com/product/tmp103\n" + "> +\n" + "> +Author:\n" + "> +\tHeiko Schocher <hs@denx.de>\n" + "> +\n" + "> +Description\n" + "> +-----------\n" + "> +\n" + "> +The TMP103 is a digital output temperature sensor in a four-ball\n" + "> +wafer chip-scale package (WCSP). The TMP103 is capable of reading\n" + "> +temperatures to a resolution of 1\302\260C. The TMP103 is specified for\n" + "> +operation over a temperature range of \342\200\22340\302\260C to +125\302\260C.\n" + "> +\n" + "> +Resolution: 8 Bits\n" + "> +Accuracy: \302\2611\302\260C Typ (\342\200\22310\302\260C to +100\302\260C)\n" + "> +\n" + "> +The driver provides the common sysfs-interface for temperatures (see\n" + "> +Documentation/hwmon/sysfs-interface under Temperatures).\n" + "> +\n" + "> +Required node properties:\n" + "> +- compatible: manufacturer and chip name\n" + "> +\t\t\"ti,tmp103\"\n" + "> +- reg: I2C bus address of the device\n" + "\n" + "You don't need this part, and it is not really correct (there are\n" + "other ways to instantiate the device, devicetree is just one of them).\n" + "\n" + "I would suggest to refer to Documentation/i2c/instantiating-devices\n" + "instead. It might also make sense to update\n" + "Documentation/devicetree/bindings/i2c/trivial-devices.txt.\n" + "\n" + "Also, whenever you touch any of the the dt files, you need to copy\n" + "the DT maintainers. scripts/get_maintainer.pl will tell you who needs\n" + "to be copied.\n" + "\n" + "> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig\n" + "> index 0034316..0f44dbb 100644\n" + "> --- a/drivers/hwmon/Kconfig\n" + "> +++ b/drivers/hwmon/Kconfig\n" + "> @@ -1381,6 +1381,16 @@ config SENSORS_TMP102\n" + "> \t This driver can also be built as a module. If so, the module\n" + "> \t will be called tmp102.\n" + ">\n" + "> +config SENSORS_TMP103\n" + "> +\ttristate \"Texas Instruments TMP103\"\n" + "> +\tdepends on I2C\n" + "> +\thelp\n" + "> +\t If you say yes here you get support for Texas Instruments TMP103\n" + "> +\t sensor chips.\n" + "> +\n" + "> +\t This driver can also be built as a module. If so, the module\n" + "> +\t will be called tmp103.\n" + "> +\n" + "> config SENSORS_TMP401\n" + "> \ttristate \"Texas Instruments TMP401 and compatibles\"\n" + "> \tdepends on I2C\n" + "> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile\n" + "> index 11798ad..8e2f6a2 100644\n" + "> --- a/drivers/hwmon/Makefile\n" + "> +++ b/drivers/hwmon/Makefile\n" + "> @@ -134,6 +134,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o\n" + "> obj-$(CONFIG_SENSORS_AMC6821)\t+= amc6821.o\n" + "> obj-$(CONFIG_SENSORS_THMC50)\t+= thmc50.o\n" + "> obj-$(CONFIG_SENSORS_TMP102)\t+= tmp102.o\n" + "> +obj-$(CONFIG_SENSORS_TMP103)\t+= tmp103.o\n" + "> obj-$(CONFIG_SENSORS_TMP401)\t+= tmp401.o\n" + "> obj-$(CONFIG_SENSORS_TMP421)\t+= tmp421.o\n" + "> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o\n" + "> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c\n" + "> new file mode 100644\n" + "> index 0000000..0bd33d6\n" + "> --- /dev/null\n" + "> +++ b/drivers/hwmon/tmp103.c\n" + "> @@ -0,0 +1,281 @@\n" + "> +/*\n" + "> + * Texas Instruments TMP103 SMBus temperature sensor driver\n" + "> + * Copyright (C) 2014 Heiko Schocher <hs@denx.de>\n" + "> + *\n" + "> + * Based on:\n" + "> + * Texas Instruments TMP102 SMBus temperature sensor driver\n" + "> + *\n" + "> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com>\n" + "> + *\n" + "> + * This program is free software; you can redistribute it and/or modify\n" + "> + * it under the terms of the GNU General Public License as published by\n" + "> + * the Free Software Foundation; either version 2 of the License, or\n" + "> + * (at your option) any later version.\n" + "> + *\n" + "> + * This program is distributed in the hope that it will be useful,\n" + "> + * but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + "> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "> + * GNU General Public License for more details.\n" + "> + *\n" + "> + */\n" + "> +\n" + "> +#include <linux/module.h>\n" + "> +#include <linux/init.h>\n" + "> +#include <linux/slab.h>\n" + "> +#include <linux/i2c.h>\n" + "> +#include <linux/hwmon.h>\n" + "> +#include <linux/hwmon-sysfs.h>\n" + "> +#include <linux/err.h>\n" + "> +#include <linux/mutex.h>\n" + "> +#include <linux/device.h>\n" + "> +#include <linux/jiffies.h>\n" + "> +\n" + "> +#define\tDRIVER_NAME \"tmp103\"\n" + "> +\n" + "> +#define\tTMP103_TEMP_REG\t\t\t0x00\n" + "> +#define\tTMP103_CONF_REG\t\t\t0x01\n" + "> +#define\tTMP103_TLOW_REG\t\t\t0x02\n" + "> +#define\tTMP103_THIGH_REG\t\t0x03\n" + "> +\n" + "> +#define\t\tTMP103_CONF_M0\t\t0x01\n" + "> +#define\t\tTMP103_CONF_M1\t\t0x02\n" + "> +#define\t\tTMP103_CONF_LC\t\t0x04\n" + "> +#define\t\tTMP103_CONF_FL\t\t0x08\n" + "> +#define\t\tTMP103_CONF_FH\t\t0x10\n" + "> +#define\t\tTMP103_CONF_CR0\t\t0x20\n" + "> +#define\t\tTMP103_CONF_CR1\t\t0x40\n" + "> +#define\t\tTMP103_CONF_ID\t\t0x80\n" + "> +#define\t\tTMP103_CONF_SD\t\t(TMP103_CONF_M0 | TMP103_CONF_M1)\n" + "> +\n" + "> +struct tmp103 {\n" + "> +\tstruct device *hwmon_dev;\n" + "> +\tstruct mutex lock;\n" + "> +\tu16 config_orig;\n" + "> +\tunsigned long last_update;\n" + "> +\tint temp[3];\n" + "> +};\n" + "> +\n" + "> +static inline int tmp103_reg_to_mC(s8 val)\n" + "> +{\n" + "> +\treturn val * 1000;\n" + "> +}\n" + "> +\n" + "> +static inline u8 tmp103_mC_to_reg(int val)\n" + "> +{\n" + "> +\treturn val / 1000;\n" + "\n" + "DIV_ROUND_CLOSEST() ?\n" + "\n" + "No camelCase, please.\n" + "\n" + "> +}\n" + "> +\n" + "> +static const u8 tmp103_reg[] = {\n" + "> +\tTMP103_TEMP_REG,\n" + "> +\tTMP103_TLOW_REG,\n" + "> +\tTMP103_THIGH_REG,\n" + "> +};\n" + "> +\n" + "> +static struct tmp103 *tmp103_update_device(struct i2c_client *client)\n" + "> +{\n" + "> +\tstruct tmp103 *tmp103 = i2c_get_clientdata(client);\n" + "> +\n" + "> +\tmutex_lock(&tmp103->lock);\n" + "> +\tif (time_after(jiffies, tmp103->last_update + HZ / 3)) {\n" + "> +\t\tint i;\n" + "> +\n" + "> +\t\tfor (i = 0; i < ARRAY_SIZE(tmp103->temp); ++i) {\n" + "> +\t\t\tint status = i2c_smbus_read_byte_data(client,\n" + "> +\t\t\t\t\t\t\t tmp103_reg[i]);\n" + "> +\t\t\tif (status > -1)\n" + "> +\t\t\t\ttmp103->temp[i] = tmp103_reg_to_mC(status);\n" + "\n" + "I understand this is from the tmp102 driver, but it is kind of unusual\n" + "because it does not report the error back to the user. Please consider\n" + "doing that, ie return PTR_ERR(status) on error and check/return the error\n" + "from the calling functions. Irrelevant if you use regmap (see below).\n" + "\n" + "> +\t\t}\n" + "> +\t\ttmp103->last_update = jiffies;\n" + "> +\t}\n" + "> +\tmutex_unlock(&tmp103->lock);\n" + "> +\treturn tmp103;\n" + "> +}\n" + "\n" + "Overall you might consider dropping the update function and using regmap instead.\n" + "It would be an excellent fit for this driver; while it doesn't do timed caching\n" + "it supports per-register caching which is ultimately more useful anyway.\n" + "Some of the drivers in the hwmon directory use it, so you could use that\n" + "as example. Not mandatory, though; just a suggestion.\n" + "\n" + "> +\n" + "> +static ssize_t tmp103_show_temp(struct device *dev,\n" + "> +\t\t\t\tstruct device_attribute *attr,\n" + "> +\t\t\t\tchar *buf)\n" + "> +{\n" + "> +\tstruct sensor_device_attribute *sda = to_sensor_dev_attr(attr);\n" + "> +\tstruct tmp103 *tmp103 = tmp103_update_device(to_i2c_client(dev));\n" + "> +\n" + "> +\treturn sprintf(buf, \"%d\\n\", tmp103->temp[sda->index]);\n" + "> +}\n" + "> +\n" + "> +static ssize_t tmp103_set_temp(struct device *dev,\n" + "> +\t\t\t struct device_attribute *attr,\n" + "> +\t\t\t const char *buf, size_t count)\n" + "> +{\n" + "> +\tstruct sensor_device_attribute *sda = to_sensor_dev_attr(attr);\n" + "> +\tstruct i2c_client *client = to_i2c_client(dev);\n" + "> +\tstruct tmp103 *tmp103 = i2c_get_clientdata(client);\n" + "> +\tlong val;\n" + "> +\tint status;\n" + "> +\n" + "> +\tif (kstrtol(buf, 10, &val) < 0)\n" + "> +\t\treturn -EINVAL;\n" + "> +\tval = clamp_val(val, -55000, 128000);\n" + "\n" + "Max should be 127000.\n" + "\n" + "> +\n" + "> +\tmutex_lock(&tmp103->lock);\n" + "> +\ttmp103->temp[sda->index] = val;\n" + "\n" + "You can not do that since it is the non-rounded value. You have to convert to\n" + "the register value, then convert back to the display value.\n" + "\n" + "If you use regmap, the problem goes away, since you would not cache converted\n" + "data but convert in the show function. Alternatively, you could store register\n" + "values and convert in the show function.\n" + "\n" + "> +\tstatus = i2c_smbus_write_byte_data(client, tmp103_reg[sda->index],\n" + "> +\t\t\t\t\t tmp103_mC_to_reg(val));\n" + "\n" + "Please make sure that continuation lines match the '(' in the line above.\n" + "Alignments are inconsistent, otherwise I would not mention it.\n" + "checkpatch --strict tells you which ones are misaligned.\n" + "\n" + "> +\tmutex_unlock(&tmp103->lock);\n" + "> +\treturn status ? : count;\n" + "> +}\n" + "> +\n" + "> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , 0);\n" + "> +\n" + "If you use regmap you can store the register directly here and you would not\n" + "need tmp103_reg[].\n" + "\n" + "> +static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + "> +\t\t\t tmp103_set_temp, 1);\n" + "> +\n" + "Per the datasheet this should be temp1_min. The register definition is different to TMP102.\n" + "\n" + "> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + "> +\t\t\t tmp103_set_temp, 2);\n" + "> +\n" + "> +static struct attribute *tmp103_attributes[] = {\n" + "> +\t&sensor_dev_attr_temp1_input.dev_attr.attr,\n" + "> +\t&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,\n" + "> +\t&sensor_dev_attr_temp1_max.dev_attr.attr,\n" + "\n" + "You might also consider adding temp1_min_alarm and temp1_max_alarm to inform\n" + "user space if limits are exceeded. The status is reported with the FL and FH\n" + "bits in the configuration register.\n" + "\n" + "> +\tNULL\n" + "> +};\n" + "> +\n" + "> +static const struct attribute_group tmp103_attr_group = {\n" + "> +\t.attrs = tmp103_attributes,\n" + "> +};\n" + "> +\n" + "Please use the ATTRIBUTE_GROUPS() macro.\n" + "\n" + "> +#define TMP103_CONFIG\t\t(TMP103_CONF_CR1 | TMP103_CONF_M1)\n" + "> +#define TMP103_CONFIG_RD_ONLY\t(TMP103_CONF_CR1 | TMP103_CONF_M1)\n" + "\n" + "Latter define is not used as far as I can see. Since it is the same\n" + "it is unnecessary anyway.\n" + "\n" + "> +\n" + "> +static int tmp103_probe(struct i2c_client *client,\n" + "> +\t\t\t\t const struct i2c_device_id *id)\n" + "> +{\n" + "> +\tstruct tmp103 *tmp103;\n" + "> +\tint status;\n" + "> +\n" + "> +\tif (!i2c_check_functionality(client->adapter,\n" + "> +\t\t\t\t I2C_FUNC_SMBUS_WORD_DATA)) {\n" + "> +\t\tdev_err(&client->dev,\n" + "> +\t\t\t\"adapter doesn't support SMBus word transactions\\n\");\n" + "\n" + "Good that the chip doesn't support any ;-). Check for byte transactions instead.\n" + "\n" + "> +\t\treturn -ENODEV;\n" + "> +\t}\n" + "> +\n" + "> +\ttmp103 = devm_kzalloc(&client->dev, sizeof(*tmp103), GFP_KERNEL);\n" + "> +\tif (!tmp103)\n" + "> +\t\treturn -ENOMEM;\n" + "> +\n" + "> +\ti2c_set_clientdata(client, tmp103);\n" + "> +\n" + "> +\tstatus = i2c_smbus_read_byte_data(client, TMP103_CONF_REG);\n" + "> +\tif (status < 0) {\n" + "> +\t\tdev_err(&client->dev, \"error reading config register\\n\");\n" + "> +\t\treturn status;\n" + "> +\t}\n" + "> +\ttmp103->config_orig = status;\n" + "\n" + "You don't use config_orig outside the probe function,\n" + "so storing it in private data doesn't add any value.\n" + "Alternatively, you could restore the original configuration on exit.\n" + "\n" + "> +\tstatus = i2c_smbus_write_byte_data(client, TMP103_CONF_REG,\n" + "> +\t\t\t\t\t TMP103_CONFIG);\n" + "> +\tif (status < 0) {\n" + "> +\t\tdev_err(&client->dev, \"error writing config register\\n\");\n" + "> +\t\tgoto fail_restore_config;\n" + "> +\t}\n" + "> +\tstatus = i2c_smbus_read_byte_data(client, TMP103_CONF_REG);\n" + "> +\tif (status < 0) {\n" + "> +\t\tdev_err(&client->dev, \"error reading config register\\n\");\n" + "> +\t\tgoto fail_restore_config;\n" + "> +\t}\n" + "> +\tif (status != TMP103_CONFIG) {\n" + "> +\t\tdev_err(&client->dev, \"config settings did not stick\\n\");\n" + "> +\t\tstatus = -ENODEV;\n" + "> +\t\tgoto fail_restore_config;\n" + "> +\t}\n" + "> +\ttmp103->last_update = jiffies - HZ;\n" + "> +\tmutex_init(&tmp103->lock);\n" + "> +\n" + "> +\tstatus = sysfs_create_group(&client->dev.kobj, &tmp103_attr_group);\n" + "> +\tif (status) {\n" + "> +\t\tdev_dbg(&client->dev, \"could not create sysfs files\\n\");\n" + "> +\t\tgoto fail_restore_config;\n" + "> +\t}\n" + "> +\ttmp103->hwmon_dev = hwmon_device_register(&client->dev);\n" + "> +\tif (IS_ERR(tmp103->hwmon_dev)) {\n" + "> +\t\tdev_dbg(&client->dev, \"unable to register hwmon device\\n\");\n" + "> +\t\tstatus = PTR_ERR(tmp103->hwmon_dev);\n" + "> +\t\tgoto fail_remove_sysfs;\n" + "> +\t}\n" + "\n" + "Please use devm_hwmon_device_register_with_groups().\n" + "\n" + "> +\n" + "> +\tdev_info(&client->dev, \"initialized\\n\");\n" + "\n" + "Please drop this message.\n" + "\n" + "> +\n" + "> +\treturn 0;\n" + "> +\n" + "> +fail_remove_sysfs:\n" + "> +\tsysfs_remove_group(&client->dev.kobj, &tmp103_attr_group);\n" + "> +fail_restore_config:\n" + "> +\ti2c_smbus_write_word_swapped(client, TMP103_CONF_REG,\n" + "> +\t\t\t\t tmp103->config_orig);\n" + "\n" + "i2c_smbus_write_byte_data() ?\n" + "\n" + "> +\treturn status;\n" + "> +}\n" + "> +\n" + "> +static int tmp103_remove(struct i2c_client *client)\n" + "> +{\n" + "> +\tstruct tmp103 *tmp103 = i2c_get_clientdata(client);\n" + "> +\n" + "> +\thwmon_device_unregister(tmp103->hwmon_dev);\n" + "> +\tsysfs_remove_group(&client->dev.kobj, &tmp103_attr_group);\n" + "> +\n" + "> +\treturn 0;\n" + "> +}\n" + "> +\n" + "> +#ifdef CONFIG_PM\n" + "> +static int tmp103_suspend(struct device *dev)\n" + "> +{\n" + "> +\tstruct i2c_client *client = to_i2c_client(dev);\n" + "> +\tint config;\n" + "> +\n" + "> +\tconfig = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG);\n" + "\n" + "byte\n" + "\n" + "> +\tif (config < 0)\n" + "> +\t\treturn config;\n" + "> +\n" + "> +\tconfig &= ~TMP103_CONF_SD;\n" + "> +\treturn i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config);\n" + "\n" + "byte\n" + "\n" + "> +}\n" + "> +\n" + "> +static int tmp103_resume(struct device *dev)\n" + "> +{\n" + "> +\tstruct i2c_client *client = to_i2c_client(dev);\n" + "> +\tint config;\n" + "> +\n" + "> +\tconfig = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG);\n" + "\n" + "byte\n" + "\n" + "> +\tif (config < 0)\n" + "> +\t\treturn config;\n" + "> +\n" + "> +\tconfig |= TMP103_CONF_SD;\n" + "> +\treturn i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config);\n" + "\n" + "byte\n" + "\n" + "> +}\n" + "> +\n" + "> +static const struct dev_pm_ops tmp103_dev_pm_ops = {\n" + "> +\t.suspend\t= tmp103_suspend,\n" + "> +\t.resume\t\t= tmp103_resume,\n" + "> +};\n" + "> +\n" + "> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops)\n" + "> +#else\n" + "> +#define\tTMP103_DEV_PM_OPS NULL\n" + "> +#endif /* CONFIG_PM */\n" + "> +\n" + "> +static const struct i2c_device_id tmp103_id[] = {\n" + "> +\t{ DRIVER_NAME, 0 },\n" + "> +\t{ }\n" + "> +};\n" + "> +MODULE_DEVICE_TABLE(i2c, tmp103_id);\n" + "> +\n" + "> +static struct i2c_driver tmp103_driver = {\n" + "> +\t.driver.name\t= DRIVER_NAME,\n" + "> +\t.driver.pm\t= TMP103_DEV_PM_OPS,\n" + "\n" + "\t.driver = {\n" + "\t\t.name\t= DRIVER_NAME,\n" + "\t\t.pm\t= TMP103_DEV_PM_OPS,\n" + "\t},\n" + "\n" + "would be a bit nicer. I won't mandate it, though.\n" + "\n" + "> +\t.probe\t\t= tmp103_probe,\n" + "> +\t.remove\t\t= tmp103_remove,\n" + "> +\t.id_table\t= tmp103_id,\n" + "> +};\n" + "> +\n" + "> +module_i2c_driver(tmp103_driver);\n" + "> +\n" + "> +MODULE_AUTHOR(\"Heiko Schocher <hs@denx.de>\");\n" + "> +MODULE_DESCRIPTION(\"Texas Instruments TMP103 temperature sensor driver\");\n" + "> +MODULE_LICENSE(\"GPL\");\n" + > -0429ba055c1bc7b4093605bd963dab2aabf7fc4d1846f5ef0eb6c038329810ff +69052877391c30afb376d23e5938524f6946ce8cb563820ae4058d67d9e0eac1
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.