From mboxrd@z Thu Jan 1 00:00:00 1970 From: Guenter Roeck Date: Fri, 15 Jan 2016 15:40:34 +0000 Subject: Re: [lm-sensors] [PATCH v4] hwmon: Add LTC2990 sensor driver Message-Id: <569912F2.9020906@roeck-us.net> List-Id: References: <1452851699-14652-1-git-send-email-mike.looijmans@topic.nl> In-Reply-To: <1452851699-14652-1-git-send-email-mike.looijmans@topic.nl> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: Mike Looijmans , lm-sensors@lm-sensors.org Cc: jdelvare@suse.com, linux-kernel@vger.kernel.org T24gMDEvMTUvMjAxNiAwMTo1NCBBTSwgTWlrZSBMb29pam1hbnMgd3JvdGU6Cj4gVGhpcyBhZGRz IHN1cHBvcnQgZm9yIHRoZSBMaW5lYXIgVGVjaG5vbG9neSBMVEMyOTkwICBJMkMgU3lzdGVtIE1v bml0b3IuCj4gVGhlIExUQzI5OTAgc3VwcG9ydHMgYSBjb21iaW5hdGlvbiBvZiB2b2x0YWdlLCBj dXJyZW50IGFuZCB0ZW1wZXJhdHVyZQo+IG1vbml0b3JpbmcuIFRoaXMgZHJpdmVyIGN1cnJlbnRs eSBvbmx5IHN1cHBvcnRzIHJlYWRpbmcgdHdvIGN1cnJlbnRzCj4gYnkgbWVhc3VyaW5nIHR3byBk aWZmZXJlbnRpYWwgdm9sdGFnZXMgYWNyb3NzIHNlcmllcyByZXNpc3RvcnMsIGluCj4gYWRkaXRp b24gdG8gdGhlIFZjYyBzdXBwbHkgdm9sdGFnZSBhbmQgaW50ZXJuYWwgdGVtcGVyYXR1cmUuCj4K PiBUaGlzIGlzIHN1ZmZpY2llbnQgdG8gc3VwcG9ydCB0aGUgVG9waWMgTWlhbWkgU09NIHdoaWNo IHVzZXMgdGhpcyBjaGlwCj4gdG8gbW9uaXRvciB0aGUgY3VycmVudHMgZmxvd2luZyBpbnRvIHRo ZSBGUEdBIGFuZCB0aGUgQ1BVIHBhcnRzLgo+Cj4gU2lnbmVkLW9mZi1ieTogTWlrZSBMb29pam1h bnMgPG1pa2UubG9vaWptYW5zQHRvcGljLm5sPgoKQXBwbGllZCB0byAtbmV4dC4KClRoYW5rcywK R3VlbnRlcgoKPiAtLS0KPiB2NDogRml4IGNoZWNrcGF0Y2ggd2FybmluZ3MKPiAgICAgIGx0YzI5 OTBfZ2V0X3ZhbHVlIGNhbiByZXR1cm4gZXJyb3IgY29kZQo+IHYzOiBSZW1vdmUgdW51c2VkIGlu Y2x1ZGVzLgo+ICAgICAgUmVtb3ZlIChtb3N0KSB1bnVzZWQgcmVnaXN0ZXIgZGVmaW5lcy4KPiAg ICAgIEFsc28gY2hlY2sgb24gU01CVVMgV09SRCBjYXBhYmlsaXR5Lgo+ICAgICAgVXNlIHJlZ2lz dGVyIGRlZmluZXMgYXMgdmFsdWUgaW5kaWNlcy4KPiAgICAgIEFsaWdubWVudCBmaXh1cHMgd2l0 aCAiKCIuCj4gdjI6IFByb2Nlc3NlZCBhbGwgcmV2aWV3IGNvbW1lbnRzLgo+ICAgICAgIFB1dCBj aGlwIGludG8gY29udGludW91cyBtZWFzdXJlbWVudCBtb2RlLgo+ICAgICAgIEFkZGVkIGR1Y3Vt ZW50YXRpb24uCj4gICAgICAgVXNlIHN0YW5kYXJkIGh3bW9uIGludGVyZmFjZXMgYW5kIG1hY3Jv cy4KPiAgIERvY3VtZW50YXRpb24vaHdtb24vbHRjMjk5MCB8ICA0NCArKysrKysrKysrKysKPiAg IGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICB8ICAxNCArKysrCj4gICBkcml2ZXJzL2h3bW9u L01ha2VmaWxlICAgICAgfCAgIDEgKwo+ICAgZHJpdmVycy9od21vbi9sdGMyOTkwLmMgICAgIHwg MTYxICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gICA0IGZp bGVzIGNoYW5nZWQsIDIyMCBpbnNlcnRpb25zKCspCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgRG9j dW1lbnRhdGlvbi9od21vbi9sdGMyOTkwCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9o d21vbi9sdGMyOTkwLmMKPgo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2h3bW9uL2x0YzI5 OTAgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL2x0YzI5OTAKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ IGluZGV4IDAwMDAwMDAuLjgzOGI3NGUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvRG9jdW1lbnRh dGlvbi9od21vbi9sdGMyOTkwCj4gQEAgLTAsMCArMSw0NCBAQAo+ICtLZXJuZWwgZHJpdmVyIGx0 YzI5OTAKPiArPT09PT09PT09PT09PT09PT09PT09Cj4gKwo+ICtTdXBwb3J0ZWQgY2hpcHM6Cj4g KyAgKiBMaW5lYXIgVGVjaG5vbG9neSBMVEMyOTkwCj4gKyAgICBQcmVmaXg6ICdsdGMyOTkwJwo+ ICsgICAgQWRkcmVzc2VzIHNjYW5uZWQ6IC0KPiArICAgIERhdGFzaGVldDogaHR0cDovL3d3dy5s aW5lYXIuY29tL3Byb2R1Y3QvbHRjMjk5MAo+ICsKPiArQXV0aG9yOiBNaWtlIExvb2lqbWFucyA8 bWlrZS5sb29pam1hbnNAdG9waWMubmw+Cj4gKwo+ICsKPiArRGVzY3JpcHRpb24KPiArLS0tLS0t LS0tLS0KPiArCj4gK0xUQzI5OTAgaXMgYSBRdWFkIEkyQyBWb2x0YWdlLCBDdXJyZW50IGFuZCBU ZW1wZXJhdHVyZSBNb25pdG9yLgo+ICtUaGUgY2hpcCdzIGlucHV0cyBjYW4gbWVhc3VyZSA0IHZv bHRhZ2VzLCBvciB0d28gaW5wdXRzIHRvZ2V0aGVyICgxKzIgYW5kIDMrNCkKPiArY2FuIGJlIGNv bWJpbmVkIHRvIG1lYXN1cmUgYSBkaWZmZXJlbnRpYWwgdm9sdGFnZSwgd2hpY2ggaXMgdHlwaWNh bGx5IHVzZWQgdG8KPiArbWVhc3VyZSBjdXJyZW50IHRocm91Z2ggYSBzZXJpZXMgcmVzaXN0b3Is IG9yIGEgdGVtcGVyYXR1cmUuCj4gKwo+ICtUaGlzIGRyaXZlciBjdXJyZW50bHkgdXNlcyB0aGUg MnggZGlmZmVyZW50aWFsIG1vZGUgb25seS4gSW4gb3JkZXIgdG8gc3VwcG9ydAo+ICtvdGhlciBt b2RlcywgdGhlIGRyaXZlciB3aWxsIG5lZWQgdG8gYmUgZXhwYW5kZWQuCj4gKwo+ICsKPiArVXNh Z2UgTm90ZXMKPiArLS0tLS0tLS0tLS0KPiArCj4gK1RoaXMgZHJpdmVyIGRvZXMgbm90IHByb2Jl IGZvciBQTUJ1cyBkZXZpY2VzLiBZb3Ugd2lsbCBoYXZlIHRvIGluc3RhbnRpYXRlCj4gK2Rldmlj ZXMgZXhwbGljaXRseS4KPiArCj4gKwo+ICtTeXNmcyBhdHRyaWJ1dGVzCj4gKy0tLS0tLS0tLS0t LS0tLS0KPiArCj4gK1RoZSAiY3VycipfaW5wdXQiIG1lYXN1cmVtZW50cyBhY3R1YWxseSByZXBv cnQgdGhlIHZvbHRhZ2UgZHJvcCBhY3Jvc3MgdGhlCj4gK2lucHV0IHBpbnMgaW4gbWljcm92b2x0 cy4gVGhpcyBpcyBlcXVpdmFsZW50IHRvIHRoZSBjdXJyZW50IHRocm91Z2ggYSAxbU9obQo+ICtz ZW5zZSByZXNpc3Rvci4gRGl2aWRlIHRoZSByZXBvcnRlZCB2YWx1ZSBieSB0aGUgYWN0dWFsIHNl bnNlIHJlc2lzdG9yIHZhbHVlCj4gK2luIG1PaG0gdG8gZ2V0IHRoZSBhY3R1YWwgdmFsdWUuCj4g Kwo+ICtpbjBfaW5wdXQgICAgIFZvbHRhZ2UgYXQgVmNjIHBpbiBpbiBtaWxsaXZvbHQgKHJhbmdl IDIuNVYgdG8gNVYpCj4gK3RlbXAxX2lucHV0ICAgSW50ZXJuYWwgY2hpcCB0ZW1wZXJhdHVyZSBp biBtaWxsaWRlZ3JlZXMgQ2VsY2l1cwo+ICtjdXJyMV9pbnB1dCAgIEN1cnJlbnQgaW4gbUEgYWNy b3NzIHYxLXYyIGFzc3VtaW5nIGEgMW1PaG0gc2Vuc2UgcmVzaXN0b3IuCj4gK2N1cnIyX2lucHV0 ICAgQ3VycmVudCBpbiBtQSBhY3Jvc3MgdjMtdjQgYXNzdW1pbmcgYSAxbU9obSBzZW5zZSByZXNp c3Rvci4KPiArCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vS2NvbmZpZyBiL2RyaXZlcnMv aHdtb24vS2NvbmZpZwo+IGluZGV4IDgwYTczYmYuLjhhMzFkNjQgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9od21vbi9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9od21vbi9LY29uZmlnCj4gQEAgLTY4 NSw2ICs2ODUsMjAgQEAgY29uZmlnIFNFTlNPUlNfTFRDMjk0NQo+ICAgCSAgVGhpcyBkcml2ZXIg Y2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuIElmIHNvLCB0aGUgbW9kdWxlIHdpbGwKPiAg IAkgIGJlIGNhbGxlZCBsdGMyOTQ1Lgo+Cj4gK2NvbmZpZyBTRU5TT1JTX0xUQzI5OTAKPiArCXRy aXN0YXRlICJMaW5lYXIgVGVjaG5vbG9neSBMVEMyOTkwIChjdXJyZW50IG1vbml0b3JpbmcgbW9k ZSBvbmx5KSIKPiArCWRlcGVuZHMgb24gSTJDCj4gKwloZWxwCj4gKwkgIElmIHlvdSBzYXkgeWVz IGhlcmUgeW91IGdldCBzdXBwb3J0IGZvciBMaW5lYXIgVGVjaG5vbG9neSBMVEMyOTkwCj4gKwkg IEkyQyBTeXN0ZW0gTW9uaXRvci4gVGhlIExUQzI5OTAgc3VwcG9ydHMgYSBjb21iaW5hdGlvbiBv ZiB2b2x0YWdlLAo+ICsJICBjdXJyZW50IGFuZCB0ZW1wZXJhdHVyZSBtb25pdG9yaW5nLCBidXQg aW4gYWRkaXRpb24gdG8gdGhlIFZjYyBzdXBwbHkKPiArCSAgdm9sdGFnZSBhbmQgY2hpcCB0ZW1w ZXJhdHVyZSwgdGhpcyBkcml2ZXIgY3VycmVudGx5IG9ubHkgc3VwcG9ydHMKPiArCSAgcmVhZGlu ZyB0d28gY3VycmVudHMgYnkgbWVhc3VyaW5nIHR3byBkaWZmZXJlbnRpYWwgdm9sdGFnZXMgYWNy b3NzCj4gKwkgIHNlcmllcyByZXNpc3RvcnMuCj4gKwo+ICsJICBUaGlzIGRyaXZlciBjYW4gYWxz byBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUgd2lsbAo+ICsJICBiZSBj YWxsZWQgbHRjMjk5MC4KPiArCj4gICBjb25maWcgU0VOU09SU19MVEM0MTUxCj4gICAJdHJpc3Rh dGUgIkxpbmVhciBUZWNobm9sb2d5IExUQzQxNTEiCj4gICAJZGVwZW5kcyBvbiBJMkMKPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9od21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUK PiBpbmRleCAxMmEzMjM5Li5lNGJkMTViIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFr ZWZpbGUKPiArKysgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4gQEAgLTEwMSw2ICsxMDEsNyBA QCBvYmotJChDT05GSUdfU0VOU09SU19MTTk1MjM0KQkrPSBsbTk1MjM0Lm8KPiAgIG9iai0kKENP TkZJR19TRU5TT1JTX0xNOTUyNDEpCSs9IGxtOTUyNDEubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNP UlNfTE05NTI0NSkJKz0gbG05NTI0NS5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19MVEMyOTQ1 KQkrPSBsdGMyOTQ1Lm8KPiArb2JqLSQoQ09ORklHX1NFTlNPUlNfTFRDMjk5MCkJKz0gbHRjMjk5 MC5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19MVEM0MTUxKQkrPSBsdGM0MTUxLm8KPiAgIG9i ai0kKENPTkZJR19TRU5TT1JTX0xUQzQyMTUpCSs9IGx0YzQyMTUubwo+ICAgb2JqLSQoQ09ORklH X1NFTlNPUlNfTFRDNDIyMikJKz0gbHRjNDIyMi5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdt b24vbHRjMjk5MC5jIGIvZHJpdmVycy9od21vbi9sdGMyOTkwLmMKPiBuZXcgZmlsZSBtb2RlIDEw MDY0NAo+IGluZGV4IDAwMDAwMDAuLjhmOGZlMDUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJp dmVycy9od21vbi9sdGMyOTkwLmMKPiBAQCAtMCwwICsxLDE2MSBAQAo+ICsvKgo+ICsgKiBEcml2 ZXIgZm9yIExpbmVhciBUZWNobm9sb2d5IExUQzI5OTAgcG93ZXIgbW9uaXRvcgo+ICsgKgo+ICsg KiBDb3B5cmlnaHQgKEMpIDIwMTQgVG9waWMgRW1iZWRkZWQgUHJvZHVjdHMKPiArICogQXV0aG9y OiBNaWtlIExvb2lqbWFucyA8bWlrZS5sb29pam1hbnNAdG9waWMubmw+Cj4gKyAqCj4gKyAqIExp Y2Vuc2U6IEdQTHYyCj4gKyAqCj4gKyAqIFRoaXMgZHJpdmVyIGFzc3VtZXMgdGhlIGNoaXAgaXMg d2lyZWQgYXMgYSBkdWFsIGN1cnJlbnQgbW9uaXRvciwgYW5kCj4gKyAqIHJlcG9ydHMgdGhlIHZv bHRhZ2UgZHJvcCBhY3Jvc3MgdHdvIHNlcmllcyByZXNpc3RvcnMuIEl0IGFsc28gcmVwb3J0cwo+ ICsgKiB0aGUgY2hpcCdzIGludGVybmFsIHRlbXBlcmF0dXJlIGFuZCBWY2MgcG93ZXIgc3VwcGx5 IHZvbHRhZ2UuCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgo+ICsjaW5jbHVk ZSA8bGludXgvaHdtb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9pMmMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+ICsjaW5j bHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKwo+ICsjZGVmaW5lIExUQzI5OTBfU1RBVFVTCTB4MDAK PiArI2RlZmluZSBMVEMyOTkwX0NPTlRST0wJMHgwMQo+ICsjZGVmaW5lIExUQzI5OTBfVFJJR0dF UgkweDAyCj4gKyNkZWZpbmUgTFRDMjk5MF9USU5UX01TQgkweDA0Cj4gKyNkZWZpbmUgTFRDMjk5 MF9WMV9NU0IJMHgwNgo+ICsjZGVmaW5lIExUQzI5OTBfVjJfTVNCCTB4MDgKPiArI2RlZmluZSBM VEMyOTkwX1YzX01TQgkweDBBCj4gKyNkZWZpbmUgTFRDMjk5MF9WNF9NU0IJMHgwQwo+ICsjZGVm aW5lIExUQzI5OTBfVkNDX01TQgkweDBFCj4gKwo+ICsjZGVmaW5lIExUQzI5OTBfQ09OVFJPTF9L RUxWSU4JCUJJVCg3KQo+ICsjZGVmaW5lIExUQzI5OTBfQ09OVFJPTF9TSU5HTEUJCUJJVCg2KQo+ ICsjZGVmaW5lIExUQzI5OTBfQ09OVFJPTF9NRUFTVVJFX0FMTAkoMHgzIDw8IDMpCj4gKyNkZWZp bmUgTFRDMjk5MF9DT05UUk9MX01PREVfQ1VSUkVOVAkweDA2Cj4gKyNkZWZpbmUgTFRDMjk5MF9D T05UUk9MX01PREVfVk9MVEFHRQkweDA3Cj4gKwo+ICsvKiBjb252ZXJ0IHJhdyByZWdpc3RlciB2 YWx1ZSB0byBzaWduLWV4dGVuZGVkIGludGVnZXIgaW4gMTYtYml0IHJhbmdlICovCj4gK3N0YXRp YyBpbnQgbHRjMjk5MF92b2x0YWdlX3RvX2ludChpbnQgcmF3KQo+ICt7Cj4gKwlpZiAocmF3ICYg QklUKDE0KSkKPiArCQlyZXR1cm4gLSgweDQwMDAgLSAocmF3ICYgMHgzRkZGKSkgPDwgMjsKPiAr CWVsc2UKPiArCQlyZXR1cm4gKHJhdyAmIDB4M0ZGRikgPDwgMjsKPiArfQo+ICsKPiArLyogUmV0 dXJuIHRoZSBjb252ZXJ0ZWQgdmFsdWUgZnJvbSB0aGUgZ2l2ZW4gcmVnaXN0ZXIgaW4gdVYgb3Ig bUMgKi8KPiArc3RhdGljIGludCBsdGMyOTkwX2dldF92YWx1ZShzdHJ1Y3QgaTJjX2NsaWVudCAq aTJjLCB1OCByZWcsIGludCAqcmVzdWx0KQo+ICt7Cj4gKwlpbnQgdmFsOwo+ICsKPiArCXZhbCA9 IGkyY19zbWJ1c19yZWFkX3dvcmRfc3dhcHBlZChpMmMsIHJlZyk7Cj4gKwlpZiAodW5saWtlbHko dmFsIDwgMCkpCj4gKwkJcmV0dXJuIHZhbDsKPiArCj4gKwlzd2l0Y2ggKHJlZykgewo+ICsJY2Fz ZSBMVEMyOTkwX1RJTlRfTVNCOgo+ICsJCS8qIGludGVybmFsIHRlbXAsIDAuMDYyNSBkZWdyZWVz L0xTQiwgMTMtYml0ICAqLwo+ICsJCXZhbCA9ICh2YWwgJiAweDFGRkYpIDw8IDM7Cj4gKwkJKnJl c3VsdCA9ICh2YWwgKiAxMDAwKSA+PiA3Owo+ICsJCWJyZWFrOwo+ICsJY2FzZSBMVEMyOTkwX1Yx X01TQjoKPiArCWNhc2UgTFRDMjk5MF9WM19NU0I6Cj4gKwkJIC8qIFZ4LVZ5LCAxOS40MnVWL0xT Qi4gRGVwZW5kcyBvbiBtb2RlLiAqLwo+ICsJCSpyZXN1bHQgPSBsdGMyOTkwX3ZvbHRhZ2VfdG9f aW50KHZhbCkgKiAxOTQyIC8gKDQgKiAxMDApOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBMVEMyOTkw X1ZDQ19NU0I6Cj4gKwkJLyogVmNjLCAzMDUuMTjOvFYvTFNCLCAyLjVWIG9mZnNldCAqLwo+ICsJ CSpyZXN1bHQgPSAobHRjMjk5MF92b2x0YWdlX3RvX2ludCh2YWwpICogMzA1MTggLwo+ICsJCQkg ICAoNCAqIDEwMCAqIDEwMDApKSArIDI1MDA7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJ CXJldHVybiAtRUlOVkFMOyAvKiB3b24ndCBoYXBwZW4sIGtlZXAgY29tcGlsZXIgaGFwcHkgKi8K PiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgbHRjMjk5 MF9zaG93X3ZhbHVlKHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCSAgc3RydWN0IGRldmljZV9h dHRyaWJ1dGUgKmRhLCBjaGFyICpidWYpCj4gK3sKPiArCXN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0 dHJpYnV0ZSAqYXR0ciA9IHRvX3NlbnNvcl9kZXZfYXR0cihkYSk7Cj4gKwlpbnQgdmFsdWU7Cj4g KwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGx0YzI5OTBfZ2V0X3ZhbHVlKGRldl9nZXRfZHJ2ZGF0 YShkZXYpLCBhdHRyLT5pbmRleCwgJnZhbHVlKTsKPiArCWlmICh1bmxpa2VseShyZXQgPCAwKSkK PiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwg IiVkXG4iLCB2YWx1ZSk7Cj4gK30KPiArCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVt cDFfaW5wdXQsIFNfSVJVR08sIGx0YzI5OTBfc2hvd192YWx1ZSwgTlVMTCwKPiArCQkJICBMVEMy OTkwX1RJTlRfTVNCKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihjdXJyMV9pbnB1dCwg U19JUlVHTywgbHRjMjk5MF9zaG93X3ZhbHVlLCBOVUxMLAo+ICsJCQkgIExUQzI5OTBfVjFfTVNC KTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihjdXJyMl9pbnB1dCwgU19JUlVHTywgbHRj Mjk5MF9zaG93X3ZhbHVlLCBOVUxMLAo+ICsJCQkgIExUQzI5OTBfVjNfTVNCKTsKPiArc3RhdGlj IFNFTlNPUl9ERVZJQ0VfQVRUUihpbjBfaW5wdXQsIFNfSVJVR08sIGx0YzI5OTBfc2hvd192YWx1 ZSwgTlVMTCwKPiArCQkJICBMVEMyOTkwX1ZDQ19NU0IpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBh dHRyaWJ1dGUgKmx0YzI5OTBfYXR0cnNbXSA9IHsKPiArCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFf aW5wdXQuZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5zb3JfZGV2X2F0dHJfY3VycjFfaW5wdXQuZGV2 X2F0dHIuYXR0ciwKPiArCSZzZW5zb3JfZGV2X2F0dHJfY3VycjJfaW5wdXQuZGV2X2F0dHIuYXR0 ciwKPiArCSZzZW5zb3JfZGV2X2F0dHJfaW4wX2lucHV0LmRldl9hdHRyLmF0dHIsCj4gKwlOVUxM LAo+ICt9Owo+ICtBVFRSSUJVVEVfR1JPVVBTKGx0YzI5OTApOwo+ICsKPiArc3RhdGljIGludCBs dGMyOTkwX2kyY19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqaTJjLAo+ICsJCQkgICAgIGNvbnN0 IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPiArewo+ICsJaW50IHJldDsKPiArCXN0cnVjdCBk ZXZpY2UgKmh3bW9uX2RldjsKPiArCj4gKwlpZiAoIWkyY19jaGVja19mdW5jdGlvbmFsaXR5KGky Yy0+YWRhcHRlciwgSTJDX0ZVTkNfU01CVVNfQllURV9EQVRBIHwKPiArCQkJCSAgICAgSTJDX0ZV TkNfU01CVVNfV09SRF9EQVRBKSkKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiArCj4gKwkvKiBTZXR1 cCBjb250aW51b3VzIG1vZGUsIGN1cnJlbnQgbW9uaXRvciAqLwo+ICsJcmV0ID0gaTJjX3NtYnVz X3dyaXRlX2J5dGVfZGF0YShpMmMsIExUQzI5OTBfQ09OVFJPTCwKPiArCQkJCQlMVEMyOTkwX0NP TlRST0xfTUVBU1VSRV9BTEwgfAo+ICsJCQkJCUxUQzI5OTBfQ09OVFJPTF9NT0RFX0NVUlJFTlQp Owo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKCZpMmMtPmRldiwgIkVycm9yOiBGYWls ZWQgdG8gc2V0IGNvbnRyb2wgbW9kZS5cbiIpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwkv KiBUcmlnZ2VyIG9uY2UgdG8gc3RhcnQgY29udGludW91cyBjb252ZXJzaW9uICovCj4gKwlyZXQg PSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGkyYywgTFRDMjk5MF9UUklHR0VSLCAxKTsKPiAr CWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycigmaTJjLT5kZXYsICJFcnJvcjogRmFpbGVkIHRv IHN0YXJ0IGFjcXVpc2l0aW9uLlxuIik7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwlo d21vbl9kZXYgPSBkZXZtX2h3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dyb3VwcygmaTJjLT5k ZXYsCj4gKwkJCQkJCQkgICBpMmMtPm5hbWUsCj4gKwkJCQkJCQkgICBpMmMsCj4gKwkJCQkJCQkg ICBsdGMyOTkwX2dyb3Vwcyk7Cj4gKwo+ICsJcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9k ZXYpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgbHRjMjk5 MF9pMmNfaWRbXSA9IHsKPiArCXsgImx0YzI5OTAiLCAwIH0sCj4gKwl7fQo+ICt9Owo+ICtNT0RV TEVfREVWSUNFX1RBQkxFKGkyYywgbHRjMjk5MF9pMmNfaWQpOwo+ICsKPiArc3RhdGljIHN0cnVj dCBpMmNfZHJpdmVyIGx0YzI5OTBfaTJjX2RyaXZlciA9IHsKPiArCS5kcml2ZXIgPSB7Cj4gKwkJ Lm5hbWUgPSAibHRjMjk5MCIsCj4gKwl9LAo+ICsJLnByb2JlICAgID0gbHRjMjk5MF9pMmNfcHJv YmUsCj4gKwkuaWRfdGFibGUgPSBsdGMyOTkwX2kyY19pZCwKPiArfTsKPiArCj4gK21vZHVsZV9p MmNfZHJpdmVyKGx0YzI5OTBfaTJjX2RyaXZlcik7Cj4gKwo+ICtNT0RVTEVfREVTQ1JJUFRJT04o IkxUQzI5OTAgU2Vuc29yIERyaXZlciIpOwo+ICtNT0RVTEVfQVVUSE9SKCJUb3BpYyBFbWJlZGRl ZCBQcm9kdWN0cyIpOwo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7Cj4KCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcg bGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751681AbcAOPkl (ORCPT ); Fri, 15 Jan 2016 10:40:41 -0500 Received: from bh-25.webhostbox.net ([208.91.199.152]:60351 "EHLO bh-25.webhostbox.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751082AbcAOPki (ORCPT ); Fri, 15 Jan 2016 10:40:38 -0500 Subject: Re: [PATCH v4] hwmon: Add LTC2990 sensor driver To: Mike Looijmans , lm-sensors@lm-sensors.org References: <1452851699-14652-1-git-send-email-mike.looijmans@topic.nl> Cc: jdelvare@suse.com, linux-kernel@vger.kernel.org From: Guenter Roeck Message-ID: <569912F2.9020906@roeck-us.net> Date: Fri, 15 Jan 2016 07:40:34 -0800 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.4.0 MIME-Version: 1.0 In-Reply-To: <1452851699-14652-1-git-send-email-mike.looijmans@topic.nl> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit X-Authenticated_sender: linux@roeck-us.net X-OutGoing-Spam-Status: No, score=-1.0 X-AntiAbuse: This header was added to track abuse, please include it with any abuse report X-AntiAbuse: Primary Hostname - bh-25.webhostbox.net X-AntiAbuse: Original Domain - vger.kernel.org X-AntiAbuse: Originator/Caller UID/GID - [47 12] / [47 12] X-AntiAbuse: Sender Address Domain - roeck-us.net X-Get-Message-Sender-Via: bh-25.webhostbox.net: authenticated_id: linux@roeck-us.net X-Authenticated-Sender: bh-25.webhostbox.net: linux@roeck-us.net X-Source: X-Source-Args: X-Source-Dir: Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 01/15/2016 01:54 AM, 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 Applied to -next. Thanks, Guenter > --- > v4: Fix checkpatch warnings > ltc2990_get_value can return error code > 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 | 161 ++++++++++++++++++++++++++++++++++++++++++++ > 4 files changed, 220 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 > + > + > +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..8f8fe05 > --- /dev/null > +++ b/drivers/hwmon/ltc2990.c > @@ -0,0 +1,161 @@ > +/* > + * Driver for Linear Technology LTC2990 power monitor > + * > + * Copyright (C) 2014 Topic Embedded Products > + * Author: Mike Looijmans > + * > + * 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 > +#include > +#include > +#include > +#include > +#include > + > +#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; > +} > + > +/* Return the converted value from the given register in uV or mC */ > +static int ltc2990_get_value(struct i2c_client *i2c, u8 reg, int *result) > +{ > + int val; > + > + val = i2c_smbus_read_word_swapped(i2c, reg); > + if (unlikely(val < 0)) > + return val; > + > + 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)) + 2500; > + break; > + default: > + return -EINVAL; /* won't happen, keep compiler happy */ > + } > + > + return 0; > +} > + > +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; > + int ret; > + > + ret = ltc2990_get_value(dev_get_drvdata(dev), attr->index, &value); > + if (unlikely(ret < 0)) > + return ret; > + > + 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"); >