* [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-11 6:28 ` Heiko Schocher 0 siblings, 0 replies; 8+ messages in thread From: Heiko Schocher @ 2014-06-11 6:28 UTC (permalink / raw) To: lm-sensors; +Cc: Heiko Schocher, Jean Delvare, Guenter Roeck, linux-kernel RHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgoKVGhlIFRJIFRNUDEwMyBpcyBzaW1pbGFyIHRvIHRo ZSBUTVAxMDIuICBJdCBkaWZmZXJzIGZyb20gdGhlIFRNUDEwMgpieSBoYXZpbmcgb25seSA4IGJp dCByZWdpc3RlcnMuCgpTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4K Q2M6IEplYW4gRGVsdmFyZSA8a2hhbGlAbGludXgtZnIub3JnPgpDYzogR3VlbnRlciBSb2VjayA8 bGludXhAcm9lY2stdXMubmV0PgpDYzogbGludXgta2VybmVsQHZnZXIua2VybmVsLm9yZwotLS0K IERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9od21vbi90bXAxMDMgfCAgMzAgKysr CiBkcml2ZXJzL2h3bW9uL0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDEwICsK IGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwog ZHJpdmVycy9od21vbi90bXAxMDMuYyAgICAgICAgICAgICAgICAgICAgICAgICB8IDI4MSArKysr KysrKysrKysrKysrKysrKysrKysrCiA0IGZpbGVzIGNoYW5nZWQsIDMyMiBpbnNlcnRpb25zKCsp CiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3 bW9uL3RtcDEwMwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKCmRp ZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAz IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zNmQ3YjM2Ci0tLSAvZGV2L251bGwKKysrIGIv RG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMwpAQCAtMCwwICsx LDMwIEBACitLZXJuZWwgZHJpdmVyIHRtcDEwMworPT09PT09PT09PT09PT09PT09PT0KKworU3Vw cG9ydGVkIGNoaXBzOgorICAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMworICAgIFByZWZpeDog J3RtcDEwMycKKyAgICBBZGRyZXNzZXMgc2Nhbm5lZDogbm9uZQorICAgIFByb2R1Y3QgaW5mbyBh bmQgZGF0YXNoZWV0OiBodHRwOi8vd3d3LnRpLmNvbS9wcm9kdWN0L3RtcDEwMworCitBdXRob3I6 CisJSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+CisKK0Rlc2NyaXB0aW9uCistLS0tLS0tLS0t LQorCitUaGUgVE1QMTAzIGlzIGEgZGlnaXRhbCBvdXRwdXQgdGVtcGVyYXR1cmUgc2Vuc29yIGlu IGEgZm91ci1iYWxsCit3YWZlciBjaGlwLXNjYWxlIHBhY2thZ2UgKFdDU1ApLiBUaGUgVE1QMTAz IGlzIGNhcGFibGUgb2YgcmVhZGluZwordGVtcGVyYXR1cmVzIHRvIGEgcmVzb2x1dGlvbiBvZiAx wrBDLiBUaGUgVE1QMTAzIGlzIHNwZWNpZmllZCBmb3IKK29wZXJhdGlvbiBvdmVyIGEgdGVtcGVy YXR1cmUgcmFuZ2Ugb2Yg4oCTNDDCsEMgdG8gKzEyNcKwQy4KKworUmVzb2x1dGlvbjogOCBCaXRz CitBY2N1cmFjeTogwrExwrBDIFR5cCAo4oCTMTDCsEMgdG8gKzEwMMKwQykKKworVGhlIGRyaXZl ciBwcm92aWRlcyB0aGUgY29tbW9uIHN5c2ZzLWludGVyZmFjZSBmb3IgdGVtcGVyYXR1cmVzIChz ZWUKK0RvY3VtZW50YXRpb24vaHdtb24vc3lzZnMtaW50ZXJmYWNlIHVuZGVyIFRlbXBlcmF0dXJl cykuCisKK1JlcXVpcmVkIG5vZGUgcHJvcGVydGllczoKKy0gY29tcGF0aWJsZTogbWFudWZhY3R1 cmVyIGFuZCBjaGlwIG5hbWUKKwkJInRpLHRtcDEwMyIKKy0gcmVnOiBJMkMgYnVzIGFkZHJlc3Mg b2YgdGhlIGRldmljZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVy cy9od21vbi9LY29uZmlnCmluZGV4IDAwMzQzMTYuLjBmNDRkYmIgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvaHdtb24vS2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTEzODEsNiAr MTM4MSwxNiBAQCBjb25maWcgU0VOU09SU19UTVAxMDIKIAkgIFRoaXMgZHJpdmVyIGNhbiBhbHNv IGJlIGJ1aWx0IGFzIGEgbW9kdWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKIAkgIHdpbGwgYmUgY2Fs bGVkIHRtcDEwMi4KIAorY29uZmlnIFNFTlNPUlNfVE1QMTAzCisJdHJpc3RhdGUgIlRleGFzIElu c3RydW1lbnRzIFRNUDEwMyIKKwlkZXBlbmRzIG9uIEkyQworCWhlbHAKKwkgIElmIHlvdSBzYXkg eWVzIGhlcmUgeW91IGdldCBzdXBwb3J0IGZvciBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKKwkg IHNlbnNvciBjaGlwcy4KKworCSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBt b2R1bGUuICBJZiBzbywgdGhlIG1vZHVsZQorCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgorCiBj b25maWcgU0VOU09SU19UTVA0MDEKIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAx IGFuZCBjb21wYXRpYmxlcyIKIAlkZXBlbmRzIG9uIEkyQwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9o d21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKaW5kZXggMTE3OThhZC4uOGUy ZjZhMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2h3 bW9uL01ha2VmaWxlCkBAIC0xMzQsNiArMTM0LDcgQEAgb2JqLSQoQ09ORklHX1NFTlNPUlNfU01T QzQ3TTE5MikrPSBzbXNjNDdtMTkyLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0FNQzY4MjEpCSs9 IGFtYzY4MjEubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfVEhNQzUwKQkrPSB0aG1jNTAubwogb2Jq LSQoQ09ORklHX1NFTlNPUlNfVE1QMTAyKQkrPSB0bXAxMDIubworb2JqLSQoQ09ORklHX1NFTlNP UlNfVE1QMTAzKQkrPSB0bXAxMDMubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDAxKQkrPSB0 bXA0MDEubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIxKQkrPSB0bXA0MjEubwogb2JqLSQo Q09ORklHX1NFTlNPUlNfVFdMNDAzMF9NQURDKSs9IHR3bDQwMzAtbWFkYy1od21vbi5vCmRpZmYg LS1naXQgYS9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jIGIvZHJpdmVycy9od21vbi90bXAxMDMuYwpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wYmQzM2Q2Ci0tLSAvZGV2L251bGwK KysrIGIvZHJpdmVycy9od21vbi90bXAxMDMuYwpAQCAtMCwwICsxLDI4MSBAQAorLyoKKyAqIFRl eGFzIEluc3RydW1lbnRzIFRNUDEwMyBTTUJ1cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyCisg KiBDb3B5cmlnaHQgKEMpIDIwMTQgSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+CisgKgorICog QmFzZWQgb246CisgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDIgU01CdXMgdGVtcGVyYXR1cmUg c2Vuc29yIGRyaXZlcgorICoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBTdGV2ZW4gS2luZyA8c2Zr aW5nQGZkd2RjLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu c2UsIG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRo aXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICovCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNp bmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUg PGxpbnV4L2kyYy5oPgorI2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+CisjaW5jbHVkZSA8bGludXgv aHdtb24tc3lzZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9t dXRleC5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2ppZmZp ZXMuaD4KKworI2RlZmluZQlEUklWRVJfTkFNRSAidG1wMTAzIgorCisjZGVmaW5lCVRNUDEwM19U RU1QX1JFRwkJCTB4MDAKKyNkZWZpbmUJVE1QMTAzX0NPTkZfUkVHCQkJMHgwMQorI2RlZmluZQlU TVAxMDNfVExPV19SRUcJCQkweDAyCisjZGVmaW5lCVRNUDEwM19USElHSF9SRUcJCTB4MDMKKwor I2RlZmluZQkJVE1QMTAzX0NPTkZfTTAJCTB4MDEKKyNkZWZpbmUJCVRNUDEwM19DT05GX00xCQkw eDAyCisjZGVmaW5lCQlUTVAxMDNfQ09ORl9MQwkJMHgwNAorI2RlZmluZQkJVE1QMTAzX0NPTkZf RkwJCTB4MDgKKyNkZWZpbmUJCVRNUDEwM19DT05GX0ZICQkweDEwCisjZGVmaW5lCQlUTVAxMDNf Q09ORl9DUjAJCTB4MjAKKyNkZWZpbmUJCVRNUDEwM19DT05GX0NSMQkJMHg0MAorI2RlZmluZQkJ VE1QMTAzX0NPTkZfSUQJCTB4ODAKKyNkZWZpbmUJCVRNUDEwM19DT05GX1NECQkoVE1QMTAzX0NP TkZfTTAgfCBUTVAxMDNfQ09ORl9NMSkKKworc3RydWN0IHRtcDEwMyB7CisJc3RydWN0IGRldmlj ZSAqaHdtb25fZGV2OworCXN0cnVjdCBtdXRleCBsb2NrOworCXUxNiBjb25maWdfb3JpZzsKKwl1 bnNpZ25lZCBsb25nIGxhc3RfdXBkYXRlOworCWludCB0ZW1wWzNdOworfTsKKworc3RhdGljIGlu bGluZSBpbnQgdG1wMTAzX3JlZ190b19tQyhzOCB2YWwpCit7CisJcmV0dXJuIHZhbCAqIDEwMDA7 Cit9CisKK3N0YXRpYyBpbmxpbmUgdTggdG1wMTAzX21DX3RvX3JlZyhpbnQgdmFsKQoreworCXJl dHVybiB2YWwgLyAxMDAwOworfQorCitzdGF0aWMgY29uc3QgdTggdG1wMTAzX3JlZ1tdID0gewor CVRNUDEwM19URU1QX1JFRywKKwlUTVAxMDNfVExPV19SRUcsCisJVE1QMTAzX1RISUdIX1JFRywK K307CisKK3N0YXRpYyBzdHJ1Y3QgdG1wMTAzICp0bXAxMDNfdXBkYXRlX2RldmljZShzdHJ1Y3Qg aTJjX2NsaWVudCAqY2xpZW50KQoreworCXN0cnVjdCB0bXAxMDMgKnRtcDEwMyA9IGkyY19nZXRf Y2xpZW50ZGF0YShjbGllbnQpOworCisJbXV0ZXhfbG9jaygmdG1wMTAzLT5sb2NrKTsKKwlpZiAo dGltZV9hZnRlcihqaWZmaWVzLCB0bXAxMDMtPmxhc3RfdXBkYXRlICsgSFogLyAzKSkgeworCQlp bnQgaTsKKworCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh0bXAxMDMtPnRlbXApOyArK2kp IHsKKwkJCWludCBzdGF0dXMgPSBpMmNfc21idXNfcmVhZF9ieXRlX2RhdGEoY2xpZW50LAorCQkJ CQkJCSB0bXAxMDNfcmVnW2ldKTsKKwkJCWlmIChzdGF0dXMgPiAtMSkKKwkJCQl0bXAxMDMtPnRl bXBbaV0gPSB0bXAxMDNfcmVnX3RvX21DKHN0YXR1cyk7CisJCX0KKwkJdG1wMTAzLT5sYXN0X3Vw ZGF0ZSA9IGppZmZpZXM7CisJfQorCW11dGV4X3VubG9jaygmdG1wMTAzLT5sb2NrKTsKKwlyZXR1 cm4gdG1wMTAzOworfQorCitzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2hvd190ZW1wKHN0cnVjdCBk ZXZpY2UgKmRldiwKKwkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQljaGFy ICpidWYpCit7CisJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5z b3JfZGV2X2F0dHIoYXR0cik7CisJc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gdG1wMTAzX3VwZGF0 ZV9kZXZpY2UodG9faTJjX2NsaWVudChkZXYpKTsKKworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVk XG4iLCB0bXAxMDMtPnRlbXBbc2RhLT5pbmRleF0pOworfQorCitzdGF0aWMgc3NpemVfdCB0bXAx MDNfc2V0X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAorCQkJICAgICAgIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLAorCQkJICAgICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50 KQoreworCXN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAqc2RhID0gdG9fc2Vuc29yX2Rl dl9hdHRyKGF0dHIpOworCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB0b19pMmNfY2xpZW50 KGRldik7CisJc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVu dCk7CisJbG9uZyB2YWw7CisJaW50IHN0YXR1czsKKworCWlmIChrc3RydG9sKGJ1ZiwgMTAsICZ2 YWwpIDwgMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisJdmFsID0gY2xhbXBfdmFsKHZhbCwgLTU1MDAw LCAxMjgwMDApOworCisJbXV0ZXhfbG9jaygmdG1wMTAzLT5sb2NrKTsKKwl0bXAxMDMtPnRlbXBb c2RhLT5pbmRleF0gPSB2YWw7CisJc3RhdHVzID0gaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0YShj bGllbnQsIHRtcDEwM19yZWdbc2RhLT5pbmRleF0sCisJCQkJCSAgICAgIHRtcDEwM19tQ190b19y ZWcodmFsKSk7CisJbXV0ZXhfdW5sb2NrKCZ0bXAxMDMtPmxvY2spOworCXJldHVybiBzdGF0dXMg PyA6IGNvdW50OworfQorCitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBT X0lSVUdPLCB0bXAxMDNfc2hvd190ZW1wLCBOVUxMICwgMCk7CisKK3N0YXRpYyBTRU5TT1JfREVW SUNFX0FUVFIodGVtcDFfbWF4X2h5c3QsIFNfSVdVU1IgfCBTX0lSVUdPLCB0bXAxMDNfc2hvd190 ZW1wLAorCQkJICB0bXAxMDNfc2V0X3RlbXAsIDEpOworCitzdGF0aWMgU0VOU09SX0RFVklDRV9B VFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEwM19zaG93X3RlbXAsCisJCQkg IHRtcDEwM19zZXRfdGVtcCwgMik7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNf YXR0cmlidXRlc1tdID0geworCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIu YXR0ciwKKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heF9oeXN0LmRldl9hdHRyLmF0dHIsCisJ JnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9tYXguZGV2X2F0dHIuYXR0ciwKKwlOVUxMCit9OworCitz dGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCB0bXAxMDNfYXR0cl9ncm91cCA9IHsK KwkuYXR0cnMgPSB0bXAxMDNfYXR0cmlidXRlcywKK307CisKKyNkZWZpbmUgVE1QMTAzX0NPTkZJ RwkJKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQorI2RlZmluZSBUTVAxMDNfQ09O RklHX1JEX09OTFkJKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQorCitzdGF0aWMg aW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAorCQkJCSAgY29uc3Qg c3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQoreworCXN0cnVjdCB0bXAxMDMgKnRtcDEwMzsKKwlp bnQgc3RhdHVzOworCisJaWYgKCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0 ZXIsCisJCQkJICAgICBJMkNfRlVOQ19TTUJVU19XT1JEX0RBVEEpKSB7CisJCWRldl9lcnIoJmNs aWVudC0+ZGV2LAorCQkJImFkYXB0ZXIgZG9lc24ndCBzdXBwb3J0IFNNQnVzIHdvcmQgdHJhbnNh Y3Rpb25zXG4iKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJdG1wMTAzID0gZGV2bV9remFs bG9jKCZjbGllbnQtPmRldiwgc2l6ZW9mKCp0bXAxMDMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXRt cDEwMykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlpMmNfc2V0X2NsaWVudGRhdGEoY2xpZW50LCB0 bXAxMDMpOworCisJc3RhdHVzID0gaTJjX3NtYnVzX3JlYWRfYnl0ZV9kYXRhKGNsaWVudCwgVE1Q MTAzX0NPTkZfUkVHKTsKKwlpZiAoc3RhdHVzIDwgMCkgeworCQlkZXZfZXJyKCZjbGllbnQtPmRl diwgImVycm9yIHJlYWRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKKwkJcmV0dXJuIHN0YXR1czsK Kwl9CisJdG1wMTAzLT5jb25maWdfb3JpZyA9IHN0YXR1czsKKwlzdGF0dXMgPSBpMmNfc21idXNf d3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLAorCQkJCQkgICAgICBUTVAx MDNfQ09ORklHKTsKKwlpZiAoc3RhdHVzIDwgMCkgeworCQlkZXZfZXJyKCZjbGllbnQtPmRldiwg ImVycm9yIHdyaXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKKwkJZ290byBmYWlsX3Jlc3RvcmVf Y29uZmlnOworCX0KKwlzdGF0dXMgPSBpMmNfc21idXNfcmVhZF9ieXRlX2RhdGEoY2xpZW50LCBU TVAxMDNfQ09ORl9SRUcpOworCWlmIChzdGF0dXMgPCAwKSB7CisJCWRldl9lcnIoJmNsaWVudC0+ ZGV2LCAiZXJyb3IgcmVhZGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOworCQlnb3RvIGZhaWxfcmVz dG9yZV9jb25maWc7CisJfQorCWlmIChzdGF0dXMgIT0gVE1QMTAzX0NPTkZJRykgeworCQlkZXZf ZXJyKCZjbGllbnQtPmRldiwgImNvbmZpZyBzZXR0aW5ncyBkaWQgbm90IHN0aWNrXG4iKTsKKwkJ c3RhdHVzID0gLUVOT0RFVjsKKwkJZ290byBmYWlsX3Jlc3RvcmVfY29uZmlnOworCX0KKwl0bXAx MDMtPmxhc3RfdXBkYXRlID0gamlmZmllcyAtIEhaOworCW11dGV4X2luaXQoJnRtcDEwMy0+bG9j ayk7CisKKwlzdGF0dXMgPSBzeXNmc19jcmVhdGVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0 bXAxMDNfYXR0cl9ncm91cCk7CisJaWYgKHN0YXR1cykgeworCQlkZXZfZGJnKCZjbGllbnQtPmRl diwgImNvdWxkIG5vdCBjcmVhdGUgc3lzZnMgZmlsZXNcbiIpOworCQlnb3RvIGZhaWxfcmVzdG9y ZV9jb25maWc7CisJfQorCXRtcDEwMy0+aHdtb25fZGV2ID0gaHdtb25fZGV2aWNlX3JlZ2lzdGVy KCZjbGllbnQtPmRldik7CisJaWYgKElTX0VSUih0bXAxMDMtPmh3bW9uX2RldikpIHsKKwkJZGV2 X2RiZygmY2xpZW50LT5kZXYsICJ1bmFibGUgdG8gcmVnaXN0ZXIgaHdtb24gZGV2aWNlXG4iKTsK KwkJc3RhdHVzID0gUFRSX0VSUih0bXAxMDMtPmh3bW9uX2Rldik7CisJCWdvdG8gZmFpbF9yZW1v dmVfc3lzZnM7CisJfQorCisJZGV2X2luZm8oJmNsaWVudC0+ZGV2LCAiaW5pdGlhbGl6ZWRcbiIp OworCisJcmV0dXJuIDA7CisKK2ZhaWxfcmVtb3ZlX3N5c2ZzOgorCXN5c2ZzX3JlbW92ZV9ncm91 cCgmY2xpZW50LT5kZXYua29iaiwgJnRtcDEwM19hdHRyX2dyb3VwKTsKK2ZhaWxfcmVzdG9yZV9j b25maWc6CisJaTJjX3NtYnVzX3dyaXRlX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05G X1JFRywKKwkJCQkgICAgIHRtcDEwMy0+Y29uZmlnX29yaWcpOworCXJldHVybiBzdGF0dXM7Cit9 CisKK3N0YXRpYyBpbnQgdG1wMTAzX3JlbW92ZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQor eworCXN0cnVjdCB0bXAxMDMgKnRtcDEwMyA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOwor CisJaHdtb25fZGV2aWNlX3VucmVnaXN0ZXIodG1wMTAzLT5od21vbl9kZXYpOworCXN5c2ZzX3Jl bW92ZV9ncm91cCgmY2xpZW50LT5kZXYua29iaiwgJnRtcDEwM19hdHRyX2dyb3VwKTsKKworCXJl dHVybiAwOworfQorCisjaWZkZWYgQ09ORklHX1BNCitzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5k KHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdG9f aTJjX2NsaWVudChkZXYpOworCWludCBjb25maWc7CisKKwljb25maWcgPSBpMmNfc21idXNfcmVh ZF93b3JkX3N3YXBwZWQoY2xpZW50LCBUTVAxMDNfQ09ORl9SRUcpOworCWlmIChjb25maWcgPCAw KQorCQlyZXR1cm4gY29uZmlnOworCisJY29uZmlnICY9IH5UTVAxMDNfQ09ORl9TRDsKKwlyZXR1 cm4gaTJjX3NtYnVzX3dyaXRlX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05GX1JFRywg Y29uZmlnKTsKK30KKworc3RhdGljIGludCB0bXAxMDNfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRl dikKK3sKKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdG9faTJjX2NsaWVudChkZXYpOwor CWludCBjb25maWc7CisKKwljb25maWcgPSBpMmNfc21idXNfcmVhZF93b3JkX3N3YXBwZWQoY2xp ZW50LCBUTVAxMDNfQ09ORl9SRUcpOworCWlmIChjb25maWcgPCAwKQorCQlyZXR1cm4gY29uZmln OworCisJY29uZmlnIHw9IFRNUDEwM19DT05GX1NEOworCXJldHVybiBpMmNfc21idXNfd3JpdGVf d29yZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLCBjb25maWcpOworfQorCitzdGF0 aWMgY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgdG1wMTAzX2Rldl9wbV9vcHMgPSB7CisJLnN1c3Bl bmQJPSB0bXAxMDNfc3VzcGVuZCwKKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1bWUsCit9OworCisj ZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCisjZWxzZQorI2Rl ZmluZQlUTVAxMDNfREVWX1BNX09QUyBOVUxMCisjZW5kaWYgLyogQ09ORklHX1BNICovCisKK3N0 YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKKwl7IERSSVZF Ul9OQU1FLCAwIH0sCisJeyB9Cit9OworTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19p ZCk7CisKK3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciB0bXAxMDNfZHJpdmVyID0geworCS5kcml2 ZXIubmFtZQk9IERSSVZFUl9OQU1FLAorCS5kcml2ZXIucG0JPSBUTVAxMDNfREVWX1BNX09QUywK KwkucHJvYmUJCT0gdG1wMTAzX3Byb2JlLAorCS5yZW1vdmUJCT0gdG1wMTAzX3JlbW92ZSwKKwku aWRfdGFibGUJPSB0bXAxMDNfaWQsCit9OworCittb2R1bGVfaTJjX2RyaXZlcih0bXAxMDNfZHJp dmVyKTsKKworTU9EVUxFX0FVVEhPUigiSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Iik7CitN T0RVTEVfREVTQ1JJUFRJT04oIlRleGFzIEluc3RydW1lbnRzIFRNUDEwMyB0ZW1wZXJhdHVyZSBz ZW5zb3IgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7Ci0tIAoxLjguMy4xCgoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbG0tc2Vuc29ycyBt YWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0tc2Vu c29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz ^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-11 6:28 ` Heiko Schocher 0 siblings, 0 replies; 8+ messages in thread From: Heiko Schocher @ 2014-06-11 6:28 UTC (permalink / raw) To: lm-sensors; +Cc: Heiko Schocher, Jean Delvare, Guenter Roeck, linux-kernel 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 --- Documentation/devicetree/bindings/hwmon/tmp103 | 30 +++ drivers/hwmon/Kconfig | 10 + drivers/hwmon/Makefile | 1 + drivers/hwmon/tmp103.c | 281 +++++++++++++++++++++++++ 4 files changed, 322 insertions(+) create mode 100644 Documentation/devicetree/bindings/hwmon/tmp103 create mode 100644 drivers/hwmon/tmp103.c diff --git a/Documentation/devicetree/bindings/hwmon/tmp103 b/Documentation/devicetree/bindings/hwmon/tmp103 new file mode 100644 index 0000000..36d7b36 --- /dev/null +++ b/Documentation/devicetree/bindings/hwmon/tmp103 @@ -0,0 +1,30 @@ +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). + +Required node properties: +- compatible: manufacturer and chip name + "ti,tmp103" +- reg: I2C bus address of the device diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 0034316..0f44dbb 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -1381,6 +1381,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 11798ad..8e2f6a2 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -134,6 +134,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..0bd33d6 --- /dev/null +++ b/drivers/hwmon/tmp103.c @@ -0,0 +1,281 @@ +/* + * 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> + +#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) + +struct tmp103 { + struct device *hwmon_dev; + struct mutex lock; + u16 config_orig; + unsigned long last_update; + int temp[3]; +}; + +static inline int tmp103_reg_to_mC(s8 val) +{ + return val * 1000; +} + +static inline u8 tmp103_mC_to_reg(int val) +{ + return val / 1000; +} + +static const u8 tmp103_reg[] = { + TMP103_TEMP_REG, + TMP103_TLOW_REG, + TMP103_THIGH_REG, +}; + +static struct tmp103 *tmp103_update_device(struct i2c_client *client) +{ + struct tmp103 *tmp103 = i2c_get_clientdata(client); + + mutex_lock(&tmp103->lock); + if (time_after(jiffies, tmp103->last_update + HZ / 3)) { + int i; + + for (i = 0; i < ARRAY_SIZE(tmp103->temp); ++i) { + int status = i2c_smbus_read_byte_data(client, + tmp103_reg[i]); + if (status > -1) + tmp103->temp[i] = tmp103_reg_to_mC(status); + } + tmp103->last_update = jiffies; + } + mutex_unlock(&tmp103->lock); + return tmp103; +} + +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 tmp103 *tmp103 = tmp103_update_device(to_i2c_client(dev)); + + return sprintf(buf, "%d\n", tmp103->temp[sda->index]); +} + +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 i2c_client *client = to_i2c_client(dev); + struct tmp103 *tmp103 = i2c_get_clientdata(client); + long val; + int status; + + if (kstrtol(buf, 10, &val) < 0) + return -EINVAL; + val = clamp_val(val, -55000, 128000); + + mutex_lock(&tmp103->lock); + tmp103->temp[sda->index] = val; + status = i2c_smbus_write_byte_data(client, tmp103_reg[sda->index], + tmp103_mC_to_reg(val)); + mutex_unlock(&tmp103->lock); + return status ? : count; +} + +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , 0); + +static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp103_show_temp, + tmp103_set_temp, 1); + +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, + tmp103_set_temp, 2); + +static struct attribute *tmp103_attributes[] = { + &sensor_dev_attr_temp1_input.dev_attr.attr, + &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, + &sensor_dev_attr_temp1_max.dev_attr.attr, + NULL +}; + +static const struct attribute_group tmp103_attr_group = { + .attrs = tmp103_attributes, +}; + +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) +#define TMP103_CONFIG_RD_ONLY (TMP103_CONF_CR1 | TMP103_CONF_M1) + +static int tmp103_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct tmp103 *tmp103; + int status; + + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_WORD_DATA)) { + dev_err(&client->dev, + "adapter doesn't support SMBus word transactions\n"); + return -ENODEV; + } + + tmp103 = devm_kzalloc(&client->dev, sizeof(*tmp103), GFP_KERNEL); + if (!tmp103) + return -ENOMEM; + + i2c_set_clientdata(client, tmp103); + + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); + if (status < 0) { + dev_err(&client->dev, "error reading config register\n"); + return status; + } + tmp103->config_orig = status; + status = i2c_smbus_write_byte_data(client, TMP103_CONF_REG, + TMP103_CONFIG); + if (status < 0) { + dev_err(&client->dev, "error writing config register\n"); + goto fail_restore_config; + } + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); + if (status < 0) { + dev_err(&client->dev, "error reading config register\n"); + goto fail_restore_config; + } + if (status != TMP103_CONFIG) { + dev_err(&client->dev, "config settings did not stick\n"); + status = -ENODEV; + goto fail_restore_config; + } + tmp103->last_update = jiffies - HZ; + mutex_init(&tmp103->lock); + + status = sysfs_create_group(&client->dev.kobj, &tmp103_attr_group); + if (status) { + dev_dbg(&client->dev, "could not create sysfs files\n"); + goto fail_restore_config; + } + tmp103->hwmon_dev = hwmon_device_register(&client->dev); + if (IS_ERR(tmp103->hwmon_dev)) { + dev_dbg(&client->dev, "unable to register hwmon device\n"); + status = PTR_ERR(tmp103->hwmon_dev); + goto fail_remove_sysfs; + } + + dev_info(&client->dev, "initialized\n"); + + return 0; + +fail_remove_sysfs: + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); +fail_restore_config: + i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, + tmp103->config_orig); + return status; +} + +static int tmp103_remove(struct i2c_client *client) +{ + struct tmp103 *tmp103 = i2c_get_clientdata(client); + + hwmon_device_unregister(tmp103->hwmon_dev); + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); + + return 0; +} + +#ifdef CONFIG_PM +static int tmp103_suspend(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + int config; + + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); + if (config < 0) + return config; + + config &= ~TMP103_CONF_SD; + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); +} + +static int tmp103_resume(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + int config; + + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); + if (config < 0) + return config; + + config |= TMP103_CONF_SD; + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); +} + +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 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, tmp103_id); + +static struct i2c_driver tmp103_driver = { + .driver.name = DRIVER_NAME, + .driver.pm = TMP103_DEV_PM_OPS, + .probe = tmp103_probe, + .remove = tmp103_remove, + .id_table = tmp103_id, +}; + +module_i2c_driver(tmp103_driver); + +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); +MODULE_LICENSE("GPL"); -- 1.8.3.1 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor 2014-06-11 6:28 ` Heiko Schocher @ 2014-06-11 17:11 ` Guenter Roeck -1 siblings, 0 replies; 8+ messages in thread From: Guenter Roeck @ 2014-06-11 17:11 UTC (permalink / raw) To: Heiko Schocher, lm-sensors; +Cc: Jean Delvare, linux-kernel T24gMDYvMTAvMjAxNCAxMToyOCBQTSwgSGVpa28gU2Nob2NoZXIgd3JvdGU6Cj4gRHJpdmVyIGZv ciB0aGUgVEkgVE1QMTAzLgo+Cj4gVGhlIFRJIFRNUDEwMyBpcyBzaW1pbGFyIHRvIHRoZSBUTVAx MDIuICBJdCBkaWZmZXJzIGZyb20gdGhlIFRNUDEwMgo+IGJ5IGhhdmluZyBvbmx5IDggYml0IHJl Z2lzdGVycy4KPgo+IFNpZ25lZC1vZmYtYnk6IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4KPiBDYzogR3VlbnRlciBSb2Vj ayA8bGludXhAcm9lY2stdXMubmV0Pgo+IENjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3Jn CgpIaSBIZWlrbywKCllvdSBkb24ndCBuZWVkIHRob3NlIENjOiBpbiB0aGUgaGVhZGVyLgoKV2h5 IHBhdGNoIDA5LzEzID8gSSdkIGV4cGVjdCB0byBzZWUgMTIgbW9yZSBwYXRjaGVzIGluIHRoaXMg c2VyaWVzLApidXQgdGhlcmUgaXMgb25seSBvbmUgKGV2ZW4gb24ga2VybmVsLm9yZykuIElmIHlv dSBzZW50IHRob3NlCm90aGVyIHBhdGNoZXMgdG8gdmFyaW91cyBvdGhlciBtYWlsaW5nIGxpc3Rz LCBldmVyeW9uZSB3aWxsIHdvbmRlcgp3aGVyZSB0aGUgcmVtYWluaW5nIHBhdGNoZXMgYXJlLiBJ ZiB0aGVyZSBpcyBqdXN0IG9uZSBwYXRjaCwKaXQgaXMganVzdCBjb25mdXNpbmcuCgo+IC0tLQo+ ICAgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMyB8ICAzMCAr KysKPiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg MTAgKwo+ICAgZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgMSArCj4gICBkcml2ZXJzL2h3bW9uL3RtcDEwMy5jICAgICAgICAgICAgICAgICAgICAgICAg IHwgMjgxICsrKysrKysrKysrKysrKysrKysrKysrKysKPiAgIDQgZmlsZXMgY2hhbmdlZCwgMzIy IGluc2VydGlvbnMoKykKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2Rldmlj ZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9od21vbi90bXAxMDMuYwo+Cj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJl ZS9iaW5kaW5ncy9od21vbi90bXAxMDMgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGlu Z3MvaHdtb24vdG1wMTAzCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwLi4z NmQ3YjM2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i aW5kaW5ncy9od21vbi90bXAxMDMKClNob3VsZCBiZSBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw My4KCj4gQEAgLTAsMCArMSwzMCBAQAo+ICtLZXJuZWwgZHJpdmVyIHRtcDEwMwo+ICs9PT09PT09 PT09PT09PT09PT09PQo+ICsKPiArU3VwcG9ydGVkIGNoaXBzOgo+ICsgICogVGV4YXMgSW5zdHJ1 bWVudHMgVE1QMTAzCj4gKyAgICBQcmVmaXg6ICd0bXAxMDMnCj4gKyAgICBBZGRyZXNzZXMgc2Nh bm5lZDogbm9uZQo+ICsgICAgUHJvZHVjdCBpbmZvIGFuZCBkYXRhc2hlZXQ6IGh0dHA6Ly93d3cu dGkuY29tL3Byb2R1Y3QvdG1wMTAzCj4gKwo+ICtBdXRob3I6Cj4gKwlIZWlrbyBTY2hvY2hlciA8 aHNAZGVueC5kZT4KPiArCj4gK0Rlc2NyaXB0aW9uCj4gKy0tLS0tLS0tLS0tCj4gKwo+ICtUaGUg VE1QMTAzIGlzIGEgZGlnaXRhbCBvdXRwdXQgdGVtcGVyYXR1cmUgc2Vuc29yIGluIGEgZm91ci1i YWxsCj4gK3dhZmVyIGNoaXAtc2NhbGUgcGFja2FnZSAoV0NTUCkuIFRoZSBUTVAxMDMgaXMgY2Fw YWJsZSBvZiByZWFkaW5nCj4gK3RlbXBlcmF0dXJlcyB0byBhIHJlc29sdXRpb24gb2YgMcKwQy4g VGhlIFRNUDEwMyBpcyBzcGVjaWZpZWQgZm9yCj4gK29wZXJhdGlvbiBvdmVyIGEgdGVtcGVyYXR1 cmUgcmFuZ2Ugb2Yg4oCTNDDCsEMgdG8gKzEyNcKwQy4KPiArCj4gK1Jlc29sdXRpb246IDggQml0 cwo+ICtBY2N1cmFjeTogwrExwrBDIFR5cCAo4oCTMTDCsEMgdG8gKzEwMMKwQykKPiArCj4gK1Ro ZSBkcml2ZXIgcHJvdmlkZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRlcmZhY2UgZm9yIHRlbXBlcmF0 dXJlcyAoc2VlCj4gK0RvY3VtZW50YXRpb24vaHdtb24vc3lzZnMtaW50ZXJmYWNlIHVuZGVyIFRl bXBlcmF0dXJlcykuCj4gKwo+ICtSZXF1aXJlZCBub2RlIHByb3BlcnRpZXM6Cj4gKy0gY29tcGF0 aWJsZTogbWFudWZhY3R1cmVyIGFuZCBjaGlwIG5hbWUKPiArCQkidGksdG1wMTAzIgo+ICstIHJl ZzogSTJDIGJ1cyBhZGRyZXNzIG9mIHRoZSBkZXZpY2UKCllvdSBkb24ndCBuZWVkIHRoaXMgcGFy dCwgYW5kIGl0IGlzIG5vdCByZWFsbHkgY29ycmVjdCAodGhlcmUgYXJlCm90aGVyIHdheXMgdG8g aW5zdGFudGlhdGUgdGhlIGRldmljZSwgZGV2aWNldHJlZSBpcyBqdXN0IG9uZSBvZiB0aGVtKS4K Ckkgd291bGQgc3VnZ2VzdCB0byByZWZlciB0byBEb2N1bWVudGF0aW9uL2kyYy9pbnN0YW50aWF0 aW5nLWRldmljZXMKaW5zdGVhZC4gSXQgbWlnaHQgYWxzbyBtYWtlIHNlbnNlIHRvIHVwZGF0ZQpE b2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQu CgpBbHNvLCB3aGVuZXZlciB5b3UgdG91Y2ggYW55IG9mIHRoZSB0aGUgZHQgZmlsZXMsIHlvdSBu ZWVkIHRvIGNvcHkKdGhlIERUIG1haW50YWluZXJzLiBzY3JpcHRzL2dldF9tYWludGFpbmVyLnBs IHdpbGwgdGVsbCB5b3Ugd2hvIG5lZWRzCnRvIGJlIGNvcGllZC4KCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvaHdtb24vS2NvbmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IDAwMzQz MTYuLjBmNDRkYmIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIv ZHJpdmVycy9od21vbi9LY29uZmlnCj4gQEAgLTEzODEsNiArMTM4MSwxNiBAQCBjb25maWcgU0VO U09SU19UTVAxMDIKPiAgIAkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9k dWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKPiAgIAkgIHdpbGwgYmUgY2FsbGVkIHRtcDEwMi4KPgo+ ICtjb25maWcgU0VOU09SU19UTVAxMDMKPiArCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBU TVAxMDMiCj4gKwlkZXBlbmRzIG9uIEkyQwo+ICsJaGVscAo+ICsJICBJZiB5b3Ugc2F5IHllcyBo ZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4gKwkgIHNl bnNvciBjaGlwcy4KPiArCj4gKwkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEg bW9kdWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+ ICsKPiAgIGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+ICAgCXRyaXN0YXRlICJUZXhhcyBJbnN0cnVt ZW50cyBUTVA0MDEgYW5kIGNvbXBhdGlibGVzIgo+ICAgCWRlcGVuZHMgb24gSTJDCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4g aW5kZXggMTE3OThhZC4uOGUyZjZhMiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2Vm aWxlCj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+IEBAIC0xMzQsNiArMTM0LDcgQEAg b2JqLSQoQ09ORklHX1NFTlNPUlNfU01TQzQ3TTE5MikrPSBzbXNjNDdtMTkyLm8KPiAgIG9iai0k KENPTkZJR19TRU5TT1JTX0FNQzY4MjEpCSs9IGFtYzY4MjEubwo+ICAgb2JqLSQoQ09ORklHX1NF TlNPUlNfVEhNQzUwKQkrPSB0aG1jNTAubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QMTAy KQkrPSB0bXAxMDIubwo+ICtvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDMpCSs9IHRtcDEwMy5v Cj4gICBvYmotJChDT05GSUdfU0VOU09SU19UTVA0MDEpCSs9IHRtcDQwMS5vCj4gICBvYmotJChD T05GSUdfU0VOU09SU19UTVA0MjEpCSs9IHRtcDQyMS5vCj4gICBvYmotJChDT05GSUdfU0VOU09S U19UV0w0MDMwX01BREMpKz0gdHdsNDAzMC1tYWRjLWh3bW9uLm8KPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9od21vbi90bXAxMDMuYyBiL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMKPiBuZXcgZmlsZSBt b2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjBiZDMzZDYKPiAtLS0gL2Rldi9udWxsCj4gKysr IGIvZHJpdmVycy9od21vbi90bXAxMDMuYwo+IEBAIC0wLDAgKzEsMjgxIEBACj4gKy8qCj4gKyAq IFRleGFzIEluc3RydW1lbnRzIFRNUDEwMyBTTUJ1cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVy Cj4gKyAqIENvcHlyaWdodCAoQykgMjAxNCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPiAr ICoKPiArICogQmFzZWQgb246Cj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0 ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyCj4gKyAqCj4gKyAqIENvcHlyaWdodCAoQykgMjAxMCBT dGV2ZW4gS2luZyA8c2ZraW5nQGZkd2RjLmNvbT4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKPiAr ICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBh cyBwdWJsaXNoZWQgYnkKPiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPiArICogKGF0IHlvdXIgb3B0aW9uKSBhbnkg bGF0ZXIgdmVyc2lvbi4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4gKyAqIGJ1dCBXSVRIT1VUIEFOWSBX QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCj4gKyAqIE1FUkNI QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUK PiArICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICoK PiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9pbml0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9p MmMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9od21v bi1zeXNmcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9t dXRleC5oPgo+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9q aWZmaWVzLmg+Cj4gKwo+ICsjZGVmaW5lCURSSVZFUl9OQU1FICJ0bXAxMDMiCj4gKwo+ICsjZGVm aW5lCVRNUDEwM19URU1QX1JFRwkJCTB4MDAKPiArI2RlZmluZQlUTVAxMDNfQ09ORl9SRUcJCQkw eDAxCj4gKyNkZWZpbmUJVE1QMTAzX1RMT1dfUkVHCQkJMHgwMgo+ICsjZGVmaW5lCVRNUDEwM19U SElHSF9SRUcJCTB4MDMKPiArCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX00wCQkweDAxCj4gKyNk ZWZpbmUJCVRNUDEwM19DT05GX00xCQkweDAyCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0xDCQkw eDA0Cj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0ZMCQkweDA4Cj4gKyNkZWZpbmUJCVRNUDEwM19D T05GX0ZICQkweDEwCj4gKyNkZWZpbmUJCVRNUDEwM19DT05GX0NSMAkJMHgyMAo+ICsjZGVmaW5l CQlUTVAxMDNfQ09ORl9DUjEJCTB4NDAKPiArI2RlZmluZQkJVE1QMTAzX0NPTkZfSUQJCTB4ODAK PiArI2RlZmluZQkJVE1QMTAzX0NPTkZfU0QJCShUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05G X00xKQo+ICsKPiArc3RydWN0IHRtcDEwMyB7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7 Cj4gKwlzdHJ1Y3QgbXV0ZXggbG9jazsKPiArCXUxNiBjb25maWdfb3JpZzsKPiArCXVuc2lnbmVk IGxvbmcgbGFzdF91cGRhdGU7Cj4gKwlpbnQgdGVtcFszXTsKPiArfTsKPiArCj4gK3N0YXRpYyBp bmxpbmUgaW50IHRtcDEwM19yZWdfdG9fbUMoczggdmFsKQo+ICt7Cj4gKwlyZXR1cm4gdmFsICog MTAwMDsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB1OCB0bXAxMDNfbUNfdG9fcmVnKGludCB2 YWwpCj4gK3sKPiArCXJldHVybiB2YWwgLyAxMDAwOwoKRElWX1JPVU5EX0NMT1NFU1QoKSA/CgpO byBjYW1lbENhc2UsIHBsZWFzZS4KCj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCB1OCB0bXAxMDNf cmVnW10gPSB7Cj4gKwlUTVAxMDNfVEVNUF9SRUcsCj4gKwlUTVAxMDNfVExPV19SRUcsCj4gKwlU TVAxMDNfVEhJR0hfUkVHLAo+ICt9Owo+ICsKPiArc3RhdGljIHN0cnVjdCB0bXAxMDMgKnRtcDEw M191cGRhdGVfZGV2aWNlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVj dCB0bXAxMDMgKnRtcDEwMyA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOwo+ICsKPiArCW11 dGV4X2xvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0bXAx MDMtPmxhc3RfdXBkYXRlICsgSFogLyAzKSkgewo+ICsJCWludCBpOwo+ICsKPiArCQlmb3IgKGkg PSAwOyBpIDwgQVJSQVlfU0laRSh0bXAxMDMtPnRlbXApOyArK2kpIHsKPiArCQkJaW50IHN0YXR1 cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsCj4gKwkJCQkJCQkgdG1wMTAzX3Jl Z1tpXSk7Cj4gKwkJCWlmIChzdGF0dXMgPiAtMSkKPiArCQkJCXRtcDEwMy0+dGVtcFtpXSA9IHRt cDEwM19yZWdfdG9fbUMoc3RhdHVzKTsKCkkgdW5kZXJzdGFuZCB0aGlzIGlzIGZyb20gdGhlIHRt cDEwMiBkcml2ZXIsIGJ1dCBpdCBpcyBraW5kIG9mIHVudXN1YWwKYmVjYXVzZSBpdCBkb2VzIG5v dCByZXBvcnQgdGhlIGVycm9yIGJhY2sgdG8gdGhlIHVzZXIuIFBsZWFzZSBjb25zaWRlcgpkb2lu ZyB0aGF0LCBpZSByZXR1cm4gUFRSX0VSUihzdGF0dXMpIG9uIGVycm9yIGFuZCBjaGVjay9yZXR1 cm4gdGhlIGVycm9yCmZyb20gdGhlIGNhbGxpbmcgZnVuY3Rpb25zLiBJcnJlbGV2YW50IGlmIHlv dSB1c2UgcmVnbWFwIChzZWUgYmVsb3cpLgoKPiArCQl9Cj4gKwkJdG1wMTAzLT5sYXN0X3VwZGF0 ZSA9IGppZmZpZXM7Cj4gKwl9Cj4gKwltdXRleF91bmxvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwly ZXR1cm4gdG1wMTAzOwo+ICt9CgpPdmVyYWxsIHlvdSBtaWdodCBjb25zaWRlciBkcm9wcGluZyB0 aGUgdXBkYXRlIGZ1bmN0aW9uIGFuZCB1c2luZyByZWdtYXAgaW5zdGVhZC4KSXQgd291bGQgYmUg YW4gZXhjZWxsZW50IGZpdCBmb3IgdGhpcyBkcml2ZXI7IHdoaWxlIGl0IGRvZXNuJ3QgZG8gdGlt ZWQgY2FjaGluZwppdCBzdXBwb3J0cyBwZXItcmVnaXN0ZXIgY2FjaGluZyB3aGljaCBpcyB1bHRp bWF0ZWx5IG1vcmUgdXNlZnVsIGFueXdheS4KU29tZSBvZiB0aGUgZHJpdmVycyBpbiB0aGUgaHdt b24gZGlyZWN0b3J5IHVzZSBpdCwgc28geW91IGNvdWxkIHVzZSB0aGF0CmFzIGV4YW1wbGUuIE5v dCBtYW5kYXRvcnksIHRob3VnaDsganVzdCBhIHN1Z2dlc3Rpb24uCgo+ICsKPiArc3RhdGljIHNz aXplX3QgdG1wMTAzX3Nob3dfdGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQlzdHJ1Y3Qg ZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCWNoYXIgKmJ1ZikKPiArewo+ICsJc3RydWN0 IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7 Cj4gKwlzdHJ1Y3QgdG1wMTAzICp0bXAxMDMgPSB0bXAxMDNfdXBkYXRlX2RldmljZSh0b19pMmNf Y2xpZW50KGRldikpOwo+ICsKPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDMt PnRlbXBbc2RhLT5pbmRleF0pOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0 X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAo+ICsJCQkgICAgICAgc3RydWN0IGRldmljZV9hdHRy aWJ1dGUgKmF0dHIsCj4gKwkJCSAgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkK PiArewo+ICsJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3Jf ZGV2X2F0dHIoYXR0cik7Cj4gKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdG9faTJjX2Ns aWVudChkZXYpOwo+ICsJc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gaTJjX2dldF9jbGllbnRkYXRh KGNsaWVudCk7Cj4gKwlsb25nIHZhbDsKPiArCWludCBzdGF0dXM7Cj4gKwo+ICsJaWYgKGtzdHJ0 b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJdmFsID0gY2xh bXBfdmFsKHZhbCwgLTU1MDAwLCAxMjgwMDApOwoKTWF4IHNob3VsZCBiZSAxMjcwMDAuCgo+ICsK PiArCW11dGV4X2xvY2soJnRtcDEwMy0+bG9jayk7Cj4gKwl0bXAxMDMtPnRlbXBbc2RhLT5pbmRl eF0gPSB2YWw7CgpZb3UgY2FuIG5vdCBkbyB0aGF0IHNpbmNlIGl0IGlzIHRoZSBub24tcm91bmRl ZCB2YWx1ZS4gWW91IGhhdmUgdG8gY29udmVydCB0bwp0aGUgcmVnaXN0ZXIgdmFsdWUsIHRoZW4g Y29udmVydCBiYWNrIHRvIHRoZSBkaXNwbGF5IHZhbHVlLgoKSWYgeW91IHVzZSByZWdtYXAsIHRo ZSBwcm9ibGVtIGdvZXMgYXdheSwgc2luY2UgeW91IHdvdWxkIG5vdCBjYWNoZSBjb252ZXJ0ZWQK ZGF0YSBidXQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5jdGlvbi4gQWx0ZXJuYXRpdmVseSwgeW91 IGNvdWxkIHN0b3JlIHJlZ2lzdGVyCnZhbHVlcyBhbmQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5j dGlvbi4KCj4gKwlzdGF0dXMgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgdG1w MTAzX3JlZ1tzZGEtPmluZGV4XSwKPiArCQkJCQkgICAgICB0bXAxMDNfbUNfdG9fcmVnKHZhbCkp OwoKUGxlYXNlIG1ha2Ugc3VyZSB0aGF0IGNvbnRpbnVhdGlvbiBsaW5lcyBtYXRjaCB0aGUgJygn IGluIHRoZSBsaW5lIGFib3ZlLgpBbGlnbm1lbnRzIGFyZSBpbmNvbnNpc3RlbnQsIG90aGVyd2lz ZSBJIHdvdWxkIG5vdCBtZW50aW9uIGl0LgpjaGVja3BhdGNoIC0tc3RyaWN0IHRlbGxzIHlvdSB3 aGljaCBvbmVzIGFyZSBtaXNhbGlnbmVkLgoKPiArCW11dGV4X3VubG9jaygmdG1wMTAzLT5sb2Nr KTsKPiArCXJldHVybiBzdGF0dXMgPyA6IGNvdW50Owo+ICt9Cj4gKwo+ICtzdGF0aWMgU0VOU09S X0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAxMDNfc2hvd190ZW1wLCBOVUxM ICwgMCk7Cj4gKwpJZiB5b3UgdXNlIHJlZ21hcCB5b3UgY2FuIHN0b3JlIHRoZSByZWdpc3RlciBk aXJlY3RseSBoZXJlIGFuZCB5b3Ugd291bGQgbm90Cm5lZWQgdG1wMTAzX3JlZ1tdLgoKPiArc3Rh dGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9tYXhfaHlzdCwgU19JV1VTUiB8IFNfSVJVR08s IHRtcDEwM19zaG93X3RlbXAsCj4gKwkJCSAgdG1wMTAzX3NldF90ZW1wLCAxKTsKPiArClBlciB0 aGUgZGF0YXNoZWV0IHRoaXMgc2hvdWxkIGJlIHRlbXAxX21pbi4gVGhlIHJlZ2lzdGVyIGRlZmlu aXRpb24gaXMgZGlmZmVyZW50IHRvIFRNUDEwMi4KCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FU VFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPiArCQkJ ICB0bXAxMDNfc2V0X3RlbXAsIDIpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRt cDEwM19hdHRyaWJ1dGVzW10gPSB7Cj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2lucHV0LmRl dl9hdHRyLmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heF9oeXN0LmRldl9hdHRy LmF0dHIsCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAoKWW91 IG1pZ2h0IGFsc28gY29uc2lkZXIgYWRkaW5nIHRlbXAxX21pbl9hbGFybSBhbmQgdGVtcDFfbWF4 X2FsYXJtIHRvIGluZm9ybQp1c2VyIHNwYWNlIGlmIGxpbWl0cyBhcmUgZXhjZWVkZWQuIFRoZSBz dGF0dXMgaXMgcmVwb3J0ZWQgd2l0aCB0aGUgRkwgYW5kIEZICmJpdHMgaW4gdGhlIGNvbmZpZ3Vy YXRpb24gcmVnaXN0ZXIuCgo+ICsJTlVMTAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVj dCBhdHRyaWJ1dGVfZ3JvdXAgdG1wMTAzX2F0dHJfZ3JvdXAgPSB7Cj4gKwkuYXR0cnMgPSB0bXAx MDNfYXR0cmlidXRlcywKPiArfTsKPiArClBsZWFzZSB1c2UgdGhlIEFUVFJJQlVURV9HUk9VUFMo KSBtYWNyby4KCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJRwkJKFRNUDEwM19DT05GX0NSMSB8IFRN UDEwM19DT05GX00xKQo+ICsjZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQkoVE1QMTAzX0NP TkZfQ1IxIHwgVE1QMTAzX0NPTkZfTTEpCgpMYXR0ZXIgZGVmaW5lIGlzIG5vdCB1c2VkIGFzIGZh ciBhcyBJIGNhbiBzZWUuIFNpbmNlIGl0IGlzIHRoZSBzYW1lCml0IGlzIHVubmVjZXNzYXJ5IGFu eXdheS4KCj4gKwo+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAq Y2xpZW50LAo+ICsJCQkJICBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCj4gK3sKPiAr CXN0cnVjdCB0bXAxMDMgKnRtcDEwMzsKPiArCWludCBzdGF0dXM7Cj4gKwo+ICsJaWYgKCFpMmNf Y2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0ZXIsCj4gKwkJCQkgICAgIEkyQ19GVU5D X1NNQlVTX1dPUkRfREFUQSkpIHsKPiArCQlkZXZfZXJyKCZjbGllbnQtPmRldiwKPiArCQkJImFk YXB0ZXIgZG9lc24ndCBzdXBwb3J0IFNNQnVzIHdvcmQgdHJhbnNhY3Rpb25zXG4iKTsKCkdvb2Qg dGhhdCB0aGUgY2hpcCBkb2Vzbid0IHN1cHBvcnQgYW55IDstKS4gQ2hlY2sgZm9yIGJ5dGUgdHJh bnNhY3Rpb25zIGluc3RlYWQuCgo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJfQo+ICsKPiArCXRt cDEwMyA9IGRldm1fa3phbGxvYygmY2xpZW50LT5kZXYsIHNpemVvZigqdG1wMTAzKSwgR0ZQX0tF Uk5FTCk7Cj4gKwlpZiAoIXRtcDEwMykKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlpMmNf c2V0X2NsaWVudGRhdGEoY2xpZW50LCB0bXAxMDMpOwo+ICsKPiArCXN0YXR1cyA9IGkyY19zbWJ1 c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRNUDEwM19DT05GX1JFRyk7Cj4gKwlpZiAoc3RhdHVz IDwgMCkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiZXJyb3IgcmVhZGluZyBjb25maWcg cmVnaXN0ZXJcbiIpOwo+ICsJCXJldHVybiBzdGF0dXM7Cj4gKwl9Cj4gKwl0bXAxMDMtPmNvbmZp Z19vcmlnID0gc3RhdHVzOwoKWW91IGRvbid0IHVzZSBjb25maWdfb3JpZyBvdXRzaWRlIHRoZSBw cm9iZSBmdW5jdGlvbiwKc28gc3RvcmluZyBpdCBpbiBwcml2YXRlIGRhdGEgZG9lc24ndCBhZGQg YW55IHZhbHVlLgpBbHRlcm5hdGl2ZWx5LCB5b3UgY291bGQgcmVzdG9yZSB0aGUgb3JpZ2luYWwg Y29uZmlndXJhdGlvbiBvbiBleGl0LgoKPiArCXN0YXR1cyA9IGkyY19zbWJ1c193cml0ZV9ieXRl X2RhdGEoY2xpZW50LCBUTVAxMDNfQ09ORl9SRUcsCj4gKwkJCQkJICAgICAgVE1QMTAzX0NPTkZJ Ryk7Cj4gKwlpZiAoc3RhdHVzIDwgMCkgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiZXJy b3Igd3JpdGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+ICsJCWdvdG8gZmFpbF9yZXN0b3JlX2Nv bmZpZzsKPiArCX0KPiArCXN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQs IFRNUDEwM19DT05GX1JFRyk7Cj4gKwlpZiAoc3RhdHVzIDwgMCkgewo+ICsJCWRldl9lcnIoJmNs aWVudC0+ZGV2LCAiZXJyb3IgcmVhZGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+ICsJCWdvdG8g ZmFpbF9yZXN0b3JlX2NvbmZpZzsKPiArCX0KPiArCWlmIChzdGF0dXMgIT0gVE1QMTAzX0NPTkZJ Rykgewo+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiY29uZmlnIHNldHRpbmdzIGRpZCBub3Qg c3RpY2tcbiIpOwo+ICsJCXN0YXR1cyA9IC1FTk9ERVY7Cj4gKwkJZ290byBmYWlsX3Jlc3RvcmVf Y29uZmlnOwo+ICsJfQo+ICsJdG1wMTAzLT5sYXN0X3VwZGF0ZSA9IGppZmZpZXMgLSBIWjsKPiAr CW11dGV4X2luaXQoJnRtcDEwMy0+bG9jayk7Cj4gKwo+ICsJc3RhdHVzID0gc3lzZnNfY3JlYXRl X2dyb3VwKCZjbGllbnQtPmRldi5rb2JqLCAmdG1wMTAzX2F0dHJfZ3JvdXApOwo+ICsJaWYgKHN0 YXR1cykgewo+ICsJCWRldl9kYmcoJmNsaWVudC0+ZGV2LCAiY291bGQgbm90IGNyZWF0ZSBzeXNm cyBmaWxlc1xuIik7Cj4gKwkJZ290byBmYWlsX3Jlc3RvcmVfY29uZmlnOwo+ICsJfQo+ICsJdG1w MTAzLT5od21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXIoJmNsaWVudC0+ZGV2KTsKPiAr CWlmIChJU19FUlIodG1wMTAzLT5od21vbl9kZXYpKSB7Cj4gKwkJZGV2X2RiZygmY2xpZW50LT5k ZXYsICJ1bmFibGUgdG8gcmVnaXN0ZXIgaHdtb24gZGV2aWNlXG4iKTsKPiArCQlzdGF0dXMgPSBQ VFJfRVJSKHRtcDEwMy0+aHdtb25fZGV2KTsKPiArCQlnb3RvIGZhaWxfcmVtb3ZlX3N5c2ZzOwo+ ICsJfQoKUGxlYXNlIHVzZSBkZXZtX2h3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dyb3Vwcygp LgoKPiArCj4gKwlkZXZfaW5mbygmY2xpZW50LT5kZXYsICJpbml0aWFsaXplZFxuIik7CgpQbGVh c2UgZHJvcCB0aGlzIG1lc3NhZ2UuCgo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZmFpbF9yZW1v dmVfc3lzZnM6Cj4gKwlzeXNmc19yZW1vdmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAx MDNfYXR0cl9ncm91cCk7Cj4gK2ZhaWxfcmVzdG9yZV9jb25maWc6Cj4gKwlpMmNfc21idXNfd3Jp dGVfd29yZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLAo+ICsJCQkJICAgICB0bXAx MDMtPmNvbmZpZ19vcmlnKTsKCmkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoKSA/Cgo+ICsJcmV0 dXJuIHN0YXR1czsKPiArfQo+ICsKPiArc3RhdGljIGludCB0bXAxMDNfcmVtb3ZlKHN0cnVjdCBp MmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVjdCB0bXAxMDMgKnRtcDEwMyA9IGkyY19n ZXRfY2xpZW50ZGF0YShjbGllbnQpOwo+ICsKPiArCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKHRt cDEwMy0+aHdtb25fZGV2KTsKPiArCXN5c2ZzX3JlbW92ZV9ncm91cCgmY2xpZW50LT5kZXYua29i aiwgJnRtcDEwM19hdHRyX2dyb3VwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArI2lm ZGVmIENPTkZJR19QTQo+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0cnVjdCBkZXZpY2Ug KmRldikKPiArewo+ICsJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19jbGllbnQo ZGV2KTsKPiArCWludCBjb25maWc7Cj4gKwo+ICsJY29uZmlnID0gaTJjX3NtYnVzX3JlYWRfd29y ZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKCmJ5dGUKCj4gKwlpZiAoY29uZmln IDwgMCkKPiArCQlyZXR1cm4gY29uZmlnOwo+ICsKPiArCWNvbmZpZyAmPSB+VE1QMTAzX0NPTkZf U0Q7Cj4gKwlyZXR1cm4gaTJjX3NtYnVzX3dyaXRlX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEw M19DT05GX1JFRywgY29uZmlnKTsKCmJ5dGUKCj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdG1wMTAz X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7Cj4gKwlpbnQgY29uZmlnOwo+ICsKPiArCWNvbmZp ZyA9IGkyY19zbWJ1c19yZWFkX3dvcmRfc3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05GX1JFRyk7 CgpieXRlCgo+ICsJaWYgKGNvbmZpZyA8IDApCj4gKwkJcmV0dXJuIGNvbmZpZzsKPiArCj4gKwlj b25maWcgfD0gVE1QMTAzX0NPTkZfU0Q7Cj4gKwlyZXR1cm4gaTJjX3NtYnVzX3dyaXRlX3dvcmRf c3dhcHBlZChjbGllbnQsIFRNUDEwM19DT05GX1JFRywgY29uZmlnKTsKCmJ5dGUKCj4gK30KPiAr Cj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyB0bXAxMDNfZGV2X3BtX29wcyA9IHsK PiArCS5zdXNwZW5kCT0gdG1wMTAzX3N1c3BlbmQsCj4gKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1 bWUsCj4gK307Cj4gKwo+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9w bV9vcHMpCj4gKyNlbHNlCj4gKyNkZWZpbmUJVE1QMTAzX0RFVl9QTV9PUFMgTlVMTAo+ICsjZW5k aWYgLyogQ09ORklHX1BNICovCj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2Vf aWQgdG1wMTAzX2lkW10gPSB7Cj4gKwl7IERSSVZFUl9OQU1FLCAwIH0sCj4gKwl7IH0KPiArfTsK PiArTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4gKwo+ICtzdGF0aWMgc3Ry dWN0IGkyY19kcml2ZXIgdG1wMTAzX2RyaXZlciA9IHsKPiArCS5kcml2ZXIubmFtZQk9IERSSVZF Ul9OQU1FLAo+ICsJLmRyaXZlci5wbQk9IFRNUDEwM19ERVZfUE1fT1BTLAoKCS5kcml2ZXIgPSB7 CgkJLm5hbWUJPSBEUklWRVJfTkFNRSwKCQkucG0JPSBUTVAxMDNfREVWX1BNX09QUywKCX0sCgp3 b3VsZCBiZSBhIGJpdCBuaWNlci4gSSB3b24ndCBtYW5kYXRlIGl0LCB0aG91Z2guCgo+ICsJLnBy b2JlCQk9IHRtcDEwM19wcm9iZSwKPiArCS5yZW1vdmUJCT0gdG1wMTAzX3JlbW92ZSwKPiArCS5p ZF90YWJsZQk9IHRtcDEwM19pZCwKPiArfTsKPiArCj4gK21vZHVsZV9pMmNfZHJpdmVyKHRtcDEw M19kcml2ZXIpOwo+ICsKPiArTU9EVUxFX0FVVEhPUigiSGVpa28gU2Nob2NoZXIgPGhzQGRlbngu ZGU+Iik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIHRl bXBlcmF0dXJlIHNlbnNvciBkcml2ZXIiKTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo+CgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbG0tc2Vuc29y cyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0t c2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-11 17:11 ` Guenter Roeck 0 siblings, 0 replies; 8+ messages in thread From: Guenter Roeck @ 2014-06-11 17:11 UTC (permalink / raw) To: Heiko Schocher, lm-sensors; +Cc: Jean Delvare, linux-kernel On 06/10/2014 11:28 PM, 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 Hi Heiko, You don't need those Cc: in the header. Why patch 09/13 ? I'd expect to see 12 more patches in this series, but there is only one (even on kernel.org). If you sent those other patches to various other mailing lists, everyone will wonder where the remaining patches are. If there is just one patch, it is just confusing. > --- > Documentation/devicetree/bindings/hwmon/tmp103 | 30 +++ > drivers/hwmon/Kconfig | 10 + > drivers/hwmon/Makefile | 1 + > drivers/hwmon/tmp103.c | 281 +++++++++++++++++++++++++ > 4 files changed, 322 insertions(+) > create mode 100644 Documentation/devicetree/bindings/hwmon/tmp103 > create mode 100644 drivers/hwmon/tmp103.c > > diff --git a/Documentation/devicetree/bindings/hwmon/tmp103 b/Documentation/devicetree/bindings/hwmon/tmp103 > new file mode 100644 > index 0000000..36d7b36 > --- /dev/null > +++ b/Documentation/devicetree/bindings/hwmon/tmp103 Should be Documentation/hwmon/tmp103. > @@ -0,0 +1,30 @@ > +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). > + > +Required node properties: > +- compatible: manufacturer and chip name > + "ti,tmp103" > +- reg: I2C bus address of the device You don't need this part, and it is not really correct (there are other ways to instantiate the device, devicetree is just one of them). I would suggest to refer to Documentation/i2c/instantiating-devices instead. It might also make sense to update Documentation/devicetree/bindings/i2c/trivial-devices.txt. Also, whenever you touch any of the the dt files, you need to copy the DT maintainers. scripts/get_maintainer.pl will tell you who needs to be copied. > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > index 0034316..0f44dbb 100644 > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -1381,6 +1381,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 11798ad..8e2f6a2 100644 > --- a/drivers/hwmon/Makefile > +++ b/drivers/hwmon/Makefile > @@ -134,6 +134,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..0bd33d6 > --- /dev/null > +++ b/drivers/hwmon/tmp103.c > @@ -0,0 +1,281 @@ > +/* > + * 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> > + > +#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) > + > +struct tmp103 { > + struct device *hwmon_dev; > + struct mutex lock; > + u16 config_orig; > + unsigned long last_update; > + int temp[3]; > +}; > + > +static inline int tmp103_reg_to_mC(s8 val) > +{ > + return val * 1000; > +} > + > +static inline u8 tmp103_mC_to_reg(int val) > +{ > + return val / 1000; DIV_ROUND_CLOSEST() ? No camelCase, please. > +} > + > +static const u8 tmp103_reg[] = { > + TMP103_TEMP_REG, > + TMP103_TLOW_REG, > + TMP103_THIGH_REG, > +}; > + > +static struct tmp103 *tmp103_update_device(struct i2c_client *client) > +{ > + struct tmp103 *tmp103 = i2c_get_clientdata(client); > + > + mutex_lock(&tmp103->lock); > + if (time_after(jiffies, tmp103->last_update + HZ / 3)) { > + int i; > + > + for (i = 0; i < ARRAY_SIZE(tmp103->temp); ++i) { > + int status = i2c_smbus_read_byte_data(client, > + tmp103_reg[i]); > + if (status > -1) > + tmp103->temp[i] = tmp103_reg_to_mC(status); I understand this is from the tmp102 driver, but it is kind of unusual because it does not report the error back to the user. Please consider doing that, ie return PTR_ERR(status) on error and check/return the error from the calling functions. Irrelevant if you use regmap (see below). > + } > + tmp103->last_update = jiffies; > + } > + mutex_unlock(&tmp103->lock); > + return tmp103; > +} Overall you might consider dropping the update function and using regmap instead. It would be an excellent fit for this driver; while it doesn't do timed caching it supports per-register caching which is ultimately more useful anyway. Some of the drivers in the hwmon directory use it, so you could use that as example. Not mandatory, though; just a suggestion. > + > +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 tmp103 *tmp103 = tmp103_update_device(to_i2c_client(dev)); > + > + return sprintf(buf, "%d\n", tmp103->temp[sda->index]); > +} > + > +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 i2c_client *client = to_i2c_client(dev); > + struct tmp103 *tmp103 = i2c_get_clientdata(client); > + long val; > + int status; > + > + if (kstrtol(buf, 10, &val) < 0) > + return -EINVAL; > + val = clamp_val(val, -55000, 128000); Max should be 127000. > + > + mutex_lock(&tmp103->lock); > + tmp103->temp[sda->index] = val; You can not do that since it is the non-rounded value. You have to convert to the register value, then convert back to the display value. If you use regmap, the problem goes away, since you would not cache converted data but convert in the show function. Alternatively, you could store register values and convert in the show function. > + status = i2c_smbus_write_byte_data(client, tmp103_reg[sda->index], > + tmp103_mC_to_reg(val)); Please make sure that continuation lines match the '(' in the line above. Alignments are inconsistent, otherwise I would not mention it. checkpatch --strict tells you which ones are misaligned. > + mutex_unlock(&tmp103->lock); > + return status ? : count; > +} > + > +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , 0); > + If you use regmap you can store the register directly here and you would not need tmp103_reg[]. > +static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp103_show_temp, > + tmp103_set_temp, 1); > + Per the datasheet this should be temp1_min. The register definition is different to TMP102. > +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, > + tmp103_set_temp, 2); > + > +static struct attribute *tmp103_attributes[] = { > + &sensor_dev_attr_temp1_input.dev_attr.attr, > + &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, > + &sensor_dev_attr_temp1_max.dev_attr.attr, You might also consider adding temp1_min_alarm and temp1_max_alarm to inform user space if limits are exceeded. The status is reported with the FL and FH bits in the configuration register. > + NULL > +}; > + > +static const struct attribute_group tmp103_attr_group = { > + .attrs = tmp103_attributes, > +}; > + Please use the ATTRIBUTE_GROUPS() macro. > +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) > +#define TMP103_CONFIG_RD_ONLY (TMP103_CONF_CR1 | TMP103_CONF_M1) Latter define is not used as far as I can see. Since it is the same it is unnecessary anyway. > + > +static int tmp103_probe(struct i2c_client *client, > + const struct i2c_device_id *id) > +{ > + struct tmp103 *tmp103; > + int status; > + > + if (!i2c_check_functionality(client->adapter, > + I2C_FUNC_SMBUS_WORD_DATA)) { > + dev_err(&client->dev, > + "adapter doesn't support SMBus word transactions\n"); Good that the chip doesn't support any ;-). Check for byte transactions instead. > + return -ENODEV; > + } > + > + tmp103 = devm_kzalloc(&client->dev, sizeof(*tmp103), GFP_KERNEL); > + if (!tmp103) > + return -ENOMEM; > + > + i2c_set_clientdata(client, tmp103); > + > + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); > + if (status < 0) { > + dev_err(&client->dev, "error reading config register\n"); > + return status; > + } > + tmp103->config_orig = status; You don't use config_orig outside the probe function, so storing it in private data doesn't add any value. Alternatively, you could restore the original configuration on exit. > + status = i2c_smbus_write_byte_data(client, TMP103_CONF_REG, > + TMP103_CONFIG); > + if (status < 0) { > + dev_err(&client->dev, "error writing config register\n"); > + goto fail_restore_config; > + } > + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); > + if (status < 0) { > + dev_err(&client->dev, "error reading config register\n"); > + goto fail_restore_config; > + } > + if (status != TMP103_CONFIG) { > + dev_err(&client->dev, "config settings did not stick\n"); > + status = -ENODEV; > + goto fail_restore_config; > + } > + tmp103->last_update = jiffies - HZ; > + mutex_init(&tmp103->lock); > + > + status = sysfs_create_group(&client->dev.kobj, &tmp103_attr_group); > + if (status) { > + dev_dbg(&client->dev, "could not create sysfs files\n"); > + goto fail_restore_config; > + } > + tmp103->hwmon_dev = hwmon_device_register(&client->dev); > + if (IS_ERR(tmp103->hwmon_dev)) { > + dev_dbg(&client->dev, "unable to register hwmon device\n"); > + status = PTR_ERR(tmp103->hwmon_dev); > + goto fail_remove_sysfs; > + } Please use devm_hwmon_device_register_with_groups(). > + > + dev_info(&client->dev, "initialized\n"); Please drop this message. > + > + return 0; > + > +fail_remove_sysfs: > + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); > +fail_restore_config: > + i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, > + tmp103->config_orig); i2c_smbus_write_byte_data() ? > + return status; > +} > + > +static int tmp103_remove(struct i2c_client *client) > +{ > + struct tmp103 *tmp103 = i2c_get_clientdata(client); > + > + hwmon_device_unregister(tmp103->hwmon_dev); > + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); > + > + return 0; > +} > + > +#ifdef CONFIG_PM > +static int tmp103_suspend(struct device *dev) > +{ > + struct i2c_client *client = to_i2c_client(dev); > + int config; > + > + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); byte > + if (config < 0) > + return config; > + > + config &= ~TMP103_CONF_SD; > + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); byte > +} > + > +static int tmp103_resume(struct device *dev) > +{ > + struct i2c_client *client = to_i2c_client(dev); > + int config; > + > + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); byte > + if (config < 0) > + return config; > + > + config |= TMP103_CONF_SD; > + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); byte > +} > + > +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 }, > + { } > +}; > +MODULE_DEVICE_TABLE(i2c, tmp103_id); > + > +static struct i2c_driver tmp103_driver = { > + .driver.name = DRIVER_NAME, > + .driver.pm = TMP103_DEV_PM_OPS, .driver = { .name = DRIVER_NAME, .pm = TMP103_DEV_PM_OPS, }, would be a bit nicer. I won't mandate it, though. > + .probe = tmp103_probe, > + .remove = tmp103_remove, > + .id_table = tmp103_id, > +}; > + > +module_i2c_driver(tmp103_driver); > + > +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); > +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); > +MODULE_LICENSE("GPL"); > ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor 2014-06-11 17:11 ` Guenter Roeck @ 2014-06-12 9:39 ` Heiko Schocher -1 siblings, 0 replies; 8+ messages in thread From: Heiko Schocher @ 2014-06-12 9:39 UTC (permalink / raw) To: Guenter Roeck; +Cc: lm-sensors, Jean Delvare, linux-kernel SGVsbG8gR3VlbnRlciwKCkFtIDExLjA2LjIwMTQgMTk6MTEsIHNjaHJpZWIgR3VlbnRlciBSb2Vj azoKPiBPbiAwNi8xMC8yMDE0IDExOjI4IFBNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPj4gRHJp dmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+Pgo+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWlsYXIgdG8g dGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4gYnkgaGF2aW5nIG9ubHkg OCBiaXQgcmVnaXN0ZXJzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hlciA8aHNA ZGVueC5kZT4KPj4gQ2M6IEplYW4gRGVsdmFyZSA8a2hhbGlAbGludXgtZnIub3JnPgo+PiBDYzog R3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0Pgo+PiBDYzogbGludXgta2VybmVsQHZn ZXIua2VybmVsLm9yZwo+Cj4gSGkgSGVpa28sCj4KPiBZb3UgZG9uJ3QgbmVlZCB0aG9zZSBDYzog aW4gdGhlIGhlYWRlci4KCk9rLCBJIHJlbW92ZSB0aGVtLgoKPiBXaHkgcGF0Y2ggMDkvMTMgPyBJ J2QgZXhwZWN0IHRvIHNlZSAxMiBtb3JlIHBhdGNoZXMgaW4gdGhpcyBzZXJpZXMsCgpIdXBzLCBz b3JyeSwgbXkgbWlzdGFrZSwgdGhlcmUgaXMganVzdCB0aGlzIHBhdGNoLi4uCgo+IGJ1dCB0aGVy ZSBpcyBvbmx5IG9uZSAoZXZlbiBvbiBrZXJuZWwub3JnKS4gSWYgeW91IHNlbnQgdGhvc2UKPiBv dGhlciBwYXRjaGVzIHRvIHZhcmlvdXMgb3RoZXIgbWFpbGluZyBsaXN0cywgZXZlcnlvbmUgd2ls bCB3b25kZXIKPiB3aGVyZSB0aGUgcmVtYWluaW5nIHBhdGNoZXMgYXJlLiBJZiB0aGVyZSBpcyBq dXN0IG9uZSBwYXRjaCwKPiBpdCBpcyBqdXN0IGNvbmZ1c2luZy4KPgo+PiAtLS0KPj4gRG9jdW1l bnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMyB8IDMwICsrKwo+PiBkcml2 ZXJzL2h3bW9uL0tjb25maWcgfCAxMCArCj4+IGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgfCAxICsK Pj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDI4MSArKysrKysrKysrKysrKysrKysrKysrKysr Cj4+IDQgZmlsZXMgY2hhbmdlZCwgMzIyIGluc2VydGlvbnMoKykKPj4gY3JlYXRlIG1vZGUgMTAw NjQ0IERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9od21vbi90bXAxMDMKPj4gY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4KPj4gZGlmZiAtLWdpdCBh L0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9od21vbi90bXAxMDMgYi9Eb2N1bWVu dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4+IG5ldyBmaWxlIG1vZGUg MTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjM2ZDdiMzYKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysg Yi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4KPiBTaG91 bGQgYmUgRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMuCgpIbW0uLiBJIGRpZCB0aGlzIGZpcnN0 IHRoZXJlLCBidXQgInNjcmlwdHMvY2hlY2twYXRjaC5wbCIKd2FybnMgKGlmIHVzaW5nIGEgRFQg YmFzZWQgYm9hcmQgd2l0aCBjb21wYXRpYmxlID0gInRpLHRtcDEwMyIpOgoKV0FSTklORzogRFQg Y29tcGF0aWJsZSBzdHJpbmcgInRpLHRtcDEwMyIgYXBwZWFycyB1bi1kb2N1bWVudGVkIC0tIGNo ZWNrIC4vRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzLwojMzI0OiBGSUxFOiBhcmNo L2FybS9ib290L2R0cy9pbXg2cWRsLWFyaXN0YWluZXRvcy5kdHNpOjEwNzoKKyAgICAgICAgICAg ICAgIGNvbXBhdGlibGUgPSAidGksdG1wMTAzIjsKCj4+IEBAIC0wLDAgKzEsMzAgQEAKPj4gK0tl cm5lbCBkcml2ZXIgdG1wMTAzCj4+ICs9PT09PT09PT09PT09PT09PT09PQo+PiArCj4+ICtTdXBw b3J0ZWQgY2hpcHM6Cj4+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKPj4gKyBQcmVmaXg6 ICd0bXAxMDMnCj4+ICsgQWRkcmVzc2VzIHNjYW5uZWQ6IG5vbmUKPj4gKyBQcm9kdWN0IGluZm8g YW5kIGRhdGFzaGVldDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPj4gKwo+PiAr QXV0aG9yOgo+PiArIEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+PiArCj4+ICtEZXNjcmlw dGlvbgo+PiArLS0tLS0tLS0tLS0KPj4gKwo+PiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0 cHV0IHRlbXBlcmF0dXJlIHNlbnNvciBpbiBhIGZvdXItYmFsbAo+PiArd2FmZXIgY2hpcC1zY2Fs ZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRNUDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPj4gK3Rl bXBlcmF0dXJlcyB0byBhIHJlc29sdXRpb24gb2YgMcKwQy4gVGhlIFRNUDEwMyBpcyBzcGVjaWZp ZWQgZm9yCj4+ICtvcGVyYXRpb24gb3ZlciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBD IHRvICsxMjXCsEMuCj4+ICsKPj4gK1Jlc29sdXRpb246IDggQml0cwo+PiArQWNjdXJhY3k6IMKx McKwQyBUeXAgKOKAkzEwwrBDIHRvICsxMDDCsEMpCj4+ICsKPj4gK1RoZSBkcml2ZXIgcHJvdmlk ZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRlcmZhY2UgZm9yIHRlbXBlcmF0dXJlcyAoc2VlCj4+ICtE b2N1bWVudGF0aW9uL2h3bW9uL3N5c2ZzLWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+ PiArCj4+ICtSZXF1aXJlZCBub2RlIHByb3BlcnRpZXM6Cj4+ICstIGNvbXBhdGlibGU6IG1hbnVm YWN0dXJlciBhbmQgY2hpcCBuYW1lCj4+ICsgInRpLHRtcDEwMyIKPj4gKy0gcmVnOiBJMkMgYnVz IGFkZHJlc3Mgb2YgdGhlIGRldmljZQo+Cj4gWW91IGRvbid0IG5lZWQgdGhpcyBwYXJ0LCBhbmQg aXQgaXMgbm90IHJlYWxseSBjb3JyZWN0ICh0aGVyZSBhcmUKPiBvdGhlciB3YXlzIHRvIGluc3Rh bnRpYXRlIHRoZSBkZXZpY2UsIGRldmljZXRyZWUgaXMganVzdCBvbmUgb2YgdGhlbSkuCgpPay4K Cj4gSSB3b3VsZCBzdWdnZXN0IHRvIHJlZmVyIHRvIERvY3VtZW50YXRpb24vaTJjL2luc3RhbnRp YXRpbmctZGV2aWNlcwo+IGluc3RlYWQuIEl0IG1pZ2h0IGFsc28gbWFrZSBzZW5zZSB0byB1cGRh dGUKPiBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNl cy50eHQuCgpBaCwgb2ssIGdvb2QgaWRlYSwgdGhpcyByZW1vdmVzIGFsc28gdGhlIGNoZWNrcGF0 Y2ggd2FybmluZywgdGhhbmtzIQpDaGFuZ2VkLgoKPiBBbHNvLCB3aGVuZXZlciB5b3UgdG91Y2gg YW55IG9mIHRoZSB0aGUgZHQgZmlsZXMsIHlvdSBuZWVkIHRvIGNvcHkKPiB0aGUgRFQgbWFpbnRh aW5lcnMuIHNjcmlwdHMvZ2V0X21haW50YWluZXIucGwgd2lsbCB0ZWxsIHlvdSB3aG8gbmVlZHMK PiB0byBiZSBjb3BpZWQuCgpPay4KClsuLi5dCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9u L01ha2VmaWxlIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+PiBpbmRleCAxMTc5OGFkLi44ZTJm NmEyIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+ICsrKyBiL2RyaXZl cnMvaHdtb24vTWFrZWZpbGUKPj4gQEAgLTEzNCw2ICsxMzQsNyBAQCBvYmotJChDT05GSUdfU0VO U09SU19TTVNDNDdNMTkyKSs9IHNtc2M0N20xOTIubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19B TUM2ODIxKSArPSBhbWM2ODIxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVEhNQzUwKSArPSB0 aG1jNTAubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpICs9IHRtcDEwMi5vCj4+ICtv YmotJChDT05GSUdfU0VOU09SU19UTVAxMDMpICs9IHRtcDEwMy5vCj4+IG9iai0kKENPTkZJR19T RU5TT1JTX1RNUDQwMSkgKz0gdG1wNDAxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIx KSArPSB0bXA0MjEubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UV0w0MDMwX01BREMpKz0gdHds NDAzMC1tYWRjLWh3bW9uLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMg Yi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4 IDAwMDAwMDAuLjBiZDMzZDYKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2h3bW9u L3RtcDEwMy5jCj4+IEBAIC0wLDAgKzEsMjgxIEBACj4+ICsvKgo+PiArICogVGV4YXMgSW5zdHJ1 bWVudHMgVE1QMTAzIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPj4gKyAqIENvcHly aWdodCAoQykgMjAxNCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPj4gKyAqCj4+ICsgKiBC YXNlZCBvbjoKPj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0ZW1wZXJhdHVy ZSBzZW5zb3IgZHJpdmVyCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBL aW5nIDxzZmtpbmdAZmR3ZGMuY29tPgo+PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4+ICsgKiBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieQo+PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZl cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCj4+ICsgKgo+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+ICsgKiBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+PiArICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhl Cj4+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+PiAr ICoKPj4gKyAqLwo+PiArCj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsjaW5jbHVk ZSA8bGludXgvaW5pdC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRl IDxsaW51eC9pMmMuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgo+PiArI2luY2x1ZGUg PGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5j bHVkZSA8bGludXgvbXV0ZXguaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPj4gKyNp bmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+Cj4+ICsKPj4gKyNkZWZpbmUgRFJJVkVSX05BTUUgInRt cDEwMyIKPj4gKwo+PiArI2RlZmluZSBUTVAxMDNfVEVNUF9SRUcgMHgwMAo+PiArI2RlZmluZSBU TVAxMDNfQ09ORl9SRUcgMHgwMQo+PiArI2RlZmluZSBUTVAxMDNfVExPV19SRUcgMHgwMgo+PiAr I2RlZmluZSBUTVAxMDNfVEhJR0hfUkVHIDB4MDMKPj4gKwo+PiArI2RlZmluZSBUTVAxMDNfQ09O Rl9NMCAweDAxCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX00xIDB4MDIKPj4gKyNkZWZpbmUgVE1Q MTAzX0NPTkZfTEMgMHgwNAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GTCAweDA4Cj4+ICsjZGVm aW5lIFRNUDEwM19DT05GX0ZIIDB4MTAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwIDB4MjAK Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IxIDB4NDAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZf SUQgMHg4MAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRCAoVE1QMTAzX0NPTkZfTTAgfCBUTVAx MDNfQ09ORl9NMSkKPj4gKwo+PiArc3RydWN0IHRtcDEwMyB7Cj4+ICsgc3RydWN0IGRldmljZSAq aHdtb25fZGV2Owo+PiArIHN0cnVjdCBtdXRleCBsb2NrOwo+PiArIHUxNiBjb25maWdfb3JpZzsK Pj4gKyB1bnNpZ25lZCBsb25nIGxhc3RfdXBkYXRlOwo+PiArIGludCB0ZW1wWzNdOwo+PiArfTsK Pj4gKwo+PiArc3RhdGljIGlubGluZSBpbnQgdG1wMTAzX3JlZ190b19tQyhzOCB2YWwpCj4+ICt7 Cj4+ICsgcmV0dXJuIHZhbCAqIDEwMDA7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpbmxpbmUgdTgg dG1wMTAzX21DX3RvX3JlZyhpbnQgdmFsKQo+PiArewo+PiArIHJldHVybiB2YWwgLyAxMDAwOwo+ Cj4gRElWX1JPVU5EX0NMT1NFU1QoKSA/Cj4KPiBObyBjYW1lbENhc2UsIHBsZWFzZS4KCk9rIC4u LiBobW0sIHdvbmRlcmluZyB0aGF0IGNoZWNrcGF0Y2gucGwgbm90IGNsYWltZWQgdGhpcy4KcmVt b3ZlZC4KCj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBjb25zdCB1OCB0bXAxMDNfcmVnW10gPSB7Cj4+ ICsgVE1QMTAzX1RFTVBfUkVHLAo+PiArIFRNUDEwM19UTE9XX1JFRywKPj4gKyBUTVAxMDNfVEhJ R0hfUkVHLAo+PiArfTsKPj4gKwo+PiArc3RhdGljIHN0cnVjdCB0bXAxMDMgKnRtcDEwM191cGRh dGVfZGV2aWNlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4+ICt7Cj4+ICsgc3RydWN0IHRt cDEwMyAqdG1wMTAzID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Cj4+ICsKPj4gKyBtdXRl eF9sb2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIGlmICh0aW1lX2FmdGVyKGppZmZpZXMsIHRtcDEw My0+bGFzdF91cGRhdGUgKyBIWiAvIDMpKSB7Cj4+ICsgaW50IGk7Cj4+ICsKPj4gKyBmb3IgKGkg PSAwOyBpIDwgQVJSQVlfU0laRSh0bXAxMDMtPnRlbXApOyArK2kpIHsKPj4gKyBpbnQgc3RhdHVz ID0gaTJjX3NtYnVzX3JlYWRfYnl0ZV9kYXRhKGNsaWVudCwKPj4gKyB0bXAxMDNfcmVnW2ldKTsK Pj4gKyBpZiAoc3RhdHVzID4gLTEpCj4+ICsgdG1wMTAzLT50ZW1wW2ldID0gdG1wMTAzX3JlZ190 b19tQyhzdGF0dXMpOwo+Cj4gSSB1bmRlcnN0YW5kIHRoaXMgaXMgZnJvbSB0aGUgdG1wMTAyIGRy aXZlciwgYnV0IGl0IGlzIGtpbmQgb2YgdW51c3VhbAo+IGJlY2F1c2UgaXQgZG9lcyBub3QgcmVw b3J0IHRoZSBlcnJvciBiYWNrIHRvIHRoZSB1c2VyLiBQbGVhc2UgY29uc2lkZXIKPiBkb2luZyB0 aGF0LCBpZSByZXR1cm4gUFRSX0VSUihzdGF0dXMpIG9uIGVycm9yIGFuZCBjaGVjay9yZXR1cm4g dGhlIGVycm9yCj4gZnJvbSB0aGUgY2FsbGluZyBmdW5jdGlvbnMuIElycmVsZXZhbnQgaWYgeW91 IHVzZSByZWdtYXAgKHNlZSBiZWxvdykuCgp5b3UgbWVhbiBFUlJfUFRSKCkgPwpPaywgYWRkIHRo aXMuCgo+PiArIH0KPj4gKyB0bXAxMDMtPmxhc3RfdXBkYXRlID0gamlmZmllczsKPj4gKyB9Cj4+ ICsgbXV0ZXhfdW5sb2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIHJldHVybiB0bXAxMDM7Cj4+ICt9 Cj4KPiBPdmVyYWxsIHlvdSBtaWdodCBjb25zaWRlciBkcm9wcGluZyB0aGUgdXBkYXRlIGZ1bmN0 aW9uIGFuZCB1c2luZyByZWdtYXAgaW5zdGVhZC4KPiBJdCB3b3VsZCBiZSBhbiBleGNlbGxlbnQg Zml0IGZvciB0aGlzIGRyaXZlcjsgd2hpbGUgaXQgZG9lc24ndCBkbyB0aW1lZCBjYWNoaW5nCj4g aXQgc3VwcG9ydHMgcGVyLXJlZ2lzdGVyIGNhY2hpbmcgd2hpY2ggaXMgdWx0aW1hdGVseSBtb3Jl IHVzZWZ1bCBhbnl3YXkuCj4gU29tZSBvZiB0aGUgZHJpdmVycyBpbiB0aGUgaHdtb24gZGlyZWN0 b3J5IHVzZSBpdCwgc28geW91IGNvdWxkIHVzZSB0aGF0Cj4gYXMgZXhhbXBsZS4gTm90IG1hbmRh dG9yeSwgdGhvdWdoOyBqdXN0IGEgc3VnZ2VzdGlvbi4KCkNvdWxkIHlvdSBnaXZlIG1lIGFuIGV4 YW1wbGU/Cgo+PiArCj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2hvd190ZW1wKHN0cnVjdCBk ZXZpY2UgKmRldiwKPj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPj4gKyBjaGFy ICpidWYpCj4+ICt7Cj4+ICsgc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0 b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4+ICsgc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gdG1w MTAzX3VwZGF0ZV9kZXZpY2UodG9faTJjX2NsaWVudChkZXYpKTsKPj4gKwo+PiArIHJldHVybiBz cHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDMtPnRlbXBbc2RhLT5pbmRleF0pOwo+PiArfQo+PiAr Cj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAo+ PiArIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+PiArIGNvbnN0IGNoYXIgKmJ1Ziwg c2l6ZV90IGNvdW50KQo+PiArewo+PiArIHN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAq c2RhID0gdG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpOwo+PiArIHN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7Cj4+ICsgc3RydWN0IHRtcDEwMyAqdG1wMTAzID0g aTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Cj4+ICsgbG9uZyB2YWw7Cj4+ICsgaW50IHN0YXR1 czsKPj4gKwo+PiArIGlmIChrc3RydG9sKGJ1ZiwgMTAsICZ2YWwpIDwgMCkKPj4gKyByZXR1cm4g LUVJTlZBTDsKPj4gKyB2YWwgPSBjbGFtcF92YWwodmFsLCAtNTUwMDAsIDEyODAwMCk7Cj4KPiBN YXggc2hvdWxkIGJlIDEyNzAwMC4KCk9rLCBjaGFuZ2UgdGhpcy4KCj4+ICsKPj4gKyBtdXRleF9s b2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIHRtcDEwMy0+dGVtcFtzZGEtPmluZGV4XSA9IHZhbDsK Pgo+IFlvdSBjYW4gbm90IGRvIHRoYXQgc2luY2UgaXQgaXMgdGhlIG5vbi1yb3VuZGVkIHZhbHVl LiBZb3UgaGF2ZSB0byBjb252ZXJ0IHRvCj4gdGhlIHJlZ2lzdGVyIHZhbHVlLCB0aGVuIGNvbnZl cnQgYmFjayB0byB0aGUgZGlzcGxheSB2YWx1ZS4KPgo+IElmIHlvdSB1c2UgcmVnbWFwLCB0aGUg cHJvYmxlbSBnb2VzIGF3YXksIHNpbmNlIHlvdSB3b3VsZCBub3QgY2FjaGUgY29udmVydGVkCj4g ZGF0YSBidXQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5jdGlvbi4gQWx0ZXJuYXRpdmVseSwgeW91 IGNvdWxkIHN0b3JlIHJlZ2lzdGVyCj4gdmFsdWVzIGFuZCBjb252ZXJ0IGluIHRoZSBzaG93IGZ1 bmN0aW9uLgoKSSB0YWtlIGEgbG9vayBhdCB0aGlzLgoKPj4gKyBzdGF0dXMgPSBpMmNfc21idXNf d3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgdG1wMTAzX3JlZ1tzZGEtPmluZGV4XSwKPj4gKyB0bXAx MDNfbUNfdG9fcmVnKHZhbCkpOwo+Cj4gUGxlYXNlIG1ha2Ugc3VyZSB0aGF0IGNvbnRpbnVhdGlv biBsaW5lcyBtYXRjaCB0aGUgJygnIGluIHRoZSBsaW5lIGFib3ZlLgo+IEFsaWdubWVudHMgYXJl IGluY29uc2lzdGVudCwgb3RoZXJ3aXNlIEkgd291bGQgbm90IG1lbnRpb24gaXQuCj4gY2hlY2tw YXRjaCAtLXN0cmljdCB0ZWxscyB5b3Ugd2hpY2ggb25lcyBhcmUgbWlzYWxpZ25lZC4KCkFoLCBk aWQgYSBjaGVja3BhdGNoIGJ1dCB3aXRob3V0IHRoZSAiLS1zdHJpY3QiIG9wdGlvbiAhCgpJIGZp eCB0aGlzIGdsb2JhbGx5LgoKPj4gKyBtdXRleF91bmxvY2soJnRtcDEwMy0+bG9jayk7Cj4+ICsg cmV0dXJuIHN0YXR1cyA/IDogY291bnQ7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBTRU5TT1JfREVW SUNFX0FUVFIodGVtcDFfaW5wdXQsIFNfSVJVR08sIHRtcDEwM19zaG93X3RlbXAsIE5VTEwgLCAw KTsKPj4gKwo+IElmIHlvdSB1c2UgcmVnbWFwIHlvdSBjYW4gc3RvcmUgdGhlIHJlZ2lzdGVyIGRp cmVjdGx5IGhlcmUgYW5kIHlvdSB3b3VsZCBub3QKPiBuZWVkIHRtcDEwM19yZWdbXS4KCk9rLgoK Pj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4X2h5c3QsIFNfSVdVU1IgfCBT X0lSVUdPLCB0bXAxMDNfc2hvd190ZW1wLAo+PiArIHRtcDEwM19zZXRfdGVtcCwgMSk7Cj4+ICsK PiBQZXIgdGhlIGRhdGFzaGVldCB0aGlzIHNob3VsZCBiZSB0ZW1wMV9taW4uIFRoZSByZWdpc3Rl ciBkZWZpbml0aW9uIGlzIGRpZmZlcmVudCB0byBUTVAxMDIuCgpjaGFuZ2VkLgoKPj4gK3N0YXRp YyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAz X3Nob3dfdGVtcCwKPj4gKyB0bXAxMDNfc2V0X3RlbXAsIDIpOwo+PiArCj4+ICtzdGF0aWMgc3Ry dWN0IGF0dHJpYnV0ZSAqdG1wMTAzX2F0dHJpYnV0ZXNbXSA9IHsKPj4gKyAmc2Vuc29yX2Rldl9h dHRyX3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIsCj4+ICsgJnNlbnNvcl9kZXZfYXR0cl90ZW1w MV9tYXhfaHlzdC5kZXZfYXR0ci5hdHRyLAo+PiArICZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfbWF4 LmRldl9hdHRyLmF0dHIsCj4KPiBZb3UgbWlnaHQgYWxzbyBjb25zaWRlciBhZGRpbmcgdGVtcDFf bWluX2FsYXJtIGFuZCB0ZW1wMV9tYXhfYWxhcm0gdG8gaW5mb3JtCj4gdXNlciBzcGFjZSBpZiBs aW1pdHMgYXJlIGV4Y2VlZGVkLiBUaGUgc3RhdHVzIGlzIHJlcG9ydGVkIHdpdGggdGhlIEZMIGFu ZCBGSAo+IGJpdHMgaW4gdGhlIGNvbmZpZ3VyYXRpb24gcmVnaXN0ZXIuCgpBZGQgdGhpcyBpZiBJ IGZpbmQgdGltZSwgb3IgaW4gYW4gYW5vdGhlciBwYXRjaC4uLgoKPj4gKyBOVUxMCj4+ICt9Owo+ PiArCj4+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCB0bXAxMDNfYXR0cl9n cm91cCA9IHsKPj4gKyAuYXR0cnMgPSB0bXAxMDNfYXR0cmlidXRlcywKPj4gK307Cj4+ICsKPiBQ bGVhc2UgdXNlIHRoZSBBVFRSSUJVVEVfR1JPVVBTKCkgbWFjcm8uCgpPay4KCj4+ICsjZGVmaW5l IFRNUDEwM19DT05GSUcgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQo+PiArI2Rl ZmluZSBUTVAxMDNfQ09ORklHX1JEX09OTFkgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05G X00xKQo+Cj4gTGF0dGVyIGRlZmluZSBpcyBub3QgdXNlZCBhcyBmYXIgYXMgSSBjYW4gc2VlLiBT aW5jZSBpdCBpcyB0aGUgc2FtZQo+IGl0IGlzIHVubmVjZXNzYXJ5IGFueXdheS4KCnJlbW92ZWQu Cgo+PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xp ZW50LAo+PiArIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPj4gK3sKPj4gKyBzdHJ1 Y3QgdG1wMTAzICp0bXAxMDM7Cj4+ICsgaW50IHN0YXR1czsKPj4gKwo+PiArIGlmICghaTJjX2No ZWNrX2Z1bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+PiArIEkyQ19GVU5DX1NNQlVTX1dP UkRfREFUQSkpIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwKPj4gKyAiYWRhcHRlciBkb2Vz bid0IHN1cHBvcnQgU01CdXMgd29yZCB0cmFuc2FjdGlvbnNcbiIpOwo+Cj4gR29vZCB0aGF0IHRo ZSBjaGlwIGRvZXNuJ3Qgc3VwcG9ydCBhbnkgOy0pLiBDaGVjayBmb3IgYnl0ZSB0cmFuc2FjdGlv bnMgaW5zdGVhZC4KCkhlaC4uLiBjaGFuZ2VkLgoKPj4gKyByZXR1cm4gLUVOT0RFVjsKPj4gKyB9 Cj4+ICsKPj4gKyB0bXAxMDMgPSBkZXZtX2t6YWxsb2MoJmNsaWVudC0+ZGV2LCBzaXplb2YoKnRt cDEwMyksIEdGUF9LRVJORUwpOwo+PiArIGlmICghdG1wMTAzKQo+PiArIHJldHVybiAtRU5PTUVN Owo+PiArCj4+ICsgaTJjX3NldF9jbGllbnRkYXRhKGNsaWVudCwgdG1wMTAzKTsKPj4gKwo+PiAr IHN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRNUDEwM19DT05GX1JF Ryk7Cj4+ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwgImVy cm9yIHJlYWRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyByZXR1cm4gc3RhdHVzOwo+PiAr IH0KPj4gKyB0bXAxMDMtPmNvbmZpZ19vcmlnID0gc3RhdHVzOwo+Cj4gWW91IGRvbid0IHVzZSBj b25maWdfb3JpZyBvdXRzaWRlIHRoZSBwcm9iZSBmdW5jdGlvbiwKPiBzbyBzdG9yaW5nIGl0IGlu IHByaXZhdGUgZGF0YSBkb2Vzbid0IGFkZCBhbnkgdmFsdWUuCj4gQWx0ZXJuYXRpdmVseSwgeW91 IGNvdWxkIHJlc3RvcmUgdGhlIG9yaWdpbmFsIGNvbmZpZ3VyYXRpb24gb24gZXhpdC4KCkkgYWRk ICJyZXN0b3JpbmcgaXQgb24gZXhpdC4iCgo+PiArIHN0YXR1cyA9IGkyY19zbWJ1c193cml0ZV9i eXRlX2RhdGEoY2xpZW50LCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgVE1QMTAzX0NPTkZJRyk7Cj4+ ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwgImVycm9yIHdy aXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyBnb3RvIGZhaWxfcmVzdG9yZV9jb25maWc7 Cj4+ICsgfQo+PiArIHN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRN UDEwM19DT05GX1JFRyk7Cj4+ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGll bnQtPmRldiwgImVycm9yIHJlYWRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyBnb3RvIGZh aWxfcmVzdG9yZV9jb25maWc7Cj4+ICsgfQo+PiArIGlmIChzdGF0dXMgIT0gVE1QMTAzX0NPTkZJ Rykgewo+PiArIGRldl9lcnIoJmNsaWVudC0+ZGV2LCAiY29uZmlnIHNldHRpbmdzIGRpZCBub3Qg c3RpY2tcbiIpOwo+PiArIHN0YXR1cyA9IC1FTk9ERVY7Cj4+ICsgZ290byBmYWlsX3Jlc3RvcmVf Y29uZmlnOwo+PiArIH0KPj4gKyB0bXAxMDMtPmxhc3RfdXBkYXRlID0gamlmZmllcyAtIEhaOwo+ PiArIG11dGV4X2luaXQoJnRtcDEwMy0+bG9jayk7Cj4+ICsKPj4gKyBzdGF0dXMgPSBzeXNmc19j cmVhdGVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICsg aWYgKHN0YXR1cykgewo+PiArIGRldl9kYmcoJmNsaWVudC0+ZGV2LCAiY291bGQgbm90IGNyZWF0 ZSBzeXNmcyBmaWxlc1xuIik7Cj4+ICsgZ290byBmYWlsX3Jlc3RvcmVfY29uZmlnOwo+PiArIH0K Pj4gKyB0bXAxMDMtPmh3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3RlcigmY2xpZW50LT5k ZXYpOwo+PiArIGlmIChJU19FUlIodG1wMTAzLT5od21vbl9kZXYpKSB7Cj4+ICsgZGV2X2RiZygm Y2xpZW50LT5kZXYsICJ1bmFibGUgdG8gcmVnaXN0ZXIgaHdtb24gZGV2aWNlXG4iKTsKPj4gKyBz dGF0dXMgPSBQVFJfRVJSKHRtcDEwMy0+aHdtb25fZGV2KTsKPj4gKyBnb3RvIGZhaWxfcmVtb3Zl X3N5c2ZzOwo+PiArIH0KPgo+IFBsZWFzZSB1c2UgZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJf d2l0aF9ncm91cHMoKS4KCk9rLgoKPj4gKwo+PiArIGRldl9pbmZvKCZjbGllbnQtPmRldiwgImlu aXRpYWxpemVkXG4iKTsKPgo+IFBsZWFzZSBkcm9wIHRoaXMgbWVzc2FnZS4KCk9rLgoKPj4gKwo+ PiArIHJldHVybiAwOwo+PiArCj4+ICtmYWlsX3JlbW92ZV9zeXNmczoKPj4gKyBzeXNmc19yZW1v dmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICtmYWls X3Jlc3RvcmVfY29uZmlnOgo+PiArIGkyY19zbWJ1c193cml0ZV93b3JkX3N3YXBwZWQoY2xpZW50 LCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgdG1wMTAzLT5jb25maWdfb3JpZyk7Cj4KPiBpMmNfc21i dXNfd3JpdGVfYnl0ZV9kYXRhKCkgPwoKWWVzLCBjaGFuZ2VkIQoKPj4gKyByZXR1cm4gc3RhdHVz Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19yZW1vdmUoc3RydWN0IGkyY19jbGll bnQgKmNsaWVudCkKPj4gK3sKPj4gKyBzdHJ1Y3QgdG1wMTAzICp0bXAxMDMgPSBpMmNfZ2V0X2Ns aWVudGRhdGEoY2xpZW50KTsKPj4gKwo+PiArIGh3bW9uX2RldmljZV91bnJlZ2lzdGVyKHRtcDEw My0+aHdtb25fZGV2KTsKPj4gKyBzeXNmc19yZW1vdmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmos ICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICsKPj4gKyByZXR1cm4gMDsKPj4gK30KPj4gKwo+PiAr I2lmZGVmIENPTkZJR19QTQo+PiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2 aWNlICpkZXYpCj4+ICt7Cj4+ICsgc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19j bGllbnQoZGV2KTsKPj4gKyBpbnQgY29uZmlnOwo+PiArCj4+ICsgY29uZmlnID0gaTJjX3NtYnVz X3JlYWRfd29yZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKPgo+IGJ5dGUKPgo+ PiArIGlmIChjb25maWcgPCAwKQo+PiArIHJldHVybiBjb25maWc7Cj4+ICsKPj4gKyBjb25maWcg Jj0gflRNUDEwM19DT05GX1NEOwo+PiArIHJldHVybiBpMmNfc21idXNfd3JpdGVfd29yZF9zd2Fw cGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLCBjb25maWcpOwo+Cj4gYnl0ZQo+Cj4+ICt9Cj4+ ICsKPj4gK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICt7 Cj4+ICsgc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19jbGllbnQoZGV2KTsKPj4g KyBpbnQgY29uZmlnOwo+PiArCj4+ICsgY29uZmlnID0gaTJjX3NtYnVzX3JlYWRfd29yZF9zd2Fw cGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKPgo+IGJ5dGUKPgo+PiArIGlmIChjb25maWcg PCAwKQo+PiArIHJldHVybiBjb25maWc7Cj4+ICsKPj4gKyBjb25maWcgfD0gVE1QMTAzX0NPTkZf U0Q7Cj4+ICsgcmV0dXJuIGkyY19zbWJ1c193cml0ZV93b3JkX3N3YXBwZWQoY2xpZW50LCBUTVAx MDNfQ09ORl9SRUcsIGNvbmZpZyk7Cj4KPiBieXRlCgpjaGFuZ2VkLgoKPj4gK30KPj4gKwo+PiAr c3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+PiAr IC5zdXNwZW5kID0gdG1wMTAzX3N1c3BlbmQsCj4+ICsgLnJlc3VtZSA9IHRtcDEwM19yZXN1bWUs Cj4+ICt9Owo+PiArCj4+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9w bV9vcHMpCj4+ICsjZWxzZQo+PiArI2RlZmluZSBUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4+ICsj ZW5kaWYgLyogQ09ORklHX1BNICovCj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2Rl dmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKPj4gKyB7IERSSVZFUl9OQU1FLCAwIH0sCj4+ICsgeyB9 Cj4+ICt9Owo+PiArTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4+ICsKPj4g K3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciB0bXAxMDNfZHJpdmVyID0gewo+PiArIC5kcml2ZXIu bmFtZSA9IERSSVZFUl9OQU1FLAo+PiArIC5kcml2ZXIucG0gPSBUTVAxMDNfREVWX1BNX09QUywK Pgo+IC5kcml2ZXIgPSB7Cj4gLm5hbWUgPSBEUklWRVJfTkFNRSwKPiAucG0gPSBUTVAxMDNfREVW X1BNX09QUywKPiB9LAo+Cj4gd291bGQgYmUgYSBiaXQgbmljZXIuIEkgd29uJ3QgbWFuZGF0ZSBp dCwgdGhvdWdoLgoKY2hhbmdlZC4KCj4+ICsgLnByb2JlID0gdG1wMTAzX3Byb2JlLAo+PiArIC5y ZW1vdmUgPSB0bXAxMDNfcmVtb3ZlLAo+PiArIC5pZF90YWJsZSA9IHRtcDEwM19pZCwKPj4gK307 Cj4+ICsKPj4gK21vZHVsZV9pMmNfZHJpdmVyKHRtcDEwM19kcml2ZXIpOwo+PiArCj4+ICtNT0RV TEVfQVVUSE9SKCJIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4iKTsKPj4gK01PRFVMRV9ERVND UklQVElPTigiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2 ZXIiKTsKPj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKClRoYW5rcyBmb3IgdGhpcyBncmVhdCBy ZXZpZXchCgpieWUsCkhlaWtvCi0tIApERU5YIFNvZnR3YXJlIEVuZ2luZWVyaW5nIEdtYkgsICAg ICBNRDogV29sZmdhbmcgRGVuayAmIERldGxldiBadW5kZWwKSFJCIDE2NTIzNSBNdW5pY2gsIE9m ZmljZTogS2lyY2hlbnN0ci41LCBELTgyMTk0IEdyb2ViZW56ZWxsLCBHZXJtYW55CgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxp bmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3Jz Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-12 9:39 ` Heiko Schocher 0 siblings, 0 replies; 8+ messages in thread From: Heiko Schocher @ 2014-06-12 9:39 UTC (permalink / raw) To: Guenter Roeck; +Cc: lm-sensors, Jean Delvare, linux-kernel Hello Guenter, Am 11.06.2014 19:11, schrieb Guenter Roeck: > On 06/10/2014 11:28 PM, 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 > > Hi Heiko, > > You don't need those Cc: in the header. Ok, I remove them. > Why patch 09/13 ? I'd expect to see 12 more patches in this series, Hups, sorry, my mistake, there is just this patch... > but there is only one (even on kernel.org). If you sent those > other patches to various other mailing lists, everyone will wonder > where the remaining patches are. If there is just one patch, > it is just confusing. > >> --- >> Documentation/devicetree/bindings/hwmon/tmp103 | 30 +++ >> drivers/hwmon/Kconfig | 10 + >> drivers/hwmon/Makefile | 1 + >> drivers/hwmon/tmp103.c | 281 +++++++++++++++++++++++++ >> 4 files changed, 322 insertions(+) >> create mode 100644 Documentation/devicetree/bindings/hwmon/tmp103 >> create mode 100644 drivers/hwmon/tmp103.c >> >> diff --git a/Documentation/devicetree/bindings/hwmon/tmp103 b/Documentation/devicetree/bindings/hwmon/tmp103 >> new file mode 100644 >> index 0000000..36d7b36 >> --- /dev/null >> +++ b/Documentation/devicetree/bindings/hwmon/tmp103 > > Should be Documentation/hwmon/tmp103. Hmm.. I did this first there, but "scripts/checkpatch.pl" warns (if using a DT based board with compatible = "ti,tmp103"): WARNING: DT compatible string "ti,tmp103" appears un-documented -- check ./Documentation/devicetree/bindings/ #324: FILE: arch/arm/boot/dts/imx6qdl-aristainetos.dtsi:107: + compatible = "ti,tmp103"; >> @@ -0,0 +1,30 @@ >> +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). >> + >> +Required node properties: >> +- compatible: manufacturer and chip name >> + "ti,tmp103" >> +- reg: I2C bus address of the device > > You don't need this part, and it is not really correct (there are > other ways to instantiate the device, devicetree is just one of them). Ok. > I would suggest to refer to Documentation/i2c/instantiating-devices > instead. It might also make sense to update > Documentation/devicetree/bindings/i2c/trivial-devices.txt. Ah, ok, good idea, this removes also the checkpatch warning, thanks! Changed. > Also, whenever you touch any of the the dt files, you need to copy > the DT maintainers. scripts/get_maintainer.pl will tell you who needs > to be copied. Ok. [...] >> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile >> index 11798ad..8e2f6a2 100644 >> --- a/drivers/hwmon/Makefile >> +++ b/drivers/hwmon/Makefile >> @@ -134,6 +134,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..0bd33d6 >> --- /dev/null >> +++ b/drivers/hwmon/tmp103.c >> @@ -0,0 +1,281 @@ >> +/* >> + * 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> >> + >> +#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) >> + >> +struct tmp103 { >> + struct device *hwmon_dev; >> + struct mutex lock; >> + u16 config_orig; >> + unsigned long last_update; >> + int temp[3]; >> +}; >> + >> +static inline int tmp103_reg_to_mC(s8 val) >> +{ >> + return val * 1000; >> +} >> + >> +static inline u8 tmp103_mC_to_reg(int val) >> +{ >> + return val / 1000; > > DIV_ROUND_CLOSEST() ? > > No camelCase, please. Ok ... hmm, wondering that checkpatch.pl not claimed this. removed. >> +} >> + >> +static const u8 tmp103_reg[] = { >> + TMP103_TEMP_REG, >> + TMP103_TLOW_REG, >> + TMP103_THIGH_REG, >> +}; >> + >> +static struct tmp103 *tmp103_update_device(struct i2c_client *client) >> +{ >> + struct tmp103 *tmp103 = i2c_get_clientdata(client); >> + >> + mutex_lock(&tmp103->lock); >> + if (time_after(jiffies, tmp103->last_update + HZ / 3)) { >> + int i; >> + >> + for (i = 0; i < ARRAY_SIZE(tmp103->temp); ++i) { >> + int status = i2c_smbus_read_byte_data(client, >> + tmp103_reg[i]); >> + if (status > -1) >> + tmp103->temp[i] = tmp103_reg_to_mC(status); > > I understand this is from the tmp102 driver, but it is kind of unusual > because it does not report the error back to the user. Please consider > doing that, ie return PTR_ERR(status) on error and check/return the error > from the calling functions. Irrelevant if you use regmap (see below). you mean ERR_PTR() ? Ok, add this. >> + } >> + tmp103->last_update = jiffies; >> + } >> + mutex_unlock(&tmp103->lock); >> + return tmp103; >> +} > > Overall you might consider dropping the update function and using regmap instead. > It would be an excellent fit for this driver; while it doesn't do timed caching > it supports per-register caching which is ultimately more useful anyway. > Some of the drivers in the hwmon directory use it, so you could use that > as example. Not mandatory, though; just a suggestion. Could you give me an example? >> + >> +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 tmp103 *tmp103 = tmp103_update_device(to_i2c_client(dev)); >> + >> + return sprintf(buf, "%d\n", tmp103->temp[sda->index]); >> +} >> + >> +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 i2c_client *client = to_i2c_client(dev); >> + struct tmp103 *tmp103 = i2c_get_clientdata(client); >> + long val; >> + int status; >> + >> + if (kstrtol(buf, 10, &val) < 0) >> + return -EINVAL; >> + val = clamp_val(val, -55000, 128000); > > Max should be 127000. Ok, change this. >> + >> + mutex_lock(&tmp103->lock); >> + tmp103->temp[sda->index] = val; > > You can not do that since it is the non-rounded value. You have to convert to > the register value, then convert back to the display value. > > If you use regmap, the problem goes away, since you would not cache converted > data but convert in the show function. Alternatively, you could store register > values and convert in the show function. I take a look at this. >> + status = i2c_smbus_write_byte_data(client, tmp103_reg[sda->index], >> + tmp103_mC_to_reg(val)); > > Please make sure that continuation lines match the '(' in the line above. > Alignments are inconsistent, otherwise I would not mention it. > checkpatch --strict tells you which ones are misaligned. Ah, did a checkpatch but without the "--strict" option ! I fix this globally. >> + mutex_unlock(&tmp103->lock); >> + return status ? : count; >> +} >> + >> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , 0); >> + > If you use regmap you can store the register directly here and you would not > need tmp103_reg[]. Ok. >> +static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, 1); >> + > Per the datasheet this should be temp1_min. The register definition is different to TMP102. changed. >> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, 2); >> + >> +static struct attribute *tmp103_attributes[] = { >> + &sensor_dev_attr_temp1_input.dev_attr.attr, >> + &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, >> + &sensor_dev_attr_temp1_max.dev_attr.attr, > > You might also consider adding temp1_min_alarm and temp1_max_alarm to inform > user space if limits are exceeded. The status is reported with the FL and FH > bits in the configuration register. Add this if I find time, or in an another patch... >> + NULL >> +}; >> + >> +static const struct attribute_group tmp103_attr_group = { >> + .attrs = tmp103_attributes, >> +}; >> + > Please use the ATTRIBUTE_GROUPS() macro. Ok. >> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) >> +#define TMP103_CONFIG_RD_ONLY (TMP103_CONF_CR1 | TMP103_CONF_M1) > > Latter define is not used as far as I can see. Since it is the same > it is unnecessary anyway. removed. >> + >> +static int tmp103_probe(struct i2c_client *client, >> + const struct i2c_device_id *id) >> +{ >> + struct tmp103 *tmp103; >> + int status; >> + >> + if (!i2c_check_functionality(client->adapter, >> + I2C_FUNC_SMBUS_WORD_DATA)) { >> + dev_err(&client->dev, >> + "adapter doesn't support SMBus word transactions\n"); > > Good that the chip doesn't support any ;-). Check for byte transactions instead. Heh... changed. >> + return -ENODEV; >> + } >> + >> + tmp103 = devm_kzalloc(&client->dev, sizeof(*tmp103), GFP_KERNEL); >> + if (!tmp103) >> + return -ENOMEM; >> + >> + i2c_set_clientdata(client, tmp103); >> + >> + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); >> + if (status < 0) { >> + dev_err(&client->dev, "error reading config register\n"); >> + return status; >> + } >> + tmp103->config_orig = status; > > You don't use config_orig outside the probe function, > so storing it in private data doesn't add any value. > Alternatively, you could restore the original configuration on exit. I add "restoring it on exit." >> + status = i2c_smbus_write_byte_data(client, TMP103_CONF_REG, >> + TMP103_CONFIG); >> + if (status < 0) { >> + dev_err(&client->dev, "error writing config register\n"); >> + goto fail_restore_config; >> + } >> + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG); >> + if (status < 0) { >> + dev_err(&client->dev, "error reading config register\n"); >> + goto fail_restore_config; >> + } >> + if (status != TMP103_CONFIG) { >> + dev_err(&client->dev, "config settings did not stick\n"); >> + status = -ENODEV; >> + goto fail_restore_config; >> + } >> + tmp103->last_update = jiffies - HZ; >> + mutex_init(&tmp103->lock); >> + >> + status = sysfs_create_group(&client->dev.kobj, &tmp103_attr_group); >> + if (status) { >> + dev_dbg(&client->dev, "could not create sysfs files\n"); >> + goto fail_restore_config; >> + } >> + tmp103->hwmon_dev = hwmon_device_register(&client->dev); >> + if (IS_ERR(tmp103->hwmon_dev)) { >> + dev_dbg(&client->dev, "unable to register hwmon device\n"); >> + status = PTR_ERR(tmp103->hwmon_dev); >> + goto fail_remove_sysfs; >> + } > > Please use devm_hwmon_device_register_with_groups(). Ok. >> + >> + dev_info(&client->dev, "initialized\n"); > > Please drop this message. Ok. >> + >> + return 0; >> + >> +fail_remove_sysfs: >> + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); >> +fail_restore_config: >> + i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, >> + tmp103->config_orig); > > i2c_smbus_write_byte_data() ? Yes, changed! >> + return status; >> +} >> + >> +static int tmp103_remove(struct i2c_client *client) >> +{ >> + struct tmp103 *tmp103 = i2c_get_clientdata(client); >> + >> + hwmon_device_unregister(tmp103->hwmon_dev); >> + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group); >> + >> + return 0; >> +} >> + >> +#ifdef CONFIG_PM >> +static int tmp103_suspend(struct device *dev) >> +{ >> + struct i2c_client *client = to_i2c_client(dev); >> + int config; >> + >> + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); > > byte > >> + if (config < 0) >> + return config; >> + >> + config &= ~TMP103_CONF_SD; >> + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); > > byte > >> +} >> + >> +static int tmp103_resume(struct device *dev) >> +{ >> + struct i2c_client *client = to_i2c_client(dev); >> + int config; >> + >> + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG); > > byte > >> + if (config < 0) >> + return config; >> + >> + config |= TMP103_CONF_SD; >> + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config); > > byte changed. >> +} >> + >> +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 }, >> + { } >> +}; >> +MODULE_DEVICE_TABLE(i2c, tmp103_id); >> + >> +static struct i2c_driver tmp103_driver = { >> + .driver.name = DRIVER_NAME, >> + .driver.pm = TMP103_DEV_PM_OPS, > > .driver = { > .name = DRIVER_NAME, > .pm = TMP103_DEV_PM_OPS, > }, > > would be a bit nicer. I won't mandate it, though. changed. >> + .probe = tmp103_probe, >> + .remove = tmp103_remove, >> + .id_table = tmp103_id, >> +}; >> + >> +module_i2c_driver(tmp103_driver); >> + >> +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); >> +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); >> +MODULE_LICENSE("GPL"); Thanks for this great review! bye, Heiko -- DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor 2014-06-12 9:39 ` Heiko Schocher @ 2014-06-12 12:06 ` Guenter Roeck -1 siblings, 0 replies; 8+ messages in thread From: Guenter Roeck @ 2014-06-12 12:06 UTC (permalink / raw) To: hs; +Cc: lm-sensors, Jean Delvare, linux-kernel On 06/12/2014 02:39 AM, Heiko Schocher wrote: > Hello Guenter, [ ... ] >> >> Overall you might consider dropping the update function and using regmap instead. >> It would be an excellent fit for this driver; while it doesn't do timed caching >> it supports per-register caching which is ultimately more useful anyway. >> Some of the drivers in the hwmon directory use it, so you could use that >> as example. Not mandatory, though; just a suggestion. > > Could you give me an example? > Hello Heiko, check for the use of regmap in drivers/hwmon. Any of the drivers using it can serve as example. Guenter _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-12 12:06 ` Guenter Roeck 0 siblings, 0 replies; 8+ messages in thread From: Guenter Roeck @ 2014-06-12 12:06 UTC (permalink / raw) To: hs; +Cc: lm-sensors, Jean Delvare, linux-kernel On 06/12/2014 02:39 AM, Heiko Schocher wrote: > Hello Guenter, [ ... ] >> >> Overall you might consider dropping the update function and using regmap instead. >> It would be an excellent fit for this driver; while it doesn't do timed caching >> it supports per-register caching which is ultimately more useful anyway. >> Some of the drivers in the hwmon directory use it, so you could use that >> as example. Not mandatory, though; just a suggestion. > > Could you give me an example? > Hello Heiko, check for the use of regmap in drivers/hwmon. Any of the drivers using it can serve as example. Guenter ^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2014-06-12 12:06 UTC | newest] Thread overview: 8+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2014-06-11 6:28 [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor Heiko Schocher 2014-06-11 6:28 ` Heiko Schocher 2014-06-11 17:11 ` [lm-sensors] " Guenter Roeck 2014-06-11 17:11 ` Guenter Roeck 2014-06-12 9:39 ` [lm-sensors] " Heiko Schocher 2014-06-12 9:39 ` Heiko Schocher 2014-06-12 12:06 ` [lm-sensors] " Guenter Roeck 2014-06-12 12:06 ` Guenter Roeck
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.