diff for duplicates of <53A12ED2.4080004@denx.de> diff --git a/a/1.txt b/N1/1.txt index cf5745b..b6aa22d 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,218 +1,375 @@ -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 +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 <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>" + +There are a lot of drivers in drivers/hwmon which use "i2c_device_id struct", +and for them only "model" is necessary ... + +As this is not a platform driver, I do not know, if "of_device_id struct" +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 = { +>> + .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"); +> +> +> + +-- +DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel +HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany diff --git a/a/content_digest b/N1/content_digest index dac95a8..e84694d 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -1,8 +1,8 @@ "ref\01403069837-15651-1-git-send-email-hs@denx.de\0" "ref\053A127BB.7090802@gmail.com\0" "From\0Heiko Schocher <hs@denx.de>\0" - "Subject\0Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor\0" - "Date\0Wed, 18 Jun 2014 06:16:50 +0000\0" + "Subject\0Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor\0" + "Date\0Wed, 18 Jun 2014 08:16:50 +0200\0" "To\0Varka Bhadram <varkabhadram@gmail.com>\0" "Cc\0lm-sensors@lm-sensors.org" Jean Delvare <khali@linux-fr.org> @@ -13,223 +13,380 @@ " Mark Rutland <mark.rutland@arm.com>\0" "\00:1\0" "b\0" - "SGVsbG8gVmFya2EsCgpBbSAxOC4wNi4yMDE0IDA3OjQ2LCBzY2hyaWViIFZhcmthIEJoYWRyYW06\n" - "Cj4gSGksCj4KPiBPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToK\n" - "Pj4gRHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+Pgo+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWls\n" - "YXIgdG8gdGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4gYnkgaGF2aW5n\n" - "IG9ubHkgOCBiaXQgcmVnaXN0ZXJzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hl\n" - "ciA8aHNAZGVueC5kZT4KPj4KPj4gLS0tCj4+Cj4+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxp\n" - "bnV4LWZyLm9yZz4KPj4gQ2M6IEd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVzLm5ldD4KPj4g\n" - "Q2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4gQ2M6IGRldmljZXRyZWVAdmdlci5r\n" - "ZXJuZWwub3JnCj4+IENjOiBsaW51eC1kb2NAdmdlci5rZXJuZWwub3JnCj4+IENjOiBNYXJrIFJ1\n" - "dGxhbmQgPG1hcmsucnV0bGFuZEBhcm0uY29tPgo+Pgo+PiAtIGNoYW5nZSBmb3IgdjI6Cj4+IC0g\n" - "YWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+PiAtIHJlbW92ZSBDYyBmcm9tIGNvbW1p\n" - "dCBzdWJqZWN0Cj4+IC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5lcgo+PiAtIG1vdmUgRG9jdW1l\n" - "bnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+PiAtIHJlbW92ZSBkZXZpY2V0\n" - "cmVlIGJpbmRpbmdzIGZyb20gRG9jdW1lbnRhdGlvbgo+PiAtIGFkZCBjb21wYXRpYmxlIHN0cmlu\n" - "ZyB0bwo+PiAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRl\n" - "dmljZXMudHh0Igo+PiAtIHJlbW92ZSBDYW1lbENhc2UKPj4gLSBmaXggQ29kaW5nc3R5bGUgaXNz\n" - "dWVzCj4+IC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5kIGRldm1faHdtb25fZGV2aWNlX3JlZ2lz\n" - "dGVyX3dpdGhfZ3JvdXBzKCkKPj4gLSByZW1vdmUgdW5zdXNlZCBkZWZpbmUgVE1QMTAzX0NPTkZJ\n" - "R19SRF9PTkxZCj4+IC0gcmVzdG9yZSBjb25maWcgcmVnaXN0ZXIgd2hlbiBleGl0KCkKPj4gLSB1\n" - "c2UgcmVnbWFwCj4+IC0gY2hhbmdlcyBmb3IgdjM6Cj4+IGFnYWluIGEgbG90IG9mIGZhbnRhc3Rp\n" - "YyB0aXBzIGhvdyB0byB1c2UgcmVnbWFwIGVmZmljaWVudGx5Cj4+IGZyb20gR3VlbnRlciBSb2Vj\n" - "azoKPj4gLSBnZXQgcmlkIG9mICJzdHJ1Y3QgdG1wMTAzIgo+PiAtIGdldCByaWQgb2YgInN0YXRp\n" - "YyBjb25zdCB1OCB0bXAxMDNfcmVnW10iCj4+IC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4+IC0g\n" - "ZHJvcCBjb25maWdfb3JpZyBlbnRpcmVseQo+PiAtIHVzZSByZWdtYXBfdXBkYXRlX2JpdHMoKQo+\n" - "PiAtIGNoYW5nZXMgZm9yIHY0Ogo+PiAtIGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoK\n" - "Pj4gZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZfU0RfTUFTSwo+PiBz\n" - "ZXBhcmF0ZWx5IHRvIGVuc3VyZSB5b3UgY2F0Y2ggYWxsIHRoZSB0by1iZS1jbGVhcmVkIGJpdHMu\n" - "Cj4+IC0gY2hhbmdlcyBmb3IgdjU6Cj4+IGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoK\n" - "Pj4gLSB1c2UgIiNkZWZpbmUgVE1QMTAzX0NPTkZfU0QgVE1QMTAzX0NPTkZfTTEiCj4+IGFkZCBj\n" - "b21tZW50IGZyb20gTWFyayBSdXRsYW5kOgo+PiAtIHVzZSBmdWxsIHN0cmluZyBmb3IgRFQgY29t\n" - "cGF0aWJsZSBzdHJpbmcgbWF0Y2hpbmcsIGluc3RlYWQgb2YKPj4gRFJJVkVSX05BTUUuIEdldCBy\n" - "aWQgY29tcGxldGUgb2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Pgo+PiAuLi4vZGV2aWNldHJlZS9i\n" - "aW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCB8IDEgKwo+PiBEb2N1bWVudGF0aW9uL2h3\n" - "bW9uL3RtcDEwMyB8IDI4ICsrKwo+PiBkcml2ZXJzL2h3bW9uL0tjb25maWcgfCAxMCArCj4+IGRy\n" - "aXZlcnMvaHdtb24vTWFrZWZpbGUgfCAxICsKPj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDIw\n" - "NSArKysrKysrKysrKysrKysrKysrKysKPj4gNSBmaWxlcyBjaGFuZ2VkLCAyNDUgaW5zZXJ0aW9u\n" - "cygrKQo+PiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPj4g\n" - "Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4KPj4gZGlmZiAtLWdp\n" - "dCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2Vz\n" - "LnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZp\n" - "Y2VzLnR4dAo+PiBpbmRleCBiZWY4NmU1Li5mYzk0NGUwIDEwMDY0NAo+PiAtLS0gYS9Eb2N1bWVu\n" - "dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKPj4gKysr\n" - "IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMu\n" - "dHh0Cj4+IEBAIC04Myw1ICs4Myw2IEBAIHN0bSxtNDF0ODAgTTQxVDgwIC0gU0VSSUFMIEFDQ0VT\n" - "UyBSVEMgV0lUSCBBTEFSTVMKPj4gdGFvcyx0c2wyNTUwIEFtYmllbnQgTGlnaHQgU2Vuc29yIHdp\n" - "dGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQo+PiB0aSx0c2MyMDAzIEkyQyBUb3Vj\n" - "aC1TY3JlZW4gQ29udHJvbGxlcgo+PiB0aSx0bXAxMDIgTG93IFBvd2VyIERpZ2l0YWwgVGVtcGVy\n" - "YXR1cmUgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQo+PiArdGks\n" - "dG1wMTAzIExvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3\n" - "byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPj4gdGksdG1wMjc1IERpZ2l0YWwgVGVtcGVyYXR1cmUg\n" - "U2Vuc29yCj4+IHdpbmJvbmQsd3BjdDMwMSBpMmMgdHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQ\n" - "TSkKPj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdtb24vdG1wMTAzIGIvRG9jdW1lbnRh\n" - "dGlvbi9od21vbi90bXAxMDMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAw\n" - "MC4uZWMwMGExNQo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL0RvY3VtZW50YXRpb24vaHdtb24v\n" - "dG1wMTAzCj4+IEBAIC0wLDAgKzEsMjggQEAKPj4gK0tlcm5lbCBkcml2ZXIgdG1wMTAzCj4+ICs9\n" - "PT09PT09PT09PT09PT09PT09PQo+PiArCj4+ICtTdXBwb3J0ZWQgY2hpcHM6Cj4+ICsgKiBUZXhh\n" - "cyBJbnN0cnVtZW50cyBUTVAxMDMKPj4gKyBQcmVmaXg6ICd0bXAxMDMnCj4+ICsgQWRkcmVzc2Vz\n" - "IHNjYW5uZWQ6IG5vbmUKPj4gKyBQcm9kdWN0IGluZm8gYW5kIGRhdGFzaGVldDogaHR0cDovL3d3\n" - "dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPj4gKwo+PiArQXV0aG9yOgo+PiArIEhlaWtvIFNjaG9j\n" - "aGVyIDxoc0BkZW54LmRlPgo+PiArCj4+ICtEZXNjcmlwdGlvbgo+PiArLS0tLS0tLS0tLS0KPj4g\n" - "Kwo+PiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0cHV0IHRlbXBlcmF0dXJlIHNlbnNvciBp\n" - "biBhIGZvdXItYmFsbAo+PiArd2FmZXIgY2hpcC1zY2FsZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRN\n" - "UDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPj4gK3RlbXBlcmF0dXJlcyB0byBhIHJlc29sdXRp\n" - "b24gb2YgMcKwQy4gVGhlIFRNUDEwMyBpcyBzcGVjaWZpZWQgZm9yCj4+ICtvcGVyYXRpb24gb3Zl\n" - "ciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBDIHRvICsxMjXCsEMuCj4+ICsKPj4gK1Jl\n" - "c29sdXRpb246IDggQml0cwo+PiArQWNjdXJhY3k6IMKxMcKwQyBUeXAgKOKAkzEwwrBDIHRvICsx\n" - "MDDCsEMpCj4+ICsKPj4gK1RoZSBkcml2ZXIgcHJvdmlkZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRl\n" - "cmZhY2UgZm9yIHRlbXBlcmF0dXJlcyAoc2VlCj4+ICtEb2N1bWVudGF0aW9uL2h3bW9uL3N5c2Zz\n" - "LWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+PiArCj4+ICtQbGVhc2UgcmVmZXIgaG93\n" - "IHRvIGluc3RhbnRpYXRlIHRoaXMgZHJpdmVyOgo+PiArRG9jdW1lbnRhdGlvbi9pMmMvaW5zdGFu\n" - "dGlhdGluZy1kZXZpY2VzCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcgYi9k\n" - "cml2ZXJzL2h3bW9uL0tjb25maWcKPj4gaW5kZXggMDg1MzFhMS4uYzg4MmQ0YiAxMDA2NDQKPj4g\n" - "LS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vS2NvbmZp\n" - "Zwo+PiBAQCAtMTM5MSw2ICsxMzkxLDE2IEBAIGNvbmZpZyBTRU5TT1JTX1RNUDEwMgo+PiBUaGlz\n" - "IGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUK\n" - "Pj4gd2lsbCBiZSBjYWxsZWQgdG1wMTAyLgo+PiArY29uZmlnIFNFTlNPUlNfVE1QMTAzCj4+ICsg\n" - "dHJpc3RhdGUgIlRleGFzIEluc3RydW1lbnRzIFRNUDEwMyIKPj4gKyBkZXBlbmRzIG9uIEkyQwo+\n" - "PiArIGhlbHAKPj4gKyBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgVGV4\n" - "YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4+ICsgc2Vuc29yIGNoaXBzLgo+PiArCj4+ICsgVGhpcyBk\n" - "cml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuIElmIHNvLCB0aGUgbW9kdWxlCj4+\n" - "ICsgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+PiArCj4+IGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+\n" - "PiB0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBjb21wYXRpYmxlcyIKPj4g\n" - "ZGVwZW5kcyBvbiBJMkMKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9k\n" - "cml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+IGluZGV4IDNkYzBmMDIuLmNjMGRmMWVmIDEwMDY0NAo+\n" - "PiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vTWFr\n" - "ZWZpbGUKPj4gQEAgLTEzNSw2ICsxMzUsNyBAQCBvYmotJChDT05GSUdfU0VOU09SU19TTVNDNDdN\n" - "MTkyKSs9IHNtc2M0N20xOTIubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19BTUM2ODIxKSArPSBh\n" - "bWM2ODIxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVEhNQzUwKSArPSB0aG1jNTAubwo+PiBv\n" - "YmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpICs9IHRtcDEwMi5vCj4+ICtvYmotJChDT05GSUdf\n" - "U0VOU09SU19UTVAxMDMpICs9IHRtcDEwMy5vCj4+IG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQw\n" - "MSkgKz0gdG1wNDAxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIxKSArPSB0bXA0MjEu\n" - "bwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UV0w0MDMwX01BREMpKz0gdHdsNDAzMC1tYWRjLWh3\n" - "bW9uLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9kcml2ZXJzL2h3\n" - "bW9uL3RtcDEwMy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLmU2\n" - "OWRiY2EKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+\n" - "IEBAIC0wLDAgKzEsMjA1IEBACj4+ICsvKgo+PiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAz\n" - "IFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPj4gKyAqIENvcHlyaWdodCAoQykgMjAx\n" - "NCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPj4gKyAqCj4+ICsgKiBCYXNlZCBvbjoKPj4g\n" - "KyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJp\n" - "dmVyCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBLaW5nIDxzZmtpbmdA\n" - "ZmR3ZGMuY29tPgo+PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5\n" - "b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4+ICsgKiBpdCB1bmRlciB0aGUg\n" - "dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQo+\n" - "PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0\n" - "aGUgTGljZW5zZSwgb3IKPj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u\n" - "Cj4+ICsgKgo+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo\n" - "YXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp\n" - "dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+PiArICogTUVSQ0hBTlRBQklMSVRZ\n" - "IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCj4+ICsgKiBHTlUg\n" - "R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+PiArICoKPj4gKyAqLwo+\n" - "PiArCj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvaW5p\n" - "dC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9pMmMu\n" - "aD4KPj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2h3bW9u\n" - "LXN5c2ZzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgv\n" - "bXV0ZXguaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPj4gKyNpbmNsdWRlIDxsaW51\n" - "eC9qaWZmaWVzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4+ICsKPj4gKyNkZWZp\n" - "bmUgVE1QMTAzX1RFTVBfUkVHIDB4MDAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfUkVHIDB4MDEK\n" - "Pj4gKyNkZWZpbmUgVE1QMTAzX1RMT1dfUkVHIDB4MDIKPj4gKyNkZWZpbmUgVE1QMTAzX1RISUdI\n" - "X1JFRyAweDAzCj4+ICsKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTTAgMHgwMQo+PiArI2RlZmlu\n" - "ZSBUTVAxMDNfQ09ORl9NMSAweDAyCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0xDIDB4MDQKPj4g\n" - "KyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwgMHgwOAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GSCAw\n" - "eDEwCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMCAweDIwCj4+ICsjZGVmaW5lIFRNUDEwM19D\n" - "T05GX0NSMSAweDQwCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0lEIDB4ODAKPj4gKyNkZWZpbmUg\n" - "VE1QMTAzX0NPTkZfU0QgKFRNUDEwM19DT05GX00xKQo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9T\n" - "RF9NQVNLIChUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQo+PiArCj4+ICsjZGVmaW5l\n" - "IFRNUDEwM19DT05GSUcgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQo+PiArI2Rl\n" - "ZmluZSBUTVAxMDNfQ09ORklHX01BU0sgKFRNUDEwM19DT05GX0NSMCB8IFRNUDEwM19DT05GX0NS\n" - "MSB8IFwKPj4gKyBUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQo+PiArCj4+ICtzdGF0\n" - "aWMgaW5saW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZhbCkKPj4gK3sKPj4gKyByZXR1cm4g\n" - "dmFsICogMTAwMDsKPj4gK30KPj4gKwo+PiArc3RhdGljIGlubGluZSB1OCB0bXAxMDNfbWNfdG9f\n" - "cmVnKGludCB2YWwpCj4+ICt7Cj4+ICsgcmV0dXJuIERJVl9ST1VORF9DTE9TRVNUKHZhbCwgMTAw\n" - "MCk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBzc2l6ZV90IHRtcDEwM19zaG93X3RlbXAoc3RydWN0\n" - "IGRldmljZSAqZGV2LAo+PiArIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+PiArIGNo\n" - "YXIgKmJ1ZikKPj4gK3sKPj4gKyBzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9\n" - "IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBk\n" - "ZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4gKyB1bnNpZ25lZCBpbnQgcmVndmFsOwo+PiArIGludCBy\n" - "ZXQ7Cj4+ICsKPj4gKyByZXQgPSByZWdtYXBfcmVhZChyZWdtYXAsIHNkYS0+aW5kZXgsICZyZWd2\n" - "YWwpOwo+PiArIGlmIChyZXQgPCAwKQo+PiArIHJldHVybiByZXQ7Cj4+ICsKPj4gKyByZXR1cm4g\n" - "c3ByaW50ZihidWYsICIlZFxuIiwgdG1wMTAzX3JlZ190b19tYyhyZWd2YWwpKTsKPj4gK30KPj4g\n" - "Kwo+PiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3NldF90ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwK\n" - "Pj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPj4gKyBjb25zdCBjaGFyICpidWYs\n" - "IHNpemVfdCBjb3VudCkKPj4gK3sKPj4gKyBzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUg\n" - "KnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdt\n" - "YXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4gKyBsb25nIHZhbDsKPj4gKyBpbnQgcmV0Owo+\n" - "PiArCj4+ICsgaWYgKGtzdHJ0b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+PiArIHJldHVybiAtRUlO\n" - "VkFMOwo+PiArCj4+ICsgdmFsID0gY2xhbXBfdmFsKHZhbCwgLTU1MDAwLCAxMjcwMDApOwo+PiAr\n" - "IHJldCA9IHJlZ21hcF93cml0ZShyZWdtYXAsIHNkYS0+aW5kZXgsIHRtcDEwM19tY190b19yZWco\n" - "dmFsKSk7Cj4+ICsgcmV0dXJuIHJldCA/IHJldCA6IGNvdW50Owo+PiArfQo+PiArCj4+ICtzdGF0\n" - "aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAxMDNfc2hvd190\n" - "ZW1wLCBOVUxMICwKPj4gKyBUTVAxMDNfVEVNUF9SRUcpOwo+PiArCj4+ICtzdGF0aWMgU0VOU09S\n" - "X0RFVklDRV9BVFRSKHRlbXAxX21pbiwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEwM19zaG93X3Rl\n" - "bXAsCj4+ICsgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVExPV19SRUcpOwo+PiArCj4+ICtzdGF0\n" - "aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEw\n" - "M19zaG93X3RlbXAsCj4+ICsgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVEhJR0hfUkVHKTsKPj4g\n" - "Kwo+PiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRtcDEwM19hdHRyc1tdID0gewo+PiArICZz\n" - "ZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPj4gKyAmc2Vuc29yX2Rl\n" - "dl9hdHRyX3RlbXAxX21pbi5kZXZfYXR0ci5hdHRyLAo+PiArICZzZW5zb3JfZGV2X2F0dHJfdGVt\n" - "cDFfbWF4LmRldl9hdHRyLmF0dHIsCj4+ICsgTlVMTAo+PiArfTsKPj4gK0FUVFJJQlVURV9HUk9V\n" - "UFModG1wMTAzKTsKPj4gKwo+PiArc3RhdGljIGJvb2wgdG1wMTAzX3JlZ21hcF9pc192b2xhdGls\n" - "ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGludCByZWcpCj4+ICt7Cj4+ICsgcmV0dXJu\n" - "IHJlZyA9PSBUTVAxMDNfVEVNUF9SRUc7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBzdHJ1Y3QgcmVn\n" - "bWFwX2NvbmZpZyB0bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPj4gKyAucmVnX2JpdHMgPSA4LAo+\n" - "PiArIC52YWxfYml0cyA9IDgsCj4+ICsgLm1heF9yZWdpc3RlciA9IFRNUDEwM19USElHSF9SRUcs\n" - "Cj4+ICsgLnZvbGF0aWxlX3JlZyA9IHRtcDEwM19yZWdtYXBfaXNfdm9sYXRpbGUsCj4+ICt9Owo+\n" - "PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50\n" - "LAo+PiArIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPj4gK3sKPj4gKyBzdHJ1Y3Qg\n" - "ZGV2aWNlICpkZXYgPSAmY2xpZW50LT5kZXY7Cj4+ICsgc3RydWN0IGRldmljZSAqaHdtb25fZGV2\n" - "Owo+PiArIHN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPj4gKyBpbnQgcmV0Owo+PiArCj4+ICsgaWYg\n" - "KCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0ZXIsCj4+ICsgSTJDX0ZVTkNf\n" - "U01CVVNfQllURV9EQVRBKSkgewo+PiArIGRldl9lcnIoJmNsaWVudC0+ZGV2LAo+PiArICJhZGFw\n" - "dGVyIGRvZXNuJ3Qgc3VwcG9ydCBTTUJ1cyBieXRlIHRyYW5zYWN0aW9uc1xuIik7Cj4+ICsgcmV0\n" - "dXJuIC1FTk9ERVY7Cj4+ICsgfQo+PiArCj4+ICsgcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9p\n" - "MmMoY2xpZW50LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOwo+PiArIGlmIChJU19FUlIocmVnbWFw\n" - "KSkgewo+PiArIGRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxu\n" - "Iik7Cj4+ICsgcmV0dXJuIFBUUl9FUlIocmVnbWFwKTsKPj4gKyB9Cj4+ICsKPj4gKyByZXQgPSBy\n" - "ZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsIFRNUDEwM19DT05GSUdf\n" - "TUFTSywKPj4gKyBUTVAxMDNfQ09ORklHKTsKPj4gKyBpZiAocmV0IDwgMCkgewo+PiArIGRldl9l\n" - "cnIoJmNsaWVudC0+ZGV2LCAiZXJyb3Igd3JpdGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+PiAr\n" - "IHJldHVybiByZXQ7Cj4+ICsgfQo+PiArCj4+ICsgaHdtb25fZGV2ID0gaHdtb25fZGV2aWNlX3Jl\n" - "Z2lzdGVyX3dpdGhfZ3JvdXBzKGRldiwgY2xpZW50LT5uYW1lLAo+PiArIHJlZ21hcCwgdG1wMTAz\n" - "X2dyb3Vwcyk7Cj4+ICsgcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9kZXYpOwo+PiArfQo+\n" - "PiArCj4+ICsjaWZkZWYgQ09ORklHX1BNCj4+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0\n" - "cnVjdCBkZXZpY2UgKmRldikKPj4gK3sKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZf\n" - "Z2V0X2RydmRhdGEoZGV2KTsKPj4gKwo+PiArIHJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVn\n" - "bWFwLCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgVE1QMTAzX0NPTkZfU0RfTUFTSywgMCk7Cj4+ICt9\n" - "Cj4+ICsKPj4gK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+\n" - "ICt7Cj4+ICsgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+\n" - "ICsKPj4gKyByZXR1cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVH\n" - "LAo+PiArIFRNUDEwM19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPj4gK30KPj4gKwo+\n" - "PiArc3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+\n" - "PiArIC5zdXNwZW5kID0gdG1wMTAzX3N1c3BlbmQsCj4+ICsgLnJlc3VtZSA9IHRtcDEwM19yZXN1\n" - "bWUsCj4+ICt9Owo+PiArCj4+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rl\n" - "dl9wbV9vcHMpCj4+ICsjZWxzZQo+PiArI2RlZmluZSBUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4+\n" - "ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJj\n" - "X2RldmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKPj4gKyB7ICJ0bXAxMDMiLCAwIH0sCj4+ICsgeyB9\n" - "Cj4+ICt9Owo+Cj4gSW4gdGhlIGJpbmRpbmdzIHlvdSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxl\n" - "IHByb3BlcnR5IGFzIDogdGksdG1wMTAzLCBidXQgaGVyZSBvbmx5IHRtcDEwMy4KPgo+IEluc3Rl\n" - "YWQgb2YgdXNpbmcgdGhlIGkyY19kZXZpY2VfaWQgc3RydWN0ICwgdXNlIG9mX2RldmljZV9pZCBz\n" - "dHJ1Y3QgZm9yIGdpdmluZyB0aGUKPiBjb21wYXRpYmxlIHByb3BlcnR5IHZhbHVlLgo+IGNvbXBh\n" - "dGJsZSA9ICI8bWFudWZhY3R1cmVyPiw8bW9kZWw+IgoKVGhlcmUgYXJlIGEgbG90IG9mIGRyaXZl\n" - "cnMgaW4gZHJpdmVycy9od21vbiB3aGljaCB1c2UgImkyY19kZXZpY2VfaWQgc3RydWN0IiwKYW5k\n" - "IGZvciB0aGVtIG9ubHkgIm1vZGVsIiBpcyBuZWNlc3NhcnkgLi4uCgpBcyB0aGlzIGlzIG5vdCBh\n" - "IHBsYXRmb3JtIGRyaXZlciwgSSBkbyBub3Qga25vdywgaWYgIm9mX2RldmljZV9pZCBzdHJ1Y3Qi\n" - "CmlzIHBvc3NpYmxlIHRvIHVzZS4gRm9yIHRoYXQsIGl0IG11c3QgYmUgY29udmVydGVkIHRvIGEg\n" - "cGxhdGZvcm0KZGV2aWNlIGRyaXZlciAuLi4KCmJ5ZSwKSGVpa28KPgo+PiArTU9EVUxFX0RFVklD\n" - "RV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4+ICsrc3RhdGljIHN0cnVjdCBpMmNfZHJpdmVyIHRt\n" - "cDEwM19kcml2ZXIgPSB7Cj4+ICsgLmRyaXZlciA9IHsKPj4gKyAubmFtZSA9ICJ0bXAxMDMiLAo+\n" - "PiArIC5wbSA9IFRNUDEwM19ERVZfUE1fT1BTLAo+PiArIH0sCj4+ICsgLnByb2JlID0gdG1wMTAz\n" - "X3Byb2JlLAo+PiArIC5pZF90YWJsZSA9IHRtcDEwM19pZCwKPj4gK307Cj4+ICsKPj4gK21vZHVs\n" - "ZV9pMmNfZHJpdmVyKHRtcDEwM19kcml2ZXIpOwo+PiArCj4+ICtNT0RVTEVfQVVUSE9SKCJIZWlr\n" - "byBTY2hvY2hlciA8aHNAZGVueC5kZT4iKTsKPj4gK01PRFVMRV9ERVNDUklQVElPTigiVGV4YXMg\n" - "SW5zdHJ1bWVudHMgVE1QMTAzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIiKTsKPj4gK01PRFVM\n" - "RV9MSUNFTlNFKCJHUEwiKTsKPgo+Cj4KCi0tIApERU5YIFNvZnR3YXJlIEVuZ2luZWVyaW5nIEdt\n" - "YkgsICAgICBNRDogV29sZmdhbmcgRGVuayAmIERldGxldiBadW5kZWwKSFJCIDE2NTIzNSBNdW5p\n" - "Y2gsIE9mZmljZTogS2lyY2hlbnN0ci41LCBELTgyMTk0IEdyb2ViZW56ZWxsLCBHZXJtYW55Cgpf\n" - "X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3Jz\n" - "IG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1z\n" - ZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM + "Hello Varka,\n" + "\n" + "Am 18.06.2014 07:46, schrieb Varka Bhadram:\n" + "> 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 M41T80 - SERIAL ACCESS RTC WITH ALARMS\n" + ">> taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface\n" + ">> ti,tsc2003 I2C Touch-Screen Controller\n" + ">> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface\n" + ">> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface\n" + ">> ti,tmp275 Digital Temperature Sensor\n" + ">> winbond,wpct301 i2c 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" + ">> + Heiko 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" + ">> This driver can also be built as a module. If so, the module\n" + ">> will be called tmp102.\n" + ">> +config SENSORS_TMP103\n" + ">> + tristate \"Texas Instruments TMP103\"\n" + ">> + depends on I2C\n" + ">> + help\n" + ">> + If you say yes here you get support for Texas Instruments TMP103\n" + ">> + sensor chips.\n" + ">> +\n" + ">> + This driver can also be built as a module. If so, the module\n" + ">> + will be called tmp103.\n" + ">> +\n" + ">> config SENSORS_TMP401\n" + ">> tristate \"Texas Instruments TMP401 and compatibles\"\n" + ">> depends 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) += amc6821.o\n" + ">> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o\n" + ">> obj-$(CONFIG_SENSORS_TMP102) += tmp102.o\n" + ">> +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o\n" + ">> obj-$(CONFIG_SENSORS_TMP401) += tmp401.o\n" + ">> obj-$(CONFIG_SENSORS_TMP421) += 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 0x00\n" + ">> +#define TMP103_CONF_REG 0x01\n" + ">> +#define TMP103_TLOW_REG 0x02\n" + ">> +#define TMP103_THIGH_REG 0x03\n" + ">> +\n" + ">> +#define TMP103_CONF_M0 0x01\n" + ">> +#define TMP103_CONF_M1 0x02\n" + ">> +#define TMP103_CONF_LC 0x04\n" + ">> +#define TMP103_CONF_FL 0x08\n" + ">> +#define TMP103_CONF_FH 0x10\n" + ">> +#define TMP103_CONF_CR0 0x20\n" + ">> +#define TMP103_CONF_CR1 0x40\n" + ">> +#define TMP103_CONF_ID 0x80\n" + ">> +#define TMP103_CONF_SD (TMP103_CONF_M1)\n" + ">> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1)\n" + ">> +\n" + ">> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1)\n" + ">> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \\\n" + ">> + TMP103_CONF_M0 | TMP103_CONF_M1)\n" + ">> +\n" + ">> +static inline int tmp103_reg_to_mc(s8 val)\n" + ">> +{\n" + ">> + return val * 1000;\n" + ">> +}\n" + ">> +\n" + ">> +static inline u8 tmp103_mc_to_reg(int val)\n" + ">> +{\n" + ">> + return DIV_ROUND_CLOSEST(val, 1000);\n" + ">> +}\n" + ">> +\n" + ">> +static ssize_t tmp103_show_temp(struct device *dev,\n" + ">> + struct device_attribute *attr,\n" + ">> + char *buf)\n" + ">> +{\n" + ">> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);\n" + ">> + struct regmap *regmap = dev_get_drvdata(dev);\n" + ">> + unsigned int regval;\n" + ">> + int ret;\n" + ">> +\n" + ">> + ret = regmap_read(regmap, sda->index, ®val);\n" + ">> + if (ret < 0)\n" + ">> + return ret;\n" + ">> +\n" + ">> + return sprintf(buf, \"%d\\n\", tmp103_reg_to_mc(regval));\n" + ">> +}\n" + ">> +\n" + ">> +static ssize_t tmp103_set_temp(struct device *dev,\n" + ">> + struct device_attribute *attr,\n" + ">> + const char *buf, size_t count)\n" + ">> +{\n" + ">> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);\n" + ">> + struct regmap *regmap = dev_get_drvdata(dev);\n" + ">> + long val;\n" + ">> + int ret;\n" + ">> +\n" + ">> + if (kstrtol(buf, 10, &val) < 0)\n" + ">> + return -EINVAL;\n" + ">> +\n" + ">> + val = clamp_val(val, -55000, 127000);\n" + ">> + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val));\n" + ">> + return ret ? ret : count;\n" + ">> +}\n" + ">> +\n" + ">> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL ,\n" + ">> + TMP103_TEMP_REG);\n" + ">> +\n" + ">> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + ">> + tmp103_set_temp, TMP103_TLOW_REG);\n" + ">> +\n" + ">> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + ">> + tmp103_set_temp, TMP103_THIGH_REG);\n" + ">> +\n" + ">> +static struct attribute *tmp103_attrs[] = {\n" + ">> + &sensor_dev_attr_temp1_input.dev_attr.attr,\n" + ">> + &sensor_dev_attr_temp1_min.dev_attr.attr,\n" + ">> + &sensor_dev_attr_temp1_max.dev_attr.attr,\n" + ">> + NULL\n" + ">> +};\n" + ">> +ATTRIBUTE_GROUPS(tmp103);\n" + ">> +\n" + ">> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg)\n" + ">> +{\n" + ">> + return reg == TMP103_TEMP_REG;\n" + ">> +}\n" + ">> +\n" + ">> +static struct regmap_config tmp103_regmap_config = {\n" + ">> + .reg_bits = 8,\n" + ">> + .val_bits = 8,\n" + ">> + .max_register = TMP103_THIGH_REG,\n" + ">> + .volatile_reg = tmp103_regmap_is_volatile,\n" + ">> +};\n" + ">> +\n" + ">> +static int tmp103_probe(struct i2c_client *client,\n" + ">> + const struct i2c_device_id *id)\n" + ">> +{\n" + ">> + struct device *dev = &client->dev;\n" + ">> + struct device *hwmon_dev;\n" + ">> + struct regmap *regmap;\n" + ">> + int ret;\n" + ">> +\n" + ">> + if (!i2c_check_functionality(client->adapter,\n" + ">> + I2C_FUNC_SMBUS_BYTE_DATA)) {\n" + ">> + dev_err(&client->dev,\n" + ">> + \"adapter doesn't support SMBus byte transactions\\n\");\n" + ">> + return -ENODEV;\n" + ">> + }\n" + ">> +\n" + ">> + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config);\n" + ">> + if (IS_ERR(regmap)) {\n" + ">> + dev_err(dev, \"failed to allocate register map\\n\");\n" + ">> + return PTR_ERR(regmap);\n" + ">> + }\n" + ">> +\n" + ">> + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK,\n" + ">> + TMP103_CONFIG);\n" + ">> + if (ret < 0) {\n" + ">> + dev_err(&client->dev, \"error writing config register\\n\");\n" + ">> + return ret;\n" + ">> + }\n" + ">> +\n" + ">> + hwmon_dev = hwmon_device_register_with_groups(dev, client->name,\n" + ">> + regmap, tmp103_groups);\n" + ">> + return PTR_ERR_OR_ZERO(hwmon_dev);\n" + ">> +}\n" + ">> +\n" + ">> +#ifdef CONFIG_PM\n" + ">> +static int tmp103_suspend(struct device *dev)\n" + ">> +{\n" + ">> + struct regmap *regmap = dev_get_drvdata(dev);\n" + ">> +\n" + ">> + return regmap_update_bits(regmap, TMP103_CONF_REG,\n" + ">> + TMP103_CONF_SD_MASK, 0);\n" + ">> +}\n" + ">> +\n" + ">> +static int tmp103_resume(struct device *dev)\n" + ">> +{\n" + ">> + struct regmap *regmap = dev_get_drvdata(dev);\n" + ">> +\n" + ">> + return regmap_update_bits(regmap, TMP103_CONF_REG,\n" + ">> + TMP103_CONF_SD_MASK, TMP103_CONF_SD);\n" + ">> +}\n" + ">> +\n" + ">> +static const struct dev_pm_ops tmp103_dev_pm_ops = {\n" + ">> + .suspend = tmp103_suspend,\n" + ">> + .resume = tmp103_resume,\n" + ">> +};\n" + ">> +\n" + ">> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops)\n" + ">> +#else\n" + ">> +#define TMP103_DEV_PM_OPS NULL\n" + ">> +#endif /* CONFIG_PM */\n" + ">> +\n" + ">> +static const struct i2c_device_id tmp103_id[] = {\n" + ">> + { \"tmp103\", 0 },\n" + ">> + { }\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" + "There are a lot of drivers in drivers/hwmon which use \"i2c_device_id struct\",\n" + "and for them only \"model\" is necessary ...\n" + "\n" + "As this is not a platform driver, I do not know, if \"of_device_id struct\"\n" + "is possible to use. For that, it must be converted to a platform\n" + "device driver ...\n" + "\n" + "bye,\n" + "Heiko\n" + ">\n" + ">> +MODULE_DEVICE_TABLE(i2c, tmp103_id);\n" + ">> ++static struct i2c_driver tmp103_driver = {\n" + ">> + .driver = {\n" + ">> + .name = \"tmp103\",\n" + ">> + .pm = TMP103_DEV_PM_OPS,\n" + ">> + },\n" + ">> + .probe = tmp103_probe,\n" + ">> + .id_table = tmp103_id,\n" + ">> +};\n" + ">> +\n" + ">> +module_i2c_driver(tmp103_driver);\n" + ">> +\n" + ">> +MODULE_AUTHOR(\"Heiko Schocher <hs@denx.de>\");\n" + ">> +MODULE_DESCRIPTION(\"Texas Instruments TMP103 temperature sensor driver\");\n" + ">> +MODULE_LICENSE(\"GPL\");\n" + ">\n" + ">\n" + ">\n" + "\n" + "-- \n" + "DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel\n" + HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany -f173b08259ca921dc85f0cf3edb73bd599346d0e256dd18fab73f64995562f00 +82182152292aa909661d5436787c2046f7abb0eac08c5dad80a7bc5d92f5137e
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.