From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark Rutland Date: Tue, 17 Jun 2014 16:11:05 +0000 Subject: Re: [lm-sensors] [PATCH v4] hwmon: Driver for TI TMP103 temperature sensor Message-Id: <20140617161105.GF8930@leverpostej> List-Id: References: <1402992713-22711-1-git-send-email-hs@denx.de> In-Reply-To: <1402992713-22711-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 Cc: "lm-sensors@lm-sensors.org" , Jean Delvare , Guenter Roeck , "linux-kernel@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-doc@vger.kernel.org" T24gVHVlLCBKdW4gMTcsIDIwMTQgYXQgMDk6MTE6NTNBTSArMDEwMCwgSGVpa28gU2Nob2NoZXIg d3JvdGU6Cj4gRHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+IAo+IFRoZSBUSSBUTVAxMDMgaXMg c2ltaWxhciB0byB0aGUgVE1QMTAyLiAgSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPiBieSBo YXZpbmcgb25seSA4IGJpdCByZWdpc3RlcnMuCj4gCj4gU2lnbmVkLW9mZi1ieTogSGVpa28gU2No b2NoZXIgPGhzQGRlbnguZGU+Cj4gCj4gLS0tCj4gCj4gQ2M6IEplYW4gRGVsdmFyZSA8a2hhbGlA bGludXgtZnIub3JnPgo+IENjOiBHdWVudGVyIFJvZWNrIDxsaW51eEByb2Vjay11cy5uZXQ+Cj4g Q2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPiBDYzogZGV2aWNldHJlZUB2Z2VyLmtl cm5lbC5vcmcKPiBDYzogbGludXgtZG9jQHZnZXIua2VybmVsLm9yZwo+IAo+IC0gY2hhbmdlIGZv ciB2MjoKPiAgIC0gYWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+ICAgICAtIHJlbW92 ZSBDYyBmcm9tIGNvbW1pdCBzdWJqZWN0Cj4gICAgIC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5l cgo+ICAgICAtIG1vdmUgRG9jdW1lbnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw Mwo+ICAgICAtIHJlbW92ZSBkZXZpY2V0cmVlIGJpbmRpbmdzIGZyb20gRG9jdW1lbnRhdGlvbgo+ ICAgICAtIGFkZCBjb21wYXRpYmxlIHN0cmluZyB0bwo+ICAgICAgICJEb2N1bWVudGF0aW9uL2Rl dmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQiCj4gICAgIC0gcmVtb3Zl IENhbWVsQ2FzZQo+ICAgICAtIGZpeCBDb2RpbmdzdHlsZSBpc3N1ZXMKPiAgICAgLSB1c2UgQVRU UklCVVRFX0dST1VQUyBhbmQgZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMo KQo+ICAgICAtIHJlbW92ZSB1bnN1c2VkIGRlZmluZSBUTVAxMDNfQ09ORklHX1JEX09OTFkKPiAg ICAgLSByZXN0b3JlIGNvbmZpZyByZWdpc3RlciB3aGVuIGV4aXQoKQo+ICAgICAtIHVzZSByZWdt YXAKPiAtIGNoYW5nZXMgZm9yIHYzOgo+ICAgYWdhaW4gYSBsb3Qgb2YgZmFudGFzdGljIHRpcHMg aG93IHRvIHVzZSByZWdtYXAgZWZmaWNpZW50bHkKPiAgIGZyb20gR3VlbnRlciBSb2VjazoKPiAg IC0gZ2V0IHJpZCBvZiAic3RydWN0IHRtcDEwMyIKPiAgIC0gZ2V0IHJpZCBvZiAic3RhdGljIGNv bnN0IHU4IHRtcDEwM19yZWdbXSIKPiAgIC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4gICAtIGRy b3AgY29uZmlnX29yaWcgZW50aXJlbHkKPiAgIC0gdXNlIHJlZ21hcF91cGRhdGVfYml0cygpCj4g LSBjaGFuZ2VzIGZvciB2NDoKPiAgIC0gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ ICAgICBkZWZpbmUgVE1QMTAzX0NPTkZJR19NQVNLIGFuZCBUTVAxMDNfQ09ORl9TRF9NQVNLCj4g ICAgIHNlcGFyYXRlbHkgdG8gZW5zdXJlIHlvdSBjYXRjaCBhbGwgdGhlIHRvLWJlLWNsZWFyZWQg Yml0cy4KPiAKPiAgLi4uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50 eHQgICAgfCAgIDEgKwo+ICBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMyAgICAgICAgICAgICAg ICAgICAgICAgICB8ICAyOCArKysKPiAgZHJpdmVycy9od21vbi9LY29uZmlnICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfCAgMTAgKwo+ICBkcml2ZXJzL2h3bW9uL01ha2VmaWxlICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMvaHdtb24vdG1wMTAzLmMg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjA3ICsrKysrKysrKysrKysrKysrKysrKwo+ ICA1IGZpbGVzIGNoYW5nZWQsIDI0NyBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0 NCBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9od21vbi90bXAxMDMuYwo+IAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRy ZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2Rldmlj ZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKPiBpbmRleCBiZWY4NmU1Li5m Yzk0NGUwIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9p MmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i aW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+IEBAIC04Myw1ICs4Myw2IEBAIHN0bSxt NDF0ODAJCU00MVQ4MCAtIFNFUklBTCBBQ0NFU1MgUlRDIFdJVEggQUxBUk1TCj4gIHRhb3MsdHNs MjU1MAkJQW1iaWVudCBMaWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50 ZXJmYWNlCj4gIHRpLHRzYzIwMDMJCUkyQyBUb3VjaC1TY3JlZW4gQ29udHJvbGxlcgo+ICB0aSx0 bXAxMDIJCUxvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3 byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPiArdGksdG1wMTAzCQlMb3cgUG93ZXIgRGlnaXRhbCBU ZW1wZXJhdHVyZSBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4g IHRpLHRtcDI3NQkJRGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3IKPiAgd2luYm9uZCx3cGN0MzAx CQlpMmMgdHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQTSkKPiBkaWZmIC0tZ2l0IGEvRG9jdW1l bnRhdGlvbi9od21vbi90bXAxMDMgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uZWMwMGExNQo+IC0tLSAvZGV2L251bGwK PiArKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+IEBAIC0wLDAgKzEsMjggQEAKPiAr S2VybmVsIGRyaXZlciB0bXAxMDMKPiArPT09PT09PT09PT09PT09PT09PT0KPiArCj4gK1N1cHBv cnRlZCBjaGlwczoKPiArICAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMwo+ICsgICAgUHJlZml4 OiAndG1wMTAzJwo+ICsgICAgQWRkcmVzc2VzIHNjYW5uZWQ6IG5vbmUKPiArICAgIFByb2R1Y3Qg aW5mbyBhbmQgZGF0YXNoZWV0OiBodHRwOi8vd3d3LnRpLmNvbS9wcm9kdWN0L3RtcDEwMwo+ICsK PiArQXV0aG9yOgo+ICsJSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Cj4gKwo+ICtEZXNjcmlw dGlvbgo+ICstLS0tLS0tLS0tLQo+ICsKPiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0cHV0 IHRlbXBlcmF0dXJlIHNlbnNvciBpbiBhIGZvdXItYmFsbAo+ICt3YWZlciBjaGlwLXNjYWxlIHBh Y2thZ2UgKFdDU1ApLiBUaGUgVE1QMTAzIGlzIGNhcGFibGUgb2YgcmVhZGluZwo+ICt0ZW1wZXJh dHVyZXMgdG8gYSByZXNvbHV0aW9uIG9mIDHCsEMuIFRoZSBUTVAxMDMgaXMgc3BlY2lmaWVkIGZv cgo+ICtvcGVyYXRpb24gb3ZlciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBDIHRvICsx MjXCsEMuCj4gKwo+ICtSZXNvbHV0aW9uOiA4IEJpdHMKPiArQWNjdXJhY3k6IMKxMcKwQyBUeXAg KOKAkzEwwrBDIHRvICsxMDDCsEMpCj4gKwo+ICtUaGUgZHJpdmVyIHByb3ZpZGVzIHRoZSBjb21t b24gc3lzZnMtaW50ZXJmYWNlIGZvciB0ZW1wZXJhdHVyZXMgKHNlZQo+ICtEb2N1bWVudGF0aW9u L2h3bW9uL3N5c2ZzLWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+ICsKPiArUGxlYXNl IHJlZmVyIGhvdyB0byBpbnN0YW50aWF0ZSB0aGlzIGRyaXZlcjoKPiArRG9jdW1lbnRhdGlvbi9p MmMvaW5zdGFudGlhdGluZy1kZXZpY2VzCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vS2Nv bmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IDA4NTMxYTEuLmM4ODJkNGIgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9od21vbi9L Y29uZmlnCj4gQEAgLTEzOTEsNiArMTM5MSwxNiBAQCBjb25maWcgU0VOU09SU19UTVAxMDIKPiAg CSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuICBJZiBzbywgdGhl IG1vZHVsZQo+ICAJICB3aWxsIGJlIGNhbGxlZCB0bXAxMDIuCj4gIAo+ICtjb25maWcgU0VOU09S U19UTVAxMDMKPiArCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMiCj4gKwlkZXBl bmRzIG9uIEkyQwo+ICsJaGVscAo+ICsJICBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3Vw cG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4gKwkgIHNlbnNvciBjaGlwcy4KPiAr Cj4gKwkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9kdWxlLiAgSWYgc28s IHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+ICsKPiAgY29uZmlnIFNF TlNPUlNfVE1QNDAxCj4gIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBj b21wYXRpYmxlcyIKPiAgCWRlcGVuZHMgb24gSTJDCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdt b24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4gaW5kZXggM2RjMGYwMi4uY2Mw ZGYxZWYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+ICsrKyBiL2RyaXZl cnMvaHdtb24vTWFrZWZpbGUKPiBAQCAtMTM1LDYgKzEzNSw3IEBAIG9iai0kKENPTkZJR19TRU5T T1JTX1NNU0M0N00xOTIpKz0gc21zYzQ3bTE5Mi5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX0FN QzY4MjEpCSs9IGFtYzY4MjEubwo+ICBvYmotJChDT05GSUdfU0VOU09SU19USE1DNTApCSs9IHRo bWM1MC5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDEwMikJKz0gdG1wMTAyLm8KPiArb2Jq LSQoQ09ORklHX1NFTlNPUlNfVE1QMTAzKQkrPSB0bXAxMDMubwo+ICBvYmotJChDT05GSUdfU0VO U09SU19UTVA0MDEpCSs9IHRtcDQwMS5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkJ Kz0gdG1wNDIxLm8KPiAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVFdMNDAzMF9NQURDKSs9IHR3bDQw MzAtbWFkYy1od21vbi5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9k cml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAw MDAwLi5kMTMzZDA5Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvaHdtb24vdG1wMTAz LmMKPiBAQCAtMCwwICsxLDIwNyBAQAo+ICsvKgo+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAx MDMgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZlcgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIw MTQgSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Cj4gKyAqCj4gKyAqIEJhc2VkIG9uOgo+ICsg KiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDIgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZl cgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU3RldmVuIEtpbmcgPHNma2luZ0BmZHdk Yy5jb20+Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Cj4gKyAqIHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu c2UsIG9yCj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCj4gKyAqCj4g KyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAo+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4gKyAqCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUg PGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW5pdC5oPgo+ICsjaW5jbHVkZSA8 bGludXgvc2xhYi5oPgo+ICsjaW5jbHVkZSA8bGludXgvaTJjLmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9od21vbi5oPgo+ICsjaW5jbHVkZSA8bGludXgvaHdtb24tc3lzZnMuaD4KPiArI2luY2x1ZGUg PGxpbnV4L2Vyci5oPgo+ICsjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KPiArI2luY2x1ZGUgPGxp bnV4L2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgo+ICsjaW5jbHVkZSA8 bGludXgvcmVnbWFwLmg+Cj4gKwo+ICsjZGVmaW5lCURSSVZFUl9OQU1FICJ0bXAxMDMiCj4gKwo+ ICsjZGVmaW5lIFRNUDEwM19URU1QX1JFRwkJMHgwMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX1JF RwkJMHgwMQo+ICsjZGVmaW5lIFRNUDEwM19UTE9XX1JFRwkJMHgwMgo+ICsjZGVmaW5lIFRNUDEw M19USElHSF9SRUcJMHgwMwo+ICsKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9NMAkJMHgwMQo+ICsj ZGVmaW5lIFRNUDEwM19DT05GX00xCQkweDAyCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTEMJCTB4 MDQKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9GTAkJMHgwOAo+ICsjZGVmaW5lIFRNUDEwM19DT05G X0ZICQkweDEwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwCQkweDIwCj4gKyNkZWZpbmUgVE1Q MTAzX0NPTkZfQ1IxCQkweDQwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfSUQJCTB4ODAKPiArI2Rl ZmluZSBUTVAxMDNfQ09ORl9TRAkJKFRNUDEwM19DT05GX00wIHwgVE1QMTAzX0NPTkZfTTEpCj4g KyNkZWZpbmUgVE1QMTAzX0NPTkZfU0RfTUFTSwkoVE1QMTAzX0NPTkZfTTAgfCBUTVAxMDNfQ09O Rl9NMSkKPiArCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJRwkJKFRNUDEwM19DT05GX0NSMSB8IFRN UDEwM19DT05GX00xKQo+ICsjZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSwkoVE1QMTAzX0NPTkZf Q1IwIHwgVE1QMTAzX0NPTkZfQ1IxIHwgXAo+ICsJCQkJIFRNUDEwM19DT05GX00wIHwgVE1QMTAz X0NPTkZfTTEpCj4gKwo+ICtzdGF0aWMgaW5saW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZh bCkKPiArewo+ICsJcmV0dXJuIHZhbCAqIDEwMDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbmxpbmUg dTggdG1wMTAzX21jX3RvX3JlZyhpbnQgdmFsKQo+ICt7Cj4gKwlyZXR1cm4gRElWX1JPVU5EX0NM T1NFU1QodmFsLCAxMDAwKTsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3Nob3df dGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq YXR0ciwKPiArCQkJCWNoYXIgKmJ1ZikKPiArewo+ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0 cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1Y3QgcmVnbWFw ICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCXVuc2lnbmVkIGludCByZWd2YWw7 Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IHJlZ21hcF9yZWFkKHJlZ21hcCwgc2RhLT5pbmRl eCwgJnJlZ3ZhbCk7Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJl dHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDNfcmVnX3RvX21jKHJlZ3ZhbCkpOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAoc3RydWN0IGRldmljZSAqZGV2 LAo+ICsJCQkgICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4gKwkJCSAgICAg ICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKPiArewo+ICsJc3RydWN0IHNlbnNvcl9k ZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1 Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCWxvbmcgdmFsOwo+ ICsJaW50IHJldDsKPiArCj4gKwlpZiAoa3N0cnRvbChidWYsIDEwLCAmdmFsKSA8IDApCj4gKwkJ cmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJdmFsID0gY2xhbXBfdmFsKHZhbCwgLTU1MDAwLCAxMjcw MDApOwo+ICsJcmV0ID0gcmVnbWFwX3dyaXRlKHJlZ21hcCwgc2RhLT5pbmRleCwgdG1wMTAzX21j X3RvX3JlZyh2YWwpKTsKPiArCXJldHVybiByZXQgPyByZXQgOiBjb3VudDsKPiArfQo+ICsKPiAr c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywgdG1wMTAzX3No b3dfdGVtcCwgTlVMTCAsCj4gKwkJCSAgVE1QMTAzX1RFTVBfUkVHKTsKPiArCj4gK3N0YXRpYyBT RU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWluLCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3No b3dfdGVtcCwKPiArCQkJICB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19UTE9XX1JFRyk7Cj4gKwo+ ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08s IHRtcDEwM19zaG93X3RlbXAsCj4gKwkJCSAgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVEhJR0hf UkVHKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNfYXR0cnNbXSA9IHsK PiArCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5z b3JfZGV2X2F0dHJfdGVtcDFfbWluLmRldl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRy X3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAo+ICsJTlVMTAo+ICt9Owo+ICtBVFRSSUJVVEVfR1JP VVBTKHRtcDEwMyk7Cj4gKwo+ICtzdGF0aWMgYm9vbCB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxl KHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHJlZykKPiArewo+ICsJcmV0dXJuIHJl ZyA9PSBUTVAxMDNfVEVNUF9SRUc7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcmVnbWFwX2Nv bmZpZyB0bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPiArCS5yZWdfYml0cyA9IDgsCj4gKwkudmFs X2JpdHMgPSA4LAo+ICsJLm1heF9yZWdpc3RlciA9IFRNUDEwM19USElHSF9SRUcsCj4gKwkudm9s YXRpbGVfcmVnID0gdG1wMTAzX3JlZ21hcF9pc192b2xhdGlsZSwKPiArfTsKPiArCj4gK3N0YXRp YyBpbnQgdG1wMTAzX3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4gKwkJCWNvbnN0 IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0g JmNsaWVudC0+ZGV2Owo+ICsJc3RydWN0IGRldmljZSAqaHdtb25fZGV2Owo+ICsJc3RydWN0IHJl Z21hcCAqcmVnbWFwOwo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAoIWkyY19jaGVja19mdW5jdGlv bmFsaXR5KGNsaWVudC0+YWRhcHRlciwKPiArCQkJCSAgICAgSTJDX0ZVTkNfU01CVVNfQllURV9E QVRBKSkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LAo+ICsJCQkiYWRhcHRlciBkb2Vzbid0 IHN1cHBvcnQgU01CdXMgYnl0ZSB0cmFuc2FjdGlvbnNcbiIpOwo+ICsJCXJldHVybiAtRU5PREVW Owo+ICsJfQo+ICsKPiArCXJlZ21hcCA9IGRldm1fcmVnbWFwX2luaXRfaTJjKGNsaWVudCwgJnRt cDEwM19yZWdtYXBfY29uZmlnKTsKPiArCWlmIChJU19FUlIocmVnbWFwKSkgewo+ICsJCWRldl9l cnIoZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxuIik7Cj4gKwkJcmV0dXJu IFBUUl9FUlIocmVnbWFwKTsKPiArCX0KPiArCj4gKwlyZXQgPSByZWdtYXBfdXBkYXRlX2JpdHMo cmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsIFRNUDEwM19DT05GSUdfTUFTSywKPiArCQkJCSBUTVAx MDNfQ09ORklHKTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYs ICJlcnJvciB3cml0aW5nIGNvbmZpZyByZWdpc3RlclxuIik7Cj4gKwkJcmV0dXJuIHJldDsKPiAr CX0KPiArCj4gKwlod21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMo ZGV2LCBjbGllbnQtPm5hbWUsCj4gKwkJCQkJCSAgICAgIHJlZ21hcCwgdG1wMTAzX2dyb3Vwcyk7 Cj4gKwlyZXR1cm4gUFRSX0VSUl9PUl9aRVJPKGh3bW9uX2Rldik7Cj4gK30KPiArCj4gKyNpZmRl ZiBDT05GSUdfUE0KPiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpk ZXYpCj4gK3sKPiArCXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYp Owo+ICsKPiArCXJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9S RUcsCj4gKwkJCQkgIFRNUDEwM19DT05GX1NEX01BU0ssIDApOwo+ICt9Cj4gKwo+ICtzdGF0aWMg aW50IHRtcDEwM19yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgcmVn bWFwICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCj4gKwlyZXR1cm4gcmVnbWFw X3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVHLAo+ICsJCQkJICBUTVAxMDNfQ09O Rl9TRF9NQVNLLCBUTVAxMDNfQ09ORl9TRCk7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgZGV2X3BtX29wcyB0bXAxMDNfZGV2X3BtX29wcyA9IHsKPiArCS5zdXNwZW5kCT0gdG1wMTAz X3N1c3BlbmQsCj4gKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1bWUsCj4gK307Cj4gKwo+ICsjZGVm aW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCj4gKyNlbHNlCj4gKyNk ZWZpbmUJVE1QMTAzX0RFVl9QTV9PUFMgTlVMTAo+ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4g Kwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgdG1wMTAzX2lkW10gPSB7Cj4g Kwl7IERSSVZFUl9OQU1FLCAwIH0sCgpUaGlzIHNlZW1zIHRvIGJlIHVzZWQgZm9yIGNvbXBhdGli bGUgc3RyaW5nIG1hdGNoaW5nLiBBcyBzdWNoLCBJIHRoaW5rCml0IHdvdWxkIG1ha2UgbW9yZSBz ZW5zZSB0byBoYXZlIHRoZSBzdHJpbmcgaW4gZnVsbCBoZXJlIHNvIGFzIHRvCmRpc2NvdXJhZ2Ug aXQgZnJvbSBiZWluZyBjaGFuZ2VkIGFyYml0cmFyaWx5IGluIGZ1dHVyZS4KCk90aGVyd2lzZSwg dGhlIGR0IHBhcnQgbG9va3MgZmluZSBieSBtZS4KCkNoZWVycywKTWFyay4KCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBs aXN0CmxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3Jn L21haWxtYW4vbGlzdGluZm8vbG0tc2Vuc29ycw= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark Rutland Subject: Re: [PATCH v4] hwmon: Driver for TI TMP103 temperature sensor Date: Tue, 17 Jun 2014 17:11:05 +0100 Message-ID: <20140617161105.GF8930@leverpostej> References: <1402992713-22711-1-git-send-email-hs@denx.de> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: QUOTED-PRINTABLE Return-path: Content-Disposition: inline In-Reply-To: <1402992713-22711-1-git-send-email-hs@denx.de> Sender: linux-doc-owner@vger.kernel.org To: Heiko Schocher Cc: "lm-sensors@lm-sensors.org" , Jean Delvare , Guenter Roeck , "linux-kernel@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-doc@vger.kernel.org" List-Id: devicetree@vger.kernel.org On Tue, Jun 17, 2014 at 09:11:53AM +0100, Heiko Schocher wrote: > Driver for the TI TMP103. >=20 > The TI TMP103 is similar to the TMP102. It differs from the TMP102 > by having only 8 bit registers. >=20 > Signed-off-by: Heiko Schocher >=20 > --- >=20 > Cc: Jean Delvare > Cc: Guenter Roeck > Cc: linux-kernel@vger.kernel.org > Cc: devicetree@vger.kernel.org > Cc: linux-doc@vger.kernel.org >=20 > - 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. >=20 > .../devicetree/bindings/i2c/trivial-devices.txt | 1 + > Documentation/hwmon/tmp103 | 28 +++ > drivers/hwmon/Kconfig | 10 + > drivers/hwmon/Makefile | 1 + > drivers/hwmon/tmp103.c | 207 +++++++++++= ++++++++++ > 5 files changed, 247 insertions(+) > create mode 100644 Documentation/hwmon/tmp103 > create mode 100644 drivers/hwmon/tmp103.c >=20 > 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 Interf= ace > 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..d133d09 > --- /dev/null > +++ b/drivers/hwmon/tmp103.c > @@ -0,0 +1,207 @@ > +/* > + * 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 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) > +#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 { > + { DRIVER_NAME, 0 }, This seems to be used for compatible string matching. As such, I think it would make more sense to have the string in full here so as to discourage it from being changed arbitrarily in future. Otherwise, the dt part looks fine by me. Cheers, Mark.