From mboxrd@z Thu Jan 1 00:00:00 1970 From: Varka Bhadram Date: Wed, 18 Jun 2014 05:58:35 +0000 Subject: Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor Message-Id: <53A127BB.7090802@gmail.com> List-Id: References: <1403069837-15651-1-git-send-email-hs@denx.de> In-Reply-To: <1403069837-15651-1-git-send-email-hs@denx.de> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: Heiko Schocher , lm-sensors@lm-sensors.org Cc: Jean Delvare , Guenter Roeck , linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org, Mark Rutland 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 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Varka Bhadram Subject: Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor Date: Wed, 18 Jun 2014 11:16:35 +0530 Message-ID: <53A127BB.7090802@gmail.com> References: <1403069837-15651-1-git-send-email-hs@denx.de> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: QUOTED-PRINTABLE Return-path: In-Reply-To: <1403069837-15651-1-git-send-email-hs@denx.de> Sender: linux-doc-owner@vger.kernel.org To: Heiko Schocher , lm-sensors@lm-sensors.org Cc: Jean Delvare , Guenter Roeck , linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org, Mark Rutland List-Id: devicetree@vger.kernel.org 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 > > --- > > Cc: Jean Delvare > Cc: Guenter Roeck > Cc: linux-kernel@vger.kernel.org > Cc: devicetree@vger.kernel.org > Cc: linux-doc@vger.kernel.org > Cc: Mark Rutland > > - 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_group= s() > - 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.tx= t 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 Inter= face > 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 > +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D > + > +Supported chips: > + * Texas Instruments TMP103 > + Prefix: 'tmp103' > + Addresses scanned: none > + Product info and datasheet: http://www.ti.com/product/tmp103 > + > +Author: > + Heiko Schocher > + > +Description > +----------- > + > +The TMP103 is a digital output temperature sensor in a four-ball > +wafer chip-scale package (WCSP). The TMP103 is capable of reading > +temperatures to a resolution of 1=C2=B0C. The TMP103 is specified fo= r > +operation over a temperature range of =E2=80=9340=C2=B0C to +125=C2=B0= C. > + > +Resolution: 8 Bits > +Accuracy: =C2=B11=C2=B0C Typ (=E2=80=9310=C2=B0C to +100=C2=B0C) > + > +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. > =20 > +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)+=3D smsc47m192.o > obj-$(CONFIG_SENSORS_AMC6821) +=3D amc6821.o > obj-$(CONFIG_SENSORS_THMC50) +=3D thmc50.o > obj-$(CONFIG_SENSORS_TMP102) +=3D tmp102.o > +obj-$(CONFIG_SENSORS_TMP103) +=3D tmp103.o > obj-$(CONFIG_SENSORS_TMP401) +=3D tmp401.o > obj-$(CONFIG_SENSORS_TMP421) +=3D tmp421.o > obj-$(CONFIG_SENSORS_TWL4030_MADC)+=3D 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 > + * > + * Based on: > + * Texas Instruments TMP102 SMBus temperature sensor driver > + * > + * Copyright (C) 2010 Steven King > + * > + * This program is free software; you can redistribute it and/or mod= ify > + * it under the terms of the GNU General Public License as published= by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#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 =3D to_sensor_dev_attr(attr); > + struct regmap *regmap =3D dev_get_drvdata(dev); > + unsigned int regval; > + int ret; > + > + ret =3D 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 =3D to_sensor_dev_attr(attr); > + struct regmap *regmap =3D dev_get_drvdata(dev); > + long val; > + int ret; > + > + if (kstrtol(buf, 10, &val) < 0) > + return -EINVAL; > + > + val =3D clamp_val(val, -55000, 127000); > + ret =3D 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, NU= LL , > + 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[] =3D { > + &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 i= nt reg) > +{ > + return reg =3D=3D TMP103_TEMP_REG; > +} > + > +static struct regmap_config tmp103_regmap_config =3D { > + .reg_bits =3D 8, > + .val_bits =3D 8, > + .max_register =3D TMP103_THIGH_REG, > + .volatile_reg =3D tmp103_regmap_is_volatile, > +}; > + > +static int tmp103_probe(struct i2c_client *client, > + const struct i2c_device_id *id) > +{ > + struct device *dev =3D &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 =3D 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 =3D regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_M= ASK, > + TMP103_CONFIG); > + if (ret < 0) { > + dev_err(&client->dev, "error writing config register\n"); > + return ret; > + } > + > + hwmon_dev =3D 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 =3D 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 =3D 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 =3D { > + .suspend =3D tmp103_suspend, > + .resume =3D 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[] =3D { > + { "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 =3D "," > +MODULE_DEVICE_TABLE(i2c, tmp103_id); > ++static struct i2c_driver tmp103_driver =3D { > + .driver =3D { > + .name =3D "tmp103", > + .pm =3D TMP103_DEV_PM_OPS, > + }, > + .probe =3D tmp103_probe, > + .id_table =3D tmp103_id, > +}; > + > +module_i2c_driver(tmp103_driver); > + > +MODULE_AUTHOR("Heiko Schocher "); > +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driv= er"); > +MODULE_LICENSE("GPL");