diff for duplicates of <5698C1DD.6000607@topic.nl> diff --git a/a/1.txt b/N1/1.txt index b4be243..8864964 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,197 +1,339 @@ -77u/T24gMTQtMDEtMTYgMjA6MTQsIEd1ZW50ZXIgUm9lY2sgd3JvdGU6Cj4gT24gV2VkLCBKYW4g -MTMsIDIwMTYgYXQgMDM6NDU6MDFQTSArMDEwMCwgTWlrZSBMb29pam1hbnMgd3JvdGU6Cj4+IFRo -aXMgYWRkcyBzdXBwb3J0IGZvciB0aGUgTGluZWFyIFRlY2hub2xvZ3kgTFRDMjk5MCAgSTJDIFN5 -c3RlbSBNb25pdG9yLgo+PiBUaGUgTFRDMjk5MCBzdXBwb3J0cyBhIGNvbWJpbmF0aW9uIG9mIHZv -bHRhZ2UsIGN1cnJlbnQgYW5kIHRlbXBlcmF0dXJlCj4+IG1vbml0b3JpbmcuIFRoaXMgZHJpdmVy -IGN1cnJlbnRseSBvbmx5IHN1cHBvcnRzIHJlYWRpbmcgdHdvIGN1cnJlbnRzCj4+IGJ5IG1lYXN1 -cmluZyB0d28gZGlmZmVyZW50aWFsIHZvbHRhZ2VzIGFjcm9zcyBzZXJpZXMgcmVzaXN0b3JzLCBp -bgo+PiBhZGRpdGlvbiB0byB0aGUgVmNjIHN1cHBseSB2b2x0YWdlIGFuZCBpbnRlcm5hbCB0ZW1w -ZXJhdHVyZS4KPj4KPj4gVGhpcyBpcyBzdWZmaWNpZW50IHRvIHN1cHBvcnQgdGhlIFRvcGljIE1p -YW1pIFNPTSB3aGljaCB1c2VzIHRoaXMgY2hpcAo+PiB0byBtb25pdG9yIHRoZSBjdXJyZW50cyBm -bG93aW5nIGludG8gdGhlIEZQR0EgYW5kIHRoZSBDUFUgcGFydHMuCj4+Cj4+IFNpZ25lZC1vZmYt -Ynk6IE1pa2UgTG9vaWptYW5zIDxtaWtlLmxvb2lqbWFuc0B0b3BpYy5ubD4KPgo+IEhpIE1pa2Us -Cj4KPiBhbG1vc3QgdGhlcmUuIFBsZWFzZSBzZWUgaW5saW5lLgoKR3JlYXQsIEknbGwgb3JkZXIg -c29tZSBjYWtlIDopCgpFeHBlY3QgdjQgaW4gYSBmZXcgbWludXRlcywgSSdtIHRlc3RpbmcgaXQg -b24gdGhlIGhhcmR3YXJlIG5vdy4KCj4gVGhhbmtzLAo+IEd1ZW50ZXIKPgo+PiAtLS0KPj4gdjM6 -IFJlbW92ZSB1bnVzZWQgaW5jbHVkZXMuCj4+ICAgICAgUmVtb3ZlIChtb3N0KSB1bnVzZWQgcmVn -aXN0ZXIgZGVmaW5lcy4KPj4gICAgICBBbHNvIGNoZWNrIG9uIFNNQlVTIFdPUkQgY2FwYWJpbGl0 -eS4KPj4gICAgICBVc2UgcmVnaXN0ZXIgZGVmaW5lcyBhcyB2YWx1ZSBpbmRpY2VzLgo+PiAgICAg -IEFsaWdubWVudCBmaXh1cHMgd2l0aCAiKCIuCj4+IHYyOiBQcm9jZXNzZWQgYWxsIHJldmlldyBj -b21tZW50cy4KPj4gICAgICAgUHV0IGNoaXAgaW50byBjb250aW51b3VzIG1lYXN1cmVtZW50IG1v -ZGUuCj4+ICAgICAgIEFkZGVkIGR1Y3VtZW50YXRpb24uCj4+ICAgICAgIFVzZSBzdGFuZGFyZCBo -d21vbiBpbnRlcmZhY2VzIGFuZCBtYWNyb3MuCj4+Cj4+ICAgRG9jdW1lbnRhdGlvbi9od21vbi9s -dGMyOTkwIHwgIDQ0ICsrKysrKysrKysrKwo+PiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAg -ICB8ICAxNCArKysrCj4+ICAgZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgIHwgICAxICsKPj4g -ICBkcml2ZXJzL2h3bW9uL2x0YzI5OTAuYyAgICAgfCAxNTkgKysrKysrKysrKysrKysrKysrKysr -KysrKysrKysrKysrKysrKysrKysrKysKPj4gICA0IGZpbGVzIGNoYW5nZWQsIDIxOCBpbnNlcnRp -b25zKCspCj4+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vaHdtb24vbHRjMjk5 -MAo+PiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2h3bW9uL2x0YzI5OTAuYwo+Pgo+PiBk -aWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9od21vbi9sdGMyOTkwIGIvRG9jdW1lbnRhdGlvbi9o -d21vbi9sdGMyOTkwCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjgz -OGI3NGUKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL2x0YzI5 -OTAKPj4gQEAgLTAsMCArMSw0NCBAQAo+PiArS2VybmVsIGRyaXZlciBsdGMyOTkwCj4+ICs9PT09 -PT09PT09PT09PT09PT09PT0KPj4gKwo+PiArU3VwcG9ydGVkIGNoaXBzOgo+PiArICAqIExpbmVh -ciBUZWNobm9sb2d5IExUQzI5OTAKPj4gKyAgICBQcmVmaXg6ICdsdGMyOTkwJwo+PiArICAgIEFk -ZHJlc3NlcyBzY2FubmVkOiAtCj4+ICsgICAgRGF0YXNoZWV0OiBodHRwOi8vd3d3LmxpbmVhci5j -b20vcHJvZHVjdC9sdGMyOTkwCj4+ICsKPj4gK0F1dGhvcjogTWlrZSBMb29pam1hbnMgPG1pa2Uu -bG9vaWptYW5zQHRvcGljLm5sPgo+PiArCj4+ICsKPj4gK0Rlc2NyaXB0aW9uCj4+ICstLS0tLS0t -LS0tLQo+PiArCj4+ICtMVEMyOTkwIGlzIGEgUXVhZCBJMkMgVm9sdGFnZSwgQ3VycmVudCBhbmQg -VGVtcGVyYXR1cmUgTW9uaXRvci4KPj4gK1RoZSBjaGlwJ3MgaW5wdXRzIGNhbiBtZWFzdXJlIDQg -dm9sdGFnZXMsIG9yIHR3byBpbnB1dHMgdG9nZXRoZXIgKDErMiBhbmQgMys0KQo+PiArY2FuIGJl -IGNvbWJpbmVkIHRvIG1lYXN1cmUgYSBkaWZmZXJlbnRpYWwgdm9sdGFnZSwgd2hpY2ggaXMgdHlw -aWNhbGx5IHVzZWQgdG8KPj4gK21lYXN1cmUgY3VycmVudCB0aHJvdWdoIGEgc2VyaWVzIHJlc2lz -dG9yLCBvciBhIHRlbXBlcmF0dXJlLgo+PiArCj4+ICtUaGlzIGRyaXZlciBjdXJyZW50bHkgdXNl -cyB0aGUgMnggZGlmZmVyZW50aWFsIG1vZGUgb25seS4gSW4gb3JkZXIgdG8gc3VwcG9ydAo+PiAr -b3RoZXIgbW9kZXMsIHRoZSBkcml2ZXIgd2lsbCBuZWVkIHRvIGJlIGV4cGFuZGVkLgo+PiArCj4+ -ICsKPj4gK1VzYWdlIE5vdGVzCj4+ICstLS0tLS0tLS0tLQo+PiArCj4+ICtUaGlzIGRyaXZlciBk -b2VzIG5vdCBwcm9iZSBmb3IgUE1CdXMgZGV2aWNlcy4gWW91IHdpbGwgaGF2ZSB0byBpbnN0YW50 -aWF0ZQo+PiArZGV2aWNlcyBleHBsaWNpdGx5Lgo+PiArCj4+ICsKPj4gK1N5c2ZzIGF0dHJpYnV0 -ZXMKPj4gKy0tLS0tLS0tLS0tLS0tLS0KPj4gKwo+PiArVGhlICJjdXJyKl9pbnB1dCIgbWVhc3Vy -ZW1lbnRzIGFjdHVhbGx5IHJlcG9ydCB0aGUgdm9sdGFnZSBkcm9wIGFjcm9zcyB0aGUKPj4gK2lu -cHV0IHBpbnMgaW4gbWljcm92b2x0cy4gVGhpcyBpcyBlcXVpdmFsZW50IHRvIHRoZSBjdXJyZW50 -IHRocm91Z2ggYSAxbU9obQo+PiArc2Vuc2UgcmVzaXN0b3IuIERpdmlkZSB0aGUgcmVwb3J0ZWQg -dmFsdWUgYnkgdGhlIGFjdHVhbCBzZW5zZSByZXNpc3RvciB2YWx1ZQo+PiAraW4gbU9obSB0byBn -ZXQgdGhlIGFjdHVhbCB2YWx1ZS4KPj4gKwo+PiAraW4wX2lucHV0ICAgICBWb2x0YWdlIGF0IFZj -YyBwaW4gaW4gbWlsbGl2b2x0IChyYW5nZSAyLjVWIHRvIDVWKQo+PiArdGVtcDFfaW5wdXQgICBJ -bnRlcm5hbCBjaGlwIHRlbXBlcmF0dXJlIGluIG1pbGxpZGVncmVlcyBDZWxjaXVzCj4+ICtjdXJy -MV9pbnB1dCAgIEN1cnJlbnQgaW4gbUEgYWNyb3NzIHYxLXYyIGFzc3VtaW5nIGEgMW1PaG0gc2Vu -c2UgcmVzaXN0b3IuCj4+ICtjdXJyMl9pbnB1dCAgIEN1cnJlbnQgaW4gbUEgYWNyb3NzIHYzLXY0 -IGFzc3VtaW5nIGEgMW1PaG0gc2Vuc2UgcmVzaXN0b3IuCj4+ICsKPj4gZGlmZiAtLWdpdCBhL2Ry -aXZlcnMvaHdtb24vS2NvbmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+PiBpbmRleCA4MGE3 -M2JmLi44YTMxZDY0IDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcKPj4gKysr -IGIvZHJpdmVycy9od21vbi9LY29uZmlnCj4+IEBAIC02ODUsNiArNjg1LDIwIEBAIGNvbmZpZyBT -RU5TT1JTX0xUQzI5NDUKPj4gICAJICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBh -IG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUgd2lsbAo+PiAgIAkgIGJlIGNhbGxlZCBsdGMyOTQ1 -Lgo+Pgo+PiArY29uZmlnIFNFTlNPUlNfTFRDMjk5MAo+PiArCXRyaXN0YXRlICJMaW5lYXIgVGVj -aG5vbG9neSBMVEMyOTkwIChjdXJyZW50IG1vbml0b3JpbmcgbW9kZSBvbmx5KSIKPj4gKwlkZXBl -bmRzIG9uIEkyQwo+PiArCWhlbHAKPj4gKwkgIElmIHlvdSBzYXkgeWVzIGhlcmUgeW91IGdldCBz -dXBwb3J0IGZvciBMaW5lYXIgVGVjaG5vbG9neSBMVEMyOTkwCj4+ICsJICBJMkMgU3lzdGVtIE1v -bml0b3IuIFRoZSBMVEMyOTkwIHN1cHBvcnRzIGEgY29tYmluYXRpb24gb2Ygdm9sdGFnZSwKPj4g -KwkgIGN1cnJlbnQgYW5kIHRlbXBlcmF0dXJlIG1vbml0b3JpbmcsIGJ1dCBpbiBhZGRpdGlvbiB0 -byB0aGUgVmNjIHN1cHBseQo+PiArCSAgdm9sdGFnZSBhbmQgY2hpcCB0ZW1wZXJhdHVyZSwgdGhp -cyBkcml2ZXIgY3VycmVudGx5IG9ubHkgc3VwcG9ydHMKPj4gKwkgIHJlYWRpbmcgdHdvIGN1cnJl -bnRzIGJ5IG1lYXN1cmluZyB0d28gZGlmZmVyZW50aWFsIHZvbHRhZ2VzIGFjcm9zcwo+PiArCSAg -c2VyaWVzIHJlc2lzdG9ycy4KPj4gKwo+PiArCSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVp -bHQgYXMgYSBtb2R1bGUuIElmIHNvLCB0aGUgbW9kdWxlIHdpbGwKPj4gKwkgIGJlIGNhbGxlZCBs -dGMyOTkwLgo+PiArCj4+ICAgY29uZmlnIFNFTlNPUlNfTFRDNDE1MQo+PiAgIAl0cmlzdGF0ZSAi -TGluZWFyIFRlY2hub2xvZ3kgTFRDNDE1MSIKPj4gICAJZGVwZW5kcyBvbiBJMkMKPj4gZGlmZiAt -LWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+ -IGluZGV4IDEyYTMyMzkuLmU0YmQxNWIgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFr -ZWZpbGUKPj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+PiBAQCAtMTAxLDYgKzEwMSw3 -IEBAIG9iai0kKENPTkZJR19TRU5TT1JTX0xNOTUyMzQpCSs9IGxtOTUyMzQubwo+PiAgIG9iai0k -KENPTkZJR19TRU5TT1JTX0xNOTUyNDEpCSs9IGxtOTUyNDEubwo+PiAgIG9iai0kKENPTkZJR19T -RU5TT1JTX0xNOTUyNDUpCSs9IGxtOTUyNDUubwo+PiAgIG9iai0kKENPTkZJR19TRU5TT1JTX0xU -QzI5NDUpCSs9IGx0YzI5NDUubwo+PiArb2JqLSQoQ09ORklHX1NFTlNPUlNfTFRDMjk5MCkJKz0g -bHRjMjk5MC5vCj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfTFRDNDE1MSkJKz0gbHRjNDE1MS5v -Cj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfTFRDNDIxNSkJKz0gbHRjNDIxNS5vCj4+ICAgb2Jq -LSQoQ09ORklHX1NFTlNPUlNfTFRDNDIyMikJKz0gbHRjNDIyMi5vCj4+IGRpZmYgLS1naXQgYS9k -cml2ZXJzL2h3bW9uL2x0YzI5OTAuYyBiL2RyaXZlcnMvaHdtb24vbHRjMjk5MC5jCj4+IG5ldyBm -aWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjM3Y2E1ZjQKPj4gLS0tIC9kZXYvbnVs -bAo+PiArKysgYi9kcml2ZXJzL2h3bW9uL2x0YzI5OTAuYwo+PiBAQCAtMCwwICsxLDE1OSBAQAo+ -PiArLyoKPj4gKyAqIERyaXZlciBmb3IgTGluZWFyIFRlY2hub2xvZ3kgTFRDMjk5MCBwb3dlciBt -b25pdG9yCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDE0IFRvcGljIEVtYmVkZGVkIFBy -b2R1Y3RzCj4+ICsgKiBBdXRob3I6IE1pa2UgTG9vaWptYW5zIDxtaWtlLmxvb2lqbWFuc0B0b3Bp -Yy5ubD4KPj4gKyAqCj4+ICsgKiBMaWNlbnNlOiBHUEx2Mgo+PiArICoKPj4gKyAqIFRoaXMgZHJp -dmVyIGFzc3VtZXMgdGhlIGNoaXAgaXMgd2lyZWQgYXMgYSBkdWFsIGN1cnJlbnQgbW9uaXRvciwg -YW5kCj4+ICsgKiByZXBvcnRzIHRoZSB2b2x0YWdlIGRyb3AgYWNyb3NzIHR3byBzZXJpZXMgcmVz -aXN0b3JzLiBJdCBhbHNvIHJlcG9ydHMKPj4gKyAqIHRoZSBjaGlwJ3MgaW50ZXJuYWwgdGVtcGVy -YXR1cmUgYW5kIFZjYyBwb3dlciBzdXBwbHkgdm9sdGFnZS4KPj4gKyAqLwo+PiArCj4+ICsjaW5j -bHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvaHdtb24uaD4KPj4gKyNpbmNs -dWRlIDxsaW51eC9od21vbi1zeXNmcy5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+PiAr -I2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ -PiArCj4+ICsjZGVmaW5lIExUQzI5OTBfU1RBVFVTCTB4MDAKPj4gKyNkZWZpbmUgTFRDMjk5MF9D -T05UUk9MCTB4MDEKPj4gKyNkZWZpbmUgTFRDMjk5MF9UUklHR0VSCTB4MDIKPj4gKyNkZWZpbmUg -TFRDMjk5MF9USU5UX01TQgkweDA0Cj4+ICsjZGVmaW5lIExUQzI5OTBfVjFfTVNCCTB4MDYKPj4g -KyNkZWZpbmUgTFRDMjk5MF9WMl9NU0IJMHgwOAo+PiArI2RlZmluZSBMVEMyOTkwX1YzX01TQgkw -eDBBCj4+ICsjZGVmaW5lIExUQzI5OTBfVjRfTVNCCTB4MEMKPj4gKyNkZWZpbmUgTFRDMjk5MF9W -Q0NfTVNCCTB4MEUKPj4gKwo+PiArI2RlZmluZSBMVEMyOTkwX0NPTlRST0xfS0VMVklOCQlCSVQo -NykKPj4gKyNkZWZpbmUgTFRDMjk5MF9DT05UUk9MX1NJTkdMRQkJQklUKDYpCj4+ICsjZGVmaW5l -IExUQzI5OTBfQ09OVFJPTF9NRUFTVVJFX0FMTAkoMHgzIDw8IDMpCj4+ICsjZGVmaW5lIExUQzI5 -OTBfQ09OVFJPTF9NT0RFX0NVUlJFTlQJMHgwNgo+PiArI2RlZmluZSBMVEMyOTkwX0NPTlRST0xf -TU9ERV9WT0xUQUdFCTB4MDcKPj4gKwo+PiArLyogY29udmVydCByYXcgcmVnaXN0ZXIgdmFsdWUg -dG8gc2lnbi1leHRlbmRlZCBpbnRlZ2VyIGluIDE2LWJpdCByYW5nZSAqLwo+PiArc3RhdGljIGlu -dCBsdGMyOTkwX3ZvbHRhZ2VfdG9faW50KGludCByYXcpCj4+ICt7Cj4+ICsJaWYgKHJhdyAmIEJJ -VCgxNCkpIHsKPj4gKwkJcmV0dXJuIC0oMHg0MDAwIC0gKHJhdyAmIDB4M0ZGRikpIDw8IDI7Cj4+ -ICsJfSBlbHNlIHsKPj4gKwkJcmV0dXJuIChyYXcgJiAweDNGRkYpIDw8IDI7Cj4+ICsJfQo+Cj4g -VW5uZWNlc3NhcnkgeyB9LiBQbGVhc2Ugc2VlIGNoZWNrcGF0Y2ggd2FybmluZy4KCkknbGwgbWFr -ZSBzdXJlIHRvIHJ1biBjaGVja3BhdGNoIGFnYWluLiBJdHMgb25seSByZW1haW5pbmcgd2Fybmlu -ZyBpcyBhYm91dCAKTUFJTlRBSU5FUlMgbm93LgoKPj4gK30KPj4gKwo+PiArLyogUmV0dXJuIHRo -ZSBjb252ZXJ0ZWQgdmFsdWUgZnJvbSB0aGUgZ2l2ZW4gcmVnaXN0ZXIgaW4gdVYgb3IgbUMgKi8K -Pj4gK3N0YXRpYyBpbnQgbHRjMjk5MF9nZXRfdmFsdWUoc3RydWN0IGkyY19jbGllbnQgKmkyYywg -dTggcmVnKQo+PiArewo+PiArCWludCB2YWw7Cj4+ICsJaW50IHJlc3VsdDsKPj4gKwo+PiArCXZh -bCA9IGkyY19zbWJ1c19yZWFkX3dvcmRfc3dhcHBlZChpMmMsIHJlZyk7Cj4+ICsJaWYgKHVubGlr -ZWx5KHZhbCA8IDApKQo+PiArCQlyZXR1cm4gdmFsOwo+Cj4gVGhpcyBzdWdnZXN0cyB0aGUgZnVu -Y3Rpb24gcmV0dXJucyBhIHZhbHVlIDwgMCBvbiBlcnJvciAuLi4KCk1pc2xlYWRpbmcsIHNpbmNl -IG1vc3Qgb2YgdGhlIHZhbGlkIHJlc3VsdHMgY2FuIGJlIG5lZ2F0aXZlLiBJJ2xsIGNoYW5nZSB0 -aGUgCm1ldGhvZCB0byByZXR1cm4gYSByZXN1bHQgY29kZSBhbmQgdGFrZSBhIHJlc3VsdCBwb2lu -dGVyIGluc3RlYWQuCgo+Cj4+ICsJc3dpdGNoIChyZWcpIHsKPj4gKwljYXNlIExUQzI5OTBfVElO -VF9NU0I6Cj4+ICsJCS8qIGludGVybmFsIHRlbXAsIDAuMDYyNSBkZWdyZWVzL0xTQiwgMTMtYml0 -ICAqLwo+PiArCQl2YWwgPSAodmFsICYgMHgxRkZGKSA8PCAzOwo+PiArCQlyZXN1bHQgPSAodmFs -ICogMTAwMCkgPj4gNzsKPj4gKwkJYnJlYWs7Cj4+ICsJY2FzZSBMVEMyOTkwX1YxX01TQjoKPj4g -KwljYXNlIExUQzI5OTBfVjNfTVNCOgo+PiArCQkgLyogVngtVnksIDE5LjQydVYvTFNCLiBEZXBl -bmRzIG9uIG1vZGUuICovCj4+ICsJCXJlc3VsdCA9IGx0YzI5OTBfdm9sdGFnZV90b19pbnQodmFs -KSAqIDE5NDIgLyAoNCAqIDEwMCk7Cj4+ICsJCWJyZWFrOwo+PiArCWNhc2UgTFRDMjk5MF9WQ0Nf -TVNCOgo+PiArCQkvKiBWY2MsIDMwNS4xOM68Vi9MU0IsIDIuNVYgb2Zmc2V0ICovCj4+ICsJCXJl -c3VsdCA9IGx0YzI5OTBfdm9sdGFnZV90b19pbnQodmFsKSAqIDMwNTE4IC8gKDQgKiAxMDAgKiAx -MDAwKTsKPj4gKwkJcmVzdWx0ICs9IDI1MDA7Cj4+ICsJCWJyZWFrOwo+PiArCWRlZmF1bHQ6Cj4+ -ICsJCXJlc3VsdCA9IDA7IC8qIHdvbid0IGhhcHBlbiwga2VlcCBjb21waWxlciBoYXBweSAqLwo+ -Cj4gR2l2ZW4gdGhhdCwgd2UgY2FuIHJldHVybiBzb21lIGVycm9yIGhlcmUsIGFuZCAuLi4KPgo+ -PiArCQlicmVhazsKPj4gKwl9Cj4+ICsKPj4gKwlyZXR1cm4gcmVzdWx0Owo+PiArfQo+PiArCj4+ -ICtzdGF0aWMgc3NpemVfdCBsdGMyOTkwX3Nob3dfdmFsdWUoc3RydWN0IGRldmljZSAqZGV2LAo+ -PiArCQkJCSAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRhLCBjaGFyICpidWYpCj4+ICt7Cj4+ -ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICphdHRyID0gdG9fc2Vuc29yX2Rldl9h -dHRyKGRhKTsKPj4gKwlpbnQgdmFsdWU7Cj4+ICsKPj4gKwl2YWx1ZSA9IGx0YzI5OTBfZ2V0X3Zh -bHVlKGRldl9nZXRfZHJ2ZGF0YShkZXYpLCBhdHRyLT5pbmRleCk7Cj4KPiAuLi4gd2Ugc2hvdWxk -IGFjdHVhbGx5IGNoZWNrIHRoZSBlcnJvciByZXR1cm4gaGVyZS4KPgo+IAlpZiAodmFsdWUgPCAw -KQo+IAkJcmV0dXJuIHZhbHVlOwoKWWVzLCB3aXRoIHRoZSBjaGFuZ2UgYWJvdmUsIGl0IGNhbiBw -cm9wZXJseSByZXR1cm4gYW4gZXJyb3IgY29kZSBpZiB0aGUgSTJDIAp0cmFuc2FjdGlvbiBmYWls -ZWQuCgo+PiArCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIiVkXG4iLCB2YWx1ZSk7 -Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfaW5wdXQsIFNf -SVJVR08sIGx0YzI5OTBfc2hvd192YWx1ZSwgTlVMTCwKPj4gKwkJCSAgTFRDMjk5MF9USU5UX01T -Qik7Cj4+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGN1cnIxX2lucHV0LCBTX0lSVUdPLCBs -dGMyOTkwX3Nob3dfdmFsdWUsIE5VTEwsCj4+ICsJCQkgIExUQzI5OTBfVjFfTVNCKTsKPj4gK3N0 -YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoY3VycjJfaW5wdXQsIFNfSVJVR08sIGx0YzI5OTBfc2hv -d192YWx1ZSwgTlVMTCwKPj4gKwkJCSAgTFRDMjk5MF9WM19NU0IpOwo+PiArc3RhdGljIFNFTlNP -Ul9ERVZJQ0VfQVRUUihpbjBfaW5wdXQsIFNfSVJVR08sIGx0YzI5OTBfc2hvd192YWx1ZSwgTlVM -TCwKPj4gKwkJCSAgTFRDMjk5MF9WQ0NfTVNCKTsKPj4gKwo+PiArc3RhdGljIHN0cnVjdCBhdHRy -aWJ1dGUgKmx0YzI5OTBfYXR0cnNbXSA9IHsKPj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2lu -cHV0LmRldl9hdHRyLmF0dHIsCj4+ICsJJnNlbnNvcl9kZXZfYXR0cl9jdXJyMV9pbnB1dC5kZXZf -YXR0ci5hdHRyLAo+PiArCSZzZW5zb3JfZGV2X2F0dHJfY3VycjJfaW5wdXQuZGV2X2F0dHIuYXR0 -ciwKPj4gKwkmc2Vuc29yX2Rldl9hdHRyX2luMF9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+PiArCU5V -TEwsCj4+ICt9Owo+PiArQVRUUklCVVRFX0dST1VQUyhsdGMyOTkwKTsKPj4gKwo+PiArc3RhdGlj -IGludCBsdGMyOTkwX2kyY19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqaTJjLAo+PiArCQkJICAg -ICBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCj4+ICt7Cj4+ICsJaW50IHJldDsKPj4g -KwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7Cj4+ICsKPj4gKwlpZiAoIWkyY19jaGVja19mdW5j -dGlvbmFsaXR5KGkyYy0+YWRhcHRlciwgSTJDX0ZVTkNfU01CVVNfQllURV9EQVRBIHwKPj4gKwkJ -CQkgICAgIEkyQ19GVU5DX1NNQlVTX1dPUkRfREFUQSkpCj4+ICsJCXJldHVybiAtRU5PREVWOwo+ -PiArCj4+ICsJLyogU2V0dXAgY29udGludW91cyBtb2RlLCBjdXJyZW50IG1vbml0b3IgKi8KPj4g -KwlyZXQgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGkyYywgTFRDMjk5MF9DT05UUk9MLAo+ -PiArCQkJCQlMVEMyOTkwX0NPTlRST0xfTUVBU1VSRV9BTEwgfAo+PiArCQkJCQlMVEMyOTkwX0NP -TlRST0xfTU9ERV9DVVJSRU5UKTsKPj4gKwlpZiAocmV0IDwgMCkgewo+PiArCQlkZXZfZXJyKCZp -MmMtPmRldiwgIkVycm9yOiBGYWlsZWQgdG8gc2V0IGNvbnRyb2wgbW9kZS5cbiIpOwo+PiArCQly -ZXR1cm4gcmV0Owo+PiArCX0KPj4gKwkvKiBUcmlnZ2VyIG9uY2UgdG8gc3RhcnQgY29udGludW91 -cyBjb252ZXJzaW9uICovCj4+ICsJcmV0ID0gaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0YShpMmMs -IExUQzI5OTBfVFJJR0dFUiwgMSk7Cj4+ICsJaWYgKHJldCA8IDApIHsKPj4gKwkJZGV2X2Vycigm -aTJjLT5kZXYsICJFcnJvcjogRmFpbGVkIHRvIHN0YXJ0IGFjcXVpc2l0aW9uLlxuIik7Cj4+ICsJ -CXJldHVybiByZXQ7Cj4+ICsJfQo+PiArCj4+ICsJaHdtb25fZGV2ID0gZGV2bV9od21vbl9kZXZp -Y2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoJmkyYy0+ZGV2LAo+PiArCQkJCQkJCSAgIGkyYy0+bmFt -ZSwKPj4gKwkJCQkJCQkgICBpMmMsCj4+ICsJCQkJCQkJICAgbHRjMjk5MF9ncm91cHMpOwo+PiAr -Cj4+ICsJcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9kZXYpOwo+PiArfQo+PiArCj4+ICtz -dGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgbHRjMjk5MF9pMmNfaWRbXSA9IHsKPj4g -Kwl7ICJsdGMyOTkwIiwgMCB9LAo+PiArCXt9Cj4+ICt9Owo+PiArTU9EVUxFX0RFVklDRV9UQUJM -RShpMmMsIGx0YzI5OTBfaTJjX2lkKTsKPj4gKwo+PiArc3RhdGljIHN0cnVjdCBpMmNfZHJpdmVy -IGx0YzI5OTBfaTJjX2RyaXZlciA9IHsKPj4gKwkuZHJpdmVyID0gewo+PiArCQkubmFtZSA9ICJs -dGMyOTkwIiwKPj4gKwl9LAo+PiArCS5wcm9iZSAgICA9IGx0YzI5OTBfaTJjX3Byb2JlLAo+PiAr -CS5pZF90YWJsZSA9IGx0YzI5OTBfaTJjX2lkLAo+PiArfTsKPj4gKwo+PiArbW9kdWxlX2kyY19k -cml2ZXIobHRjMjk5MF9pMmNfZHJpdmVyKTsKPj4gKwo+PiArTU9EVUxFX0RFU0NSSVBUSU9OKCJM -VEMyOTkwIFNlbnNvciBEcml2ZXIiKTsKPj4gK01PRFVMRV9BVVRIT1IoIlRvcGljIEVtYmVkZGVk -IFByb2R1Y3RzIik7Cj4+ICtNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7Cj4+IC0tCj4+IDEuOS4x -Cj4+CgoKCktpbmQgcmVnYXJkcywKCk1pa2UgTG9vaWptYW5zClN5c3RlbSBFeHBlcnQKClRPUElD -IEVtYmVkZGVkIFByb2R1Y3RzCkVpbmRob3ZlbnNld2VnIDMyLUMsIE5MLTU2ODMgS0ggQmVzdApQ -b3N0YnVzIDQ0MCwgTkwtNTY4MCBBSyBCZXN0ClRlbGVmb29uOiArMzEgKDApIDQ5OSAzMyA2OSA3 -OQpFLW1haWw6IG1pa2UubG9vaWptYW5zQHRvcGljcHJvZHVjdHMuY29tCldlYnNpdGU6IHd3dy50 -b3BpY3Byb2R1Y3RzLmNvbQoKUGxlYXNlIGNvbnNpZGVyIHRoZSBlbnZpcm9ubWVudCBiZWZvcmUg -cHJpbnRpbmcgdGhpcyBlLW1haWwKCgoKCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f -X19fX19fX19fX19fX19fX18KbG0tc2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1z -ZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9s -bS1zZW5zb3Jz +On 14-01-16 20:14, Guenter Roeck wrote: +> On Wed, Jan 13, 2016 at 03:45:01PM +0100, Mike Looijmans wrote: +>> This adds support for the Linear Technology LTC2990 I2C System Monitor. +>> The LTC2990 supports a combination of voltage, current and temperature +>> monitoring. This driver currently only supports reading two currents +>> by measuring two differential voltages across series resistors, in +>> addition to the Vcc supply voltage and internal temperature. +>> +>> This is sufficient to support the Topic Miami SOM which uses this chip +>> to monitor the currents flowing into the FPGA and the CPU parts. +>> +>> Signed-off-by: Mike Looijmans <mike.looijmans@topic.nl> +> +> Hi Mike, +> +> almost there. Please see inline. + +Great, I'll order some cake :) + +Expect v4 in a few minutes, I'm testing it on the hardware now. + +> Thanks, +> Guenter +> +>> --- +>> v3: Remove unused includes. +>> Remove (most) unused register defines. +>> Also check on SMBUS WORD capability. +>> Use register defines as value indices. +>> Alignment fixups with "(". +>> v2: Processed all review comments. +>> Put chip into continuous measurement mode. +>> Added ducumentation. +>> Use standard hwmon interfaces and macros. +>> +>> Documentation/hwmon/ltc2990 | 44 ++++++++++++ +>> drivers/hwmon/Kconfig | 14 ++++ +>> drivers/hwmon/Makefile | 1 + +>> drivers/hwmon/ltc2990.c | 159 ++++++++++++++++++++++++++++++++++++++++++++ +>> 4 files changed, 218 insertions(+) +>> create mode 100644 Documentation/hwmon/ltc2990 +>> create mode 100644 drivers/hwmon/ltc2990.c +>> +>> diff --git a/Documentation/hwmon/ltc2990 b/Documentation/hwmon/ltc2990 +>> new file mode 100644 +>> index 0000000..838b74e +>> --- /dev/null +>> +++ b/Documentation/hwmon/ltc2990 +>> @@ -0,0 +1,44 @@ +>> +Kernel driver ltc2990 +>> +===================== +>> + +>> +Supported chips: +>> + * Linear Technology LTC2990 +>> + Prefix: 'ltc2990' +>> + Addresses scanned: - +>> + Datasheet: http://www.linear.com/product/ltc2990 +>> + +>> +Author: Mike Looijmans <mike.looijmans@topic.nl> +>> + +>> + +>> +Description +>> +----------- +>> + +>> +LTC2990 is a Quad I2C Voltage, Current and Temperature Monitor. +>> +The chip's inputs can measure 4 voltages, or two inputs together (1+2 and 3+4) +>> +can be combined to measure a differential voltage, which is typically used to +>> +measure current through a series resistor, or a temperature. +>> + +>> +This driver currently uses the 2x differential mode only. In order to support +>> +other modes, the driver will need to be expanded. +>> + +>> + +>> +Usage Notes +>> +----------- +>> + +>> +This driver does not probe for PMBus devices. You will have to instantiate +>> +devices explicitly. +>> + +>> + +>> +Sysfs attributes +>> +---------------- +>> + +>> +The "curr*_input" measurements actually report the voltage drop across the +>> +input pins in microvolts. This is equivalent to the current through a 1mOhm +>> +sense resistor. Divide the reported value by the actual sense resistor value +>> +in mOhm to get the actual value. +>> + +>> +in0_input Voltage at Vcc pin in millivolt (range 2.5V to 5V) +>> +temp1_input Internal chip temperature in millidegrees Celcius +>> +curr1_input Current in mA across v1-v2 assuming a 1mOhm sense resistor. +>> +curr2_input Current in mA across v3-v4 assuming a 1mOhm sense resistor. +>> + +>> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig +>> index 80a73bf..8a31d64 100644 +>> --- a/drivers/hwmon/Kconfig +>> +++ b/drivers/hwmon/Kconfig +>> @@ -685,6 +685,20 @@ config SENSORS_LTC2945 +>> This driver can also be built as a module. If so, the module will +>> be called ltc2945. +>> +>> +config SENSORS_LTC2990 +>> + tristate "Linear Technology LTC2990 (current monitoring mode only)" +>> + depends on I2C +>> + help +>> + If you say yes here you get support for Linear Technology LTC2990 +>> + I2C System Monitor. The LTC2990 supports a combination of voltage, +>> + current and temperature monitoring, but in addition to the Vcc supply +>> + voltage and chip temperature, this driver currently only supports +>> + reading two currents by measuring two differential voltages across +>> + series resistors. +>> + +>> + This driver can also be built as a module. If so, the module will +>> + be called ltc2990. +>> + +>> config SENSORS_LTC4151 +>> tristate "Linear Technology LTC4151" +>> depends on I2C +>> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile +>> index 12a3239..e4bd15b 100644 +>> --- a/drivers/hwmon/Makefile +>> +++ b/drivers/hwmon/Makefile +>> @@ -101,6 +101,7 @@ obj-$(CONFIG_SENSORS_LM95234) += lm95234.o +>> obj-$(CONFIG_SENSORS_LM95241) += lm95241.o +>> obj-$(CONFIG_SENSORS_LM95245) += lm95245.o +>> obj-$(CONFIG_SENSORS_LTC2945) += ltc2945.o +>> +obj-$(CONFIG_SENSORS_LTC2990) += ltc2990.o +>> obj-$(CONFIG_SENSORS_LTC4151) += ltc4151.o +>> obj-$(CONFIG_SENSORS_LTC4215) += ltc4215.o +>> obj-$(CONFIG_SENSORS_LTC4222) += ltc4222.o +>> diff --git a/drivers/hwmon/ltc2990.c b/drivers/hwmon/ltc2990.c +>> new file mode 100644 +>> index 0000000..37ca5f4 +>> --- /dev/null +>> +++ b/drivers/hwmon/ltc2990.c +>> @@ -0,0 +1,159 @@ +>> +/* +>> + * Driver for Linear Technology LTC2990 power monitor +>> + * +>> + * Copyright (C) 2014 Topic Embedded Products +>> + * Author: Mike Looijmans <mike.looijmans@topic.nl> +>> + * +>> + * License: GPLv2 +>> + * +>> + * This driver assumes the chip is wired as a dual current monitor, and +>> + * reports the voltage drop across two series resistors. It also reports +>> + * the chip's internal temperature and Vcc power supply voltage. +>> + */ +>> + +>> +#include <linux/err.h> +>> +#include <linux/hwmon.h> +>> +#include <linux/hwmon-sysfs.h> +>> +#include <linux/i2c.h> +>> +#include <linux/kernel.h> +>> +#include <linux/module.h> +>> + +>> +#define LTC2990_STATUS 0x00 +>> +#define LTC2990_CONTROL 0x01 +>> +#define LTC2990_TRIGGER 0x02 +>> +#define LTC2990_TINT_MSB 0x04 +>> +#define LTC2990_V1_MSB 0x06 +>> +#define LTC2990_V2_MSB 0x08 +>> +#define LTC2990_V3_MSB 0x0A +>> +#define LTC2990_V4_MSB 0x0C +>> +#define LTC2990_VCC_MSB 0x0E +>> + +>> +#define LTC2990_CONTROL_KELVIN BIT(7) +>> +#define LTC2990_CONTROL_SINGLE BIT(6) +>> +#define LTC2990_CONTROL_MEASURE_ALL (0x3 << 3) +>> +#define LTC2990_CONTROL_MODE_CURRENT 0x06 +>> +#define LTC2990_CONTROL_MODE_VOLTAGE 0x07 +>> + +>> +/* convert raw register value to sign-extended integer in 16-bit range */ +>> +static int ltc2990_voltage_to_int(int raw) +>> +{ +>> + if (raw & BIT(14)) { +>> + return -(0x4000 - (raw & 0x3FFF)) << 2; +>> + } else { +>> + return (raw & 0x3FFF) << 2; +>> + } +> +> Unnecessary { }. Please see checkpatch warning. + +I'll make sure to run checkpatch again. Its only remaining warning is about +MAINTAINERS now. + +>> +} +>> + +>> +/* Return the converted value from the given register in uV or mC */ +>> +static int ltc2990_get_value(struct i2c_client *i2c, u8 reg) +>> +{ +>> + int val; +>> + int result; +>> + +>> + val = i2c_smbus_read_word_swapped(i2c, reg); +>> + if (unlikely(val < 0)) +>> + return val; +> +> This suggests the function returns a value < 0 on error ... + +Misleading, since most of the valid results can be negative. I'll change the +method to return a result code and take a result pointer instead. + +> +>> + switch (reg) { +>> + case LTC2990_TINT_MSB: +>> + /* internal temp, 0.0625 degrees/LSB, 13-bit */ +>> + val = (val & 0x1FFF) << 3; +>> + result = (val * 1000) >> 7; +>> + break; +>> + case LTC2990_V1_MSB: +>> + case LTC2990_V3_MSB: +>> + /* Vx-Vy, 19.42uV/LSB. Depends on mode. */ +>> + result = ltc2990_voltage_to_int(val) * 1942 / (4 * 100); +>> + break; +>> + case LTC2990_VCC_MSB: +>> + /* Vcc, 305.18μV/LSB, 2.5V offset */ +>> + result = ltc2990_voltage_to_int(val) * 30518 / (4 * 100 * 1000); +>> + result += 2500; +>> + break; +>> + default: +>> + result = 0; /* won't happen, keep compiler happy */ +> +> Given that, we can return some error here, and ... +> +>> + break; +>> + } +>> + +>> + return result; +>> +} +>> + +>> +static ssize_t ltc2990_show_value(struct device *dev, +>> + struct device_attribute *da, char *buf) +>> +{ +>> + struct sensor_device_attribute *attr = to_sensor_dev_attr(da); +>> + int value; +>> + +>> + value = ltc2990_get_value(dev_get_drvdata(dev), attr->index); +> +> ... we should actually check the error return here. +> +> if (value < 0) +> return value; + +Yes, with the change above, it can properly return an error code if the I2C +transaction failed. + +>> + return snprintf(buf, PAGE_SIZE, "%d\n", value); +>> +} +>> + +>> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ltc2990_show_value, NULL, +>> + LTC2990_TINT_MSB); +>> +static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc2990_show_value, NULL, +>> + LTC2990_V1_MSB); +>> +static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc2990_show_value, NULL, +>> + LTC2990_V3_MSB); +>> +static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ltc2990_show_value, NULL, +>> + LTC2990_VCC_MSB); +>> + +>> +static struct attribute *ltc2990_attrs[] = { +>> + &sensor_dev_attr_temp1_input.dev_attr.attr, +>> + &sensor_dev_attr_curr1_input.dev_attr.attr, +>> + &sensor_dev_attr_curr2_input.dev_attr.attr, +>> + &sensor_dev_attr_in0_input.dev_attr.attr, +>> + NULL, +>> +}; +>> +ATTRIBUTE_GROUPS(ltc2990); +>> + +>> +static int ltc2990_i2c_probe(struct i2c_client *i2c, +>> + const struct i2c_device_id *id) +>> +{ +>> + int ret; +>> + struct device *hwmon_dev; +>> + +>> + if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA | +>> + I2C_FUNC_SMBUS_WORD_DATA)) +>> + return -ENODEV; +>> + +>> + /* Setup continuous mode, current monitor */ +>> + ret = i2c_smbus_write_byte_data(i2c, LTC2990_CONTROL, +>> + LTC2990_CONTROL_MEASURE_ALL | +>> + LTC2990_CONTROL_MODE_CURRENT); +>> + if (ret < 0) { +>> + dev_err(&i2c->dev, "Error: Failed to set control mode.\n"); +>> + return ret; +>> + } +>> + /* Trigger once to start continuous conversion */ +>> + ret = i2c_smbus_write_byte_data(i2c, LTC2990_TRIGGER, 1); +>> + if (ret < 0) { +>> + dev_err(&i2c->dev, "Error: Failed to start acquisition.\n"); +>> + return ret; +>> + } +>> + +>> + hwmon_dev = devm_hwmon_device_register_with_groups(&i2c->dev, +>> + i2c->name, +>> + i2c, +>> + ltc2990_groups); +>> + +>> + return PTR_ERR_OR_ZERO(hwmon_dev); +>> +} +>> + +>> +static const struct i2c_device_id ltc2990_i2c_id[] = { +>> + { "ltc2990", 0 }, +>> + {} +>> +}; +>> +MODULE_DEVICE_TABLE(i2c, ltc2990_i2c_id); +>> + +>> +static struct i2c_driver ltc2990_i2c_driver = { +>> + .driver = { +>> + .name = "ltc2990", +>> + }, +>> + .probe = ltc2990_i2c_probe, +>> + .id_table = ltc2990_i2c_id, +>> +}; +>> + +>> +module_i2c_driver(ltc2990_i2c_driver); +>> + +>> +MODULE_DESCRIPTION("LTC2990 Sensor Driver"); +>> +MODULE_AUTHOR("Topic Embedded Products"); +>> +MODULE_LICENSE("GPL v2"); +>> -- +>> 1.9.1 +>> + + + +Kind regards, + +Mike Looijmans +System Expert + +TOPIC Embedded Products +Eindhovenseweg 32-C, NL-5683 KH Best +Postbus 440, NL-5680 AK Best +Telefoon: +31 (0) 499 33 69 79 +E-mail: mike.looijmans@topicproducts.com +Website: www.topicproducts.com + +Please consider the environment before printing this e-mail diff --git a/a/content_digest b/N1/content_digest index de8a2a9..3baa640 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -2,210 +2,352 @@ "ref\01452696301-28761-1-git-send-email-mike.looijmans@topic.nl\0" "ref\020160114191415.GA30413@roeck-us.net\0" "From\0Mike Looijmans <mike.looijmans@topic.nl>\0" - "Subject\0Re: [lm-sensors] [PATCH v3] hwmon: Add LTC2990 sensor driver\0" - "Date\0Fri, 15 Jan 2016 09:54:37 +0000\0" + "Subject\0Re: [PATCH v3] hwmon: Add LTC2990 sensor driver\0" + "Date\0Fri, 15 Jan 2016 10:54:37 +0100\0" "To\0Guenter Roeck <linux@roeck-us.net>\0" - "Cc\0lm-sensors@lm-sensors.org" - jdelvare@suse.com - " linux-kernel@vger.kernel.org\0" + "Cc\0<lm-sensors@lm-sensors.org>" + <jdelvare@suse.com> + " <linux-kernel@vger.kernel.org>\0" "\00:1\0" "b\0" - "77u/T24gMTQtMDEtMTYgMjA6MTQsIEd1ZW50ZXIgUm9lY2sgd3JvdGU6Cj4gT24gV2VkLCBKYW4g\n" - "MTMsIDIwMTYgYXQgMDM6NDU6MDFQTSArMDEwMCwgTWlrZSBMb29pam1hbnMgd3JvdGU6Cj4+IFRo\n" - "aXMgYWRkcyBzdXBwb3J0IGZvciB0aGUgTGluZWFyIFRlY2hub2xvZ3kgTFRDMjk5MCAgSTJDIFN5\n" - "c3RlbSBNb25pdG9yLgo+PiBUaGUgTFRDMjk5MCBzdXBwb3J0cyBhIGNvbWJpbmF0aW9uIG9mIHZv\n" - "bHRhZ2UsIGN1cnJlbnQgYW5kIHRlbXBlcmF0dXJlCj4+IG1vbml0b3JpbmcuIFRoaXMgZHJpdmVy\n" - "IGN1cnJlbnRseSBvbmx5IHN1cHBvcnRzIHJlYWRpbmcgdHdvIGN1cnJlbnRzCj4+IGJ5IG1lYXN1\n" - "cmluZyB0d28gZGlmZmVyZW50aWFsIHZvbHRhZ2VzIGFjcm9zcyBzZXJpZXMgcmVzaXN0b3JzLCBp\n" - "bgo+PiBhZGRpdGlvbiB0byB0aGUgVmNjIHN1cHBseSB2b2x0YWdlIGFuZCBpbnRlcm5hbCB0ZW1w\n" - "ZXJhdHVyZS4KPj4KPj4gVGhpcyBpcyBzdWZmaWNpZW50IHRvIHN1cHBvcnQgdGhlIFRvcGljIE1p\n" - "YW1pIFNPTSB3aGljaCB1c2VzIHRoaXMgY2hpcAo+PiB0byBtb25pdG9yIHRoZSBjdXJyZW50cyBm\n" - "bG93aW5nIGludG8gdGhlIEZQR0EgYW5kIHRoZSBDUFUgcGFydHMuCj4+Cj4+IFNpZ25lZC1vZmYt\n" - "Ynk6IE1pa2UgTG9vaWptYW5zIDxtaWtlLmxvb2lqbWFuc0B0b3BpYy5ubD4KPgo+IEhpIE1pa2Us\n" - "Cj4KPiBhbG1vc3QgdGhlcmUuIFBsZWFzZSBzZWUgaW5saW5lLgoKR3JlYXQsIEknbGwgb3JkZXIg\n" - "c29tZSBjYWtlIDopCgpFeHBlY3QgdjQgaW4gYSBmZXcgbWludXRlcywgSSdtIHRlc3RpbmcgaXQg\n" - "b24gdGhlIGhhcmR3YXJlIG5vdy4KCj4gVGhhbmtzLAo+IEd1ZW50ZXIKPgo+PiAtLS0KPj4gdjM6\n" - "IFJlbW92ZSB1bnVzZWQgaW5jbHVkZXMuCj4+ICAgICAgUmVtb3ZlIChtb3N0KSB1bnVzZWQgcmVn\n" - "aXN0ZXIgZGVmaW5lcy4KPj4gICAgICBBbHNvIGNoZWNrIG9uIFNNQlVTIFdPUkQgY2FwYWJpbGl0\n" - "eS4KPj4gICAgICBVc2UgcmVnaXN0ZXIgZGVmaW5lcyBhcyB2YWx1ZSBpbmRpY2VzLgo+PiAgICAg\n" - "IEFsaWdubWVudCBmaXh1cHMgd2l0aCAiKCIuCj4+IHYyOiBQcm9jZXNzZWQgYWxsIHJldmlldyBj\n" - "b21tZW50cy4KPj4gICAgICAgUHV0IGNoaXAgaW50byBjb250aW51b3VzIG1lYXN1cmVtZW50IG1v\n" - "ZGUuCj4+ICAgICAgIEFkZGVkIGR1Y3VtZW50YXRpb24uCj4+ICAgICAgIFVzZSBzdGFuZGFyZCBo\n" - "d21vbiBpbnRlcmZhY2VzIGFuZCBtYWNyb3MuCj4+Cj4+ICAgRG9jdW1lbnRhdGlvbi9od21vbi9s\n" - "dGMyOTkwIHwgIDQ0ICsrKysrKysrKysrKwo+PiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAg\n" - "ICB8ICAxNCArKysrCj4+ICAgZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgIHwgICAxICsKPj4g\n" - "ICBkcml2ZXJzL2h3bW9uL2x0YzI5OTAuYyAgICAgfCAxNTkgKysrKysrKysrKysrKysrKysrKysr\n" - "KysrKysrKysrKysrKysrKysrKysrKysKPj4gICA0IGZpbGVzIGNoYW5nZWQsIDIxOCBpbnNlcnRp\n" - "b25zKCspCj4+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vaHdtb24vbHRjMjk5\n" - "MAo+PiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2h3bW9uL2x0YzI5OTAuYwo+Pgo+PiBk\n" - "aWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9od21vbi9sdGMyOTkwIGIvRG9jdW1lbnRhdGlvbi9o\n" - "d21vbi9sdGMyOTkwCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjgz\n" - "OGI3NGUKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL2x0YzI5\n" - "OTAKPj4gQEAgLTAsMCArMSw0NCBAQAo+PiArS2VybmVsIGRyaXZlciBsdGMyOTkwCj4+ICs9PT09\n" - "PT09PT09PT09PT09PT09PT0KPj4gKwo+PiArU3VwcG9ydGVkIGNoaXBzOgo+PiArICAqIExpbmVh\n" - "ciBUZWNobm9sb2d5IExUQzI5OTAKPj4gKyAgICBQcmVmaXg6ICdsdGMyOTkwJwo+PiArICAgIEFk\n" - "ZHJlc3NlcyBzY2FubmVkOiAtCj4+ICsgICAgRGF0YXNoZWV0OiBodHRwOi8vd3d3LmxpbmVhci5j\n" - "b20vcHJvZHVjdC9sdGMyOTkwCj4+ICsKPj4gK0F1dGhvcjogTWlrZSBMb29pam1hbnMgPG1pa2Uu\n" - "bG9vaWptYW5zQHRvcGljLm5sPgo+PiArCj4+ICsKPj4gK0Rlc2NyaXB0aW9uCj4+ICstLS0tLS0t\n" - "LS0tLQo+PiArCj4+ICtMVEMyOTkwIGlzIGEgUXVhZCBJMkMgVm9sdGFnZSwgQ3VycmVudCBhbmQg\n" - "VGVtcGVyYXR1cmUgTW9uaXRvci4KPj4gK1RoZSBjaGlwJ3MgaW5wdXRzIGNhbiBtZWFzdXJlIDQg\n" - "dm9sdGFnZXMsIG9yIHR3byBpbnB1dHMgdG9nZXRoZXIgKDErMiBhbmQgMys0KQo+PiArY2FuIGJl\n" - "IGNvbWJpbmVkIHRvIG1lYXN1cmUgYSBkaWZmZXJlbnRpYWwgdm9sdGFnZSwgd2hpY2ggaXMgdHlw\n" - "aWNhbGx5IHVzZWQgdG8KPj4gK21lYXN1cmUgY3VycmVudCB0aHJvdWdoIGEgc2VyaWVzIHJlc2lz\n" - "dG9yLCBvciBhIHRlbXBlcmF0dXJlLgo+PiArCj4+ICtUaGlzIGRyaXZlciBjdXJyZW50bHkgdXNl\n" - "cyB0aGUgMnggZGlmZmVyZW50aWFsIG1vZGUgb25seS4gSW4gb3JkZXIgdG8gc3VwcG9ydAo+PiAr\n" - "b3RoZXIgbW9kZXMsIHRoZSBkcml2ZXIgd2lsbCBuZWVkIHRvIGJlIGV4cGFuZGVkLgo+PiArCj4+\n" - "ICsKPj4gK1VzYWdlIE5vdGVzCj4+ICstLS0tLS0tLS0tLQo+PiArCj4+ICtUaGlzIGRyaXZlciBk\n" - "b2VzIG5vdCBwcm9iZSBmb3IgUE1CdXMgZGV2aWNlcy4gWW91IHdpbGwgaGF2ZSB0byBpbnN0YW50\n" - "aWF0ZQo+PiArZGV2aWNlcyBleHBsaWNpdGx5Lgo+PiArCj4+ICsKPj4gK1N5c2ZzIGF0dHJpYnV0\n" - "ZXMKPj4gKy0tLS0tLS0tLS0tLS0tLS0KPj4gKwo+PiArVGhlICJjdXJyKl9pbnB1dCIgbWVhc3Vy\n" - "ZW1lbnRzIGFjdHVhbGx5IHJlcG9ydCB0aGUgdm9sdGFnZSBkcm9wIGFjcm9zcyB0aGUKPj4gK2lu\n" - "cHV0IHBpbnMgaW4gbWljcm92b2x0cy4gVGhpcyBpcyBlcXVpdmFsZW50IHRvIHRoZSBjdXJyZW50\n" - "IHRocm91Z2ggYSAxbU9obQo+PiArc2Vuc2UgcmVzaXN0b3IuIERpdmlkZSB0aGUgcmVwb3J0ZWQg\n" - "dmFsdWUgYnkgdGhlIGFjdHVhbCBzZW5zZSByZXNpc3RvciB2YWx1ZQo+PiAraW4gbU9obSB0byBn\n" - "ZXQgdGhlIGFjdHVhbCB2YWx1ZS4KPj4gKwo+PiAraW4wX2lucHV0ICAgICBWb2x0YWdlIGF0IFZj\n" - "YyBwaW4gaW4gbWlsbGl2b2x0IChyYW5nZSAyLjVWIHRvIDVWKQo+PiArdGVtcDFfaW5wdXQgICBJ\n" - "bnRlcm5hbCBjaGlwIHRlbXBlcmF0dXJlIGluIG1pbGxpZGVncmVlcyBDZWxjaXVzCj4+ICtjdXJy\n" - "MV9pbnB1dCAgIEN1cnJlbnQgaW4gbUEgYWNyb3NzIHYxLXYyIGFzc3VtaW5nIGEgMW1PaG0gc2Vu\n" - "c2UgcmVzaXN0b3IuCj4+ICtjdXJyMl9pbnB1dCAgIEN1cnJlbnQgaW4gbUEgYWNyb3NzIHYzLXY0\n" - "IGFzc3VtaW5nIGEgMW1PaG0gc2Vuc2UgcmVzaXN0b3IuCj4+ICsKPj4gZGlmZiAtLWdpdCBhL2Ry\n" - "aXZlcnMvaHdtb24vS2NvbmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+PiBpbmRleCA4MGE3\n" - "M2JmLi44YTMxZDY0IDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcKPj4gKysr\n" - "IGIvZHJpdmVycy9od21vbi9LY29uZmlnCj4+IEBAIC02ODUsNiArNjg1LDIwIEBAIGNvbmZpZyBT\n" - "RU5TT1JTX0xUQzI5NDUKPj4gICAJICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBh\n" - "IG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUgd2lsbAo+PiAgIAkgIGJlIGNhbGxlZCBsdGMyOTQ1\n" - "Lgo+Pgo+PiArY29uZmlnIFNFTlNPUlNfTFRDMjk5MAo+PiArCXRyaXN0YXRlICJMaW5lYXIgVGVj\n" - "aG5vbG9neSBMVEMyOTkwIChjdXJyZW50IG1vbml0b3JpbmcgbW9kZSBvbmx5KSIKPj4gKwlkZXBl\n" - "bmRzIG9uIEkyQwo+PiArCWhlbHAKPj4gKwkgIElmIHlvdSBzYXkgeWVzIGhlcmUgeW91IGdldCBz\n" - "dXBwb3J0IGZvciBMaW5lYXIgVGVjaG5vbG9neSBMVEMyOTkwCj4+ICsJICBJMkMgU3lzdGVtIE1v\n" - "bml0b3IuIFRoZSBMVEMyOTkwIHN1cHBvcnRzIGEgY29tYmluYXRpb24gb2Ygdm9sdGFnZSwKPj4g\n" - "KwkgIGN1cnJlbnQgYW5kIHRlbXBlcmF0dXJlIG1vbml0b3JpbmcsIGJ1dCBpbiBhZGRpdGlvbiB0\n" - "byB0aGUgVmNjIHN1cHBseQo+PiArCSAgdm9sdGFnZSBhbmQgY2hpcCB0ZW1wZXJhdHVyZSwgdGhp\n" - "cyBkcml2ZXIgY3VycmVudGx5IG9ubHkgc3VwcG9ydHMKPj4gKwkgIHJlYWRpbmcgdHdvIGN1cnJl\n" - "bnRzIGJ5IG1lYXN1cmluZyB0d28gZGlmZmVyZW50aWFsIHZvbHRhZ2VzIGFjcm9zcwo+PiArCSAg\n" - "c2VyaWVzIHJlc2lzdG9ycy4KPj4gKwo+PiArCSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVp\n" - "bHQgYXMgYSBtb2R1bGUuIElmIHNvLCB0aGUgbW9kdWxlIHdpbGwKPj4gKwkgIGJlIGNhbGxlZCBs\n" - "dGMyOTkwLgo+PiArCj4+ICAgY29uZmlnIFNFTlNPUlNfTFRDNDE1MQo+PiAgIAl0cmlzdGF0ZSAi\n" - "TGluZWFyIFRlY2hub2xvZ3kgTFRDNDE1MSIKPj4gICAJZGVwZW5kcyBvbiBJMkMKPj4gZGlmZiAt\n" - "LWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+\n" - "IGluZGV4IDEyYTMyMzkuLmU0YmQxNWIgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFr\n" - "ZWZpbGUKPj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+PiBAQCAtMTAxLDYgKzEwMSw3\n" - "IEBAIG9iai0kKENPTkZJR19TRU5TT1JTX0xNOTUyMzQpCSs9IGxtOTUyMzQubwo+PiAgIG9iai0k\n" - "KENPTkZJR19TRU5TT1JTX0xNOTUyNDEpCSs9IGxtOTUyNDEubwo+PiAgIG9iai0kKENPTkZJR19T\n" - "RU5TT1JTX0xNOTUyNDUpCSs9IGxtOTUyNDUubwo+PiAgIG9iai0kKENPTkZJR19TRU5TT1JTX0xU\n" - "QzI5NDUpCSs9IGx0YzI5NDUubwo+PiArb2JqLSQoQ09ORklHX1NFTlNPUlNfTFRDMjk5MCkJKz0g\n" - "bHRjMjk5MC5vCj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfTFRDNDE1MSkJKz0gbHRjNDE1MS5v\n" - "Cj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfTFRDNDIxNSkJKz0gbHRjNDIxNS5vCj4+ICAgb2Jq\n" - "LSQoQ09ORklHX1NFTlNPUlNfTFRDNDIyMikJKz0gbHRjNDIyMi5vCj4+IGRpZmYgLS1naXQgYS9k\n" - "cml2ZXJzL2h3bW9uL2x0YzI5OTAuYyBiL2RyaXZlcnMvaHdtb24vbHRjMjk5MC5jCj4+IG5ldyBm\n" - "aWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjM3Y2E1ZjQKPj4gLS0tIC9kZXYvbnVs\n" - "bAo+PiArKysgYi9kcml2ZXJzL2h3bW9uL2x0YzI5OTAuYwo+PiBAQCAtMCwwICsxLDE1OSBAQAo+\n" - "PiArLyoKPj4gKyAqIERyaXZlciBmb3IgTGluZWFyIFRlY2hub2xvZ3kgTFRDMjk5MCBwb3dlciBt\n" - "b25pdG9yCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDE0IFRvcGljIEVtYmVkZGVkIFBy\n" - "b2R1Y3RzCj4+ICsgKiBBdXRob3I6IE1pa2UgTG9vaWptYW5zIDxtaWtlLmxvb2lqbWFuc0B0b3Bp\n" - "Yy5ubD4KPj4gKyAqCj4+ICsgKiBMaWNlbnNlOiBHUEx2Mgo+PiArICoKPj4gKyAqIFRoaXMgZHJp\n" - "dmVyIGFzc3VtZXMgdGhlIGNoaXAgaXMgd2lyZWQgYXMgYSBkdWFsIGN1cnJlbnQgbW9uaXRvciwg\n" - "YW5kCj4+ICsgKiByZXBvcnRzIHRoZSB2b2x0YWdlIGRyb3AgYWNyb3NzIHR3byBzZXJpZXMgcmVz\n" - "aXN0b3JzLiBJdCBhbHNvIHJlcG9ydHMKPj4gKyAqIHRoZSBjaGlwJ3MgaW50ZXJuYWwgdGVtcGVy\n" - "YXR1cmUgYW5kIFZjYyBwb3dlciBzdXBwbHkgdm9sdGFnZS4KPj4gKyAqLwo+PiArCj4+ICsjaW5j\n" - "bHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvaHdtb24uaD4KPj4gKyNpbmNs\n" - "dWRlIDxsaW51eC9od21vbi1zeXNmcy5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+PiAr\n" - "I2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+\n" - "PiArCj4+ICsjZGVmaW5lIExUQzI5OTBfU1RBVFVTCTB4MDAKPj4gKyNkZWZpbmUgTFRDMjk5MF9D\n" - "T05UUk9MCTB4MDEKPj4gKyNkZWZpbmUgTFRDMjk5MF9UUklHR0VSCTB4MDIKPj4gKyNkZWZpbmUg\n" - "TFRDMjk5MF9USU5UX01TQgkweDA0Cj4+ICsjZGVmaW5lIExUQzI5OTBfVjFfTVNCCTB4MDYKPj4g\n" - "KyNkZWZpbmUgTFRDMjk5MF9WMl9NU0IJMHgwOAo+PiArI2RlZmluZSBMVEMyOTkwX1YzX01TQgkw\n" - "eDBBCj4+ICsjZGVmaW5lIExUQzI5OTBfVjRfTVNCCTB4MEMKPj4gKyNkZWZpbmUgTFRDMjk5MF9W\n" - "Q0NfTVNCCTB4MEUKPj4gKwo+PiArI2RlZmluZSBMVEMyOTkwX0NPTlRST0xfS0VMVklOCQlCSVQo\n" - "NykKPj4gKyNkZWZpbmUgTFRDMjk5MF9DT05UUk9MX1NJTkdMRQkJQklUKDYpCj4+ICsjZGVmaW5l\n" - "IExUQzI5OTBfQ09OVFJPTF9NRUFTVVJFX0FMTAkoMHgzIDw8IDMpCj4+ICsjZGVmaW5lIExUQzI5\n" - "OTBfQ09OVFJPTF9NT0RFX0NVUlJFTlQJMHgwNgo+PiArI2RlZmluZSBMVEMyOTkwX0NPTlRST0xf\n" - "TU9ERV9WT0xUQUdFCTB4MDcKPj4gKwo+PiArLyogY29udmVydCByYXcgcmVnaXN0ZXIgdmFsdWUg\n" - "dG8gc2lnbi1leHRlbmRlZCBpbnRlZ2VyIGluIDE2LWJpdCByYW5nZSAqLwo+PiArc3RhdGljIGlu\n" - "dCBsdGMyOTkwX3ZvbHRhZ2VfdG9faW50KGludCByYXcpCj4+ICt7Cj4+ICsJaWYgKHJhdyAmIEJJ\n" - "VCgxNCkpIHsKPj4gKwkJcmV0dXJuIC0oMHg0MDAwIC0gKHJhdyAmIDB4M0ZGRikpIDw8IDI7Cj4+\n" - "ICsJfSBlbHNlIHsKPj4gKwkJcmV0dXJuIChyYXcgJiAweDNGRkYpIDw8IDI7Cj4+ICsJfQo+Cj4g\n" - "VW5uZWNlc3NhcnkgeyB9LiBQbGVhc2Ugc2VlIGNoZWNrcGF0Y2ggd2FybmluZy4KCkknbGwgbWFr\n" - "ZSBzdXJlIHRvIHJ1biBjaGVja3BhdGNoIGFnYWluLiBJdHMgb25seSByZW1haW5pbmcgd2Fybmlu\n" - "ZyBpcyBhYm91dCAKTUFJTlRBSU5FUlMgbm93LgoKPj4gK30KPj4gKwo+PiArLyogUmV0dXJuIHRo\n" - "ZSBjb252ZXJ0ZWQgdmFsdWUgZnJvbSB0aGUgZ2l2ZW4gcmVnaXN0ZXIgaW4gdVYgb3IgbUMgKi8K\n" - "Pj4gK3N0YXRpYyBpbnQgbHRjMjk5MF9nZXRfdmFsdWUoc3RydWN0IGkyY19jbGllbnQgKmkyYywg\n" - "dTggcmVnKQo+PiArewo+PiArCWludCB2YWw7Cj4+ICsJaW50IHJlc3VsdDsKPj4gKwo+PiArCXZh\n" - "bCA9IGkyY19zbWJ1c19yZWFkX3dvcmRfc3dhcHBlZChpMmMsIHJlZyk7Cj4+ICsJaWYgKHVubGlr\n" - "ZWx5KHZhbCA8IDApKQo+PiArCQlyZXR1cm4gdmFsOwo+Cj4gVGhpcyBzdWdnZXN0cyB0aGUgZnVu\n" - "Y3Rpb24gcmV0dXJucyBhIHZhbHVlIDwgMCBvbiBlcnJvciAuLi4KCk1pc2xlYWRpbmcsIHNpbmNl\n" - "IG1vc3Qgb2YgdGhlIHZhbGlkIHJlc3VsdHMgY2FuIGJlIG5lZ2F0aXZlLiBJJ2xsIGNoYW5nZSB0\n" - "aGUgCm1ldGhvZCB0byByZXR1cm4gYSByZXN1bHQgY29kZSBhbmQgdGFrZSBhIHJlc3VsdCBwb2lu\n" - "dGVyIGluc3RlYWQuCgo+Cj4+ICsJc3dpdGNoIChyZWcpIHsKPj4gKwljYXNlIExUQzI5OTBfVElO\n" - "VF9NU0I6Cj4+ICsJCS8qIGludGVybmFsIHRlbXAsIDAuMDYyNSBkZWdyZWVzL0xTQiwgMTMtYml0\n" - "ICAqLwo+PiArCQl2YWwgPSAodmFsICYgMHgxRkZGKSA8PCAzOwo+PiArCQlyZXN1bHQgPSAodmFs\n" - "ICogMTAwMCkgPj4gNzsKPj4gKwkJYnJlYWs7Cj4+ICsJY2FzZSBMVEMyOTkwX1YxX01TQjoKPj4g\n" - "KwljYXNlIExUQzI5OTBfVjNfTVNCOgo+PiArCQkgLyogVngtVnksIDE5LjQydVYvTFNCLiBEZXBl\n" - "bmRzIG9uIG1vZGUuICovCj4+ICsJCXJlc3VsdCA9IGx0YzI5OTBfdm9sdGFnZV90b19pbnQodmFs\n" - "KSAqIDE5NDIgLyAoNCAqIDEwMCk7Cj4+ICsJCWJyZWFrOwo+PiArCWNhc2UgTFRDMjk5MF9WQ0Nf\n" - "TVNCOgo+PiArCQkvKiBWY2MsIDMwNS4xOM68Vi9MU0IsIDIuNVYgb2Zmc2V0ICovCj4+ICsJCXJl\n" - "c3VsdCA9IGx0YzI5OTBfdm9sdGFnZV90b19pbnQodmFsKSAqIDMwNTE4IC8gKDQgKiAxMDAgKiAx\n" - "MDAwKTsKPj4gKwkJcmVzdWx0ICs9IDI1MDA7Cj4+ICsJCWJyZWFrOwo+PiArCWRlZmF1bHQ6Cj4+\n" - "ICsJCXJlc3VsdCA9IDA7IC8qIHdvbid0IGhhcHBlbiwga2VlcCBjb21waWxlciBoYXBweSAqLwo+\n" - "Cj4gR2l2ZW4gdGhhdCwgd2UgY2FuIHJldHVybiBzb21lIGVycm9yIGhlcmUsIGFuZCAuLi4KPgo+\n" - "PiArCQlicmVhazsKPj4gKwl9Cj4+ICsKPj4gKwlyZXR1cm4gcmVzdWx0Owo+PiArfQo+PiArCj4+\n" - "ICtzdGF0aWMgc3NpemVfdCBsdGMyOTkwX3Nob3dfdmFsdWUoc3RydWN0IGRldmljZSAqZGV2LAo+\n" - "PiArCQkJCSAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRhLCBjaGFyICpidWYpCj4+ICt7Cj4+\n" - "ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICphdHRyID0gdG9fc2Vuc29yX2Rldl9h\n" - "dHRyKGRhKTsKPj4gKwlpbnQgdmFsdWU7Cj4+ICsKPj4gKwl2YWx1ZSA9IGx0YzI5OTBfZ2V0X3Zh\n" - "bHVlKGRldl9nZXRfZHJ2ZGF0YShkZXYpLCBhdHRyLT5pbmRleCk7Cj4KPiAuLi4gd2Ugc2hvdWxk\n" - "IGFjdHVhbGx5IGNoZWNrIHRoZSBlcnJvciByZXR1cm4gaGVyZS4KPgo+IAlpZiAodmFsdWUgPCAw\n" - "KQo+IAkJcmV0dXJuIHZhbHVlOwoKWWVzLCB3aXRoIHRoZSBjaGFuZ2UgYWJvdmUsIGl0IGNhbiBw\n" - "cm9wZXJseSByZXR1cm4gYW4gZXJyb3IgY29kZSBpZiB0aGUgSTJDIAp0cmFuc2FjdGlvbiBmYWls\n" - "ZWQuCgo+PiArCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIiVkXG4iLCB2YWx1ZSk7\n" - "Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfaW5wdXQsIFNf\n" - "SVJVR08sIGx0YzI5OTBfc2hvd192YWx1ZSwgTlVMTCwKPj4gKwkJCSAgTFRDMjk5MF9USU5UX01T\n" - "Qik7Cj4+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGN1cnIxX2lucHV0LCBTX0lSVUdPLCBs\n" - "dGMyOTkwX3Nob3dfdmFsdWUsIE5VTEwsCj4+ICsJCQkgIExUQzI5OTBfVjFfTVNCKTsKPj4gK3N0\n" - "YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoY3VycjJfaW5wdXQsIFNfSVJVR08sIGx0YzI5OTBfc2hv\n" - "d192YWx1ZSwgTlVMTCwKPj4gKwkJCSAgTFRDMjk5MF9WM19NU0IpOwo+PiArc3RhdGljIFNFTlNP\n" - "Ul9ERVZJQ0VfQVRUUihpbjBfaW5wdXQsIFNfSVJVR08sIGx0YzI5OTBfc2hvd192YWx1ZSwgTlVM\n" - "TCwKPj4gKwkJCSAgTFRDMjk5MF9WQ0NfTVNCKTsKPj4gKwo+PiArc3RhdGljIHN0cnVjdCBhdHRy\n" - "aWJ1dGUgKmx0YzI5OTBfYXR0cnNbXSA9IHsKPj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2lu\n" - "cHV0LmRldl9hdHRyLmF0dHIsCj4+ICsJJnNlbnNvcl9kZXZfYXR0cl9jdXJyMV9pbnB1dC5kZXZf\n" - "YXR0ci5hdHRyLAo+PiArCSZzZW5zb3JfZGV2X2F0dHJfY3VycjJfaW5wdXQuZGV2X2F0dHIuYXR0\n" - "ciwKPj4gKwkmc2Vuc29yX2Rldl9hdHRyX2luMF9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+PiArCU5V\n" - "TEwsCj4+ICt9Owo+PiArQVRUUklCVVRFX0dST1VQUyhsdGMyOTkwKTsKPj4gKwo+PiArc3RhdGlj\n" - "IGludCBsdGMyOTkwX2kyY19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqaTJjLAo+PiArCQkJICAg\n" - "ICBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCj4+ICt7Cj4+ICsJaW50IHJldDsKPj4g\n" - "KwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7Cj4+ICsKPj4gKwlpZiAoIWkyY19jaGVja19mdW5j\n" - "dGlvbmFsaXR5KGkyYy0+YWRhcHRlciwgSTJDX0ZVTkNfU01CVVNfQllURV9EQVRBIHwKPj4gKwkJ\n" - "CQkgICAgIEkyQ19GVU5DX1NNQlVTX1dPUkRfREFUQSkpCj4+ICsJCXJldHVybiAtRU5PREVWOwo+\n" - "PiArCj4+ICsJLyogU2V0dXAgY29udGludW91cyBtb2RlLCBjdXJyZW50IG1vbml0b3IgKi8KPj4g\n" - "KwlyZXQgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGkyYywgTFRDMjk5MF9DT05UUk9MLAo+\n" - "PiArCQkJCQlMVEMyOTkwX0NPTlRST0xfTUVBU1VSRV9BTEwgfAo+PiArCQkJCQlMVEMyOTkwX0NP\n" - "TlRST0xfTU9ERV9DVVJSRU5UKTsKPj4gKwlpZiAocmV0IDwgMCkgewo+PiArCQlkZXZfZXJyKCZp\n" - "MmMtPmRldiwgIkVycm9yOiBGYWlsZWQgdG8gc2V0IGNvbnRyb2wgbW9kZS5cbiIpOwo+PiArCQly\n" - "ZXR1cm4gcmV0Owo+PiArCX0KPj4gKwkvKiBUcmlnZ2VyIG9uY2UgdG8gc3RhcnQgY29udGludW91\n" - "cyBjb252ZXJzaW9uICovCj4+ICsJcmV0ID0gaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0YShpMmMs\n" - "IExUQzI5OTBfVFJJR0dFUiwgMSk7Cj4+ICsJaWYgKHJldCA8IDApIHsKPj4gKwkJZGV2X2Vycigm\n" - "aTJjLT5kZXYsICJFcnJvcjogRmFpbGVkIHRvIHN0YXJ0IGFjcXVpc2l0aW9uLlxuIik7Cj4+ICsJ\n" - "CXJldHVybiByZXQ7Cj4+ICsJfQo+PiArCj4+ICsJaHdtb25fZGV2ID0gZGV2bV9od21vbl9kZXZp\n" - "Y2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoJmkyYy0+ZGV2LAo+PiArCQkJCQkJCSAgIGkyYy0+bmFt\n" - "ZSwKPj4gKwkJCQkJCQkgICBpMmMsCj4+ICsJCQkJCQkJICAgbHRjMjk5MF9ncm91cHMpOwo+PiAr\n" - "Cj4+ICsJcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9kZXYpOwo+PiArfQo+PiArCj4+ICtz\n" - "dGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgbHRjMjk5MF9pMmNfaWRbXSA9IHsKPj4g\n" - "Kwl7ICJsdGMyOTkwIiwgMCB9LAo+PiArCXt9Cj4+ICt9Owo+PiArTU9EVUxFX0RFVklDRV9UQUJM\n" - "RShpMmMsIGx0YzI5OTBfaTJjX2lkKTsKPj4gKwo+PiArc3RhdGljIHN0cnVjdCBpMmNfZHJpdmVy\n" - "IGx0YzI5OTBfaTJjX2RyaXZlciA9IHsKPj4gKwkuZHJpdmVyID0gewo+PiArCQkubmFtZSA9ICJs\n" - "dGMyOTkwIiwKPj4gKwl9LAo+PiArCS5wcm9iZSAgICA9IGx0YzI5OTBfaTJjX3Byb2JlLAo+PiAr\n" - "CS5pZF90YWJsZSA9IGx0YzI5OTBfaTJjX2lkLAo+PiArfTsKPj4gKwo+PiArbW9kdWxlX2kyY19k\n" - "cml2ZXIobHRjMjk5MF9pMmNfZHJpdmVyKTsKPj4gKwo+PiArTU9EVUxFX0RFU0NSSVBUSU9OKCJM\n" - "VEMyOTkwIFNlbnNvciBEcml2ZXIiKTsKPj4gK01PRFVMRV9BVVRIT1IoIlRvcGljIEVtYmVkZGVk\n" - "IFByb2R1Y3RzIik7Cj4+ICtNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7Cj4+IC0tCj4+IDEuOS4x\n" - "Cj4+CgoKCktpbmQgcmVnYXJkcywKCk1pa2UgTG9vaWptYW5zClN5c3RlbSBFeHBlcnQKClRPUElD\n" - "IEVtYmVkZGVkIFByb2R1Y3RzCkVpbmRob3ZlbnNld2VnIDMyLUMsIE5MLTU2ODMgS0ggQmVzdApQ\n" - "b3N0YnVzIDQ0MCwgTkwtNTY4MCBBSyBCZXN0ClRlbGVmb29uOiArMzEgKDApIDQ5OSAzMyA2OSA3\n" - "OQpFLW1haWw6IG1pa2UubG9vaWptYW5zQHRvcGljcHJvZHVjdHMuY29tCldlYnNpdGU6IHd3dy50\n" - "b3BpY3Byb2R1Y3RzLmNvbQoKUGxlYXNlIGNvbnNpZGVyIHRoZSBlbnZpcm9ubWVudCBiZWZvcmUg\n" - "cHJpbnRpbmcgdGhpcyBlLW1haWwKCgoKCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f\n" - "X19fX19fX19fX19fX19fX18KbG0tc2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1z\n" - "ZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9s\n" - bS1zZW5zb3Jz + "\357\273\277On 14-01-16 20:14, Guenter Roeck wrote:\n" + "> On Wed, Jan 13, 2016 at 03:45:01PM +0100, Mike Looijmans wrote:\n" + ">> This adds support for the Linear Technology LTC2990 I2C System Monitor.\n" + ">> The LTC2990 supports a combination of voltage, current and temperature\n" + ">> monitoring. This driver currently only supports reading two currents\n" + ">> by measuring two differential voltages across series resistors, in\n" + ">> addition to the Vcc supply voltage and internal temperature.\n" + ">>\n" + ">> This is sufficient to support the Topic Miami SOM which uses this chip\n" + ">> to monitor the currents flowing into the FPGA and the CPU parts.\n" + ">>\n" + ">> Signed-off-by: Mike Looijmans <mike.looijmans@topic.nl>\n" + ">\n" + "> Hi Mike,\n" + ">\n" + "> almost there. Please see inline.\n" + "\n" + "Great, I'll order some cake :)\n" + "\n" + "Expect v4 in a few minutes, I'm testing it on the hardware now.\n" + "\n" + "> Thanks,\n" + "> Guenter\n" + ">\n" + ">> ---\n" + ">> v3: Remove unused includes.\n" + ">> Remove (most) unused register defines.\n" + ">> Also check on SMBUS WORD capability.\n" + ">> Use register defines as value indices.\n" + ">> Alignment fixups with \"(\".\n" + ">> v2: Processed all review comments.\n" + ">> Put chip into continuous measurement mode.\n" + ">> Added ducumentation.\n" + ">> Use standard hwmon interfaces and macros.\n" + ">>\n" + ">> Documentation/hwmon/ltc2990 | 44 ++++++++++++\n" + ">> drivers/hwmon/Kconfig | 14 ++++\n" + ">> drivers/hwmon/Makefile | 1 +\n" + ">> drivers/hwmon/ltc2990.c | 159 ++++++++++++++++++++++++++++++++++++++++++++\n" + ">> 4 files changed, 218 insertions(+)\n" + ">> create mode 100644 Documentation/hwmon/ltc2990\n" + ">> create mode 100644 drivers/hwmon/ltc2990.c\n" + ">>\n" + ">> diff --git a/Documentation/hwmon/ltc2990 b/Documentation/hwmon/ltc2990\n" + ">> new file mode 100644\n" + ">> index 0000000..838b74e\n" + ">> --- /dev/null\n" + ">> +++ b/Documentation/hwmon/ltc2990\n" + ">> @@ -0,0 +1,44 @@\n" + ">> +Kernel driver ltc2990\n" + ">> +=====================\n" + ">> +\n" + ">> +Supported chips:\n" + ">> + * Linear Technology LTC2990\n" + ">> + Prefix: 'ltc2990'\n" + ">> + Addresses scanned: -\n" + ">> + Datasheet: http://www.linear.com/product/ltc2990\n" + ">> +\n" + ">> +Author: Mike Looijmans <mike.looijmans@topic.nl>\n" + ">> +\n" + ">> +\n" + ">> +Description\n" + ">> +-----------\n" + ">> +\n" + ">> +LTC2990 is a Quad I2C Voltage, Current and Temperature Monitor.\n" + ">> +The chip's inputs can measure 4 voltages, or two inputs together (1+2 and 3+4)\n" + ">> +can be combined to measure a differential voltage, which is typically used to\n" + ">> +measure current through a series resistor, or a temperature.\n" + ">> +\n" + ">> +This driver currently uses the 2x differential mode only. In order to support\n" + ">> +other modes, the driver will need to be expanded.\n" + ">> +\n" + ">> +\n" + ">> +Usage Notes\n" + ">> +-----------\n" + ">> +\n" + ">> +This driver does not probe for PMBus devices. You will have to instantiate\n" + ">> +devices explicitly.\n" + ">> +\n" + ">> +\n" + ">> +Sysfs attributes\n" + ">> +----------------\n" + ">> +\n" + ">> +The \"curr*_input\" measurements actually report the voltage drop across the\n" + ">> +input pins in microvolts. This is equivalent to the current through a 1mOhm\n" + ">> +sense resistor. Divide the reported value by the actual sense resistor value\n" + ">> +in mOhm to get the actual value.\n" + ">> +\n" + ">> +in0_input Voltage at Vcc pin in millivolt (range 2.5V to 5V)\n" + ">> +temp1_input Internal chip temperature in millidegrees Celcius\n" + ">> +curr1_input Current in mA across v1-v2 assuming a 1mOhm sense resistor.\n" + ">> +curr2_input Current in mA across v3-v4 assuming a 1mOhm sense resistor.\n" + ">> +\n" + ">> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig\n" + ">> index 80a73bf..8a31d64 100644\n" + ">> --- a/drivers/hwmon/Kconfig\n" + ">> +++ b/drivers/hwmon/Kconfig\n" + ">> @@ -685,6 +685,20 @@ config SENSORS_LTC2945\n" + ">> \t This driver can also be built as a module. If so, the module will\n" + ">> \t be called ltc2945.\n" + ">>\n" + ">> +config SENSORS_LTC2990\n" + ">> +\ttristate \"Linear Technology LTC2990 (current monitoring mode only)\"\n" + ">> +\tdepends on I2C\n" + ">> +\thelp\n" + ">> +\t If you say yes here you get support for Linear Technology LTC2990\n" + ">> +\t I2C System Monitor. The LTC2990 supports a combination of voltage,\n" + ">> +\t current and temperature monitoring, but in addition to the Vcc supply\n" + ">> +\t voltage and chip temperature, this driver currently only supports\n" + ">> +\t reading two currents by measuring two differential voltages across\n" + ">> +\t series resistors.\n" + ">> +\n" + ">> +\t This driver can also be built as a module. If so, the module will\n" + ">> +\t be called ltc2990.\n" + ">> +\n" + ">> config SENSORS_LTC4151\n" + ">> \ttristate \"Linear Technology LTC4151\"\n" + ">> \tdepends on I2C\n" + ">> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile\n" + ">> index 12a3239..e4bd15b 100644\n" + ">> --- a/drivers/hwmon/Makefile\n" + ">> +++ b/drivers/hwmon/Makefile\n" + ">> @@ -101,6 +101,7 @@ obj-$(CONFIG_SENSORS_LM95234)\t+= lm95234.o\n" + ">> obj-$(CONFIG_SENSORS_LM95241)\t+= lm95241.o\n" + ">> obj-$(CONFIG_SENSORS_LM95245)\t+= lm95245.o\n" + ">> obj-$(CONFIG_SENSORS_LTC2945)\t+= ltc2945.o\n" + ">> +obj-$(CONFIG_SENSORS_LTC2990)\t+= ltc2990.o\n" + ">> obj-$(CONFIG_SENSORS_LTC4151)\t+= ltc4151.o\n" + ">> obj-$(CONFIG_SENSORS_LTC4215)\t+= ltc4215.o\n" + ">> obj-$(CONFIG_SENSORS_LTC4222)\t+= ltc4222.o\n" + ">> diff --git a/drivers/hwmon/ltc2990.c b/drivers/hwmon/ltc2990.c\n" + ">> new file mode 100644\n" + ">> index 0000000..37ca5f4\n" + ">> --- /dev/null\n" + ">> +++ b/drivers/hwmon/ltc2990.c\n" + ">> @@ -0,0 +1,159 @@\n" + ">> +/*\n" + ">> + * Driver for Linear Technology LTC2990 power monitor\n" + ">> + *\n" + ">> + * Copyright (C) 2014 Topic Embedded Products\n" + ">> + * Author: Mike Looijmans <mike.looijmans@topic.nl>\n" + ">> + *\n" + ">> + * License: GPLv2\n" + ">> + *\n" + ">> + * This driver assumes the chip is wired as a dual current monitor, and\n" + ">> + * reports the voltage drop across two series resistors. It also reports\n" + ">> + * the chip's internal temperature and Vcc power supply voltage.\n" + ">> + */\n" + ">> +\n" + ">> +#include <linux/err.h>\n" + ">> +#include <linux/hwmon.h>\n" + ">> +#include <linux/hwmon-sysfs.h>\n" + ">> +#include <linux/i2c.h>\n" + ">> +#include <linux/kernel.h>\n" + ">> +#include <linux/module.h>\n" + ">> +\n" + ">> +#define LTC2990_STATUS\t0x00\n" + ">> +#define LTC2990_CONTROL\t0x01\n" + ">> +#define LTC2990_TRIGGER\t0x02\n" + ">> +#define LTC2990_TINT_MSB\t0x04\n" + ">> +#define LTC2990_V1_MSB\t0x06\n" + ">> +#define LTC2990_V2_MSB\t0x08\n" + ">> +#define LTC2990_V3_MSB\t0x0A\n" + ">> +#define LTC2990_V4_MSB\t0x0C\n" + ">> +#define LTC2990_VCC_MSB\t0x0E\n" + ">> +\n" + ">> +#define LTC2990_CONTROL_KELVIN\t\tBIT(7)\n" + ">> +#define LTC2990_CONTROL_SINGLE\t\tBIT(6)\n" + ">> +#define LTC2990_CONTROL_MEASURE_ALL\t(0x3 << 3)\n" + ">> +#define LTC2990_CONTROL_MODE_CURRENT\t0x06\n" + ">> +#define LTC2990_CONTROL_MODE_VOLTAGE\t0x07\n" + ">> +\n" + ">> +/* convert raw register value to sign-extended integer in 16-bit range */\n" + ">> +static int ltc2990_voltage_to_int(int raw)\n" + ">> +{\n" + ">> +\tif (raw & BIT(14)) {\n" + ">> +\t\treturn -(0x4000 - (raw & 0x3FFF)) << 2;\n" + ">> +\t} else {\n" + ">> +\t\treturn (raw & 0x3FFF) << 2;\n" + ">> +\t}\n" + ">\n" + "> Unnecessary { }. Please see checkpatch warning.\n" + "\n" + "I'll make sure to run checkpatch again. Its only remaining warning is about \n" + "MAINTAINERS now.\n" + "\n" + ">> +}\n" + ">> +\n" + ">> +/* Return the converted value from the given register in uV or mC */\n" + ">> +static int ltc2990_get_value(struct i2c_client *i2c, u8 reg)\n" + ">> +{\n" + ">> +\tint val;\n" + ">> +\tint result;\n" + ">> +\n" + ">> +\tval = i2c_smbus_read_word_swapped(i2c, reg);\n" + ">> +\tif (unlikely(val < 0))\n" + ">> +\t\treturn val;\n" + ">\n" + "> This suggests the function returns a value < 0 on error ...\n" + "\n" + "Misleading, since most of the valid results can be negative. I'll change the \n" + "method to return a result code and take a result pointer instead.\n" + "\n" + ">\n" + ">> +\tswitch (reg) {\n" + ">> +\tcase LTC2990_TINT_MSB:\n" + ">> +\t\t/* internal temp, 0.0625 degrees/LSB, 13-bit */\n" + ">> +\t\tval = (val & 0x1FFF) << 3;\n" + ">> +\t\tresult = (val * 1000) >> 7;\n" + ">> +\t\tbreak;\n" + ">> +\tcase LTC2990_V1_MSB:\n" + ">> +\tcase LTC2990_V3_MSB:\n" + ">> +\t\t /* Vx-Vy, 19.42uV/LSB. Depends on mode. */\n" + ">> +\t\tresult = ltc2990_voltage_to_int(val) * 1942 / (4 * 100);\n" + ">> +\t\tbreak;\n" + ">> +\tcase LTC2990_VCC_MSB:\n" + ">> +\t\t/* Vcc, 305.18\316\274V/LSB, 2.5V offset */\n" + ">> +\t\tresult = ltc2990_voltage_to_int(val) * 30518 / (4 * 100 * 1000);\n" + ">> +\t\tresult += 2500;\n" + ">> +\t\tbreak;\n" + ">> +\tdefault:\n" + ">> +\t\tresult = 0; /* won't happen, keep compiler happy */\n" + ">\n" + "> Given that, we can return some error here, and ...\n" + ">\n" + ">> +\t\tbreak;\n" + ">> +\t}\n" + ">> +\n" + ">> +\treturn result;\n" + ">> +}\n" + ">> +\n" + ">> +static ssize_t ltc2990_show_value(struct device *dev,\n" + ">> +\t\t\t\t struct device_attribute *da, char *buf)\n" + ">> +{\n" + ">> +\tstruct sensor_device_attribute *attr = to_sensor_dev_attr(da);\n" + ">> +\tint value;\n" + ">> +\n" + ">> +\tvalue = ltc2990_get_value(dev_get_drvdata(dev), attr->index);\n" + ">\n" + "> ... we should actually check the error return here.\n" + ">\n" + "> \tif (value < 0)\n" + "> \t\treturn value;\n" + "\n" + "Yes, with the change above, it can properly return an error code if the I2C \n" + "transaction failed.\n" + "\n" + ">> +\treturn snprintf(buf, PAGE_SIZE, \"%d\\n\", value);\n" + ">> +}\n" + ">> +\n" + ">> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ltc2990_show_value, NULL,\n" + ">> +\t\t\t LTC2990_TINT_MSB);\n" + ">> +static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc2990_show_value, NULL,\n" + ">> +\t\t\t LTC2990_V1_MSB);\n" + ">> +static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc2990_show_value, NULL,\n" + ">> +\t\t\t LTC2990_V3_MSB);\n" + ">> +static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ltc2990_show_value, NULL,\n" + ">> +\t\t\t LTC2990_VCC_MSB);\n" + ">> +\n" + ">> +static struct attribute *ltc2990_attrs[] = {\n" + ">> +\t&sensor_dev_attr_temp1_input.dev_attr.attr,\n" + ">> +\t&sensor_dev_attr_curr1_input.dev_attr.attr,\n" + ">> +\t&sensor_dev_attr_curr2_input.dev_attr.attr,\n" + ">> +\t&sensor_dev_attr_in0_input.dev_attr.attr,\n" + ">> +\tNULL,\n" + ">> +};\n" + ">> +ATTRIBUTE_GROUPS(ltc2990);\n" + ">> +\n" + ">> +static int ltc2990_i2c_probe(struct i2c_client *i2c,\n" + ">> +\t\t\t const struct i2c_device_id *id)\n" + ">> +{\n" + ">> +\tint ret;\n" + ">> +\tstruct device *hwmon_dev;\n" + ">> +\n" + ">> +\tif (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA |\n" + ">> +\t\t\t\t I2C_FUNC_SMBUS_WORD_DATA))\n" + ">> +\t\treturn -ENODEV;\n" + ">> +\n" + ">> +\t/* Setup continuous mode, current monitor */\n" + ">> +\tret = i2c_smbus_write_byte_data(i2c, LTC2990_CONTROL,\n" + ">> +\t\t\t\t\tLTC2990_CONTROL_MEASURE_ALL |\n" + ">> +\t\t\t\t\tLTC2990_CONTROL_MODE_CURRENT);\n" + ">> +\tif (ret < 0) {\n" + ">> +\t\tdev_err(&i2c->dev, \"Error: Failed to set control mode.\\n\");\n" + ">> +\t\treturn ret;\n" + ">> +\t}\n" + ">> +\t/* Trigger once to start continuous conversion */\n" + ">> +\tret = i2c_smbus_write_byte_data(i2c, LTC2990_TRIGGER, 1);\n" + ">> +\tif (ret < 0) {\n" + ">> +\t\tdev_err(&i2c->dev, \"Error: Failed to start acquisition.\\n\");\n" + ">> +\t\treturn ret;\n" + ">> +\t}\n" + ">> +\n" + ">> +\thwmon_dev = devm_hwmon_device_register_with_groups(&i2c->dev,\n" + ">> +\t\t\t\t\t\t\t i2c->name,\n" + ">> +\t\t\t\t\t\t\t i2c,\n" + ">> +\t\t\t\t\t\t\t ltc2990_groups);\n" + ">> +\n" + ">> +\treturn PTR_ERR_OR_ZERO(hwmon_dev);\n" + ">> +}\n" + ">> +\n" + ">> +static const struct i2c_device_id ltc2990_i2c_id[] = {\n" + ">> +\t{ \"ltc2990\", 0 },\n" + ">> +\t{}\n" + ">> +};\n" + ">> +MODULE_DEVICE_TABLE(i2c, ltc2990_i2c_id);\n" + ">> +\n" + ">> +static struct i2c_driver ltc2990_i2c_driver = {\n" + ">> +\t.driver = {\n" + ">> +\t\t.name = \"ltc2990\",\n" + ">> +\t},\n" + ">> +\t.probe = ltc2990_i2c_probe,\n" + ">> +\t.id_table = ltc2990_i2c_id,\n" + ">> +};\n" + ">> +\n" + ">> +module_i2c_driver(ltc2990_i2c_driver);\n" + ">> +\n" + ">> +MODULE_DESCRIPTION(\"LTC2990 Sensor Driver\");\n" + ">> +MODULE_AUTHOR(\"Topic Embedded Products\");\n" + ">> +MODULE_LICENSE(\"GPL v2\");\n" + ">> --\n" + ">> 1.9.1\n" + ">>\n" + "\n" + "\n" + "\n" + "Kind regards,\n" + "\n" + "Mike Looijmans\n" + "System Expert\n" + "\n" + "TOPIC Embedded Products\n" + "Eindhovenseweg 32-C, NL-5683 KH Best\n" + "Postbus 440, NL-5680 AK Best\n" + "Telefoon: +31 (0) 499 33 69 79\n" + "E-mail: mike.looijmans@topicproducts.com\n" + "Website: www.topicproducts.com\n" + "\n" + Please consider the environment before printing this e-mail -c6c1d8066754ab09e0f2295570ce438671161a786e6e65d06c37862369e5f576 +cf4f1726f319aa42ce7a7ae56eeed1844d29fee3079d845a6762dd2059a997b8
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.