diff for duplicates of <53A127BB.7090802@gmail.com> diff --git a/a/1.txt b/N1/1.txt index b5b57ad..9b9d7e7 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,211 +1,356 @@ -SGksCgpPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPiBEcml2 -ZXIgZm9yIHRoZSBUSSBUTVAxMDMuCj4KPiBUaGUgVEkgVE1QMTAzIGlzIHNpbWlsYXIgdG8gdGhl -IFRNUDEwMi4gIEl0IGRpZmZlcnMgZnJvbSB0aGUgVE1QMTAyCj4gYnkgaGF2aW5nIG9ubHkgOCBi -aXQgcmVnaXN0ZXJzLgo+Cj4gU2lnbmVkLW9mZi1ieTogSGVpa28gU2Nob2NoZXIgPGhzQGRlbngu -ZGU+Cj4KPiAtLS0KPgo+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4KPiBD -YzogR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0Pgo+IENjOiBsaW51eC1rZXJuZWxA -dmdlci5rZXJuZWwub3JnCj4gQ2M6IGRldmljZXRyZWVAdmdlci5rZXJuZWwub3JnCj4gQ2M6IGxp -bnV4LWRvY0B2Z2VyLmtlcm5lbC5vcmcKPiBDYzogTWFyayBSdXRsYW5kIDxtYXJrLnJ1dGxhbmRA -YXJtLmNvbT4KPgo+IC0gY2hhbmdlIGZvciB2MjoKPiAgICAtIGFkZCBjb21tZW50cyBmcm9tIEd1 -ZW50ZXJSb2VjazoKPiAgICAgIC0gcmVtb3ZlIENjIGZyb20gY29tbWl0IHN1YmplY3QKPiAgICAg -IC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5lcgo+ICAgICAgLSBtb3ZlIERvY3VtZW50YXRpb24g -dG8gRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiAgICAgIC0gcmVtb3ZlIGRldmljZXRyZWUg -YmluZGluZ3MgZnJvbSBEb2N1bWVudGF0aW9uCj4gICAgICAtIGFkZCBjb21wYXRpYmxlIHN0cmlu -ZyB0bwo+ICAgICAgICAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2 -aWFsLWRldmljZXMudHh0Igo+ICAgICAgLSByZW1vdmUgQ2FtZWxDYXNlCj4gICAgICAtIGZpeCBD -b2RpbmdzdHlsZSBpc3N1ZXMKPiAgICAgIC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5kIGRldm1f -aHdtb25fZGV2aWNlX3JlZ2lzdGVyX3dpdGhfZ3JvdXBzKCkKPiAgICAgIC0gcmVtb3ZlIHVuc3Vz -ZWQgZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQo+ICAgICAgLSByZXN0b3JlIGNvbmZpZyBy -ZWdpc3RlciB3aGVuIGV4aXQoKQo+ICAgICAgLSB1c2UgcmVnbWFwCj4gLSBjaGFuZ2VzIGZvciB2 -MzoKPiAgICBhZ2FpbiBhIGxvdCBvZiBmYW50YXN0aWMgdGlwcyBob3cgdG8gdXNlIHJlZ21hcCBl -ZmZpY2llbnRseQo+ICAgIGZyb20gR3VlbnRlciBSb2VjazoKPiAgICAtIGdldCByaWQgb2YgInN0 -cnVjdCB0bXAxMDMiCj4gICAgLSBnZXQgcmlkIG9mICJzdGF0aWMgY29uc3QgdTggdG1wMTAzX3Jl -Z1tdIgo+ICAgIC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4gICAgLSBkcm9wIGNvbmZpZ19vcmln -IGVudGlyZWx5Cj4gICAgLSB1c2UgcmVnbWFwX3VwZGF0ZV9iaXRzKCkKPiAtIGNoYW5nZXMgZm9y -IHY0Ogo+ICAgIC0gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ICAgICAgZGVmaW5l -IFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZfU0RfTUFTSwo+ICAgICAgc2VwYXJh -dGVseSB0byBlbnN1cmUgeW91IGNhdGNoIGFsbCB0aGUgdG8tYmUtY2xlYXJlZCBiaXRzLgo+IC0g -Y2hhbmdlcyBmb3IgdjU6Cj4gICAgYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ICAg -IC0gdXNlICIjZGVmaW5lIFRNUDEwM19DT05GX1NEIFRNUDEwM19DT05GX00xIgo+ICAgIGFkZCBj -b21tZW50IGZyb20gTWFyayBSdXRsYW5kOgo+ICAgIC0gdXNlIGZ1bGwgc3RyaW5nIGZvciBEVCBj -b21wYXRpYmxlIHN0cmluZyBtYXRjaGluZywgaW5zdGVhZCBvZgo+ICAgICAgRFJJVkVSX05BTUUu -IEdldCByaWQgY29tcGxldGUgb2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Cj4gICAuLi4vZGV2aWNl -dHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCAgICB8ICAgMSArCj4gICBEb2N1 -bWVudGF0aW9uL2h3bW9uL3RtcDEwMyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyOCArKysK -PiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg -IDEwICsKPiAgIGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAg -ICAgIHwgICAxICsKPiAgIGRyaXZlcnMvaHdtb24vdG1wMTAzLmMgICAgICAgICAgICAgICAgICAg -ICAgICAgICAgIHwgMjA1ICsrKysrKysrKysrKysrKysrKysrKwo+ICAgNSBmaWxlcyBjaGFuZ2Vk -LCAyNDUgaW5zZXJ0aW9ucygrKQo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24v -aHdtb24vdG1wMTAzCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9od21vbi90bXAxMDMu -Ywo+Cj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMv -dHJpdmlhbC1kZXZpY2VzLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9p -MmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+IGluZGV4IGJlZjg2ZTUuLmZjOTQ0ZTAgMTAwNjQ0Cj4g -LS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmlj -ZXMudHh0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2 -aWFsLWRldmljZXMudHh0Cj4gQEAgLTgzLDUgKzgzLDYgQEAgc3RtLG00MXQ4MAkJTTQxVDgwIC0g -U0VSSUFMIEFDQ0VTUyBSVEMgV0lUSCBBTEFSTVMKPiAgIHRhb3MsdHNsMjU1MAkJQW1iaWVudCBM -aWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4gICB0aSx0 -c2MyMDAzCQlJMkMgVG91Y2gtU2NyZWVuIENvbnRyb2xsZXIKPiAgIHRpLHRtcDEwMgkJTG93IFBv -d2VyIERpZ2l0YWwgVGVtcGVyYXR1cmUgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFs -IEludGVyZmFjZQo+ICt0aSx0bXAxMDMJCUxvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNl -bnNvciB3aXRoIFNNQlVTL1R3byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPiAgIHRpLHRtcDI3NQkJ -RGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3IKPiAgIHdpbmJvbmQsd3BjdDMwMQkJaTJjIHRydXN0 -ZWQgcGxhdGZvcm0gbW9kdWxlIChUUE0pCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdt -b24vdG1wMTAzIGIvRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiBuZXcgZmlsZSBtb2RlIDEw -MDY0NAo+IGluZGV4IDAwMDAwMDAuLmVjMDBhMTUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvRG9j -dW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiBAQCAtMCwwICsxLDI4IEBACj4gK0tlcm5lbCBkcml2 -ZXIgdG1wMTAzCj4gKz09PT09PT09PT09PT09PT09PT09Cj4gKwo+ICtTdXBwb3J0ZWQgY2hpcHM6 -Cj4gKyAgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKPiArICAgIFByZWZpeDogJ3RtcDEwMycK -PiArICAgIEFkZHJlc3NlcyBzY2FubmVkOiBub25lCj4gKyAgICBQcm9kdWN0IGluZm8gYW5kIGRh -dGFzaGVldDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPiArCj4gK0F1dGhvcjoK -PiArCUhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ICsKPiArRGVzY3JpcHRpb24KPiArLS0t -LS0tLS0tLS0KPiArCj4gK1RoZSBUTVAxMDMgaXMgYSBkaWdpdGFsIG91dHB1dCB0ZW1wZXJhdHVy -ZSBzZW5zb3IgaW4gYSBmb3VyLWJhbGwKPiArd2FmZXIgY2hpcC1zY2FsZSBwYWNrYWdlIChXQ1NQ -KS4gVGhlIFRNUDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPiArdGVtcGVyYXR1cmVzIHRvIGEg -cmVzb2x1dGlvbiBvZiAxwrBDLiBUaGUgVE1QMTAzIGlzIHNwZWNpZmllZCBmb3IKPiArb3BlcmF0 -aW9uIG92ZXIgYSB0ZW1wZXJhdHVyZSByYW5nZSBvZiDigJM0MMKwQyB0byArMTI1wrBDLgo+ICsK -PiArUmVzb2x1dGlvbjogOCBCaXRzCj4gK0FjY3VyYWN5OiDCsTHCsEMgVHlwICjigJMxMMKwQyB0 -byArMTAwwrBDKQo+ICsKPiArVGhlIGRyaXZlciBwcm92aWRlcyB0aGUgY29tbW9uIHN5c2ZzLWlu -dGVyZmFjZSBmb3IgdGVtcGVyYXR1cmVzIChzZWUKPiArRG9jdW1lbnRhdGlvbi9od21vbi9zeXNm -cy1pbnRlcmZhY2UgdW5kZXIgVGVtcGVyYXR1cmVzKS4KPiArCj4gK1BsZWFzZSByZWZlciBob3cg -dG8gaW5zdGFudGlhdGUgdGhpcyBkcml2ZXI6Cj4gK0RvY3VtZW50YXRpb24vaTJjL2luc3RhbnRp -YXRpbmctZGV2aWNlcwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcgYi9kcml2 -ZXJzL2h3bW9uL0tjb25maWcKPiBpbmRleCAwODUzMWExLi5jODgyZDRiIDEwMDY0NAo+IC0tLSBh -L2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IEBA -IC0xMzkxLDYgKzEzOTEsMTYgQEAgY29uZmlnIFNFTlNPUlNfVE1QMTAyCj4gICAJICBUaGlzIGRy -aXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCj4g -ICAJICB3aWxsIGJlIGNhbGxlZCB0bXAxMDIuCj4gICAKPiArY29uZmlnIFNFTlNPUlNfVE1QMTAz -Cj4gKwl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIgo+ICsJZGVwZW5kcyBvbiBJ -MkMKPiArCWhlbHAKPiArCSAgSWYgeW91IHNheSB5ZXMgaGVyZSB5b3UgZ2V0IHN1cHBvcnQgZm9y -IFRleGFzIEluc3RydW1lbnRzIFRNUDEwMwo+ICsJICBzZW5zb3IgY2hpcHMuCj4gKwo+ICsJICBU -aGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9k -dWxlCj4gKwkgIHdpbGwgYmUgY2FsbGVkIHRtcDEwMy4KPiArCj4gICBjb25maWcgU0VOU09SU19U -TVA0MDEKPiAgIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBjb21wYXRp -YmxlcyIKPiAgIAlkZXBlbmRzIG9uIEkyQwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL01h -a2VmaWxlIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+IGluZGV4IDNkYzBmMDIuLmNjMGRmMWVm -IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL2h3 -bW9uL01ha2VmaWxlCj4gQEAgLTEzNSw2ICsxMzUsNyBAQCBvYmotJChDT05GSUdfU0VOU09SU19T -TVNDNDdNMTkyKSs9IHNtc2M0N20xOTIubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfQU1DNjgy -MSkJKz0gYW1jNjgyMS5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19USE1DNTApCSs9IHRobWM1 -MC5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpCSs9IHRtcDEwMi5vCj4gK29iai0k -KENPTkZJR19TRU5TT1JTX1RNUDEwMykJKz0gdG1wMTAzLm8KPiAgIG9iai0kKENPTkZJR19TRU5T -T1JTX1RNUDQwMSkJKz0gdG1wNDAxLm8KPiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkJ -Kz0gdG1wNDIxLm8KPiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RXTDQwMzBfTUFEQykrPSB0d2w0 -MDMwLW1hZGMtaHdtb24ubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jIGIv -ZHJpdmVycy9od21vbi90bXAxMDMuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAw -MDAwMC4uZTY5ZGJjYQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEw -My5jCj4gQEAgLTAsMCArMSwyMDUgQEAKPiArLyoKPiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1Q -MTAzIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPiArICogQ29weXJpZ2h0IChDKSAy -MDE0IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ICsgKgo+ICsgKiBCYXNlZCBvbjoKPiAr -ICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAyIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2 -ZXIKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBLaW5nIDxzZmtpbmdAZmR3 -ZGMuY29tPgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh -biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQo+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMg -b2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQo+ICsgKiB0 -aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNl -bnNlLCBvcgo+ICsgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgo+ICsgKgo+ -ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs -IGJlIHVzZWZ1bCwKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g -dGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg -Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJs -aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+ICsgKgo+ICsgKi8KPiArCj4gKyNpbmNsdWRl -IDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KPiArI2luY2x1ZGUg -PGxpbnV4L3NsYWIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+ICsjaW5jbHVkZSA8bGlu -dXgvaHdtb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4gKyNpbmNsdWRl -IDxsaW51eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Cj4gKyNpbmNsdWRlIDxs -aW51eC9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2ppZmZpZXMuaD4KPiArI2luY2x1ZGUg -PGxpbnV4L3JlZ21hcC5oPgo+ICsKPiArI2RlZmluZSBUTVAxMDNfVEVNUF9SRUcJCTB4MDAKPiAr -I2RlZmluZSBUTVAxMDNfQ09ORl9SRUcJCTB4MDEKPiArI2RlZmluZSBUTVAxMDNfVExPV19SRUcJ -CTB4MDIKPiArI2RlZmluZSBUTVAxMDNfVEhJR0hfUkVHCTB4MDMKPiArCj4gKyNkZWZpbmUgVE1Q -MTAzX0NPTkZfTTAJCTB4MDEKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9NMQkJMHgwMgo+ICsjZGVm -aW5lIFRNUDEwM19DT05GX0xDCQkweDA0Cj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwJCTB4MDgK -PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GSAkJMHgxMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NS -MAkJMHgyMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMQkJMHg0MAo+ICsjZGVmaW5lIFRNUDEw -M19DT05GX0lECQkweDgwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfU0QJCShUTVAxMDNfQ09ORl9N -MSkKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRF9NQVNLCShUTVAxMDNfQ09ORl9NMCB8IFRNUDEw -M19DT05GX00xKQo+ICsKPiArI2RlZmluZSBUTVAxMDNfQ09ORklHCQkoVE1QMTAzX0NPTkZfQ1Ix -IHwgVE1QMTAzX0NPTkZfTTEpCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJR19NQVNLCShUTVAxMDNf -Q09ORl9DUjAgfCBUTVAxMDNfQ09ORl9DUjEgfCBcCj4gKwkJCQkgVE1QMTAzX0NPTkZfTTAgfCBU -TVAxMDNfQ09ORl9NMSkKPiArCj4gK3N0YXRpYyBpbmxpbmUgaW50IHRtcDEwM19yZWdfdG9fbWMo -czggdmFsKQo+ICt7Cj4gKwlyZXR1cm4gdmFsICogMTAwMDsKPiArfQo+ICsKPiArc3RhdGljIGlu -bGluZSB1OCB0bXAxMDNfbWNfdG9fcmVnKGludCB2YWwpCj4gK3sKPiArCXJldHVybiBESVZfUk9V -TkRfQ0xPU0VTVCh2YWwsIDEwMDApOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNf -c2hvd190ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCXN0cnVjdCBkZXZpY2VfYXR0cmli -dXRlICphdHRyLAo+ICsJCQkJY2hhciAqYnVmKQo+ICt7Cj4gKwlzdHJ1Y3Qgc2Vuc29yX2Rldmlj -ZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPiArCXN0cnVjdCBy -ZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJdW5zaWduZWQgaW50IHJl -Z3ZhbDsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gcmVnbWFwX3JlYWQocmVnbWFwLCBzZGEt -PmluZGV4LCAmcmVndmFsKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ -ICsJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIHRtcDEwM19yZWdfdG9fbWMocmVndmFsKSk7 -Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90IHRtcDEwM19zZXRfdGVtcChzdHJ1Y3QgZGV2aWNl -ICpkZXYsCj4gKwkJCSAgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJ -ICAgICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQo+ICt7Cj4gKwlzdHJ1Y3Qgc2Vu -c29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPiAr -CXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJbG9uZyB2 -YWw7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmIChrc3RydG9sKGJ1ZiwgMTAsICZ2YWwpIDwgMCkK -PiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwl2YWwgPSBjbGFtcF92YWwodmFsLCAtNTUwMDAs -IDEyNzAwMCk7Cj4gKwlyZXQgPSByZWdtYXBfd3JpdGUocmVnbWFwLCBzZGEtPmluZGV4LCB0bXAx -MDNfbWNfdG9fcmVnKHZhbCkpOwo+ICsJcmV0dXJuIHJldCA/IHJldCA6IGNvdW50Owo+ICt9Cj4g -Kwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAx -MDNfc2hvd190ZW1wLCBOVUxMICwKPiArCQkJICBUTVAxMDNfVEVNUF9SRUcpOwo+ICsKPiArc3Rh -dGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9taW4sIFNfSVdVU1IgfCBTX0lSVUdPLCB0bXAx -MDNfc2hvd190ZW1wLAo+ICsJCQkgIHRtcDEwM19zZXRfdGVtcCwgVE1QMTAzX1RMT1dfUkVHKTsK -PiArCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19J -UlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPiArCQkJICB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19U -SElHSF9SRUcpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRtcDEwM19hdHRyc1td -ID0gewo+ICsJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+ICsJ -JnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9taW4uZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5zb3JfZGV2 -X2F0dHJfdGVtcDFfbWF4LmRldl9hdHRyLmF0dHIsCj4gKwlOVUxMCj4gK307Cj4gK0FUVFJJQlVU -RV9HUk9VUFModG1wMTAzKTsKPiArCj4gK3N0YXRpYyBib29sIHRtcDEwM19yZWdtYXBfaXNfdm9s -YXRpbGUoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgcmVnKQo+ICt7Cj4gKwlyZXR1 -cm4gcmVnID09IFRNUDEwM19URU1QX1JFRzsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCByZWdt -YXBfY29uZmlnIHRtcDEwM19yZWdtYXBfY29uZmlnID0gewo+ICsJLnJlZ19iaXRzID0gOCwKPiAr -CS52YWxfYml0cyA9IDgsCj4gKwkubWF4X3JlZ2lzdGVyID0gVE1QMTAzX1RISUdIX1JFRywKPiAr -CS52b2xhdGlsZV9yZWcgPSB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxlLAo+ICt9Owo+ICsKPiAr -c3RhdGljIGludCB0bXAxMDNfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiArCQkJ -Y29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQo+ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpk -ZXYgPSAmY2xpZW50LT5kZXY7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7Cj4gKwlzdHJ1 -Y3QgcmVnbWFwICpyZWdtYXA7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmICghaTJjX2NoZWNrX2Z1 -bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+ICsJCQkJICAgICBJMkNfRlVOQ19TTUJVU19C -WVRFX0RBVEEpKSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYsCj4gKwkJCSJhZGFwdGVyIGRv -ZXNuJ3Qgc3VwcG9ydCBTTUJ1cyBieXRlIHRyYW5zYWN0aW9uc1xuIik7Cj4gKwkJcmV0dXJuIC1F -Tk9ERVY7Cj4gKwl9Cj4gKwo+ICsJcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9pMmMoY2xpZW50 -LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOwo+ICsJaWYgKElTX0VSUihyZWdtYXApKSB7Cj4gKwkJ -ZGV2X2VycihkZXYsICJmYWlsZWQgdG8gYWxsb2NhdGUgcmVnaXN0ZXIgbWFwXG4iKTsKPiArCQly -ZXR1cm4gUFRSX0VSUihyZWdtYXApOwo+ICsJfQo+ICsKPiArCXJldCA9IHJlZ21hcF91cGRhdGVf -Yml0cyhyZWdtYXAsIFRNUDEwM19DT05GX1JFRywgVE1QMTAzX0NPTkZJR19NQVNLLAo+ICsJCQkJ -IFRNUDEwM19DT05GSUcpOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKCZjbGllbnQt -PmRldiwgImVycm9yIHdyaXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPiArCQlyZXR1cm4gcmV0 -Owo+ICsJfQo+ICsKPiArCWh3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dy -b3VwcyhkZXYsIGNsaWVudC0+bmFtZSwKPiArCQkJCQkJICAgICAgcmVnbWFwLCB0bXAxMDNfZ3Jv -dXBzKTsKPiArCXJldHVybiBQVFJfRVJSX09SX1pFUk8oaHdtb25fZGV2KTsKPiArfQo+ICsKPiAr -I2lmZGVmIENPTkZJR19QTQo+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0cnVjdCBkZXZp -Y2UgKmRldikKPiArewo+ICsJc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRh -KGRldik7Cj4gKwo+ICsJcmV0dXJuIHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAsIFRNUDEwM19D -T05GX1JFRywKPiArCQkJCSAgVE1QMTAzX0NPTkZfU0RfTUFTSywgMCk7Cj4gK30KPiArCj4gK3N0 -YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVj -dCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsKPiArCXJldHVybiBy -ZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsCj4gKwkJCQkgIFRNUDEw -M19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0 -IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+ICsJLnN1c3BlbmQJPSB0 -bXAxMDNfc3VzcGVuZCwKPiArCS5yZXN1bWUJCT0gdG1wMTAzX3Jlc3VtZSwKPiArfTsKPiArCj4g -KyNkZWZpbmUgVE1QMTAzX0RFVl9QTV9PUFMgKCZ0bXAxMDNfZGV2X3BtX29wcykKPiArI2Vsc2UK -PiArI2RlZmluZQlUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4gKyNlbmRpZiAvKiBDT05GSUdfUE0g -Ki8KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCB0bXAxMDNfaWRbXSA9 -IHsKPiArCXsgInRtcDEwMyIsIDAgfSwKPiArCXsgfQo+ICt9OwoKSW4gdGhlIGJpbmRpbmdzIHlv -dSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxlIHByb3BlcnR5IGFzIDogdGksdG1wMTAzLCBidXQg -aGVyZSBvbmx5IHRtcDEwMy4KCkluc3RlYWQgb2YgdXNpbmcgdGhlIGkyY19kZXZpY2VfaWQgc3Ry -dWN0ICwgdXNlIG9mX2RldmljZV9pZCBzdHJ1Y3QgZm9yIGdpdmluZyB0aGUKY29tcGF0aWJsZSBw -cm9wZXJ0eSB2YWx1ZS4KY29tcGF0YmxlID0gIjxtYW51ZmFjdHVyZXI+LDxtb2RlbD4iCgo+ICtN -T0RVTEVfREVWSUNFX1RBQkxFKGkyYywgdG1wMTAzX2lkKTsKPiArK3N0YXRpYyBzdHJ1Y3QgaTJj -X2RyaXZlciB0bXAxMDNfZHJpdmVyID0gewo+ICsJLmRyaXZlciA9IHsKPiArCQkubmFtZQk9ICJ0 -bXAxMDMiLAo+ICsJCS5wbQk9IFRNUDEwM19ERVZfUE1fT1BTLAo+ICsJfSwKPiArCS5wcm9iZQkJ -PSB0bXAxMDNfcHJvYmUsCj4gKwkuaWRfdGFibGUJPSB0bXAxMDNfaWQsCj4gK307Cj4gKwo+ICtt -b2R1bGVfaTJjX2RyaXZlcih0bXAxMDNfZHJpdmVyKTsKPiArCj4gK01PRFVMRV9BVVRIT1IoIkhl -aWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPiIpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIlRleGFz -IEluc3RydW1lbnRzIFRNUDEwMyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyIik7Cj4gK01PRFVM -RV9MSUNFTlNFKCJHUEwiKTsKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f -X19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMu -b3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNv -cnM +Hi, + +On 06/18/2014 11:07 AM, 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 +> Cc: devicetree@vger.kernel.org +> Cc: linux-doc@vger.kernel.org +> Cc: Mark Rutland <mark.rutland@arm.com> +> +> - change for v2: +> - add comments from GuenterRoeck: +> - remove Cc from commit subject +> - add devicetree maintainer +> - move Documentation to Documentation/hwmon/tmp103 +> - remove devicetree bindings from Documentation +> - add compatible string to +> "Documentation/devicetree/bindings/i2c/trivial-devices.txt" +> - remove CamelCase +> - fix Codingstyle issues +> - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups() +> - remove unsused define TMP103_CONFIG_RD_ONLY +> - restore config register when exit() +> - use regmap +> - changes for v3: +> again a lot of fantastic tips how to use regmap efficiently +> from Guenter Roeck: +> - get rid of "struct tmp103" +> - get rid of "static const u8 tmp103_reg[]" +> - get rid of mutex lock +> - drop config_orig entirely +> - use regmap_update_bits() +> - changes for v4: +> - add comment from Guenter Roeck: +> define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK +> separately to ensure you catch all the to-be-cleared bits. +> - changes for v5: +> add comment from Guenter Roeck: +> - use "#define TMP103_CONF_SD TMP103_CONF_M1" +> add comment from Mark Rutland: +> - use full string for DT compatible string matching, instead of +> DRIVER_NAME. Get rid complete of DRIVER_NAME define. +> +> .../devicetree/bindings/i2c/trivial-devices.txt | 1 + +> Documentation/hwmon/tmp103 | 28 +++ +> drivers/hwmon/Kconfig | 10 + +> drivers/hwmon/Makefile | 1 + +> drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++ +> 5 files changed, 245 insertions(+) +> create mode 100644 Documentation/hwmon/tmp103 +> create mode 100644 drivers/hwmon/tmp103.c +> +> diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt +> index bef86e5..fc944e0 100644 +> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt +> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt +> @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH ALARMS +> taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface +> ti,tsc2003 I2C Touch-Screen Controller +> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface +> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface +> ti,tmp275 Digital Temperature Sensor +> winbond,wpct301 i2c trusted platform module (TPM) +> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 +> new file mode 100644 +> index 0000000..ec00a15 +> --- /dev/null +> +++ b/Documentation/hwmon/tmp103 +> @@ -0,0 +1,28 @@ +> +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). +> + +> +Please refer how to instantiate this driver: +> +Documentation/i2c/instantiating-devices +> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig +> index 08531a1..c882d4b 100644 +> --- a/drivers/hwmon/Kconfig +> +++ b/drivers/hwmon/Kconfig +> @@ -1391,6 +1391,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 3dc0f02..cc0df1ef 100644 +> --- a/drivers/hwmon/Makefile +> +++ b/drivers/hwmon/Makefile +> @@ -135,6 +135,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..e69dbca +> --- /dev/null +> +++ b/drivers/hwmon/tmp103.c +> @@ -0,0 +1,205 @@ +> +/* +> + * 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> +> +#include <linux/regmap.h> +> + +> +#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_M1) +> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) +> + +> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) +> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ +> + TMP103_CONF_M0 | TMP103_CONF_M1) +> + +> +static inline int tmp103_reg_to_mc(s8 val) +> +{ +> + return val * 1000; +> +} +> + +> +static inline u8 tmp103_mc_to_reg(int val) +> +{ +> + return DIV_ROUND_CLOSEST(val, 1000); +> +} +> + +> +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 regmap *regmap = dev_get_drvdata(dev); +> + unsigned int regval; +> + int ret; +> + +> + ret = regmap_read(regmap, sda->index, ®val); +> + if (ret < 0) +> + return ret; +> + +> + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); +> +} +> + +> +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 regmap *regmap = dev_get_drvdata(dev); +> + long val; +> + int ret; +> + +> + if (kstrtol(buf, 10, &val) < 0) +> + return -EINVAL; +> + +> + val = clamp_val(val, -55000, 127000); +> + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); +> + return ret ? ret : count; +> +} +> + +> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , +> + TMP103_TEMP_REG); +> + +> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp, +> + tmp103_set_temp, TMP103_TLOW_REG); +> + +> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, +> + tmp103_set_temp, TMP103_THIGH_REG); +> + +> +static struct attribute *tmp103_attrs[] = { +> + &sensor_dev_attr_temp1_input.dev_attr.attr, +> + &sensor_dev_attr_temp1_min.dev_attr.attr, +> + &sensor_dev_attr_temp1_max.dev_attr.attr, +> + NULL +> +}; +> +ATTRIBUTE_GROUPS(tmp103); +> + +> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg) +> +{ +> + return reg == TMP103_TEMP_REG; +> +} +> + +> +static struct regmap_config tmp103_regmap_config = { +> + .reg_bits = 8, +> + .val_bits = 8, +> + .max_register = TMP103_THIGH_REG, +> + .volatile_reg = tmp103_regmap_is_volatile, +> +}; +> + +> +static int tmp103_probe(struct i2c_client *client, +> + const struct i2c_device_id *id) +> +{ +> + struct device *dev = &client->dev; +> + struct device *hwmon_dev; +> + struct regmap *regmap; +> + int ret; +> + +> + if (!i2c_check_functionality(client->adapter, +> + I2C_FUNC_SMBUS_BYTE_DATA)) { +> + dev_err(&client->dev, +> + "adapter doesn't support SMBus byte transactions\n"); +> + return -ENODEV; +> + } +> + +> + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); +> + if (IS_ERR(regmap)) { +> + dev_err(dev, "failed to allocate register map\n"); +> + return PTR_ERR(regmap); +> + } +> + +> + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, +> + TMP103_CONFIG); +> + if (ret < 0) { +> + dev_err(&client->dev, "error writing config register\n"); +> + return ret; +> + } +> + +> + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, +> + regmap, tmp103_groups); +> + return PTR_ERR_OR_ZERO(hwmon_dev); +> +} +> + +> +#ifdef CONFIG_PM +> +static int tmp103_suspend(struct device *dev) +> +{ +> + struct regmap *regmap = dev_get_drvdata(dev); +> + +> + return regmap_update_bits(regmap, TMP103_CONF_REG, +> + TMP103_CONF_SD_MASK, 0); +> +} +> + +> +static int tmp103_resume(struct device *dev) +> +{ +> + struct regmap *regmap = dev_get_drvdata(dev); +> + +> + return regmap_update_bits(regmap, TMP103_CONF_REG, +> + TMP103_CONF_SD_MASK, TMP103_CONF_SD); +> +} +> + +> +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[] = { +> + { "tmp103", 0 }, +> + { } +> +}; + +In the bindings you are giving the compatible property as : ti,tmp103, but here only tmp103. + +Instead of using the i2c_device_id struct , use of_device_id struct for giving the +compatible property value. +compatble = "<manufacturer>,<model>" + +> +MODULE_DEVICE_TABLE(i2c, tmp103_id); +> ++static struct i2c_driver tmp103_driver = { +> + .driver = { +> + .name = "tmp103", +> + .pm = TMP103_DEV_PM_OPS, +> + }, +> + .probe = tmp103_probe, +> + .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 877363c..0e61a85 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -1,7 +1,7 @@ "ref\01403069837-15651-1-git-send-email-hs@denx.de\0" "From\0Varka Bhadram <varkabhadram@gmail.com>\0" - "Subject\0Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor\0" - "Date\0Wed, 18 Jun 2014 05:58:35 +0000\0" + "Subject\0Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor\0" + "Date\0Wed, 18 Jun 2014 11:16:35 +0530\0" "To\0Heiko Schocher <hs@denx.de>" " lm-sensors@lm-sensors.org\0" "Cc\0Jean Delvare <khali@linux-fr.org>" @@ -12,216 +12,361 @@ " Mark Rutland <mark.rutland@arm.com>\0" "\00:1\0" "b\0" - "SGksCgpPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPiBEcml2\n" - "ZXIgZm9yIHRoZSBUSSBUTVAxMDMuCj4KPiBUaGUgVEkgVE1QMTAzIGlzIHNpbWlsYXIgdG8gdGhl\n" - "IFRNUDEwMi4gIEl0IGRpZmZlcnMgZnJvbSB0aGUgVE1QMTAyCj4gYnkgaGF2aW5nIG9ubHkgOCBi\n" - "aXQgcmVnaXN0ZXJzLgo+Cj4gU2lnbmVkLW9mZi1ieTogSGVpa28gU2Nob2NoZXIgPGhzQGRlbngu\n" - "ZGU+Cj4KPiAtLS0KPgo+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4KPiBD\n" - "YzogR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0Pgo+IENjOiBsaW51eC1rZXJuZWxA\n" - "dmdlci5rZXJuZWwub3JnCj4gQ2M6IGRldmljZXRyZWVAdmdlci5rZXJuZWwub3JnCj4gQ2M6IGxp\n" - "bnV4LWRvY0B2Z2VyLmtlcm5lbC5vcmcKPiBDYzogTWFyayBSdXRsYW5kIDxtYXJrLnJ1dGxhbmRA\n" - "YXJtLmNvbT4KPgo+IC0gY2hhbmdlIGZvciB2MjoKPiAgICAtIGFkZCBjb21tZW50cyBmcm9tIEd1\n" - "ZW50ZXJSb2VjazoKPiAgICAgIC0gcmVtb3ZlIENjIGZyb20gY29tbWl0IHN1YmplY3QKPiAgICAg\n" - "IC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5lcgo+ICAgICAgLSBtb3ZlIERvY3VtZW50YXRpb24g\n" - "dG8gRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiAgICAgIC0gcmVtb3ZlIGRldmljZXRyZWUg\n" - "YmluZGluZ3MgZnJvbSBEb2N1bWVudGF0aW9uCj4gICAgICAtIGFkZCBjb21wYXRpYmxlIHN0cmlu\n" - "ZyB0bwo+ICAgICAgICAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2\n" - "aWFsLWRldmljZXMudHh0Igo+ICAgICAgLSByZW1vdmUgQ2FtZWxDYXNlCj4gICAgICAtIGZpeCBD\n" - "b2RpbmdzdHlsZSBpc3N1ZXMKPiAgICAgIC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5kIGRldm1f\n" - "aHdtb25fZGV2aWNlX3JlZ2lzdGVyX3dpdGhfZ3JvdXBzKCkKPiAgICAgIC0gcmVtb3ZlIHVuc3Vz\n" - "ZWQgZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQo+ICAgICAgLSByZXN0b3JlIGNvbmZpZyBy\n" - "ZWdpc3RlciB3aGVuIGV4aXQoKQo+ICAgICAgLSB1c2UgcmVnbWFwCj4gLSBjaGFuZ2VzIGZvciB2\n" - "MzoKPiAgICBhZ2FpbiBhIGxvdCBvZiBmYW50YXN0aWMgdGlwcyBob3cgdG8gdXNlIHJlZ21hcCBl\n" - "ZmZpY2llbnRseQo+ICAgIGZyb20gR3VlbnRlciBSb2VjazoKPiAgICAtIGdldCByaWQgb2YgInN0\n" - "cnVjdCB0bXAxMDMiCj4gICAgLSBnZXQgcmlkIG9mICJzdGF0aWMgY29uc3QgdTggdG1wMTAzX3Jl\n" - "Z1tdIgo+ICAgIC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4gICAgLSBkcm9wIGNvbmZpZ19vcmln\n" - "IGVudGlyZWx5Cj4gICAgLSB1c2UgcmVnbWFwX3VwZGF0ZV9iaXRzKCkKPiAtIGNoYW5nZXMgZm9y\n" - "IHY0Ogo+ICAgIC0gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ICAgICAgZGVmaW5l\n" - "IFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZfU0RfTUFTSwo+ICAgICAgc2VwYXJh\n" - "dGVseSB0byBlbnN1cmUgeW91IGNhdGNoIGFsbCB0aGUgdG8tYmUtY2xlYXJlZCBiaXRzLgo+IC0g\n" - "Y2hhbmdlcyBmb3IgdjU6Cj4gICAgYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ICAg\n" - "IC0gdXNlICIjZGVmaW5lIFRNUDEwM19DT05GX1NEIFRNUDEwM19DT05GX00xIgo+ICAgIGFkZCBj\n" - "b21tZW50IGZyb20gTWFyayBSdXRsYW5kOgo+ICAgIC0gdXNlIGZ1bGwgc3RyaW5nIGZvciBEVCBj\n" - "b21wYXRpYmxlIHN0cmluZyBtYXRjaGluZywgaW5zdGVhZCBvZgo+ICAgICAgRFJJVkVSX05BTUUu\n" - "IEdldCByaWQgY29tcGxldGUgb2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Cj4gICAuLi4vZGV2aWNl\n" - "dHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCAgICB8ICAgMSArCj4gICBEb2N1\n" - "bWVudGF0aW9uL2h3bW9uL3RtcDEwMyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyOCArKysK\n" - "PiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg\n" - "IDEwICsKPiAgIGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAg\n" - "ICAgIHwgICAxICsKPiAgIGRyaXZlcnMvaHdtb24vdG1wMTAzLmMgICAgICAgICAgICAgICAgICAg\n" - "ICAgICAgICAgIHwgMjA1ICsrKysrKysrKysrKysrKysrKysrKwo+ICAgNSBmaWxlcyBjaGFuZ2Vk\n" - "LCAyNDUgaW5zZXJ0aW9ucygrKQo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24v\n" - "aHdtb24vdG1wMTAzCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9od21vbi90bXAxMDMu\n" - "Ywo+Cj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMv\n" - "dHJpdmlhbC1kZXZpY2VzLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9p\n" - "MmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+IGluZGV4IGJlZjg2ZTUuLmZjOTQ0ZTAgMTAwNjQ0Cj4g\n" - "LS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmlj\n" - "ZXMudHh0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2\n" - "aWFsLWRldmljZXMudHh0Cj4gQEAgLTgzLDUgKzgzLDYgQEAgc3RtLG00MXQ4MAkJTTQxVDgwIC0g\n" - "U0VSSUFMIEFDQ0VTUyBSVEMgV0lUSCBBTEFSTVMKPiAgIHRhb3MsdHNsMjU1MAkJQW1iaWVudCBM\n" - "aWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4gICB0aSx0\n" - "c2MyMDAzCQlJMkMgVG91Y2gtU2NyZWVuIENvbnRyb2xsZXIKPiAgIHRpLHRtcDEwMgkJTG93IFBv\n" - "d2VyIERpZ2l0YWwgVGVtcGVyYXR1cmUgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFs\n" - "IEludGVyZmFjZQo+ICt0aSx0bXAxMDMJCUxvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNl\n" - "bnNvciB3aXRoIFNNQlVTL1R3byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPiAgIHRpLHRtcDI3NQkJ\n" - "RGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3IKPiAgIHdpbmJvbmQsd3BjdDMwMQkJaTJjIHRydXN0\n" - "ZWQgcGxhdGZvcm0gbW9kdWxlIChUUE0pCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdt\n" - "b24vdG1wMTAzIGIvRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiBuZXcgZmlsZSBtb2RlIDEw\n" - "MDY0NAo+IGluZGV4IDAwMDAwMDAuLmVjMDBhMTUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvRG9j\n" - "dW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiBAQCAtMCwwICsxLDI4IEBACj4gK0tlcm5lbCBkcml2\n" - "ZXIgdG1wMTAzCj4gKz09PT09PT09PT09PT09PT09PT09Cj4gKwo+ICtTdXBwb3J0ZWQgY2hpcHM6\n" - "Cj4gKyAgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKPiArICAgIFByZWZpeDogJ3RtcDEwMycK\n" - "PiArICAgIEFkZHJlc3NlcyBzY2FubmVkOiBub25lCj4gKyAgICBQcm9kdWN0IGluZm8gYW5kIGRh\n" - "dGFzaGVldDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPiArCj4gK0F1dGhvcjoK\n" - "PiArCUhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ICsKPiArRGVzY3JpcHRpb24KPiArLS0t\n" - "LS0tLS0tLS0KPiArCj4gK1RoZSBUTVAxMDMgaXMgYSBkaWdpdGFsIG91dHB1dCB0ZW1wZXJhdHVy\n" - "ZSBzZW5zb3IgaW4gYSBmb3VyLWJhbGwKPiArd2FmZXIgY2hpcC1zY2FsZSBwYWNrYWdlIChXQ1NQ\n" - "KS4gVGhlIFRNUDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPiArdGVtcGVyYXR1cmVzIHRvIGEg\n" - "cmVzb2x1dGlvbiBvZiAxwrBDLiBUaGUgVE1QMTAzIGlzIHNwZWNpZmllZCBmb3IKPiArb3BlcmF0\n" - "aW9uIG92ZXIgYSB0ZW1wZXJhdHVyZSByYW5nZSBvZiDigJM0MMKwQyB0byArMTI1wrBDLgo+ICsK\n" - "PiArUmVzb2x1dGlvbjogOCBCaXRzCj4gK0FjY3VyYWN5OiDCsTHCsEMgVHlwICjigJMxMMKwQyB0\n" - "byArMTAwwrBDKQo+ICsKPiArVGhlIGRyaXZlciBwcm92aWRlcyB0aGUgY29tbW9uIHN5c2ZzLWlu\n" - "dGVyZmFjZSBmb3IgdGVtcGVyYXR1cmVzIChzZWUKPiArRG9jdW1lbnRhdGlvbi9od21vbi9zeXNm\n" - "cy1pbnRlcmZhY2UgdW5kZXIgVGVtcGVyYXR1cmVzKS4KPiArCj4gK1BsZWFzZSByZWZlciBob3cg\n" - "dG8gaW5zdGFudGlhdGUgdGhpcyBkcml2ZXI6Cj4gK0RvY3VtZW50YXRpb24vaTJjL2luc3RhbnRp\n" - "YXRpbmctZGV2aWNlcwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcgYi9kcml2\n" - "ZXJzL2h3bW9uL0tjb25maWcKPiBpbmRleCAwODUzMWExLi5jODgyZDRiIDEwMDY0NAo+IC0tLSBh\n" - "L2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IEBA\n" - "IC0xMzkxLDYgKzEzOTEsMTYgQEAgY29uZmlnIFNFTlNPUlNfVE1QMTAyCj4gICAJICBUaGlzIGRy\n" - "aXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCj4g\n" - "ICAJICB3aWxsIGJlIGNhbGxlZCB0bXAxMDIuCj4gICAKPiArY29uZmlnIFNFTlNPUlNfVE1QMTAz\n" - "Cj4gKwl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIgo+ICsJZGVwZW5kcyBvbiBJ\n" - "MkMKPiArCWhlbHAKPiArCSAgSWYgeW91IHNheSB5ZXMgaGVyZSB5b3UgZ2V0IHN1cHBvcnQgZm9y\n" - "IFRleGFzIEluc3RydW1lbnRzIFRNUDEwMwo+ICsJICBzZW5zb3IgY2hpcHMuCj4gKwo+ICsJICBU\n" - "aGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9k\n" - "dWxlCj4gKwkgIHdpbGwgYmUgY2FsbGVkIHRtcDEwMy4KPiArCj4gICBjb25maWcgU0VOU09SU19U\n" - "TVA0MDEKPiAgIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBjb21wYXRp\n" - "YmxlcyIKPiAgIAlkZXBlbmRzIG9uIEkyQwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL01h\n" - "a2VmaWxlIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+IGluZGV4IDNkYzBmMDIuLmNjMGRmMWVm\n" - "IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL2h3\n" - "bW9uL01ha2VmaWxlCj4gQEAgLTEzNSw2ICsxMzUsNyBAQCBvYmotJChDT05GSUdfU0VOU09SU19T\n" - "TVNDNDdNMTkyKSs9IHNtc2M0N20xOTIubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfQU1DNjgy\n" - "MSkJKz0gYW1jNjgyMS5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19USE1DNTApCSs9IHRobWM1\n" - "MC5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpCSs9IHRtcDEwMi5vCj4gK29iai0k\n" - "KENPTkZJR19TRU5TT1JTX1RNUDEwMykJKz0gdG1wMTAzLm8KPiAgIG9iai0kKENPTkZJR19TRU5T\n" - "T1JTX1RNUDQwMSkJKz0gdG1wNDAxLm8KPiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkJ\n" - "Kz0gdG1wNDIxLm8KPiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RXTDQwMzBfTUFEQykrPSB0d2w0\n" - "MDMwLW1hZGMtaHdtb24ubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jIGIv\n" - "ZHJpdmVycy9od21vbi90bXAxMDMuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAw\n" - "MDAwMC4uZTY5ZGJjYQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEw\n" - "My5jCj4gQEAgLTAsMCArMSwyMDUgQEAKPiArLyoKPiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1Q\n" - "MTAzIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPiArICogQ29weXJpZ2h0IChDKSAy\n" - "MDE0IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ICsgKgo+ICsgKiBCYXNlZCBvbjoKPiAr\n" - "ICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAyIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2\n" - "ZXIKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBLaW5nIDxzZmtpbmdAZmR3\n" - "ZGMuY29tPgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh\n" - "biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQo+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMg\n" - "b2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQo+ICsgKiB0\n" - "aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNl\n" - "bnNlLCBvcgo+ICsgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgo+ICsgKgo+\n" - "ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs\n" - "IGJlIHVzZWZ1bCwKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g\n" - "dGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg\n" - "Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJs\n" - "aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+ICsgKgo+ICsgKi8KPiArCj4gKyNpbmNsdWRl\n" - "IDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KPiArI2luY2x1ZGUg\n" - "PGxpbnV4L3NsYWIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+ICsjaW5jbHVkZSA8bGlu\n" - "dXgvaHdtb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4gKyNpbmNsdWRl\n" - "IDxsaW51eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Cj4gKyNpbmNsdWRlIDxs\n" - "aW51eC9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2ppZmZpZXMuaD4KPiArI2luY2x1ZGUg\n" - "PGxpbnV4L3JlZ21hcC5oPgo+ICsKPiArI2RlZmluZSBUTVAxMDNfVEVNUF9SRUcJCTB4MDAKPiAr\n" - "I2RlZmluZSBUTVAxMDNfQ09ORl9SRUcJCTB4MDEKPiArI2RlZmluZSBUTVAxMDNfVExPV19SRUcJ\n" - "CTB4MDIKPiArI2RlZmluZSBUTVAxMDNfVEhJR0hfUkVHCTB4MDMKPiArCj4gKyNkZWZpbmUgVE1Q\n" - "MTAzX0NPTkZfTTAJCTB4MDEKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9NMQkJMHgwMgo+ICsjZGVm\n" - "aW5lIFRNUDEwM19DT05GX0xDCQkweDA0Cj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwJCTB4MDgK\n" - "PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GSAkJMHgxMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NS\n" - "MAkJMHgyMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMQkJMHg0MAo+ICsjZGVmaW5lIFRNUDEw\n" - "M19DT05GX0lECQkweDgwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfU0QJCShUTVAxMDNfQ09ORl9N\n" - "MSkKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRF9NQVNLCShUTVAxMDNfQ09ORl9NMCB8IFRNUDEw\n" - "M19DT05GX00xKQo+ICsKPiArI2RlZmluZSBUTVAxMDNfQ09ORklHCQkoVE1QMTAzX0NPTkZfQ1Ix\n" - "IHwgVE1QMTAzX0NPTkZfTTEpCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJR19NQVNLCShUTVAxMDNf\n" - "Q09ORl9DUjAgfCBUTVAxMDNfQ09ORl9DUjEgfCBcCj4gKwkJCQkgVE1QMTAzX0NPTkZfTTAgfCBU\n" - "TVAxMDNfQ09ORl9NMSkKPiArCj4gK3N0YXRpYyBpbmxpbmUgaW50IHRtcDEwM19yZWdfdG9fbWMo\n" - "czggdmFsKQo+ICt7Cj4gKwlyZXR1cm4gdmFsICogMTAwMDsKPiArfQo+ICsKPiArc3RhdGljIGlu\n" - "bGluZSB1OCB0bXAxMDNfbWNfdG9fcmVnKGludCB2YWwpCj4gK3sKPiArCXJldHVybiBESVZfUk9V\n" - "TkRfQ0xPU0VTVCh2YWwsIDEwMDApOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNf\n" - "c2hvd190ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCXN0cnVjdCBkZXZpY2VfYXR0cmli\n" - "dXRlICphdHRyLAo+ICsJCQkJY2hhciAqYnVmKQo+ICt7Cj4gKwlzdHJ1Y3Qgc2Vuc29yX2Rldmlj\n" - "ZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPiArCXN0cnVjdCBy\n" - "ZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJdW5zaWduZWQgaW50IHJl\n" - "Z3ZhbDsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gcmVnbWFwX3JlYWQocmVnbWFwLCBzZGEt\n" - "PmluZGV4LCAmcmVndmFsKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+\n" - "ICsJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIHRtcDEwM19yZWdfdG9fbWMocmVndmFsKSk7\n" - "Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90IHRtcDEwM19zZXRfdGVtcChzdHJ1Y3QgZGV2aWNl\n" - "ICpkZXYsCj4gKwkJCSAgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJ\n" - "ICAgICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQo+ICt7Cj4gKwlzdHJ1Y3Qgc2Vu\n" - "c29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPiAr\n" - "CXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJbG9uZyB2\n" - "YWw7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmIChrc3RydG9sKGJ1ZiwgMTAsICZ2YWwpIDwgMCkK\n" - "PiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwl2YWwgPSBjbGFtcF92YWwodmFsLCAtNTUwMDAs\n" - "IDEyNzAwMCk7Cj4gKwlyZXQgPSByZWdtYXBfd3JpdGUocmVnbWFwLCBzZGEtPmluZGV4LCB0bXAx\n" - "MDNfbWNfdG9fcmVnKHZhbCkpOwo+ICsJcmV0dXJuIHJldCA/IHJldCA6IGNvdW50Owo+ICt9Cj4g\n" - "Kwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAx\n" - "MDNfc2hvd190ZW1wLCBOVUxMICwKPiArCQkJICBUTVAxMDNfVEVNUF9SRUcpOwo+ICsKPiArc3Rh\n" - "dGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9taW4sIFNfSVdVU1IgfCBTX0lSVUdPLCB0bXAx\n" - "MDNfc2hvd190ZW1wLAo+ICsJCQkgIHRtcDEwM19zZXRfdGVtcCwgVE1QMTAzX1RMT1dfUkVHKTsK\n" - "PiArCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19J\n" - "UlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPiArCQkJICB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19U\n" - "SElHSF9SRUcpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRtcDEwM19hdHRyc1td\n" - "ID0gewo+ICsJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+ICsJ\n" - "JnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9taW4uZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5zb3JfZGV2\n" - "X2F0dHJfdGVtcDFfbWF4LmRldl9hdHRyLmF0dHIsCj4gKwlOVUxMCj4gK307Cj4gK0FUVFJJQlVU\n" - "RV9HUk9VUFModG1wMTAzKTsKPiArCj4gK3N0YXRpYyBib29sIHRtcDEwM19yZWdtYXBfaXNfdm9s\n" - "YXRpbGUoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgcmVnKQo+ICt7Cj4gKwlyZXR1\n" - "cm4gcmVnID09IFRNUDEwM19URU1QX1JFRzsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCByZWdt\n" - "YXBfY29uZmlnIHRtcDEwM19yZWdtYXBfY29uZmlnID0gewo+ICsJLnJlZ19iaXRzID0gOCwKPiAr\n" - "CS52YWxfYml0cyA9IDgsCj4gKwkubWF4X3JlZ2lzdGVyID0gVE1QMTAzX1RISUdIX1JFRywKPiAr\n" - "CS52b2xhdGlsZV9yZWcgPSB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxlLAo+ICt9Owo+ICsKPiAr\n" - "c3RhdGljIGludCB0bXAxMDNfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiArCQkJ\n" - "Y29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQo+ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpk\n" - "ZXYgPSAmY2xpZW50LT5kZXY7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7Cj4gKwlzdHJ1\n" - "Y3QgcmVnbWFwICpyZWdtYXA7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmICghaTJjX2NoZWNrX2Z1\n" - "bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+ICsJCQkJICAgICBJMkNfRlVOQ19TTUJVU19C\n" - "WVRFX0RBVEEpKSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYsCj4gKwkJCSJhZGFwdGVyIGRv\n" - "ZXNuJ3Qgc3VwcG9ydCBTTUJ1cyBieXRlIHRyYW5zYWN0aW9uc1xuIik7Cj4gKwkJcmV0dXJuIC1F\n" - "Tk9ERVY7Cj4gKwl9Cj4gKwo+ICsJcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9pMmMoY2xpZW50\n" - "LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOwo+ICsJaWYgKElTX0VSUihyZWdtYXApKSB7Cj4gKwkJ\n" - "ZGV2X2VycihkZXYsICJmYWlsZWQgdG8gYWxsb2NhdGUgcmVnaXN0ZXIgbWFwXG4iKTsKPiArCQly\n" - "ZXR1cm4gUFRSX0VSUihyZWdtYXApOwo+ICsJfQo+ICsKPiArCXJldCA9IHJlZ21hcF91cGRhdGVf\n" - "Yml0cyhyZWdtYXAsIFRNUDEwM19DT05GX1JFRywgVE1QMTAzX0NPTkZJR19NQVNLLAo+ICsJCQkJ\n" - "IFRNUDEwM19DT05GSUcpOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKCZjbGllbnQt\n" - "PmRldiwgImVycm9yIHdyaXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPiArCQlyZXR1cm4gcmV0\n" - "Owo+ICsJfQo+ICsKPiArCWh3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dy\n" - "b3VwcyhkZXYsIGNsaWVudC0+bmFtZSwKPiArCQkJCQkJICAgICAgcmVnbWFwLCB0bXAxMDNfZ3Jv\n" - "dXBzKTsKPiArCXJldHVybiBQVFJfRVJSX09SX1pFUk8oaHdtb25fZGV2KTsKPiArfQo+ICsKPiAr\n" - "I2lmZGVmIENPTkZJR19QTQo+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0cnVjdCBkZXZp\n" - "Y2UgKmRldikKPiArewo+ICsJc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRh\n" - "KGRldik7Cj4gKwo+ICsJcmV0dXJuIHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAsIFRNUDEwM19D\n" - "T05GX1JFRywKPiArCQkJCSAgVE1QMTAzX0NPTkZfU0RfTUFTSywgMCk7Cj4gK30KPiArCj4gK3N0\n" - "YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVj\n" - "dCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsKPiArCXJldHVybiBy\n" - "ZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsCj4gKwkJCQkgIFRNUDEw\n" - "M19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0\n" - "IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+ICsJLnN1c3BlbmQJPSB0\n" - "bXAxMDNfc3VzcGVuZCwKPiArCS5yZXN1bWUJCT0gdG1wMTAzX3Jlc3VtZSwKPiArfTsKPiArCj4g\n" - "KyNkZWZpbmUgVE1QMTAzX0RFVl9QTV9PUFMgKCZ0bXAxMDNfZGV2X3BtX29wcykKPiArI2Vsc2UK\n" - "PiArI2RlZmluZQlUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4gKyNlbmRpZiAvKiBDT05GSUdfUE0g\n" - "Ki8KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCB0bXAxMDNfaWRbXSA9\n" - "IHsKPiArCXsgInRtcDEwMyIsIDAgfSwKPiArCXsgfQo+ICt9OwoKSW4gdGhlIGJpbmRpbmdzIHlv\n" - "dSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxlIHByb3BlcnR5IGFzIDogdGksdG1wMTAzLCBidXQg\n" - "aGVyZSBvbmx5IHRtcDEwMy4KCkluc3RlYWQgb2YgdXNpbmcgdGhlIGkyY19kZXZpY2VfaWQgc3Ry\n" - "dWN0ICwgdXNlIG9mX2RldmljZV9pZCBzdHJ1Y3QgZm9yIGdpdmluZyB0aGUKY29tcGF0aWJsZSBw\n" - "cm9wZXJ0eSB2YWx1ZS4KY29tcGF0YmxlID0gIjxtYW51ZmFjdHVyZXI+LDxtb2RlbD4iCgo+ICtN\n" - "T0RVTEVfREVWSUNFX1RBQkxFKGkyYywgdG1wMTAzX2lkKTsKPiArK3N0YXRpYyBzdHJ1Y3QgaTJj\n" - "X2RyaXZlciB0bXAxMDNfZHJpdmVyID0gewo+ICsJLmRyaXZlciA9IHsKPiArCQkubmFtZQk9ICJ0\n" - "bXAxMDMiLAo+ICsJCS5wbQk9IFRNUDEwM19ERVZfUE1fT1BTLAo+ICsJfSwKPiArCS5wcm9iZQkJ\n" - "PSB0bXAxMDNfcHJvYmUsCj4gKwkuaWRfdGFibGUJPSB0bXAxMDNfaWQsCj4gK307Cj4gKwo+ICtt\n" - "b2R1bGVfaTJjX2RyaXZlcih0bXAxMDNfZHJpdmVyKTsKPiArCj4gK01PRFVMRV9BVVRIT1IoIkhl\n" - "aWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPiIpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIlRleGFz\n" - "IEluc3RydW1lbnRzIFRNUDEwMyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyIik7Cj4gK01PRFVM\n" - "RV9MSUNFTlNFKCJHUEwiKTsKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f\n" - "X19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMu\n" - "b3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNv\n" - cnM + "Hi,\n" + "\n" + "On 06/18/2014 11:07 AM, 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" + ">\n" + "> ---\n" + ">\n" + "> Cc: Jean Delvare <khali@linux-fr.org>\n" + "> Cc: Guenter Roeck <linux@roeck-us.net>\n" + "> Cc: linux-kernel@vger.kernel.org\n" + "> Cc: devicetree@vger.kernel.org\n" + "> Cc: linux-doc@vger.kernel.org\n" + "> Cc: Mark Rutland <mark.rutland@arm.com>\n" + ">\n" + "> - change for v2:\n" + "> - add comments from GuenterRoeck:\n" + "> - remove Cc from commit subject\n" + "> - add devicetree maintainer\n" + "> - move Documentation to Documentation/hwmon/tmp103\n" + "> - remove devicetree bindings from Documentation\n" + "> - add compatible string to\n" + "> \"Documentation/devicetree/bindings/i2c/trivial-devices.txt\"\n" + "> - remove CamelCase\n" + "> - fix Codingstyle issues\n" + "> - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups()\n" + "> - remove unsused define TMP103_CONFIG_RD_ONLY\n" + "> - restore config register when exit()\n" + "> - use regmap\n" + "> - changes for v3:\n" + "> again a lot of fantastic tips how to use regmap efficiently\n" + "> from Guenter Roeck:\n" + "> - get rid of \"struct tmp103\"\n" + "> - get rid of \"static const u8 tmp103_reg[]\"\n" + "> - get rid of mutex lock\n" + "> - drop config_orig entirely\n" + "> - use regmap_update_bits()\n" + "> - changes for v4:\n" + "> - add comment from Guenter Roeck:\n" + "> define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK\n" + "> separately to ensure you catch all the to-be-cleared bits.\n" + "> - changes for v5:\n" + "> add comment from Guenter Roeck:\n" + "> - use \"#define TMP103_CONF_SD TMP103_CONF_M1\"\n" + "> add comment from Mark Rutland:\n" + "> - use full string for DT compatible string matching, instead of\n" + "> DRIVER_NAME. Get rid complete of DRIVER_NAME define.\n" + ">\n" + "> .../devicetree/bindings/i2c/trivial-devices.txt | 1 +\n" + "> Documentation/hwmon/tmp103 | 28 +++\n" + "> drivers/hwmon/Kconfig | 10 +\n" + "> drivers/hwmon/Makefile | 1 +\n" + "> drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++\n" + "> 5 files changed, 245 insertions(+)\n" + "> create mode 100644 Documentation/hwmon/tmp103\n" + "> create mode 100644 drivers/hwmon/tmp103.c\n" + ">\n" + "> diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt\n" + "> index bef86e5..fc944e0 100644\n" + "> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt\n" + "> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt\n" + "> @@ -83,5 +83,6 @@ stm,m41t80\t\tM41T80 - SERIAL ACCESS RTC WITH ALARMS\n" + "> taos,tsl2550\t\tAmbient Light Sensor with SMBUS/Two Wire Serial Interface\n" + "> ti,tsc2003\t\tI2C Touch-Screen Controller\n" + "> ti,tmp102\t\tLow Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface\n" + "> +ti,tmp103\t\tLow Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface\n" + "> ti,tmp275\t\tDigital Temperature Sensor\n" + "> winbond,wpct301\t\ti2c trusted platform module (TPM)\n" + "> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103\n" + "> new file mode 100644\n" + "> index 0000000..ec00a15\n" + "> --- /dev/null\n" + "> +++ b/Documentation/hwmon/tmp103\n" + "> @@ -0,0 +1,28 @@\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" + "> +Please refer how to instantiate this driver:\n" + "> +Documentation/i2c/instantiating-devices\n" + "> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig\n" + "> index 08531a1..c882d4b 100644\n" + "> --- a/drivers/hwmon/Kconfig\n" + "> +++ b/drivers/hwmon/Kconfig\n" + "> @@ -1391,6 +1391,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 3dc0f02..cc0df1ef 100644\n" + "> --- a/drivers/hwmon/Makefile\n" + "> +++ b/drivers/hwmon/Makefile\n" + "> @@ -135,6 +135,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..e69dbca\n" + "> --- /dev/null\n" + "> +++ b/drivers/hwmon/tmp103.c\n" + "> @@ -0,0 +1,205 @@\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" + "> +#include <linux/regmap.h>\n" + "> +\n" + "> +#define TMP103_TEMP_REG\t\t0x00\n" + "> +#define TMP103_CONF_REG\t\t0x01\n" + "> +#define TMP103_TLOW_REG\t\t0x02\n" + "> +#define TMP103_THIGH_REG\t0x03\n" + "> +\n" + "> +#define TMP103_CONF_M0\t\t0x01\n" + "> +#define TMP103_CONF_M1\t\t0x02\n" + "> +#define TMP103_CONF_LC\t\t0x04\n" + "> +#define TMP103_CONF_FL\t\t0x08\n" + "> +#define TMP103_CONF_FH\t\t0x10\n" + "> +#define TMP103_CONF_CR0\t\t0x20\n" + "> +#define TMP103_CONF_CR1\t\t0x40\n" + "> +#define TMP103_CONF_ID\t\t0x80\n" + "> +#define TMP103_CONF_SD\t\t(TMP103_CONF_M1)\n" + "> +#define TMP103_CONF_SD_MASK\t(TMP103_CONF_M0 | TMP103_CONF_M1)\n" + "> +\n" + "> +#define TMP103_CONFIG\t\t(TMP103_CONF_CR1 | TMP103_CONF_M1)\n" + "> +#define TMP103_CONFIG_MASK\t(TMP103_CONF_CR0 | TMP103_CONF_CR1 | \\\n" + "> +\t\t\t\t TMP103_CONF_M0 | TMP103_CONF_M1)\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 DIV_ROUND_CLOSEST(val, 1000);\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 regmap *regmap = dev_get_drvdata(dev);\n" + "> +\tunsigned int regval;\n" + "> +\tint ret;\n" + "> +\n" + "> +\tret = regmap_read(regmap, sda->index, ®val);\n" + "> +\tif (ret < 0)\n" + "> +\t\treturn ret;\n" + "> +\n" + "> +\treturn sprintf(buf, \"%d\\n\", tmp103_reg_to_mc(regval));\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 regmap *regmap = dev_get_drvdata(dev);\n" + "> +\tlong val;\n" + "> +\tint ret;\n" + "> +\n" + "> +\tif (kstrtol(buf, 10, &val) < 0)\n" + "> +\t\treturn -EINVAL;\n" + "> +\n" + "> +\tval = clamp_val(val, -55000, 127000);\n" + "> +\tret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val));\n" + "> +\treturn ret ? ret : count;\n" + "> +}\n" + "> +\n" + "> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL ,\n" + "> +\t\t\t TMP103_TEMP_REG);\n" + "> +\n" + "> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + "> +\t\t\t tmp103_set_temp, TMP103_TLOW_REG);\n" + "> +\n" + "> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + "> +\t\t\t tmp103_set_temp, TMP103_THIGH_REG);\n" + "> +\n" + "> +static struct attribute *tmp103_attrs[] = {\n" + "> +\t&sensor_dev_attr_temp1_input.dev_attr.attr,\n" + "> +\t&sensor_dev_attr_temp1_min.dev_attr.attr,\n" + "> +\t&sensor_dev_attr_temp1_max.dev_attr.attr,\n" + "> +\tNULL\n" + "> +};\n" + "> +ATTRIBUTE_GROUPS(tmp103);\n" + "> +\n" + "> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg)\n" + "> +{\n" + "> +\treturn reg == TMP103_TEMP_REG;\n" + "> +}\n" + "> +\n" + "> +static struct regmap_config tmp103_regmap_config = {\n" + "> +\t.reg_bits = 8,\n" + "> +\t.val_bits = 8,\n" + "> +\t.max_register = TMP103_THIGH_REG,\n" + "> +\t.volatile_reg = tmp103_regmap_is_volatile,\n" + "> +};\n" + "> +\n" + "> +static int tmp103_probe(struct i2c_client *client,\n" + "> +\t\t\tconst struct i2c_device_id *id)\n" + "> +{\n" + "> +\tstruct device *dev = &client->dev;\n" + "> +\tstruct device *hwmon_dev;\n" + "> +\tstruct regmap *regmap;\n" + "> +\tint ret;\n" + "> +\n" + "> +\tif (!i2c_check_functionality(client->adapter,\n" + "> +\t\t\t\t I2C_FUNC_SMBUS_BYTE_DATA)) {\n" + "> +\t\tdev_err(&client->dev,\n" + "> +\t\t\t\"adapter doesn't support SMBus byte transactions\\n\");\n" + "> +\t\treturn -ENODEV;\n" + "> +\t}\n" + "> +\n" + "> +\tregmap = devm_regmap_init_i2c(client, &tmp103_regmap_config);\n" + "> +\tif (IS_ERR(regmap)) {\n" + "> +\t\tdev_err(dev, \"failed to allocate register map\\n\");\n" + "> +\t\treturn PTR_ERR(regmap);\n" + "> +\t}\n" + "> +\n" + "> +\tret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK,\n" + "> +\t\t\t\t TMP103_CONFIG);\n" + "> +\tif (ret < 0) {\n" + "> +\t\tdev_err(&client->dev, \"error writing config register\\n\");\n" + "> +\t\treturn ret;\n" + "> +\t}\n" + "> +\n" + "> +\thwmon_dev = hwmon_device_register_with_groups(dev, client->name,\n" + "> +\t\t\t\t\t\t regmap, tmp103_groups);\n" + "> +\treturn PTR_ERR_OR_ZERO(hwmon_dev);\n" + "> +}\n" + "> +\n" + "> +#ifdef CONFIG_PM\n" + "> +static int tmp103_suspend(struct device *dev)\n" + "> +{\n" + "> +\tstruct regmap *regmap = dev_get_drvdata(dev);\n" + "> +\n" + "> +\treturn regmap_update_bits(regmap, TMP103_CONF_REG,\n" + "> +\t\t\t\t TMP103_CONF_SD_MASK, 0);\n" + "> +}\n" + "> +\n" + "> +static int tmp103_resume(struct device *dev)\n" + "> +{\n" + "> +\tstruct regmap *regmap = dev_get_drvdata(dev);\n" + "> +\n" + "> +\treturn regmap_update_bits(regmap, TMP103_CONF_REG,\n" + "> +\t\t\t\t TMP103_CONF_SD_MASK, TMP103_CONF_SD);\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{ \"tmp103\", 0 },\n" + "> +\t{ }\n" + "> +};\n" + "\n" + "In the bindings you are giving the compatible property as : ti,tmp103, but here only tmp103.\n" + "\n" + "Instead of using the i2c_device_id struct , use of_device_id struct for giving the\n" + "compatible property value.\n" + "compatble = \"<manufacturer>,<model>\"\n" + "\n" + "> +MODULE_DEVICE_TABLE(i2c, tmp103_id);\n" + "> ++static struct i2c_driver tmp103_driver = {\n" + "> +\t.driver = {\n" + "> +\t\t.name\t= \"tmp103\",\n" + "> +\t\t.pm\t= TMP103_DEV_PM_OPS,\n" + "> +\t},\n" + "> +\t.probe\t\t= tmp103_probe,\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\");" -9eca91dec81a9cf7d4900b4da2b2cac41758ff5ee36ea42fb0742eb6449646e0 +51d0e193dee4023e5e39787d79d1efb15c012095ed8ffcef94897dc783d045e6
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.