diff for duplicates of <20140617161105.GF8930@leverpostej> diff --git a/a/1.txt b/N1/1.txt index a2ba521..112d10b 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,198 +1,334 @@ -T24gVHVlLCBKdW4gMTcsIDIwMTQgYXQgMDk6MTE6NTNBTSArMDEwMCwgSGVpa28gU2Nob2NoZXIg -d3JvdGU6Cj4gRHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+IAo+IFRoZSBUSSBUTVAxMDMgaXMg -c2ltaWxhciB0byB0aGUgVE1QMTAyLiAgSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPiBieSBo -YXZpbmcgb25seSA4IGJpdCByZWdpc3RlcnMuCj4gCj4gU2lnbmVkLW9mZi1ieTogSGVpa28gU2No -b2NoZXIgPGhzQGRlbnguZGU+Cj4gCj4gLS0tCj4gCj4gQ2M6IEplYW4gRGVsdmFyZSA8a2hhbGlA -bGludXgtZnIub3JnPgo+IENjOiBHdWVudGVyIFJvZWNrIDxsaW51eEByb2Vjay11cy5uZXQ+Cj4g -Q2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPiBDYzogZGV2aWNldHJlZUB2Z2VyLmtl -cm5lbC5vcmcKPiBDYzogbGludXgtZG9jQHZnZXIua2VybmVsLm9yZwo+IAo+IC0gY2hhbmdlIGZv -ciB2MjoKPiAgIC0gYWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+ICAgICAtIHJlbW92 -ZSBDYyBmcm9tIGNvbW1pdCBzdWJqZWN0Cj4gICAgIC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5l -cgo+ICAgICAtIG1vdmUgRG9jdW1lbnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw -Mwo+ICAgICAtIHJlbW92ZSBkZXZpY2V0cmVlIGJpbmRpbmdzIGZyb20gRG9jdW1lbnRhdGlvbgo+ -ICAgICAtIGFkZCBjb21wYXRpYmxlIHN0cmluZyB0bwo+ICAgICAgICJEb2N1bWVudGF0aW9uL2Rl -dmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQiCj4gICAgIC0gcmVtb3Zl -IENhbWVsQ2FzZQo+ICAgICAtIGZpeCBDb2RpbmdzdHlsZSBpc3N1ZXMKPiAgICAgLSB1c2UgQVRU -UklCVVRFX0dST1VQUyBhbmQgZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMo -KQo+ICAgICAtIHJlbW92ZSB1bnN1c2VkIGRlZmluZSBUTVAxMDNfQ09ORklHX1JEX09OTFkKPiAg -ICAgLSByZXN0b3JlIGNvbmZpZyByZWdpc3RlciB3aGVuIGV4aXQoKQo+ICAgICAtIHVzZSByZWdt -YXAKPiAtIGNoYW5nZXMgZm9yIHYzOgo+ICAgYWdhaW4gYSBsb3Qgb2YgZmFudGFzdGljIHRpcHMg -aG93IHRvIHVzZSByZWdtYXAgZWZmaWNpZW50bHkKPiAgIGZyb20gR3VlbnRlciBSb2VjazoKPiAg -IC0gZ2V0IHJpZCBvZiAic3RydWN0IHRtcDEwMyIKPiAgIC0gZ2V0IHJpZCBvZiAic3RhdGljIGNv -bnN0IHU4IHRtcDEwM19yZWdbXSIKPiAgIC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4gICAtIGRy -b3AgY29uZmlnX29yaWcgZW50aXJlbHkKPiAgIC0gdXNlIHJlZ21hcF91cGRhdGVfYml0cygpCj4g -LSBjaGFuZ2VzIGZvciB2NDoKPiAgIC0gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ -ICAgICBkZWZpbmUgVE1QMTAzX0NPTkZJR19NQVNLIGFuZCBUTVAxMDNfQ09ORl9TRF9NQVNLCj4g -ICAgIHNlcGFyYXRlbHkgdG8gZW5zdXJlIHlvdSBjYXRjaCBhbGwgdGhlIHRvLWJlLWNsZWFyZWQg -Yml0cy4KPiAKPiAgLi4uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50 -eHQgICAgfCAgIDEgKwo+ICBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMyAgICAgICAgICAgICAg -ICAgICAgICAgICB8ICAyOCArKysKPiAgZHJpdmVycy9od21vbi9LY29uZmlnICAgICAgICAgICAg -ICAgICAgICAgICAgICAgICAgfCAgMTAgKwo+ICBkcml2ZXJzL2h3bW9uL01ha2VmaWxlICAgICAg -ICAgICAgICAgICAgICAgICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMvaHdtb24vdG1wMTAzLmMg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjA3ICsrKysrKysrKysrKysrKysrKysrKwo+ -ICA1IGZpbGVzIGNoYW5nZWQsIDI0NyBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0 -NCBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy -cy9od21vbi90bXAxMDMuYwo+IAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRy -ZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2Rldmlj -ZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKPiBpbmRleCBiZWY4NmU1Li5m -Yzk0NGUwIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9p -MmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i -aW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+IEBAIC04Myw1ICs4Myw2IEBAIHN0bSxt -NDF0ODAJCU00MVQ4MCAtIFNFUklBTCBBQ0NFU1MgUlRDIFdJVEggQUxBUk1TCj4gIHRhb3MsdHNs -MjU1MAkJQW1iaWVudCBMaWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50 -ZXJmYWNlCj4gIHRpLHRzYzIwMDMJCUkyQyBUb3VjaC1TY3JlZW4gQ29udHJvbGxlcgo+ICB0aSx0 -bXAxMDIJCUxvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3 -byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPiArdGksdG1wMTAzCQlMb3cgUG93ZXIgRGlnaXRhbCBU -ZW1wZXJhdHVyZSBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4g -IHRpLHRtcDI3NQkJRGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3IKPiAgd2luYm9uZCx3cGN0MzAx -CQlpMmMgdHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQTSkKPiBkaWZmIC0tZ2l0IGEvRG9jdW1l -bnRhdGlvbi9od21vbi90bXAxMDMgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+IG5ldyBm -aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uZWMwMGExNQo+IC0tLSAvZGV2L251bGwK -PiArKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+IEBAIC0wLDAgKzEsMjggQEAKPiAr -S2VybmVsIGRyaXZlciB0bXAxMDMKPiArPT09PT09PT09PT09PT09PT09PT0KPiArCj4gK1N1cHBv -cnRlZCBjaGlwczoKPiArICAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMwo+ICsgICAgUHJlZml4 -OiAndG1wMTAzJwo+ICsgICAgQWRkcmVzc2VzIHNjYW5uZWQ6IG5vbmUKPiArICAgIFByb2R1Y3Qg -aW5mbyBhbmQgZGF0YXNoZWV0OiBodHRwOi8vd3d3LnRpLmNvbS9wcm9kdWN0L3RtcDEwMwo+ICsK -PiArQXV0aG9yOgo+ICsJSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Cj4gKwo+ICtEZXNjcmlw -dGlvbgo+ICstLS0tLS0tLS0tLQo+ICsKPiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0cHV0 -IHRlbXBlcmF0dXJlIHNlbnNvciBpbiBhIGZvdXItYmFsbAo+ICt3YWZlciBjaGlwLXNjYWxlIHBh -Y2thZ2UgKFdDU1ApLiBUaGUgVE1QMTAzIGlzIGNhcGFibGUgb2YgcmVhZGluZwo+ICt0ZW1wZXJh -dHVyZXMgdG8gYSByZXNvbHV0aW9uIG9mIDHCsEMuIFRoZSBUTVAxMDMgaXMgc3BlY2lmaWVkIGZv -cgo+ICtvcGVyYXRpb24gb3ZlciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBDIHRvICsx -MjXCsEMuCj4gKwo+ICtSZXNvbHV0aW9uOiA4IEJpdHMKPiArQWNjdXJhY3k6IMKxMcKwQyBUeXAg -KOKAkzEwwrBDIHRvICsxMDDCsEMpCj4gKwo+ICtUaGUgZHJpdmVyIHByb3ZpZGVzIHRoZSBjb21t -b24gc3lzZnMtaW50ZXJmYWNlIGZvciB0ZW1wZXJhdHVyZXMgKHNlZQo+ICtEb2N1bWVudGF0aW9u -L2h3bW9uL3N5c2ZzLWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+ICsKPiArUGxlYXNl -IHJlZmVyIGhvdyB0byBpbnN0YW50aWF0ZSB0aGlzIGRyaXZlcjoKPiArRG9jdW1lbnRhdGlvbi9p -MmMvaW5zdGFudGlhdGluZy1kZXZpY2VzCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vS2Nv -bmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IDA4NTMxYTEuLmM4ODJkNGIgMTAw -NjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9od21vbi9L -Y29uZmlnCj4gQEAgLTEzOTEsNiArMTM5MSwxNiBAQCBjb25maWcgU0VOU09SU19UTVAxMDIKPiAg -CSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuICBJZiBzbywgdGhl -IG1vZHVsZQo+ICAJICB3aWxsIGJlIGNhbGxlZCB0bXAxMDIuCj4gIAo+ICtjb25maWcgU0VOU09S -U19UTVAxMDMKPiArCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMiCj4gKwlkZXBl -bmRzIG9uIEkyQwo+ICsJaGVscAo+ICsJICBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3Vw -cG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4gKwkgIHNlbnNvciBjaGlwcy4KPiAr -Cj4gKwkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9kdWxlLiAgSWYgc28s -IHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+ICsKPiAgY29uZmlnIFNF -TlNPUlNfVE1QNDAxCj4gIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBj -b21wYXRpYmxlcyIKPiAgCWRlcGVuZHMgb24gSTJDCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdt -b24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4gaW5kZXggM2RjMGYwMi4uY2Mw -ZGYxZWYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+ICsrKyBiL2RyaXZl -cnMvaHdtb24vTWFrZWZpbGUKPiBAQCAtMTM1LDYgKzEzNSw3IEBAIG9iai0kKENPTkZJR19TRU5T -T1JTX1NNU0M0N00xOTIpKz0gc21zYzQ3bTE5Mi5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX0FN -QzY4MjEpCSs9IGFtYzY4MjEubwo+ICBvYmotJChDT05GSUdfU0VOU09SU19USE1DNTApCSs9IHRo -bWM1MC5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDEwMikJKz0gdG1wMTAyLm8KPiArb2Jq -LSQoQ09ORklHX1NFTlNPUlNfVE1QMTAzKQkrPSB0bXAxMDMubwo+ICBvYmotJChDT05GSUdfU0VO -U09SU19UTVA0MDEpCSs9IHRtcDQwMS5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkJ -Kz0gdG1wNDIxLm8KPiAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVFdMNDAzMF9NQURDKSs9IHR3bDQw -MzAtbWFkYy1od21vbi5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9k -cml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAw -MDAwLi5kMTMzZDA5Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvaHdtb24vdG1wMTAz -LmMKPiBAQCAtMCwwICsxLDIwNyBAQAo+ICsvKgo+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAx -MDMgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZlcgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIw -MTQgSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Cj4gKyAqCj4gKyAqIEJhc2VkIG9uOgo+ICsg -KiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDIgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZl -cgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU3RldmVuIEtpbmcgPHNma2luZ0BmZHdk -Yy5jb20+Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu -IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBv -ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Cj4gKyAqIHRo -ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu -c2UsIG9yCj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCj4gKyAqCj4g -KyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg -YmUgdXNlZnVsLAo+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 -aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBG -T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1Ymxp -YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4gKyAqCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUg -PGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW5pdC5oPgo+ICsjaW5jbHVkZSA8 -bGludXgvc2xhYi5oPgo+ICsjaW5jbHVkZSA8bGludXgvaTJjLmg+Cj4gKyNpbmNsdWRlIDxsaW51 -eC9od21vbi5oPgo+ICsjaW5jbHVkZSA8bGludXgvaHdtb24tc3lzZnMuaD4KPiArI2luY2x1ZGUg -PGxpbnV4L2Vyci5oPgo+ICsjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KPiArI2luY2x1ZGUgPGxp -bnV4L2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgo+ICsjaW5jbHVkZSA8 -bGludXgvcmVnbWFwLmg+Cj4gKwo+ICsjZGVmaW5lCURSSVZFUl9OQU1FICJ0bXAxMDMiCj4gKwo+ -ICsjZGVmaW5lIFRNUDEwM19URU1QX1JFRwkJMHgwMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX1JF -RwkJMHgwMQo+ICsjZGVmaW5lIFRNUDEwM19UTE9XX1JFRwkJMHgwMgo+ICsjZGVmaW5lIFRNUDEw -M19USElHSF9SRUcJMHgwMwo+ICsKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9NMAkJMHgwMQo+ICsj -ZGVmaW5lIFRNUDEwM19DT05GX00xCQkweDAyCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTEMJCTB4 -MDQKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9GTAkJMHgwOAo+ICsjZGVmaW5lIFRNUDEwM19DT05G -X0ZICQkweDEwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwCQkweDIwCj4gKyNkZWZpbmUgVE1Q -MTAzX0NPTkZfQ1IxCQkweDQwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfSUQJCTB4ODAKPiArI2Rl -ZmluZSBUTVAxMDNfQ09ORl9TRAkJKFRNUDEwM19DT05GX00wIHwgVE1QMTAzX0NPTkZfTTEpCj4g -KyNkZWZpbmUgVE1QMTAzX0NPTkZfU0RfTUFTSwkoVE1QMTAzX0NPTkZfTTAgfCBUTVAxMDNfQ09O -Rl9NMSkKPiArCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJRwkJKFRNUDEwM19DT05GX0NSMSB8IFRN -UDEwM19DT05GX00xKQo+ICsjZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSwkoVE1QMTAzX0NPTkZf -Q1IwIHwgVE1QMTAzX0NPTkZfQ1IxIHwgXAo+ICsJCQkJIFRNUDEwM19DT05GX00wIHwgVE1QMTAz -X0NPTkZfTTEpCj4gKwo+ICtzdGF0aWMgaW5saW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZh -bCkKPiArewo+ICsJcmV0dXJuIHZhbCAqIDEwMDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbmxpbmUg -dTggdG1wMTAzX21jX3RvX3JlZyhpbnQgdmFsKQo+ICt7Cj4gKwlyZXR1cm4gRElWX1JPVU5EX0NM -T1NFU1QodmFsLCAxMDAwKTsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3Nob3df -dGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq -YXR0ciwKPiArCQkJCWNoYXIgKmJ1ZikKPiArewo+ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0 -cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1Y3QgcmVnbWFw -ICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCXVuc2lnbmVkIGludCByZWd2YWw7 -Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IHJlZ21hcF9yZWFkKHJlZ21hcCwgc2RhLT5pbmRl -eCwgJnJlZ3ZhbCk7Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJl -dHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDNfcmVnX3RvX21jKHJlZ3ZhbCkpOwo+ICt9 -Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAoc3RydWN0IGRldmljZSAqZGV2 -LAo+ICsJCQkgICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4gKwkJCSAgICAg -ICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKPiArewo+ICsJc3RydWN0IHNlbnNvcl9k -ZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1 -Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCWxvbmcgdmFsOwo+ -ICsJaW50IHJldDsKPiArCj4gKwlpZiAoa3N0cnRvbChidWYsIDEwLCAmdmFsKSA8IDApCj4gKwkJ -cmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJdmFsID0gY2xhbXBfdmFsKHZhbCwgLTU1MDAwLCAxMjcw -MDApOwo+ICsJcmV0ID0gcmVnbWFwX3dyaXRlKHJlZ21hcCwgc2RhLT5pbmRleCwgdG1wMTAzX21j -X3RvX3JlZyh2YWwpKTsKPiArCXJldHVybiByZXQgPyByZXQgOiBjb3VudDsKPiArfQo+ICsKPiAr -c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywgdG1wMTAzX3No -b3dfdGVtcCwgTlVMTCAsCj4gKwkJCSAgVE1QMTAzX1RFTVBfUkVHKTsKPiArCj4gK3N0YXRpYyBT -RU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWluLCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3No -b3dfdGVtcCwKPiArCQkJICB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19UTE9XX1JFRyk7Cj4gKwo+ -ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08s -IHRtcDEwM19zaG93X3RlbXAsCj4gKwkJCSAgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVEhJR0hf -UkVHKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNfYXR0cnNbXSA9IHsK -PiArCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5z -b3JfZGV2X2F0dHJfdGVtcDFfbWluLmRldl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRy -X3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAo+ICsJTlVMTAo+ICt9Owo+ICtBVFRSSUJVVEVfR1JP -VVBTKHRtcDEwMyk7Cj4gKwo+ICtzdGF0aWMgYm9vbCB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxl -KHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHJlZykKPiArewo+ICsJcmV0dXJuIHJl -ZyA9PSBUTVAxMDNfVEVNUF9SRUc7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcmVnbWFwX2Nv -bmZpZyB0bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPiArCS5yZWdfYml0cyA9IDgsCj4gKwkudmFs -X2JpdHMgPSA4LAo+ICsJLm1heF9yZWdpc3RlciA9IFRNUDEwM19USElHSF9SRUcsCj4gKwkudm9s -YXRpbGVfcmVnID0gdG1wMTAzX3JlZ21hcF9pc192b2xhdGlsZSwKPiArfTsKPiArCj4gK3N0YXRp -YyBpbnQgdG1wMTAzX3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4gKwkJCWNvbnN0 -IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0g -JmNsaWVudC0+ZGV2Owo+ICsJc3RydWN0IGRldmljZSAqaHdtb25fZGV2Owo+ICsJc3RydWN0IHJl -Z21hcCAqcmVnbWFwOwo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAoIWkyY19jaGVja19mdW5jdGlv -bmFsaXR5KGNsaWVudC0+YWRhcHRlciwKPiArCQkJCSAgICAgSTJDX0ZVTkNfU01CVVNfQllURV9E -QVRBKSkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LAo+ICsJCQkiYWRhcHRlciBkb2Vzbid0 -IHN1cHBvcnQgU01CdXMgYnl0ZSB0cmFuc2FjdGlvbnNcbiIpOwo+ICsJCXJldHVybiAtRU5PREVW -Owo+ICsJfQo+ICsKPiArCXJlZ21hcCA9IGRldm1fcmVnbWFwX2luaXRfaTJjKGNsaWVudCwgJnRt -cDEwM19yZWdtYXBfY29uZmlnKTsKPiArCWlmIChJU19FUlIocmVnbWFwKSkgewo+ICsJCWRldl9l -cnIoZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxuIik7Cj4gKwkJcmV0dXJu -IFBUUl9FUlIocmVnbWFwKTsKPiArCX0KPiArCj4gKwlyZXQgPSByZWdtYXBfdXBkYXRlX2JpdHMo -cmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsIFRNUDEwM19DT05GSUdfTUFTSywKPiArCQkJCSBUTVAx -MDNfQ09ORklHKTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYs -ICJlcnJvciB3cml0aW5nIGNvbmZpZyByZWdpc3RlclxuIik7Cj4gKwkJcmV0dXJuIHJldDsKPiAr -CX0KPiArCj4gKwlod21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMo -ZGV2LCBjbGllbnQtPm5hbWUsCj4gKwkJCQkJCSAgICAgIHJlZ21hcCwgdG1wMTAzX2dyb3Vwcyk7 -Cj4gKwlyZXR1cm4gUFRSX0VSUl9PUl9aRVJPKGh3bW9uX2Rldik7Cj4gK30KPiArCj4gKyNpZmRl -ZiBDT05GSUdfUE0KPiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpk -ZXYpCj4gK3sKPiArCXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYp -Owo+ICsKPiArCXJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9S -RUcsCj4gKwkJCQkgIFRNUDEwM19DT05GX1NEX01BU0ssIDApOwo+ICt9Cj4gKwo+ICtzdGF0aWMg -aW50IHRtcDEwM19yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgcmVn -bWFwICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCj4gKwlyZXR1cm4gcmVnbWFw -X3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVHLAo+ICsJCQkJICBUTVAxMDNfQ09O -Rl9TRF9NQVNLLCBUTVAxMDNfQ09ORl9TRCk7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 -Y3QgZGV2X3BtX29wcyB0bXAxMDNfZGV2X3BtX29wcyA9IHsKPiArCS5zdXNwZW5kCT0gdG1wMTAz -X3N1c3BlbmQsCj4gKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1bWUsCj4gK307Cj4gKwo+ICsjZGVm -aW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCj4gKyNlbHNlCj4gKyNk -ZWZpbmUJVE1QMTAzX0RFVl9QTV9PUFMgTlVMTAo+ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4g -Kwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgdG1wMTAzX2lkW10gPSB7Cj4g -Kwl7IERSSVZFUl9OQU1FLCAwIH0sCgpUaGlzIHNlZW1zIHRvIGJlIHVzZWQgZm9yIGNvbXBhdGli -bGUgc3RyaW5nIG1hdGNoaW5nLiBBcyBzdWNoLCBJIHRoaW5rCml0IHdvdWxkIG1ha2UgbW9yZSBz -ZW5zZSB0byBoYXZlIHRoZSBzdHJpbmcgaW4gZnVsbCBoZXJlIHNvIGFzIHRvCmRpc2NvdXJhZ2Ug -aXQgZnJvbSBiZWluZyBjaGFuZ2VkIGFyYml0cmFyaWx5IGluIGZ1dHVyZS4KCk90aGVyd2lzZSwg -dGhlIGR0IHBhcnQgbG9va3MgZmluZSBieSBtZS4KCkNoZWVycywKTWFyay4KCl9fX19fX19fX19f -X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBs -aXN0CmxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3Jn -L21haWxtYW4vbGlzdGluZm8vbG0tc2Vuc29ycw= +On Tue, Jun 17, 2014 at 09:11:53AM +0100, 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 +> +> - 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. +> +> .../devicetree/bindings/i2c/trivial-devices.txt | 1 + +> Documentation/hwmon/tmp103 | 28 +++ +> drivers/hwmon/Kconfig | 10 + +> drivers/hwmon/Makefile | 1 + +> drivers/hwmon/tmp103.c | 207 +++++++++++++++++++++ +> 5 files changed, 247 insertions(+) +> create mode 100644 Documentation/hwmon/tmp103 +> create mode 100644 drivers/hwmon/tmp103.c +> +> 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..d133d09 +> --- /dev/null +> +++ b/drivers/hwmon/tmp103.c +> @@ -0,0 +1,207 @@ +> +/* +> + * 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 DRIVER_NAME "tmp103" +> + +> +#define TMP103_TEMP_REG 0x00 +> +#define TMP103_CONF_REG 0x01 +> +#define TMP103_TLOW_REG 0x02 +> +#define TMP103_THIGH_REG 0x03 +> + +> +#define TMP103_CONF_M0 0x01 +> +#define TMP103_CONF_M1 0x02 +> +#define TMP103_CONF_LC 0x04 +> +#define TMP103_CONF_FL 0x08 +> +#define TMP103_CONF_FH 0x10 +> +#define TMP103_CONF_CR0 0x20 +> +#define TMP103_CONF_CR1 0x40 +> +#define TMP103_CONF_ID 0x80 +> +#define TMP103_CONF_SD (TMP103_CONF_M0 | TMP103_CONF_M1) +> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) +> + +> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) +> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ +> + TMP103_CONF_M0 | TMP103_CONF_M1) +> + +> +static inline int tmp103_reg_to_mc(s8 val) +> +{ +> + return val * 1000; +> +} +> + +> +static inline u8 tmp103_mc_to_reg(int val) +> +{ +> + return DIV_ROUND_CLOSEST(val, 1000); +> +} +> + +> +static ssize_t tmp103_show_temp(struct device *dev, +> + struct device_attribute *attr, +> + char *buf) +> +{ +> + struct sensor_device_attribute *sda = 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[] = { +> + { DRIVER_NAME, 0 }, + +This seems to be used for compatible string matching. As such, I think +it would make more sense to have the string in full here so as to +discourage it from being changed arbitrarily in future. + +Otherwise, the dt part looks fine by me. + +Cheers, +Mark. diff --git a/a/content_digest b/N1/content_digest index d44069b..3096d67 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -1,7 +1,7 @@ "ref\01402992713-22711-1-git-send-email-hs@denx.de\0" "From\0Mark Rutland <mark.rutland@arm.com>\0" - "Subject\0Re: [lm-sensors] [PATCH v4] hwmon: Driver for TI TMP103 temperature sensor\0" - "Date\0Tue, 17 Jun 2014 16:11:05 +0000\0" + "Subject\0Re: [PATCH v4] hwmon: Driver for TI TMP103 temperature sensor\0" + "Date\0Tue, 17 Jun 2014 17:11:05 +0100\0" "To\0Heiko Schocher <hs@denx.de>\0" "Cc\0lm-sensors@lm-sensors.org <lm-sensors@lm-sensors.org>" Jean Delvare <khali@linux-fr.org> @@ -11,203 +11,339 @@ " linux-doc@vger.kernel.org <linux-doc@vger.kernel.org>\0" "\00:1\0" "b\0" - "T24gVHVlLCBKdW4gMTcsIDIwMTQgYXQgMDk6MTE6NTNBTSArMDEwMCwgSGVpa28gU2Nob2NoZXIg\n" - "d3JvdGU6Cj4gRHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+IAo+IFRoZSBUSSBUTVAxMDMgaXMg\n" - "c2ltaWxhciB0byB0aGUgVE1QMTAyLiAgSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPiBieSBo\n" - "YXZpbmcgb25seSA4IGJpdCByZWdpc3RlcnMuCj4gCj4gU2lnbmVkLW9mZi1ieTogSGVpa28gU2No\n" - "b2NoZXIgPGhzQGRlbnguZGU+Cj4gCj4gLS0tCj4gCj4gQ2M6IEplYW4gRGVsdmFyZSA8a2hhbGlA\n" - "bGludXgtZnIub3JnPgo+IENjOiBHdWVudGVyIFJvZWNrIDxsaW51eEByb2Vjay11cy5uZXQ+Cj4g\n" - "Q2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPiBDYzogZGV2aWNldHJlZUB2Z2VyLmtl\n" - "cm5lbC5vcmcKPiBDYzogbGludXgtZG9jQHZnZXIua2VybmVsLm9yZwo+IAo+IC0gY2hhbmdlIGZv\n" - "ciB2MjoKPiAgIC0gYWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+ICAgICAtIHJlbW92\n" - "ZSBDYyBmcm9tIGNvbW1pdCBzdWJqZWN0Cj4gICAgIC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5l\n" - "cgo+ICAgICAtIG1vdmUgRG9jdW1lbnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw\n" - "Mwo+ICAgICAtIHJlbW92ZSBkZXZpY2V0cmVlIGJpbmRpbmdzIGZyb20gRG9jdW1lbnRhdGlvbgo+\n" - "ICAgICAtIGFkZCBjb21wYXRpYmxlIHN0cmluZyB0bwo+ICAgICAgICJEb2N1bWVudGF0aW9uL2Rl\n" - "dmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQiCj4gICAgIC0gcmVtb3Zl\n" - "IENhbWVsQ2FzZQo+ICAgICAtIGZpeCBDb2RpbmdzdHlsZSBpc3N1ZXMKPiAgICAgLSB1c2UgQVRU\n" - "UklCVVRFX0dST1VQUyBhbmQgZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMo\n" - "KQo+ICAgICAtIHJlbW92ZSB1bnN1c2VkIGRlZmluZSBUTVAxMDNfQ09ORklHX1JEX09OTFkKPiAg\n" - "ICAgLSByZXN0b3JlIGNvbmZpZyByZWdpc3RlciB3aGVuIGV4aXQoKQo+ICAgICAtIHVzZSByZWdt\n" - "YXAKPiAtIGNoYW5nZXMgZm9yIHYzOgo+ICAgYWdhaW4gYSBsb3Qgb2YgZmFudGFzdGljIHRpcHMg\n" - "aG93IHRvIHVzZSByZWdtYXAgZWZmaWNpZW50bHkKPiAgIGZyb20gR3VlbnRlciBSb2VjazoKPiAg\n" - "IC0gZ2V0IHJpZCBvZiAic3RydWN0IHRtcDEwMyIKPiAgIC0gZ2V0IHJpZCBvZiAic3RhdGljIGNv\n" - "bnN0IHU4IHRtcDEwM19yZWdbXSIKPiAgIC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4gICAtIGRy\n" - "b3AgY29uZmlnX29yaWcgZW50aXJlbHkKPiAgIC0gdXNlIHJlZ21hcF91cGRhdGVfYml0cygpCj4g\n" - "LSBjaGFuZ2VzIGZvciB2NDoKPiAgIC0gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+\n" - "ICAgICBkZWZpbmUgVE1QMTAzX0NPTkZJR19NQVNLIGFuZCBUTVAxMDNfQ09ORl9TRF9NQVNLCj4g\n" - "ICAgIHNlcGFyYXRlbHkgdG8gZW5zdXJlIHlvdSBjYXRjaCBhbGwgdGhlIHRvLWJlLWNsZWFyZWQg\n" - "Yml0cy4KPiAKPiAgLi4uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50\n" - "eHQgICAgfCAgIDEgKwo+ICBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMyAgICAgICAgICAgICAg\n" - "ICAgICAgICAgICB8ICAyOCArKysKPiAgZHJpdmVycy9od21vbi9LY29uZmlnICAgICAgICAgICAg\n" - "ICAgICAgICAgICAgICAgICAgfCAgMTAgKwo+ICBkcml2ZXJzL2h3bW9uL01ha2VmaWxlICAgICAg\n" - "ICAgICAgICAgICAgICAgICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMvaHdtb24vdG1wMTAzLmMg\n" - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjA3ICsrKysrKysrKysrKysrKysrKysrKwo+\n" - "ICA1IGZpbGVzIGNoYW5nZWQsIDI0NyBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0\n" - "NCBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy\n" - "cy9od21vbi90bXAxMDMuYwo+IAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRy\n" - "ZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2Rldmlj\n" - "ZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKPiBpbmRleCBiZWY4NmU1Li5m\n" - "Yzk0NGUwIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9p\n" - "MmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i\n" - "aW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+IEBAIC04Myw1ICs4Myw2IEBAIHN0bSxt\n" - "NDF0ODAJCU00MVQ4MCAtIFNFUklBTCBBQ0NFU1MgUlRDIFdJVEggQUxBUk1TCj4gIHRhb3MsdHNs\n" - "MjU1MAkJQW1iaWVudCBMaWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50\n" - "ZXJmYWNlCj4gIHRpLHRzYzIwMDMJCUkyQyBUb3VjaC1TY3JlZW4gQ29udHJvbGxlcgo+ICB0aSx0\n" - "bXAxMDIJCUxvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3\n" - "byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPiArdGksdG1wMTAzCQlMb3cgUG93ZXIgRGlnaXRhbCBU\n" - "ZW1wZXJhdHVyZSBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4g\n" - "IHRpLHRtcDI3NQkJRGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3IKPiAgd2luYm9uZCx3cGN0MzAx\n" - "CQlpMmMgdHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQTSkKPiBkaWZmIC0tZ2l0IGEvRG9jdW1l\n" - "bnRhdGlvbi9od21vbi90bXAxMDMgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+IG5ldyBm\n" - "aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uZWMwMGExNQo+IC0tLSAvZGV2L251bGwK\n" - "PiArKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+IEBAIC0wLDAgKzEsMjggQEAKPiAr\n" - "S2VybmVsIGRyaXZlciB0bXAxMDMKPiArPT09PT09PT09PT09PT09PT09PT0KPiArCj4gK1N1cHBv\n" - "cnRlZCBjaGlwczoKPiArICAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMwo+ICsgICAgUHJlZml4\n" - "OiAndG1wMTAzJwo+ICsgICAgQWRkcmVzc2VzIHNjYW5uZWQ6IG5vbmUKPiArICAgIFByb2R1Y3Qg\n" - "aW5mbyBhbmQgZGF0YXNoZWV0OiBodHRwOi8vd3d3LnRpLmNvbS9wcm9kdWN0L3RtcDEwMwo+ICsK\n" - "PiArQXV0aG9yOgo+ICsJSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Cj4gKwo+ICtEZXNjcmlw\n" - "dGlvbgo+ICstLS0tLS0tLS0tLQo+ICsKPiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0cHV0\n" - "IHRlbXBlcmF0dXJlIHNlbnNvciBpbiBhIGZvdXItYmFsbAo+ICt3YWZlciBjaGlwLXNjYWxlIHBh\n" - "Y2thZ2UgKFdDU1ApLiBUaGUgVE1QMTAzIGlzIGNhcGFibGUgb2YgcmVhZGluZwo+ICt0ZW1wZXJh\n" - "dHVyZXMgdG8gYSByZXNvbHV0aW9uIG9mIDHCsEMuIFRoZSBUTVAxMDMgaXMgc3BlY2lmaWVkIGZv\n" - "cgo+ICtvcGVyYXRpb24gb3ZlciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBDIHRvICsx\n" - "MjXCsEMuCj4gKwo+ICtSZXNvbHV0aW9uOiA4IEJpdHMKPiArQWNjdXJhY3k6IMKxMcKwQyBUeXAg\n" - "KOKAkzEwwrBDIHRvICsxMDDCsEMpCj4gKwo+ICtUaGUgZHJpdmVyIHByb3ZpZGVzIHRoZSBjb21t\n" - "b24gc3lzZnMtaW50ZXJmYWNlIGZvciB0ZW1wZXJhdHVyZXMgKHNlZQo+ICtEb2N1bWVudGF0aW9u\n" - "L2h3bW9uL3N5c2ZzLWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+ICsKPiArUGxlYXNl\n" - "IHJlZmVyIGhvdyB0byBpbnN0YW50aWF0ZSB0aGlzIGRyaXZlcjoKPiArRG9jdW1lbnRhdGlvbi9p\n" - "MmMvaW5zdGFudGlhdGluZy1kZXZpY2VzCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vS2Nv\n" - "bmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IDA4NTMxYTEuLmM4ODJkNGIgMTAw\n" - "NjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9od21vbi9L\n" - "Y29uZmlnCj4gQEAgLTEzOTEsNiArMTM5MSwxNiBAQCBjb25maWcgU0VOU09SU19UTVAxMDIKPiAg\n" - "CSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuICBJZiBzbywgdGhl\n" - "IG1vZHVsZQo+ICAJICB3aWxsIGJlIGNhbGxlZCB0bXAxMDIuCj4gIAo+ICtjb25maWcgU0VOU09S\n" - "U19UTVAxMDMKPiArCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMiCj4gKwlkZXBl\n" - "bmRzIG9uIEkyQwo+ICsJaGVscAo+ICsJICBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3Vw\n" - "cG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4gKwkgIHNlbnNvciBjaGlwcy4KPiAr\n" - "Cj4gKwkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9kdWxlLiAgSWYgc28s\n" - "IHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+ICsKPiAgY29uZmlnIFNF\n" - "TlNPUlNfVE1QNDAxCj4gIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBj\n" - "b21wYXRpYmxlcyIKPiAgCWRlcGVuZHMgb24gSTJDCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdt\n" - "b24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4gaW5kZXggM2RjMGYwMi4uY2Mw\n" - "ZGYxZWYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+ICsrKyBiL2RyaXZl\n" - "cnMvaHdtb24vTWFrZWZpbGUKPiBAQCAtMTM1LDYgKzEzNSw3IEBAIG9iai0kKENPTkZJR19TRU5T\n" - "T1JTX1NNU0M0N00xOTIpKz0gc21zYzQ3bTE5Mi5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX0FN\n" - "QzY4MjEpCSs9IGFtYzY4MjEubwo+ICBvYmotJChDT05GSUdfU0VOU09SU19USE1DNTApCSs9IHRo\n" - "bWM1MC5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDEwMikJKz0gdG1wMTAyLm8KPiArb2Jq\n" - "LSQoQ09ORklHX1NFTlNPUlNfVE1QMTAzKQkrPSB0bXAxMDMubwo+ICBvYmotJChDT05GSUdfU0VO\n" - "U09SU19UTVA0MDEpCSs9IHRtcDQwMS5vCj4gIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkJ\n" - "Kz0gdG1wNDIxLm8KPiAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVFdMNDAzMF9NQURDKSs9IHR3bDQw\n" - "MzAtbWFkYy1od21vbi5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9k\n" - "cml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAw\n" - "MDAwLi5kMTMzZDA5Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvaHdtb24vdG1wMTAz\n" - "LmMKPiBAQCAtMCwwICsxLDIwNyBAQAo+ICsvKgo+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAx\n" - "MDMgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZlcgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIw\n" - "MTQgSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Cj4gKyAqCj4gKyAqIEJhc2VkIG9uOgo+ICsg\n" - "KiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDIgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZl\n" - "cgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU3RldmVuIEtpbmcgPHNma2luZ0BmZHdk\n" - "Yy5jb20+Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu\n" - "IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBv\n" - "ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Cj4gKyAqIHRo\n" - "ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu\n" - "c2UsIG9yCj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCj4gKyAqCj4g\n" - "KyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg\n" - "YmUgdXNlZnVsLAo+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0\n" - "aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBG\n" - "T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1Ymxp\n" - "YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4gKyAqCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUg\n" - "PGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW5pdC5oPgo+ICsjaW5jbHVkZSA8\n" - "bGludXgvc2xhYi5oPgo+ICsjaW5jbHVkZSA8bGludXgvaTJjLmg+Cj4gKyNpbmNsdWRlIDxsaW51\n" - "eC9od21vbi5oPgo+ICsjaW5jbHVkZSA8bGludXgvaHdtb24tc3lzZnMuaD4KPiArI2luY2x1ZGUg\n" - "PGxpbnV4L2Vyci5oPgo+ICsjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KPiArI2luY2x1ZGUgPGxp\n" - "bnV4L2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgo+ICsjaW5jbHVkZSA8\n" - "bGludXgvcmVnbWFwLmg+Cj4gKwo+ICsjZGVmaW5lCURSSVZFUl9OQU1FICJ0bXAxMDMiCj4gKwo+\n" - "ICsjZGVmaW5lIFRNUDEwM19URU1QX1JFRwkJMHgwMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX1JF\n" - "RwkJMHgwMQo+ICsjZGVmaW5lIFRNUDEwM19UTE9XX1JFRwkJMHgwMgo+ICsjZGVmaW5lIFRNUDEw\n" - "M19USElHSF9SRUcJMHgwMwo+ICsKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9NMAkJMHgwMQo+ICsj\n" - "ZGVmaW5lIFRNUDEwM19DT05GX00xCQkweDAyCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTEMJCTB4\n" - "MDQKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9GTAkJMHgwOAo+ICsjZGVmaW5lIFRNUDEwM19DT05G\n" - "X0ZICQkweDEwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwCQkweDIwCj4gKyNkZWZpbmUgVE1Q\n" - "MTAzX0NPTkZfQ1IxCQkweDQwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfSUQJCTB4ODAKPiArI2Rl\n" - "ZmluZSBUTVAxMDNfQ09ORl9TRAkJKFRNUDEwM19DT05GX00wIHwgVE1QMTAzX0NPTkZfTTEpCj4g\n" - "KyNkZWZpbmUgVE1QMTAzX0NPTkZfU0RfTUFTSwkoVE1QMTAzX0NPTkZfTTAgfCBUTVAxMDNfQ09O\n" - "Rl9NMSkKPiArCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJRwkJKFRNUDEwM19DT05GX0NSMSB8IFRN\n" - "UDEwM19DT05GX00xKQo+ICsjZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSwkoVE1QMTAzX0NPTkZf\n" - "Q1IwIHwgVE1QMTAzX0NPTkZfQ1IxIHwgXAo+ICsJCQkJIFRNUDEwM19DT05GX00wIHwgVE1QMTAz\n" - "X0NPTkZfTTEpCj4gKwo+ICtzdGF0aWMgaW5saW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZh\n" - "bCkKPiArewo+ICsJcmV0dXJuIHZhbCAqIDEwMDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbmxpbmUg\n" - "dTggdG1wMTAzX21jX3RvX3JlZyhpbnQgdmFsKQo+ICt7Cj4gKwlyZXR1cm4gRElWX1JPVU5EX0NM\n" - "T1NFU1QodmFsLCAxMDAwKTsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3Nob3df\n" - "dGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq\n" - "YXR0ciwKPiArCQkJCWNoYXIgKmJ1ZikKPiArewo+ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0\n" - "cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1Y3QgcmVnbWFw\n" - "ICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCXVuc2lnbmVkIGludCByZWd2YWw7\n" - "Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IHJlZ21hcF9yZWFkKHJlZ21hcCwgc2RhLT5pbmRl\n" - "eCwgJnJlZ3ZhbCk7Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJl\n" - "dHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDNfcmVnX3RvX21jKHJlZ3ZhbCkpOwo+ICt9\n" - "Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAoc3RydWN0IGRldmljZSAqZGV2\n" - "LAo+ICsJCQkgICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4gKwkJCSAgICAg\n" - "ICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKPiArewo+ICsJc3RydWN0IHNlbnNvcl9k\n" - "ZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1\n" - "Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCWxvbmcgdmFsOwo+\n" - "ICsJaW50IHJldDsKPiArCj4gKwlpZiAoa3N0cnRvbChidWYsIDEwLCAmdmFsKSA8IDApCj4gKwkJ\n" - "cmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJdmFsID0gY2xhbXBfdmFsKHZhbCwgLTU1MDAwLCAxMjcw\n" - "MDApOwo+ICsJcmV0ID0gcmVnbWFwX3dyaXRlKHJlZ21hcCwgc2RhLT5pbmRleCwgdG1wMTAzX21j\n" - "X3RvX3JlZyh2YWwpKTsKPiArCXJldHVybiByZXQgPyByZXQgOiBjb3VudDsKPiArfQo+ICsKPiAr\n" - "c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywgdG1wMTAzX3No\n" - "b3dfdGVtcCwgTlVMTCAsCj4gKwkJCSAgVE1QMTAzX1RFTVBfUkVHKTsKPiArCj4gK3N0YXRpYyBT\n" - "RU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWluLCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3No\n" - "b3dfdGVtcCwKPiArCQkJICB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19UTE9XX1JFRyk7Cj4gKwo+\n" - "ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08s\n" - "IHRtcDEwM19zaG93X3RlbXAsCj4gKwkJCSAgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVEhJR0hf\n" - "UkVHKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNfYXR0cnNbXSA9IHsK\n" - "PiArCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5z\n" - "b3JfZGV2X2F0dHJfdGVtcDFfbWluLmRldl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRy\n" - "X3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAo+ICsJTlVMTAo+ICt9Owo+ICtBVFRSSUJVVEVfR1JP\n" - "VVBTKHRtcDEwMyk7Cj4gKwo+ICtzdGF0aWMgYm9vbCB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxl\n" - "KHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHJlZykKPiArewo+ICsJcmV0dXJuIHJl\n" - "ZyA9PSBUTVAxMDNfVEVNUF9SRUc7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcmVnbWFwX2Nv\n" - "bmZpZyB0bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPiArCS5yZWdfYml0cyA9IDgsCj4gKwkudmFs\n" - "X2JpdHMgPSA4LAo+ICsJLm1heF9yZWdpc3RlciA9IFRNUDEwM19USElHSF9SRUcsCj4gKwkudm9s\n" - "YXRpbGVfcmVnID0gdG1wMTAzX3JlZ21hcF9pc192b2xhdGlsZSwKPiArfTsKPiArCj4gK3N0YXRp\n" - "YyBpbnQgdG1wMTAzX3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4gKwkJCWNvbnN0\n" - "IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0g\n" - "JmNsaWVudC0+ZGV2Owo+ICsJc3RydWN0IGRldmljZSAqaHdtb25fZGV2Owo+ICsJc3RydWN0IHJl\n" - "Z21hcCAqcmVnbWFwOwo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAoIWkyY19jaGVja19mdW5jdGlv\n" - "bmFsaXR5KGNsaWVudC0+YWRhcHRlciwKPiArCQkJCSAgICAgSTJDX0ZVTkNfU01CVVNfQllURV9E\n" - "QVRBKSkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LAo+ICsJCQkiYWRhcHRlciBkb2Vzbid0\n" - "IHN1cHBvcnQgU01CdXMgYnl0ZSB0cmFuc2FjdGlvbnNcbiIpOwo+ICsJCXJldHVybiAtRU5PREVW\n" - "Owo+ICsJfQo+ICsKPiArCXJlZ21hcCA9IGRldm1fcmVnbWFwX2luaXRfaTJjKGNsaWVudCwgJnRt\n" - "cDEwM19yZWdtYXBfY29uZmlnKTsKPiArCWlmIChJU19FUlIocmVnbWFwKSkgewo+ICsJCWRldl9l\n" - "cnIoZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxuIik7Cj4gKwkJcmV0dXJu\n" - "IFBUUl9FUlIocmVnbWFwKTsKPiArCX0KPiArCj4gKwlyZXQgPSByZWdtYXBfdXBkYXRlX2JpdHMo\n" - "cmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsIFRNUDEwM19DT05GSUdfTUFTSywKPiArCQkJCSBUTVAx\n" - "MDNfQ09ORklHKTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYs\n" - "ICJlcnJvciB3cml0aW5nIGNvbmZpZyByZWdpc3RlclxuIik7Cj4gKwkJcmV0dXJuIHJldDsKPiAr\n" - "CX0KPiArCj4gKwlod21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMo\n" - "ZGV2LCBjbGllbnQtPm5hbWUsCj4gKwkJCQkJCSAgICAgIHJlZ21hcCwgdG1wMTAzX2dyb3Vwcyk7\n" - "Cj4gKwlyZXR1cm4gUFRSX0VSUl9PUl9aRVJPKGh3bW9uX2Rldik7Cj4gK30KPiArCj4gKyNpZmRl\n" - "ZiBDT05GSUdfUE0KPiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpk\n" - "ZXYpCj4gK3sKPiArCXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYp\n" - "Owo+ICsKPiArCXJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9S\n" - "RUcsCj4gKwkJCQkgIFRNUDEwM19DT05GX1NEX01BU0ssIDApOwo+ICt9Cj4gKwo+ICtzdGF0aWMg\n" - "aW50IHRtcDEwM19yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgcmVn\n" - "bWFwICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCj4gKwlyZXR1cm4gcmVnbWFw\n" - "X3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVHLAo+ICsJCQkJICBUTVAxMDNfQ09O\n" - "Rl9TRF9NQVNLLCBUTVAxMDNfQ09ORl9TRCk7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1\n" - "Y3QgZGV2X3BtX29wcyB0bXAxMDNfZGV2X3BtX29wcyA9IHsKPiArCS5zdXNwZW5kCT0gdG1wMTAz\n" - "X3N1c3BlbmQsCj4gKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1bWUsCj4gK307Cj4gKwo+ICsjZGVm\n" - "aW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCj4gKyNlbHNlCj4gKyNk\n" - "ZWZpbmUJVE1QMTAzX0RFVl9QTV9PUFMgTlVMTAo+ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4g\n" - "Kwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgdG1wMTAzX2lkW10gPSB7Cj4g\n" - "Kwl7IERSSVZFUl9OQU1FLCAwIH0sCgpUaGlzIHNlZW1zIHRvIGJlIHVzZWQgZm9yIGNvbXBhdGli\n" - "bGUgc3RyaW5nIG1hdGNoaW5nLiBBcyBzdWNoLCBJIHRoaW5rCml0IHdvdWxkIG1ha2UgbW9yZSBz\n" - "ZW5zZSB0byBoYXZlIHRoZSBzdHJpbmcgaW4gZnVsbCBoZXJlIHNvIGFzIHRvCmRpc2NvdXJhZ2Ug\n" - "aXQgZnJvbSBiZWluZyBjaGFuZ2VkIGFyYml0cmFyaWx5IGluIGZ1dHVyZS4KCk90aGVyd2lzZSwg\n" - "dGhlIGR0IHBhcnQgbG9va3MgZmluZSBieSBtZS4KCkNoZWVycywKTWFyay4KCl9fX19fX19fX19f\n" - "X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBs\n" - "aXN0CmxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3Jn\n" - L21haWxtYW4vbGlzdGluZm8vbG0tc2Vuc29ycw= + "On Tue, Jun 17, 2014 at 09:11:53AM +0100, 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" + "> \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" + "> \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 | 207 +++++++++++++++++++++\n" + "> 5 files changed, 247 insertions(+)\n" + "> create mode 100644 Documentation/hwmon/tmp103\n" + "> create mode 100644 drivers/hwmon/tmp103.c\n" + "> \n" + "> diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt\n" + "> index bef86e5..fc944e0 100644\n" + "> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt\n" + "> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt\n" + "> @@ -83,5 +83,6 @@ stm,m41t80\t\tM41T80 - SERIAL ACCESS RTC WITH ALARMS\n" + "> taos,tsl2550\t\tAmbient Light Sensor with SMBUS/Two Wire Serial Interface\n" + "> ti,tsc2003\t\tI2C Touch-Screen Controller\n" + "> ti,tmp102\t\tLow Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface\n" + "> +ti,tmp103\t\tLow Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface\n" + "> ti,tmp275\t\tDigital Temperature Sensor\n" + "> winbond,wpct301\t\ti2c trusted platform module (TPM)\n" + "> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103\n" + "> new file mode 100644\n" + "> index 0000000..ec00a15\n" + "> --- /dev/null\n" + "> +++ b/Documentation/hwmon/tmp103\n" + "> @@ -0,0 +1,28 @@\n" + "> +Kernel driver tmp103\n" + "> +====================\n" + "> +\n" + "> +Supported chips:\n" + "> + * Texas Instruments TMP103\n" + "> + Prefix: 'tmp103'\n" + "> + Addresses scanned: none\n" + "> + Product info and datasheet: http://www.ti.com/product/tmp103\n" + "> +\n" + "> +Author:\n" + "> +\tHeiko Schocher <hs@denx.de>\n" + "> +\n" + "> +Description\n" + "> +-----------\n" + "> +\n" + "> +The TMP103 is a digital output temperature sensor in a four-ball\n" + "> +wafer chip-scale package (WCSP). The TMP103 is capable of reading\n" + "> +temperatures to a resolution of 1\302\260C. The TMP103 is specified for\n" + "> +operation over a temperature range of \342\200\22340\302\260C to +125\302\260C.\n" + "> +\n" + "> +Resolution: 8 Bits\n" + "> +Accuracy: \302\2611\302\260C Typ (\342\200\22310\302\260C to +100\302\260C)\n" + "> +\n" + "> +The driver provides the common sysfs-interface for temperatures (see\n" + "> +Documentation/hwmon/sysfs-interface under Temperatures).\n" + "> +\n" + "> +Please refer how to instantiate this driver:\n" + "> +Documentation/i2c/instantiating-devices\n" + "> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig\n" + "> index 08531a1..c882d4b 100644\n" + "> --- a/drivers/hwmon/Kconfig\n" + "> +++ b/drivers/hwmon/Kconfig\n" + "> @@ -1391,6 +1391,16 @@ config SENSORS_TMP102\n" + "> \t This driver can also be built as a module. If so, the module\n" + "> \t will be called tmp102.\n" + "> \n" + "> +config SENSORS_TMP103\n" + "> +\ttristate \"Texas Instruments TMP103\"\n" + "> +\tdepends on I2C\n" + "> +\thelp\n" + "> +\t If you say yes here you get support for Texas Instruments TMP103\n" + "> +\t sensor chips.\n" + "> +\n" + "> +\t This driver can also be built as a module. If so, the module\n" + "> +\t will be called tmp103.\n" + "> +\n" + "> config SENSORS_TMP401\n" + "> \ttristate \"Texas Instruments TMP401 and compatibles\"\n" + "> \tdepends on I2C\n" + "> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile\n" + "> index 3dc0f02..cc0df1ef 100644\n" + "> --- a/drivers/hwmon/Makefile\n" + "> +++ b/drivers/hwmon/Makefile\n" + "> @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o\n" + "> obj-$(CONFIG_SENSORS_AMC6821)\t+= amc6821.o\n" + "> obj-$(CONFIG_SENSORS_THMC50)\t+= thmc50.o\n" + "> obj-$(CONFIG_SENSORS_TMP102)\t+= tmp102.o\n" + "> +obj-$(CONFIG_SENSORS_TMP103)\t+= tmp103.o\n" + "> obj-$(CONFIG_SENSORS_TMP401)\t+= tmp401.o\n" + "> obj-$(CONFIG_SENSORS_TMP421)\t+= tmp421.o\n" + "> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o\n" + "> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c\n" + "> new file mode 100644\n" + "> index 0000000..d133d09\n" + "> --- /dev/null\n" + "> +++ b/drivers/hwmon/tmp103.c\n" + "> @@ -0,0 +1,207 @@\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\tDRIVER_NAME \"tmp103\"\n" + "> +\n" + "> +#define TMP103_TEMP_REG\t\t0x00\n" + "> +#define TMP103_CONF_REG\t\t0x01\n" + "> +#define TMP103_TLOW_REG\t\t0x02\n" + "> +#define TMP103_THIGH_REG\t0x03\n" + "> +\n" + "> +#define TMP103_CONF_M0\t\t0x01\n" + "> +#define TMP103_CONF_M1\t\t0x02\n" + "> +#define TMP103_CONF_LC\t\t0x04\n" + "> +#define TMP103_CONF_FL\t\t0x08\n" + "> +#define TMP103_CONF_FH\t\t0x10\n" + "> +#define TMP103_CONF_CR0\t\t0x20\n" + "> +#define TMP103_CONF_CR1\t\t0x40\n" + "> +#define TMP103_CONF_ID\t\t0x80\n" + "> +#define TMP103_CONF_SD\t\t(TMP103_CONF_M0 | TMP103_CONF_M1)\n" + "> +#define TMP103_CONF_SD_MASK\t(TMP103_CONF_M0 | TMP103_CONF_M1)\n" + "> +\n" + "> +#define TMP103_CONFIG\t\t(TMP103_CONF_CR1 | TMP103_CONF_M1)\n" + "> +#define TMP103_CONFIG_MASK\t(TMP103_CONF_CR0 | TMP103_CONF_CR1 | \\\n" + "> +\t\t\t\t TMP103_CONF_M0 | TMP103_CONF_M1)\n" + "> +\n" + "> +static inline int tmp103_reg_to_mc(s8 val)\n" + "> +{\n" + "> +\treturn val * 1000;\n" + "> +}\n" + "> +\n" + "> +static inline u8 tmp103_mc_to_reg(int val)\n" + "> +{\n" + "> +\treturn DIV_ROUND_CLOSEST(val, 1000);\n" + "> +}\n" + "> +\n" + "> +static ssize_t tmp103_show_temp(struct device *dev,\n" + "> +\t\t\t\tstruct device_attribute *attr,\n" + "> +\t\t\t\tchar *buf)\n" + "> +{\n" + "> +\tstruct sensor_device_attribute *sda = to_sensor_dev_attr(attr);\n" + "> +\tstruct regmap *regmap = dev_get_drvdata(dev);\n" + "> +\tunsigned int regval;\n" + "> +\tint ret;\n" + "> +\n" + "> +\tret = regmap_read(regmap, sda->index, ®val);\n" + "> +\tif (ret < 0)\n" + "> +\t\treturn ret;\n" + "> +\n" + "> +\treturn sprintf(buf, \"%d\\n\", tmp103_reg_to_mc(regval));\n" + "> +}\n" + "> +\n" + "> +static ssize_t tmp103_set_temp(struct device *dev,\n" + "> +\t\t\t struct device_attribute *attr,\n" + "> +\t\t\t const char *buf, size_t count)\n" + "> +{\n" + "> +\tstruct sensor_device_attribute *sda = to_sensor_dev_attr(attr);\n" + "> +\tstruct regmap *regmap = dev_get_drvdata(dev);\n" + "> +\tlong val;\n" + "> +\tint ret;\n" + "> +\n" + "> +\tif (kstrtol(buf, 10, &val) < 0)\n" + "> +\t\treturn -EINVAL;\n" + "> +\n" + "> +\tval = clamp_val(val, -55000, 127000);\n" + "> +\tret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val));\n" + "> +\treturn ret ? ret : count;\n" + "> +}\n" + "> +\n" + "> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL ,\n" + "> +\t\t\t TMP103_TEMP_REG);\n" + "> +\n" + "> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + "> +\t\t\t tmp103_set_temp, TMP103_TLOW_REG);\n" + "> +\n" + "> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp,\n" + "> +\t\t\t tmp103_set_temp, TMP103_THIGH_REG);\n" + "> +\n" + "> +static struct attribute *tmp103_attrs[] = {\n" + "> +\t&sensor_dev_attr_temp1_input.dev_attr.attr,\n" + "> +\t&sensor_dev_attr_temp1_min.dev_attr.attr,\n" + "> +\t&sensor_dev_attr_temp1_max.dev_attr.attr,\n" + "> +\tNULL\n" + "> +};\n" + "> +ATTRIBUTE_GROUPS(tmp103);\n" + "> +\n" + "> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg)\n" + "> +{\n" + "> +\treturn reg == TMP103_TEMP_REG;\n" + "> +}\n" + "> +\n" + "> +static struct regmap_config tmp103_regmap_config = {\n" + "> +\t.reg_bits = 8,\n" + "> +\t.val_bits = 8,\n" + "> +\t.max_register = TMP103_THIGH_REG,\n" + "> +\t.volatile_reg = tmp103_regmap_is_volatile,\n" + "> +};\n" + "> +\n" + "> +static int tmp103_probe(struct i2c_client *client,\n" + "> +\t\t\tconst struct i2c_device_id *id)\n" + "> +{\n" + "> +\tstruct device *dev = &client->dev;\n" + "> +\tstruct device *hwmon_dev;\n" + "> +\tstruct regmap *regmap;\n" + "> +\tint ret;\n" + "> +\n" + "> +\tif (!i2c_check_functionality(client->adapter,\n" + "> +\t\t\t\t I2C_FUNC_SMBUS_BYTE_DATA)) {\n" + "> +\t\tdev_err(&client->dev,\n" + "> +\t\t\t\"adapter doesn't support SMBus byte transactions\\n\");\n" + "> +\t\treturn -ENODEV;\n" + "> +\t}\n" + "> +\n" + "> +\tregmap = devm_regmap_init_i2c(client, &tmp103_regmap_config);\n" + "> +\tif (IS_ERR(regmap)) {\n" + "> +\t\tdev_err(dev, \"failed to allocate register map\\n\");\n" + "> +\t\treturn PTR_ERR(regmap);\n" + "> +\t}\n" + "> +\n" + "> +\tret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK,\n" + "> +\t\t\t\t TMP103_CONFIG);\n" + "> +\tif (ret < 0) {\n" + "> +\t\tdev_err(&client->dev, \"error writing config register\\n\");\n" + "> +\t\treturn ret;\n" + "> +\t}\n" + "> +\n" + "> +\thwmon_dev = hwmon_device_register_with_groups(dev, client->name,\n" + "> +\t\t\t\t\t\t regmap, tmp103_groups);\n" + "> +\treturn PTR_ERR_OR_ZERO(hwmon_dev);\n" + "> +}\n" + "> +\n" + "> +#ifdef CONFIG_PM\n" + "> +static int tmp103_suspend(struct device *dev)\n" + "> +{\n" + "> +\tstruct regmap *regmap = dev_get_drvdata(dev);\n" + "> +\n" + "> +\treturn regmap_update_bits(regmap, TMP103_CONF_REG,\n" + "> +\t\t\t\t TMP103_CONF_SD_MASK, 0);\n" + "> +}\n" + "> +\n" + "> +static int tmp103_resume(struct device *dev)\n" + "> +{\n" + "> +\tstruct regmap *regmap = dev_get_drvdata(dev);\n" + "> +\n" + "> +\treturn regmap_update_bits(regmap, TMP103_CONF_REG,\n" + "> +\t\t\t\t TMP103_CONF_SD_MASK, TMP103_CONF_SD);\n" + "> +}\n" + "> +\n" + "> +static const struct dev_pm_ops tmp103_dev_pm_ops = {\n" + "> +\t.suspend\t= tmp103_suspend,\n" + "> +\t.resume\t\t= tmp103_resume,\n" + "> +};\n" + "> +\n" + "> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops)\n" + "> +#else\n" + "> +#define\tTMP103_DEV_PM_OPS NULL\n" + "> +#endif /* CONFIG_PM */\n" + "> +\n" + "> +static const struct i2c_device_id tmp103_id[] = {\n" + "> +\t{ DRIVER_NAME, 0 },\n" + "\n" + "This seems to be used for compatible string matching. As such, I think\n" + "it would make more sense to have the string in full here so as to\n" + "discourage it from being changed arbitrarily in future.\n" + "\n" + "Otherwise, the dt part looks fine by me.\n" + "\n" + "Cheers,\n" + Mark. -f3c0ca17d74025c6893480517bba77abb400792e548f15931bc898ea97d0519f +11ec66013a641c785b5b95f9057fe426bd0d338261191d4e911c1ec00e339695
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.