From mboxrd@z Thu Jan 1 00:00:00 1970 From: Heiko Schocher Date: Wed, 18 Jun 2014 06:16:50 +0000 Subject: Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor Message-Id: <53A12ED2.4080004@denx.de> List-Id: References: <1403069837-15651-1-git-send-email-hs@denx.de> <53A127BB.7090802@gmail.com> In-Reply-To: <53A127BB.7090802@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: Varka Bhadram Cc: lm-sensors@lm-sensors.org, Jean Delvare , Guenter Roeck , linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org, Mark Rutland SGVsbG8gVmFya2EsCgpBbSAxOC4wNi4yMDE0IDA3OjQ2LCBzY2hyaWViIFZhcmthIEJoYWRyYW06 Cj4gSGksCj4KPiBPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToK Pj4gRHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+Pgo+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWls YXIgdG8gdGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4gYnkgaGF2aW5n IG9ubHkgOCBiaXQgcmVnaXN0ZXJzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hl ciA8aHNAZGVueC5kZT4KPj4KPj4gLS0tCj4+Cj4+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxp bnV4LWZyLm9yZz4KPj4gQ2M6IEd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVzLm5ldD4KPj4g Q2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4gQ2M6IGRldmljZXRyZWVAdmdlci5r ZXJuZWwub3JnCj4+IENjOiBsaW51eC1kb2NAdmdlci5rZXJuZWwub3JnCj4+IENjOiBNYXJrIFJ1 dGxhbmQgPG1hcmsucnV0bGFuZEBhcm0uY29tPgo+Pgo+PiAtIGNoYW5nZSBmb3IgdjI6Cj4+IC0g YWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+PiAtIHJlbW92ZSBDYyBmcm9tIGNvbW1p dCBzdWJqZWN0Cj4+IC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5lcgo+PiAtIG1vdmUgRG9jdW1l bnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+PiAtIHJlbW92ZSBkZXZpY2V0 cmVlIGJpbmRpbmdzIGZyb20gRG9jdW1lbnRhdGlvbgo+PiAtIGFkZCBjb21wYXRpYmxlIHN0cmlu ZyB0bwo+PiAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRl dmljZXMudHh0Igo+PiAtIHJlbW92ZSBDYW1lbENhc2UKPj4gLSBmaXggQ29kaW5nc3R5bGUgaXNz dWVzCj4+IC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5kIGRldm1faHdtb25fZGV2aWNlX3JlZ2lz dGVyX3dpdGhfZ3JvdXBzKCkKPj4gLSByZW1vdmUgdW5zdXNlZCBkZWZpbmUgVE1QMTAzX0NPTkZJ R19SRF9PTkxZCj4+IC0gcmVzdG9yZSBjb25maWcgcmVnaXN0ZXIgd2hlbiBleGl0KCkKPj4gLSB1 c2UgcmVnbWFwCj4+IC0gY2hhbmdlcyBmb3IgdjM6Cj4+IGFnYWluIGEgbG90IG9mIGZhbnRhc3Rp YyB0aXBzIGhvdyB0byB1c2UgcmVnbWFwIGVmZmljaWVudGx5Cj4+IGZyb20gR3VlbnRlciBSb2Vj azoKPj4gLSBnZXQgcmlkIG9mICJzdHJ1Y3QgdG1wMTAzIgo+PiAtIGdldCByaWQgb2YgInN0YXRp YyBjb25zdCB1OCB0bXAxMDNfcmVnW10iCj4+IC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4+IC0g ZHJvcCBjb25maWdfb3JpZyBlbnRpcmVseQo+PiAtIHVzZSByZWdtYXBfdXBkYXRlX2JpdHMoKQo+ PiAtIGNoYW5nZXMgZm9yIHY0Ogo+PiAtIGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoK Pj4gZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZfU0RfTUFTSwo+PiBz ZXBhcmF0ZWx5IHRvIGVuc3VyZSB5b3UgY2F0Y2ggYWxsIHRoZSB0by1iZS1jbGVhcmVkIGJpdHMu Cj4+IC0gY2hhbmdlcyBmb3IgdjU6Cj4+IGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoK Pj4gLSB1c2UgIiNkZWZpbmUgVE1QMTAzX0NPTkZfU0QgVE1QMTAzX0NPTkZfTTEiCj4+IGFkZCBj b21tZW50IGZyb20gTWFyayBSdXRsYW5kOgo+PiAtIHVzZSBmdWxsIHN0cmluZyBmb3IgRFQgY29t cGF0aWJsZSBzdHJpbmcgbWF0Y2hpbmcsIGluc3RlYWQgb2YKPj4gRFJJVkVSX05BTUUuIEdldCBy aWQgY29tcGxldGUgb2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Pgo+PiAuLi4vZGV2aWNldHJlZS9i aW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCB8IDEgKwo+PiBEb2N1bWVudGF0aW9uL2h3 bW9uL3RtcDEwMyB8IDI4ICsrKwo+PiBkcml2ZXJzL2h3bW9uL0tjb25maWcgfCAxMCArCj4+IGRy aXZlcnMvaHdtb24vTWFrZWZpbGUgfCAxICsKPj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDIw NSArKysrKysrKysrKysrKysrKysrKysKPj4gNSBmaWxlcyBjaGFuZ2VkLCAyNDUgaW5zZXJ0aW9u cygrKQo+PiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPj4g Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4KPj4gZGlmZiAtLWdp dCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2Vz LnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZp Y2VzLnR4dAo+PiBpbmRleCBiZWY4NmU1Li5mYzk0NGUwIDEwMDY0NAo+PiAtLS0gYS9Eb2N1bWVu dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKPj4gKysr IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMu dHh0Cj4+IEBAIC04Myw1ICs4Myw2IEBAIHN0bSxtNDF0ODAgTTQxVDgwIC0gU0VSSUFMIEFDQ0VT UyBSVEMgV0lUSCBBTEFSTVMKPj4gdGFvcyx0c2wyNTUwIEFtYmllbnQgTGlnaHQgU2Vuc29yIHdp dGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQo+PiB0aSx0c2MyMDAzIEkyQyBUb3Vj aC1TY3JlZW4gQ29udHJvbGxlcgo+PiB0aSx0bXAxMDIgTG93IFBvd2VyIERpZ2l0YWwgVGVtcGVy YXR1cmUgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQo+PiArdGks dG1wMTAzIExvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3 byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPj4gdGksdG1wMjc1IERpZ2l0YWwgVGVtcGVyYXR1cmUg U2Vuc29yCj4+IHdpbmJvbmQsd3BjdDMwMSBpMmMgdHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQ TSkKPj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdtb24vdG1wMTAzIGIvRG9jdW1lbnRh dGlvbi9od21vbi90bXAxMDMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAw MC4uZWMwMGExNQo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL0RvY3VtZW50YXRpb24vaHdtb24v dG1wMTAzCj4+IEBAIC0wLDAgKzEsMjggQEAKPj4gK0tlcm5lbCBkcml2ZXIgdG1wMTAzCj4+ICs9 PT09PT09PT09PT09PT09PT09PQo+PiArCj4+ICtTdXBwb3J0ZWQgY2hpcHM6Cj4+ICsgKiBUZXhh cyBJbnN0cnVtZW50cyBUTVAxMDMKPj4gKyBQcmVmaXg6ICd0bXAxMDMnCj4+ICsgQWRkcmVzc2Vz IHNjYW5uZWQ6IG5vbmUKPj4gKyBQcm9kdWN0IGluZm8gYW5kIGRhdGFzaGVldDogaHR0cDovL3d3 dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPj4gKwo+PiArQXV0aG9yOgo+PiArIEhlaWtvIFNjaG9j aGVyIDxoc0BkZW54LmRlPgo+PiArCj4+ICtEZXNjcmlwdGlvbgo+PiArLS0tLS0tLS0tLS0KPj4g Kwo+PiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0cHV0IHRlbXBlcmF0dXJlIHNlbnNvciBp biBhIGZvdXItYmFsbAo+PiArd2FmZXIgY2hpcC1zY2FsZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRN UDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPj4gK3RlbXBlcmF0dXJlcyB0byBhIHJlc29sdXRp b24gb2YgMcKwQy4gVGhlIFRNUDEwMyBpcyBzcGVjaWZpZWQgZm9yCj4+ICtvcGVyYXRpb24gb3Zl ciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBDIHRvICsxMjXCsEMuCj4+ICsKPj4gK1Jl c29sdXRpb246IDggQml0cwo+PiArQWNjdXJhY3k6IMKxMcKwQyBUeXAgKOKAkzEwwrBDIHRvICsx MDDCsEMpCj4+ICsKPj4gK1RoZSBkcml2ZXIgcHJvdmlkZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRl cmZhY2UgZm9yIHRlbXBlcmF0dXJlcyAoc2VlCj4+ICtEb2N1bWVudGF0aW9uL2h3bW9uL3N5c2Zz LWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+PiArCj4+ICtQbGVhc2UgcmVmZXIgaG93 IHRvIGluc3RhbnRpYXRlIHRoaXMgZHJpdmVyOgo+PiArRG9jdW1lbnRhdGlvbi9pMmMvaW5zdGFu dGlhdGluZy1kZXZpY2VzCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcgYi9k cml2ZXJzL2h3bW9uL0tjb25maWcKPj4gaW5kZXggMDg1MzFhMS4uYzg4MmQ0YiAxMDA2NDQKPj4g LS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vS2NvbmZp Zwo+PiBAQCAtMTM5MSw2ICsxMzkxLDE2IEBAIGNvbmZpZyBTRU5TT1JTX1RNUDEwMgo+PiBUaGlz IGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUK Pj4gd2lsbCBiZSBjYWxsZWQgdG1wMTAyLgo+PiArY29uZmlnIFNFTlNPUlNfVE1QMTAzCj4+ICsg dHJpc3RhdGUgIlRleGFzIEluc3RydW1lbnRzIFRNUDEwMyIKPj4gKyBkZXBlbmRzIG9uIEkyQwo+ PiArIGhlbHAKPj4gKyBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgVGV4 YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4+ICsgc2Vuc29yIGNoaXBzLgo+PiArCj4+ICsgVGhpcyBk cml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuIElmIHNvLCB0aGUgbW9kdWxlCj4+ ICsgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+PiArCj4+IGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+ PiB0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBjb21wYXRpYmxlcyIKPj4g ZGVwZW5kcyBvbiBJMkMKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9k cml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+IGluZGV4IDNkYzBmMDIuLmNjMGRmMWVmIDEwMDY0NAo+ PiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vTWFr ZWZpbGUKPj4gQEAgLTEzNSw2ICsxMzUsNyBAQCBvYmotJChDT05GSUdfU0VOU09SU19TTVNDNDdN MTkyKSs9IHNtc2M0N20xOTIubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19BTUM2ODIxKSArPSBh bWM2ODIxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVEhNQzUwKSArPSB0aG1jNTAubwo+PiBv YmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpICs9IHRtcDEwMi5vCj4+ICtvYmotJChDT05GSUdf U0VOU09SU19UTVAxMDMpICs9IHRtcDEwMy5vCj4+IG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQw MSkgKz0gdG1wNDAxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIxKSArPSB0bXA0MjEu bwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UV0w0MDMwX01BREMpKz0gdHdsNDAzMC1tYWRjLWh3 bW9uLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9kcml2ZXJzL2h3 bW9uL3RtcDEwMy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLmU2 OWRiY2EKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+ IEBAIC0wLDAgKzEsMjA1IEBACj4+ICsvKgo+PiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAz IFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPj4gKyAqIENvcHlyaWdodCAoQykgMjAx NCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPj4gKyAqCj4+ICsgKiBCYXNlZCBvbjoKPj4g KyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJp dmVyCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBLaW5nIDxzZmtpbmdA ZmR3ZGMuY29tPgo+PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5 b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4+ICsgKiBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQo+ PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IKPj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u Cj4+ICsgKgo+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+PiArICogTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCj4+ICsgKiBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+PiArICoKPj4gKyAqLwo+ PiArCj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvaW5p dC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9pMmMu aD4KPj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2h3bW9u LXN5c2ZzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgv bXV0ZXguaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPj4gKyNpbmNsdWRlIDxsaW51 eC9qaWZmaWVzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4+ICsKPj4gKyNkZWZp bmUgVE1QMTAzX1RFTVBfUkVHIDB4MDAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfUkVHIDB4MDEK Pj4gKyNkZWZpbmUgVE1QMTAzX1RMT1dfUkVHIDB4MDIKPj4gKyNkZWZpbmUgVE1QMTAzX1RISUdI X1JFRyAweDAzCj4+ICsKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTTAgMHgwMQo+PiArI2RlZmlu ZSBUTVAxMDNfQ09ORl9NMSAweDAyCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0xDIDB4MDQKPj4g KyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwgMHgwOAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GSCAw eDEwCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMCAweDIwCj4+ICsjZGVmaW5lIFRNUDEwM19D T05GX0NSMSAweDQwCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0lEIDB4ODAKPj4gKyNkZWZpbmUg VE1QMTAzX0NPTkZfU0QgKFRNUDEwM19DT05GX00xKQo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9T RF9NQVNLIChUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQo+PiArCj4+ICsjZGVmaW5l IFRNUDEwM19DT05GSUcgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQo+PiArI2Rl ZmluZSBUTVAxMDNfQ09ORklHX01BU0sgKFRNUDEwM19DT05GX0NSMCB8IFRNUDEwM19DT05GX0NS MSB8IFwKPj4gKyBUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQo+PiArCj4+ICtzdGF0 aWMgaW5saW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZhbCkKPj4gK3sKPj4gKyByZXR1cm4g dmFsICogMTAwMDsKPj4gK30KPj4gKwo+PiArc3RhdGljIGlubGluZSB1OCB0bXAxMDNfbWNfdG9f cmVnKGludCB2YWwpCj4+ICt7Cj4+ICsgcmV0dXJuIERJVl9ST1VORF9DTE9TRVNUKHZhbCwgMTAw MCk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBzc2l6ZV90IHRtcDEwM19zaG93X3RlbXAoc3RydWN0 IGRldmljZSAqZGV2LAo+PiArIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+PiArIGNo YXIgKmJ1ZikKPj4gK3sKPj4gKyBzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9 IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBk ZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4gKyB1bnNpZ25lZCBpbnQgcmVndmFsOwo+PiArIGludCBy ZXQ7Cj4+ICsKPj4gKyByZXQgPSByZWdtYXBfcmVhZChyZWdtYXAsIHNkYS0+aW5kZXgsICZyZWd2 YWwpOwo+PiArIGlmIChyZXQgPCAwKQo+PiArIHJldHVybiByZXQ7Cj4+ICsKPj4gKyByZXR1cm4g c3ByaW50ZihidWYsICIlZFxuIiwgdG1wMTAzX3JlZ190b19tYyhyZWd2YWwpKTsKPj4gK30KPj4g Kwo+PiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3NldF90ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwK Pj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPj4gKyBjb25zdCBjaGFyICpidWYs IHNpemVfdCBjb3VudCkKPj4gK3sKPj4gKyBzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUg KnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdt YXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4gKyBsb25nIHZhbDsKPj4gKyBpbnQgcmV0Owo+ PiArCj4+ICsgaWYgKGtzdHJ0b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+PiArIHJldHVybiAtRUlO VkFMOwo+PiArCj4+ICsgdmFsID0gY2xhbXBfdmFsKHZhbCwgLTU1MDAwLCAxMjcwMDApOwo+PiAr IHJldCA9IHJlZ21hcF93cml0ZShyZWdtYXAsIHNkYS0+aW5kZXgsIHRtcDEwM19tY190b19yZWco dmFsKSk7Cj4+ICsgcmV0dXJuIHJldCA/IHJldCA6IGNvdW50Owo+PiArfQo+PiArCj4+ICtzdGF0 aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAxMDNfc2hvd190 ZW1wLCBOVUxMICwKPj4gKyBUTVAxMDNfVEVNUF9SRUcpOwo+PiArCj4+ICtzdGF0aWMgU0VOU09S X0RFVklDRV9BVFRSKHRlbXAxX21pbiwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEwM19zaG93X3Rl bXAsCj4+ICsgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVExPV19SRUcpOwo+PiArCj4+ICtzdGF0 aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEw M19zaG93X3RlbXAsCj4+ICsgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVEhJR0hfUkVHKTsKPj4g Kwo+PiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRtcDEwM19hdHRyc1tdID0gewo+PiArICZz ZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPj4gKyAmc2Vuc29yX2Rl dl9hdHRyX3RlbXAxX21pbi5kZXZfYXR0ci5hdHRyLAo+PiArICZzZW5zb3JfZGV2X2F0dHJfdGVt cDFfbWF4LmRldl9hdHRyLmF0dHIsCj4+ICsgTlVMTAo+PiArfTsKPj4gK0FUVFJJQlVURV9HUk9V UFModG1wMTAzKTsKPj4gKwo+PiArc3RhdGljIGJvb2wgdG1wMTAzX3JlZ21hcF9pc192b2xhdGls ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGludCByZWcpCj4+ICt7Cj4+ICsgcmV0dXJu IHJlZyA9PSBUTVAxMDNfVEVNUF9SRUc7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBzdHJ1Y3QgcmVn bWFwX2NvbmZpZyB0bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPj4gKyAucmVnX2JpdHMgPSA4LAo+ PiArIC52YWxfYml0cyA9IDgsCj4+ICsgLm1heF9yZWdpc3RlciA9IFRNUDEwM19USElHSF9SRUcs Cj4+ICsgLnZvbGF0aWxlX3JlZyA9IHRtcDEwM19yZWdtYXBfaXNfdm9sYXRpbGUsCj4+ICt9Owo+ PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50 LAo+PiArIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPj4gK3sKPj4gKyBzdHJ1Y3Qg ZGV2aWNlICpkZXYgPSAmY2xpZW50LT5kZXY7Cj4+ICsgc3RydWN0IGRldmljZSAqaHdtb25fZGV2 Owo+PiArIHN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPj4gKyBpbnQgcmV0Owo+PiArCj4+ICsgaWYg KCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0ZXIsCj4+ICsgSTJDX0ZVTkNf U01CVVNfQllURV9EQVRBKSkgewo+PiArIGRldl9lcnIoJmNsaWVudC0+ZGV2LAo+PiArICJhZGFw dGVyIGRvZXNuJ3Qgc3VwcG9ydCBTTUJ1cyBieXRlIHRyYW5zYWN0aW9uc1xuIik7Cj4+ICsgcmV0 dXJuIC1FTk9ERVY7Cj4+ICsgfQo+PiArCj4+ICsgcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9p MmMoY2xpZW50LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOwo+PiArIGlmIChJU19FUlIocmVnbWFw KSkgewo+PiArIGRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxu Iik7Cj4+ICsgcmV0dXJuIFBUUl9FUlIocmVnbWFwKTsKPj4gKyB9Cj4+ICsKPj4gKyByZXQgPSBy ZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsIFRNUDEwM19DT05GSUdf TUFTSywKPj4gKyBUTVAxMDNfQ09ORklHKTsKPj4gKyBpZiAocmV0IDwgMCkgewo+PiArIGRldl9l cnIoJmNsaWVudC0+ZGV2LCAiZXJyb3Igd3JpdGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+PiAr IHJldHVybiByZXQ7Cj4+ICsgfQo+PiArCj4+ICsgaHdtb25fZGV2ID0gaHdtb25fZGV2aWNlX3Jl Z2lzdGVyX3dpdGhfZ3JvdXBzKGRldiwgY2xpZW50LT5uYW1lLAo+PiArIHJlZ21hcCwgdG1wMTAz X2dyb3Vwcyk7Cj4+ICsgcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9kZXYpOwo+PiArfQo+ PiArCj4+ICsjaWZkZWYgQ09ORklHX1BNCj4+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0 cnVjdCBkZXZpY2UgKmRldikKPj4gK3sKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZf Z2V0X2RydmRhdGEoZGV2KTsKPj4gKwo+PiArIHJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVn bWFwLCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgVE1QMTAzX0NPTkZfU0RfTUFTSywgMCk7Cj4+ICt9 Cj4+ICsKPj4gK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ ICt7Cj4+ICsgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+ ICsKPj4gKyByZXR1cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVH LAo+PiArIFRNUDEwM19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPj4gK30KPj4gKwo+ PiArc3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+ PiArIC5zdXNwZW5kID0gdG1wMTAzX3N1c3BlbmQsCj4+ICsgLnJlc3VtZSA9IHRtcDEwM19yZXN1 bWUsCj4+ICt9Owo+PiArCj4+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rl dl9wbV9vcHMpCj4+ICsjZWxzZQo+PiArI2RlZmluZSBUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4+ ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJj X2RldmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKPj4gKyB7ICJ0bXAxMDMiLCAwIH0sCj4+ICsgeyB9 Cj4+ICt9Owo+Cj4gSW4gdGhlIGJpbmRpbmdzIHlvdSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxl IHByb3BlcnR5IGFzIDogdGksdG1wMTAzLCBidXQgaGVyZSBvbmx5IHRtcDEwMy4KPgo+IEluc3Rl YWQgb2YgdXNpbmcgdGhlIGkyY19kZXZpY2VfaWQgc3RydWN0ICwgdXNlIG9mX2RldmljZV9pZCBz dHJ1Y3QgZm9yIGdpdmluZyB0aGUKPiBjb21wYXRpYmxlIHByb3BlcnR5IHZhbHVlLgo+IGNvbXBh dGJsZSA9ICI8bWFudWZhY3R1cmVyPiw8bW9kZWw+IgoKVGhlcmUgYXJlIGEgbG90IG9mIGRyaXZl cnMgaW4gZHJpdmVycy9od21vbiB3aGljaCB1c2UgImkyY19kZXZpY2VfaWQgc3RydWN0IiwKYW5k IGZvciB0aGVtIG9ubHkgIm1vZGVsIiBpcyBuZWNlc3NhcnkgLi4uCgpBcyB0aGlzIGlzIG5vdCBh IHBsYXRmb3JtIGRyaXZlciwgSSBkbyBub3Qga25vdywgaWYgIm9mX2RldmljZV9pZCBzdHJ1Y3Qi CmlzIHBvc3NpYmxlIHRvIHVzZS4gRm9yIHRoYXQsIGl0IG11c3QgYmUgY29udmVydGVkIHRvIGEg cGxhdGZvcm0KZGV2aWNlIGRyaXZlciAuLi4KCmJ5ZSwKSGVpa28KPgo+PiArTU9EVUxFX0RFVklD RV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4+ICsrc3RhdGljIHN0cnVjdCBpMmNfZHJpdmVyIHRt cDEwM19kcml2ZXIgPSB7Cj4+ICsgLmRyaXZlciA9IHsKPj4gKyAubmFtZSA9ICJ0bXAxMDMiLAo+ PiArIC5wbSA9IFRNUDEwM19ERVZfUE1fT1BTLAo+PiArIH0sCj4+ICsgLnByb2JlID0gdG1wMTAz X3Byb2JlLAo+PiArIC5pZF90YWJsZSA9IHRtcDEwM19pZCwKPj4gK307Cj4+ICsKPj4gK21vZHVs ZV9pMmNfZHJpdmVyKHRtcDEwM19kcml2ZXIpOwo+PiArCj4+ICtNT0RVTEVfQVVUSE9SKCJIZWlr byBTY2hvY2hlciA8aHNAZGVueC5kZT4iKTsKPj4gK01PRFVMRV9ERVNDUklQVElPTigiVGV4YXMg SW5zdHJ1bWVudHMgVE1QMTAzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIiKTsKPj4gK01PRFVM RV9MSUNFTlNFKCJHUEwiKTsKPgo+Cj4KCi0tIApERU5YIFNvZnR3YXJlIEVuZ2luZWVyaW5nIEdt YkgsICAgICBNRDogV29sZmdhbmcgRGVuayAmIERldGxldiBadW5kZWwKSFJCIDE2NTIzNSBNdW5p Y2gsIE9mZmljZTogS2lyY2hlbnN0ci41LCBELTgyMTk0IEdyb2ViZW56ZWxsLCBHZXJtYW55Cgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3Jz IG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1z ZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM From mboxrd@z Thu Jan 1 00:00:00 1970 From: Heiko Schocher Subject: Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor Date: Wed, 18 Jun 2014 08:16:50 +0200 Message-ID: <53A12ED2.4080004@denx.de> References: <1403069837-15651-1-git-send-email-hs@denx.de> <53A127BB.7090802@gmail.com> Reply-To: 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: <53A127BB.7090802@gmail.com> Sender: linux-kernel-owner@vger.kernel.org To: Varka Bhadram Cc: lm-sensors@lm-sensors.org, 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 Hello Varka, Am 18.06.2014 07:46, schrieb Varka Bhadram: > 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_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.t= xt 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 Interfa= ce >> ti,tsc2003 I2C Touch-Screen Controller >> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire S= erial 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 f= or >> +operation over a temperature range of =E2=80=9340=C2=B0C to +125=C2= =B0C. >> + >> +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 (se= e >> +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)+=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 mo= dify >> + * it under the terms of the GNU General Public License as publishe= d by >> + * the Free Software Foundation; either version 2 of the License, o= r >> + * (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, N= ULL , >> + 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 = int 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_= MASK, >> + 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 f= or giving the > compatible property value. > compatble =3D "," There are a lot of drivers in drivers/hwmon which use "i2c_device_id st= ruct", and for them only "model" is necessary ... As this is not a platform driver, I do not know, if "of_device_id struc= t" is possible to use. For that, it must be converted to a platform device driver ... bye, Heiko > >> +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 dri= ver"); >> +MODULE_LICENSE("GPL"); > > > --=20 DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany