* [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 5:37 ` Heiko Schocher 0 siblings, 0 replies; 21+ messages in thread From: Heiko Schocher @ 2014-06-18 5:37 UTC (permalink / raw) To: lm-sensors Cc: Heiko Schocher, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland RHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgoKVGhlIFRJIFRNUDEwMyBpcyBzaW1pbGFyIHRvIHRo ZSBUTVAxMDIuICBJdCBkaWZmZXJzIGZyb20gdGhlIFRNUDEwMgpieSBoYXZpbmcgb25seSA4IGJp dCByZWdpc3RlcnMuCgpTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4K Ci0tLQoKQ2M6IEplYW4gRGVsdmFyZSA8a2hhbGlAbGludXgtZnIub3JnPgpDYzogR3VlbnRlciBS b2VjayA8bGludXhAcm9lY2stdXMubmV0PgpDYzogbGludXgta2VybmVsQHZnZXIua2VybmVsLm9y ZwpDYzogZGV2aWNldHJlZUB2Z2VyLmtlcm5lbC5vcmcKQ2M6IGxpbnV4LWRvY0B2Z2VyLmtlcm5l bC5vcmcKQ2M6IE1hcmsgUnV0bGFuZCA8bWFyay5ydXRsYW5kQGFybS5jb20+CgotIGNoYW5nZSBm b3IgdjI6CiAgLSBhZGQgY29tbWVudHMgZnJvbSBHdWVudGVyUm9lY2s6CiAgICAtIHJlbW92ZSBD YyBmcm9tIGNvbW1pdCBzdWJqZWN0CiAgICAtIGFkZCBkZXZpY2V0cmVlIG1haW50YWluZXIKICAg IC0gbW92ZSBEb2N1bWVudGF0aW9uIHRvIERvY3VtZW50YXRpb24vaHdtb24vdG1wMTAzCiAgICAt IHJlbW92ZSBkZXZpY2V0cmVlIGJpbmRpbmdzIGZyb20gRG9jdW1lbnRhdGlvbgogICAgLSBhZGQg Y29tcGF0aWJsZSBzdHJpbmcgdG8KICAgICAgIkRvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5k aW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCIKICAgIC0gcmVtb3ZlIENhbWVsQ2FzZQogICAg LSBmaXggQ29kaW5nc3R5bGUgaXNzdWVzCiAgICAtIHVzZSBBVFRSSUJVVEVfR1JPVVBTIGFuZCBk ZXZtX2h3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dyb3VwcygpCiAgICAtIHJlbW92ZSB1bnN1 c2VkIGRlZmluZSBUTVAxMDNfQ09ORklHX1JEX09OTFkKICAgIC0gcmVzdG9yZSBjb25maWcgcmVn aXN0ZXIgd2hlbiBleGl0KCkKICAgIC0gdXNlIHJlZ21hcAotIGNoYW5nZXMgZm9yIHYzOgogIGFn YWluIGEgbG90IG9mIGZhbnRhc3RpYyB0aXBzIGhvdyB0byB1c2UgcmVnbWFwIGVmZmljaWVudGx5 CiAgZnJvbSBHdWVudGVyIFJvZWNrOgogIC0gZ2V0IHJpZCBvZiAic3RydWN0IHRtcDEwMyIKICAt IGdldCByaWQgb2YgInN0YXRpYyBjb25zdCB1OCB0bXAxMDNfcmVnW10iCiAgLSBnZXQgcmlkIG9m IG11dGV4IGxvY2sKICAtIGRyb3AgY29uZmlnX29yaWcgZW50aXJlbHkKICAtIHVzZSByZWdtYXBf dXBkYXRlX2JpdHMoKQotIGNoYW5nZXMgZm9yIHY0OgogIC0gYWRkIGNvbW1lbnQgZnJvbSBHdWVu dGVyIFJvZWNrOgogICAgZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZf U0RfTUFTSwogICAgc2VwYXJhdGVseSB0byBlbnN1cmUgeW91IGNhdGNoIGFsbCB0aGUgdG8tYmUt Y2xlYXJlZCBiaXRzLgotIGNoYW5nZXMgZm9yIHY1OgogIGFkZCBjb21tZW50IGZyb20gR3VlbnRl ciBSb2VjazoKICAtIHVzZSAiI2RlZmluZSBUTVAxMDNfQ09ORl9TRCBUTVAxMDNfQ09ORl9NMSIK ICBhZGQgY29tbWVudCBmcm9tIE1hcmsgUnV0bGFuZDoKICAtIHVzZSBmdWxsIHN0cmluZyBmb3Ig RFQgY29tcGF0aWJsZSBzdHJpbmcgbWF0Y2hpbmcsIGluc3RlYWQgb2YKICAgIERSSVZFUl9OQU1F LiBHZXQgcmlkIGNvbXBsZXRlIG9mIERSSVZFUl9OQU1FIGRlZmluZS4KCiAuLi4vZGV2aWNldHJl ZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCAgICB8ICAgMSArCiBEb2N1bWVudGF0 aW9uL2h3bW9uL3RtcDEwMyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyOCArKysKIGRyaXZl cnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDEwICsKIGRy aXZlcnMvaHdtb24vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsK IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjA1 ICsrKysrKysrKysrKysrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCAyNDUgaW5zZXJ0aW9ucygr KQogY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vaHdtb24vdG1wMTAzCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9od21vbi90bXAxMDMuYwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCBiL0RvY3Vt ZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dAppbmRl eCBiZWY4NmU1Li5mYzk0NGUwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUv YmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZp Y2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMudHh0CkBAIC04Myw1ICs4Myw2IEBA IHN0bSxtNDF0ODAJCU00MVQ4MCAtIFNFUklBTCBBQ0NFU1MgUlRDIFdJVEggQUxBUk1TCiB0YW9z LHRzbDI1NTAJCUFtYmllbnQgTGlnaHQgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFs IEludGVyZmFjZQogdGksdHNjMjAwMwkJSTJDIFRvdWNoLVNjcmVlbiBDb250cm9sbGVyCiB0aSx0 bXAxMDIJCUxvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3 byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKK3RpLHRtcDEwMwkJTG93IFBvd2VyIERpZ2l0YWwgVGVt cGVyYXR1cmUgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQogdGks dG1wMjc1CQlEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvcgogd2luYm9uZCx3cGN0MzAxCQlpMmMg dHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQTSkKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24v aHdtb24vdG1wMTAzIGIvRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uZWMwMGExNQotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50 YXRpb24vaHdtb24vdG1wMTAzCkBAIC0wLDAgKzEsMjggQEAKK0tlcm5lbCBkcml2ZXIgdG1wMTAz Cis9PT09PT09PT09PT09PT09PT09PQorCitTdXBwb3J0ZWQgY2hpcHM6CisgICogVGV4YXMgSW5z dHJ1bWVudHMgVE1QMTAzCisgICAgUHJlZml4OiAndG1wMTAzJworICAgIEFkZHJlc3NlcyBzY2Fu bmVkOiBub25lCisgICAgUHJvZHVjdCBpbmZvIGFuZCBkYXRhc2hlZXQ6IGh0dHA6Ly93d3cudGku Y29tL3Byb2R1Y3QvdG1wMTAzCisKK0F1dGhvcjoKKwlIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5k ZT4KKworRGVzY3JpcHRpb24KKy0tLS0tLS0tLS0tCisKK1RoZSBUTVAxMDMgaXMgYSBkaWdpdGFs IG91dHB1dCB0ZW1wZXJhdHVyZSBzZW5zb3IgaW4gYSBmb3VyLWJhbGwKK3dhZmVyIGNoaXAtc2Nh bGUgcGFja2FnZSAoV0NTUCkuIFRoZSBUTVAxMDMgaXMgY2FwYWJsZSBvZiByZWFkaW5nCit0ZW1w ZXJhdHVyZXMgdG8gYSByZXNvbHV0aW9uIG9mIDHCsEMuIFRoZSBUTVAxMDMgaXMgc3BlY2lmaWVk IGZvcgorb3BlcmF0aW9uIG92ZXIgYSB0ZW1wZXJhdHVyZSByYW5nZSBvZiDigJM0MMKwQyB0byAr MTI1wrBDLgorCitSZXNvbHV0aW9uOiA4IEJpdHMKK0FjY3VyYWN5OiDCsTHCsEMgVHlwICjigJMx MMKwQyB0byArMTAwwrBDKQorCitUaGUgZHJpdmVyIHByb3ZpZGVzIHRoZSBjb21tb24gc3lzZnMt aW50ZXJmYWNlIGZvciB0ZW1wZXJhdHVyZXMgKHNlZQorRG9jdW1lbnRhdGlvbi9od21vbi9zeXNm cy1pbnRlcmZhY2UgdW5kZXIgVGVtcGVyYXR1cmVzKS4KKworUGxlYXNlIHJlZmVyIGhvdyB0byBp bnN0YW50aWF0ZSB0aGlzIGRyaXZlcjoKK0RvY3VtZW50YXRpb24vaTJjL2luc3RhbnRpYXRpbmct ZGV2aWNlcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21v bi9LY29uZmlnCmluZGV4IDA4NTMxYTEuLmM4ODJkNGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdt b24vS2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTEzOTEsNiArMTM5MSwx NiBAQCBjb25maWcgU0VOU09SU19UTVAxMDIKIAkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1 aWx0IGFzIGEgbW9kdWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKIAkgIHdpbGwgYmUgY2FsbGVkIHRt cDEwMi4KIAorY29uZmlnIFNFTlNPUlNfVE1QMTAzCisJdHJpc3RhdGUgIlRleGFzIEluc3RydW1l bnRzIFRNUDEwMyIKKwlkZXBlbmRzIG9uIEkyQworCWhlbHAKKwkgIElmIHlvdSBzYXkgeWVzIGhl cmUgeW91IGdldCBzdXBwb3J0IGZvciBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKKwkgIHNlbnNv ciBjaGlwcy4KKworCSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUu ICBJZiBzbywgdGhlIG1vZHVsZQorCSAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgorCiBjb25maWcg U0VOU09SU19UTVA0MDEKIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBj b21wYXRpYmxlcyIKIAlkZXBlbmRzIG9uIEkyQwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9N YWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKaW5kZXggM2RjMGYwMi4uY2MwZGYxZWYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9od21vbi9N YWtlZmlsZQpAQCAtMTM1LDYgKzEzNSw3IEBAIG9iai0kKENPTkZJR19TRU5TT1JTX1NNU0M0N00x OTIpKz0gc21zYzQ3bTE5Mi5vCiBvYmotJChDT05GSUdfU0VOU09SU19BTUM2ODIxKQkrPSBhbWM2 ODIxLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX1RITUM1MCkJKz0gdGhtYzUwLm8KIG9iai0kKENP TkZJR19TRU5TT1JTX1RNUDEwMikJKz0gdG1wMTAyLm8KK29iai0kKENPTkZJR19TRU5TT1JTX1RN UDEwMykJKz0gdG1wMTAzLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQwMSkJKz0gdG1wNDAx Lm8KIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkJKz0gdG1wNDIxLm8KIG9iai0kKENPTkZJ R19TRU5TT1JTX1RXTDQwMzBfTUFEQykrPSB0d2w0MDMwLW1hZGMtaHdtb24ubwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9od21vbi90bXAxMDMuYyBiL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTY5ZGJjYQotLS0gL2Rldi9udWxsCisrKyBi L2RyaXZlcnMvaHdtb24vdG1wMTAzLmMKQEAgLTAsMCArMSwyMDUgQEAKKy8qCisgKiBUZXhhcyBJ bnN0cnVtZW50cyBUTVAxMDMgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZlcgorICogQ29w eXJpZ2h0IChDKSAyMDE0IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgorICoKKyAqIEJhc2Vk IG9uOgorICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAyIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNv ciBkcml2ZXIKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU3RldmVuIEtpbmcgPHNma2luZ0Bm ZHdkYy5jb20+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBv cgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHBy b2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVk ZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51 eC9pMmMuaD4KKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgorI2luY2x1ZGUgPGxpbnV4L2h3bW9u LXN5c2ZzLmg+CisjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvbXV0ZXgu aD4KKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+ CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CisKKyNkZWZpbmUgVE1QMTAzX1RFTVBfUkVHCQkw eDAwCisjZGVmaW5lIFRNUDEwM19DT05GX1JFRwkJMHgwMQorI2RlZmluZSBUTVAxMDNfVExPV19S RUcJCTB4MDIKKyNkZWZpbmUgVE1QMTAzX1RISUdIX1JFRwkweDAzCisKKyNkZWZpbmUgVE1QMTAz X0NPTkZfTTAJCTB4MDEKKyNkZWZpbmUgVE1QMTAzX0NPTkZfTTEJCTB4MDIKKyNkZWZpbmUgVE1Q MTAzX0NPTkZfTEMJCTB4MDQKKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwJCTB4MDgKKyNkZWZpbmUg VE1QMTAzX0NPTkZfRkgJCTB4MTAKKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwCQkweDIwCisjZGVm aW5lIFRNUDEwM19DT05GX0NSMQkJMHg0MAorI2RlZmluZSBUTVAxMDNfQ09ORl9JRAkJMHg4MAor I2RlZmluZSBUTVAxMDNfQ09ORl9TRAkJKFRNUDEwM19DT05GX00xKQorI2RlZmluZSBUTVAxMDNf Q09ORl9TRF9NQVNLCShUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQorCisjZGVmaW5l IFRNUDEwM19DT05GSUcJCShUTVAxMDNfQ09ORl9DUjEgfCBUTVAxMDNfQ09ORl9NMSkKKyNkZWZp bmUgVE1QMTAzX0NPTkZJR19NQVNLCShUTVAxMDNfQ09ORl9DUjAgfCBUTVAxMDNfQ09ORl9DUjEg fCBcCisJCQkJIFRNUDEwM19DT05GX00wIHwgVE1QMTAzX0NPTkZfTTEpCisKK3N0YXRpYyBpbmxp bmUgaW50IHRtcDEwM19yZWdfdG9fbWMoczggdmFsKQoreworCXJldHVybiB2YWwgKiAxMDAwOwor fQorCitzdGF0aWMgaW5saW5lIHU4IHRtcDEwM19tY190b19yZWcoaW50IHZhbCkKK3sKKwlyZXR1 cm4gRElWX1JPVU5EX0NMT1NFU1QodmFsLCAxMDAwKTsKK30KKworc3RhdGljIHNzaXplX3QgdG1w MTAzX3Nob3dfdGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJc3RydWN0IGRldmljZV9hdHRy aWJ1dGUgKmF0dHIsCisJCQkJY2hhciAqYnVmKQoreworCXN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0 dHJpYnV0ZSAqc2RhID0gdG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpOworCXN0cnVjdCByZWdtYXAg KnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCXVuc2lnbmVkIGludCByZWd2YWw7CisJ aW50IHJldDsKKworCXJldCA9IHJlZ21hcF9yZWFkKHJlZ21hcCwgc2RhLT5pbmRleCwgJnJlZ3Zh bCk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gc3ByaW50ZihidWYs ICIlZFxuIiwgdG1wMTAzX3JlZ190b19tYyhyZWd2YWwpKTsKK30KKworc3RhdGljIHNzaXplX3Qg dG1wMTAzX3NldF90ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgICAgICBzdHJ1Y3QgZGV2 aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCSAgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBj b3VudCkKK3sKKwlzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNv cl9kZXZfYXR0cihhdHRyKTsKKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZfZ2V0X2RydmRh dGEoZGV2KTsKKwlsb25nIHZhbDsKKwlpbnQgcmV0OworCisJaWYgKGtzdHJ0b2woYnVmLCAxMCwg JnZhbCkgPCAwKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXZhbCA9IGNsYW1wX3ZhbCh2YWwsIC01 NTAwMCwgMTI3MDAwKTsKKwlyZXQgPSByZWdtYXBfd3JpdGUocmVnbWFwLCBzZGEtPmluZGV4LCB0 bXAxMDNfbWNfdG9fcmVnKHZhbCkpOworCXJldHVybiByZXQgPyByZXQgOiBjb3VudDsKK30KKwor c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywgdG1wMTAzX3No b3dfdGVtcCwgTlVMTCAsCisJCQkgIFRNUDEwM19URU1QX1JFRyk7CisKK3N0YXRpYyBTRU5TT1Jf REVWSUNFX0FUVFIodGVtcDFfbWluLCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3Nob3dfdGVt cCwKKwkJCSAgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVExPV19SRUcpOworCitzdGF0aWMgU0VO U09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEwM19zaG93 X3RlbXAsCisJCQkgIHRtcDEwM19zZXRfdGVtcCwgVE1QMTAzX1RISUdIX1JFRyk7CisKK3N0YXRp YyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNfYXR0cnNbXSA9IHsKKwkmc2Vuc29yX2Rldl9hdHRy X3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIsCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9taW4u ZGV2X2F0dHIuYXR0ciwKKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX21heC5kZXZfYXR0ci5hdHRy LAorCU5VTEwKK307CitBVFRSSUJVVEVfR1JPVVBTKHRtcDEwMyk7CisKK3N0YXRpYyBib29sIHRt cDEwM19yZWdtYXBfaXNfdm9sYXRpbGUoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQg cmVnKQoreworCXJldHVybiByZWcgPT0gVE1QMTAzX1RFTVBfUkVHOworfQorCitzdGF0aWMgc3Ry dWN0IHJlZ21hcF9jb25maWcgdG1wMTAzX3JlZ21hcF9jb25maWcgPSB7CisJLnJlZ19iaXRzID0g OCwKKwkudmFsX2JpdHMgPSA4LAorCS5tYXhfcmVnaXN0ZXIgPSBUTVAxMDNfVEhJR0hfUkVHLAor CS52b2xhdGlsZV9yZWcgPSB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxlLAorfTsKKworc3RhdGlj IGludCB0bXAxMDNfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKKwkJCWNvbnN0IHN0 cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmY2xpZW50 LT5kZXY7CisJc3RydWN0IGRldmljZSAqaHdtb25fZGV2OworCXN0cnVjdCByZWdtYXAgKnJlZ21h cDsKKwlpbnQgcmV0OworCisJaWYgKCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFk YXB0ZXIsCisJCQkJICAgICBJMkNfRlVOQ19TTUJVU19CWVRFX0RBVEEpKSB7CisJCWRldl9lcnIo JmNsaWVudC0+ZGV2LAorCQkJImFkYXB0ZXIgZG9lc24ndCBzdXBwb3J0IFNNQnVzIGJ5dGUgdHJh bnNhY3Rpb25zXG4iKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJcmVnbWFwID0gZGV2bV9y ZWdtYXBfaW5pdF9pMmMoY2xpZW50LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOworCWlmIChJU19F UlIocmVnbWFwKSkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSByZWdpc3Rl ciBtYXBcbiIpOworCQlyZXR1cm4gUFRSX0VSUihyZWdtYXApOworCX0KKworCXJldCA9IHJlZ21h cF91cGRhdGVfYml0cyhyZWdtYXAsIFRNUDEwM19DT05GX1JFRywgVE1QMTAzX0NPTkZJR19NQVNL LAorCQkJCSBUTVAxMDNfQ09ORklHKTsKKwlpZiAocmV0IDwgMCkgeworCQlkZXZfZXJyKCZjbGll bnQtPmRldiwgImVycm9yIHdyaXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKKwkJcmV0dXJuIHJl dDsKKwl9CisKKwlod21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMo ZGV2LCBjbGllbnQtPm5hbWUsCisJCQkJCQkgICAgICByZWdtYXAsIHRtcDEwM19ncm91cHMpOwor CXJldHVybiBQVFJfRVJSX09SX1pFUk8oaHdtb25fZGV2KTsKK30KKworI2lmZGVmIENPTkZJR19Q TQorc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3Ry dWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisKKwlyZXR1cm4gcmVn bWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVHLAorCQkJCSAgVE1QMTAzX0NP TkZfU0RfTUFTSywgMCk7Cit9CisKK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2 aWNlICpkZXYpCit7CisJc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRl dik7CisKKwlyZXR1cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVH LAorCQkJCSAgVE1QMTAzX0NPTkZfU0RfTUFTSywgVE1QMTAzX0NPTkZfU0QpOworfQorCitzdGF0 aWMgY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgdG1wMTAzX2Rldl9wbV9vcHMgPSB7CisJLnN1c3Bl bmQJPSB0bXAxMDNfc3VzcGVuZCwKKwkucmVzdW1lCQk9IHRtcDEwM19yZXN1bWUsCit9OworCisj ZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCisjZWxzZQorI2Rl ZmluZQlUTVAxMDNfREVWX1BNX09QUyBOVUxMCisjZW5kaWYgLyogQ09ORklHX1BNICovCisKK3N0 YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKKwl7ICJ0bXAx MDMiLCAwIH0sCisJeyB9Cit9OworTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19pZCk7 CisKK3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciB0bXAxMDNfZHJpdmVyID0geworCS5kcml2ZXIg PSB7CisJCS5uYW1lCT0gInRtcDEwMyIsCisJCS5wbQk9IFRNUDEwM19ERVZfUE1fT1BTLAorCX0s CisJLnByb2JlCQk9IHRtcDEwM19wcm9iZSwKKwkuaWRfdGFibGUJPSB0bXAxMDNfaWQsCit9Owor Cittb2R1bGVfaTJjX2RyaXZlcih0bXAxMDNfZHJpdmVyKTsKKworTU9EVUxFX0FVVEhPUigiSGVp a28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Iik7CitNT0RVTEVfREVTQ1JJUFRJT04oIlRleGFzIElu c3RydW1lbnRzIFRNUDEwMyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyIik7CitNT0RVTEVfTElD RU5TRSgiR1BMIik7Ci0tIAoxLjguMy4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KbG0tc2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1z ZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9s bS1zZW5zb3Jz ^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 5:37 ` Heiko Schocher 0 siblings, 0 replies; 21+ messages in thread From: Heiko Schocher @ 2014-06-18 5:37 UTC (permalink / raw) To: lm-sensors Cc: Heiko Schocher, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland Driver for the TI TMP103. The TI TMP103 is similar to the TMP102. It differs from the TMP102 by having only 8 bit registers. Signed-off-by: Heiko Schocher <hs@denx.de> --- Cc: Jean Delvare <khali@linux-fr.org> Cc: Guenter Roeck <linux@roeck-us.net> Cc: linux-kernel@vger.kernel.org Cc: devicetree@vger.kernel.org Cc: linux-doc@vger.kernel.org Cc: Mark Rutland <mark.rutland@arm.com> - change for v2: - add comments from GuenterRoeck: - remove Cc from commit subject - add devicetree maintainer - move Documentation to Documentation/hwmon/tmp103 - remove devicetree bindings from Documentation - add compatible string to "Documentation/devicetree/bindings/i2c/trivial-devices.txt" - remove CamelCase - fix Codingstyle issues - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups() - remove unsused define TMP103_CONFIG_RD_ONLY - restore config register when exit() - use regmap - changes for v3: again a lot of fantastic tips how to use regmap efficiently from Guenter Roeck: - get rid of "struct tmp103" - get rid of "static const u8 tmp103_reg[]" - get rid of mutex lock - drop config_orig entirely - use regmap_update_bits() - changes for v4: - add comment from Guenter Roeck: define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK separately to ensure you catch all the to-be-cleared bits. - changes for v5: add comment from Guenter Roeck: - use "#define TMP103_CONF_SD TMP103_CONF_M1" add comment from Mark Rutland: - use full string for DT compatible string matching, instead of DRIVER_NAME. Get rid complete of DRIVER_NAME define. .../devicetree/bindings/i2c/trivial-devices.txt | 1 + Documentation/hwmon/tmp103 | 28 +++ drivers/hwmon/Kconfig | 10 + drivers/hwmon/Makefile | 1 + drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++ 5 files changed, 245 insertions(+) create mode 100644 Documentation/hwmon/tmp103 create mode 100644 drivers/hwmon/tmp103.c diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt index bef86e5..fc944e0 100644 --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH ALARMS taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface ti,tsc2003 I2C Touch-Screen Controller ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface ti,tmp275 Digital Temperature Sensor winbond,wpct301 i2c trusted platform module (TPM) diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 new file mode 100644 index 0000000..ec00a15 --- /dev/null +++ b/Documentation/hwmon/tmp103 @@ -0,0 +1,28 @@ +Kernel driver tmp103 +==================== + +Supported chips: + * Texas Instruments TMP103 + Prefix: 'tmp103' + Addresses scanned: none + Product info and datasheet: http://www.ti.com/product/tmp103 + +Author: + Heiko Schocher <hs@denx.de> + +Description +----------- + +The TMP103 is a digital output temperature sensor in a four-ball +wafer chip-scale package (WCSP). The TMP103 is capable of reading +temperatures to a resolution of 1°C. The TMP103 is specified for +operation over a temperature range of –40°C to +125°C. + +Resolution: 8 Bits +Accuracy: ±1°C Typ (–10°C to +100°C) + +The driver provides the common sysfs-interface for temperatures (see +Documentation/hwmon/sysfs-interface under Temperatures). + +Please refer how to instantiate this driver: +Documentation/i2c/instantiating-devices diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 08531a1..c882d4b 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -1391,6 +1391,16 @@ config SENSORS_TMP102 This driver can also be built as a module. If so, the module will be called tmp102. +config SENSORS_TMP103 + tristate "Texas Instruments TMP103" + depends on I2C + help + If you say yes here you get support for Texas Instruments TMP103 + sensor chips. + + This driver can also be built as a module. If so, the module + will be called tmp103. + config SENSORS_TMP401 tristate "Texas Instruments TMP401 and compatibles" depends on I2C diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 3dc0f02..cc0df1ef 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o obj-$(CONFIG_SENSORS_THMC50) += thmc50.o obj-$(CONFIG_SENSORS_TMP102) += tmp102.o +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o obj-$(CONFIG_SENSORS_TMP401) += tmp401.o obj-$(CONFIG_SENSORS_TMP421) += tmp421.o obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c new file mode 100644 index 0000000..e69dbca --- /dev/null +++ b/drivers/hwmon/tmp103.c @@ -0,0 +1,205 @@ +/* + * Texas Instruments TMP103 SMBus temperature sensor driver + * Copyright (C) 2014 Heiko Schocher <hs@denx.de> + * + * Based on: + * Texas Instruments TMP102 SMBus temperature sensor driver + * + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include <linux/module.h> +#include <linux/init.h> +#include <linux/slab.h> +#include <linux/i2c.h> +#include <linux/hwmon.h> +#include <linux/hwmon-sysfs.h> +#include <linux/err.h> +#include <linux/mutex.h> +#include <linux/device.h> +#include <linux/jiffies.h> +#include <linux/regmap.h> + +#define TMP103_TEMP_REG 0x00 +#define TMP103_CONF_REG 0x01 +#define TMP103_TLOW_REG 0x02 +#define TMP103_THIGH_REG 0x03 + +#define TMP103_CONF_M0 0x01 +#define TMP103_CONF_M1 0x02 +#define TMP103_CONF_LC 0x04 +#define TMP103_CONF_FL 0x08 +#define TMP103_CONF_FH 0x10 +#define TMP103_CONF_CR0 0x20 +#define TMP103_CONF_CR1 0x40 +#define TMP103_CONF_ID 0x80 +#define TMP103_CONF_SD (TMP103_CONF_M1) +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) + +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ + TMP103_CONF_M0 | TMP103_CONF_M1) + +static inline int tmp103_reg_to_mc(s8 val) +{ + return val * 1000; +} + +static inline u8 tmp103_mc_to_reg(int val) +{ + return DIV_ROUND_CLOSEST(val, 1000); +} + +static ssize_t tmp103_show_temp(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); + struct regmap *regmap = dev_get_drvdata(dev); + unsigned int regval; + int ret; + + ret = regmap_read(regmap, sda->index, ®val); + if (ret < 0) + return ret; + + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); +} + +static ssize_t tmp103_set_temp(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); + struct regmap *regmap = dev_get_drvdata(dev); + long val; + int ret; + + if (kstrtol(buf, 10, &val) < 0) + return -EINVAL; + + val = clamp_val(val, -55000, 127000); + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); + return ret ? ret : count; +} + +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , + TMP103_TEMP_REG); + +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp, + tmp103_set_temp, TMP103_TLOW_REG); + +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, + tmp103_set_temp, TMP103_THIGH_REG); + +static struct attribute *tmp103_attrs[] = { + &sensor_dev_attr_temp1_input.dev_attr.attr, + &sensor_dev_attr_temp1_min.dev_attr.attr, + &sensor_dev_attr_temp1_max.dev_attr.attr, + NULL +}; +ATTRIBUTE_GROUPS(tmp103); + +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg) +{ + return reg == TMP103_TEMP_REG; +} + +static struct regmap_config tmp103_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + .max_register = TMP103_THIGH_REG, + .volatile_reg = tmp103_regmap_is_volatile, +}; + +static int tmp103_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct device *dev = &client->dev; + struct device *hwmon_dev; + struct regmap *regmap; + int ret; + + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_BYTE_DATA)) { + dev_err(&client->dev, + "adapter doesn't support SMBus byte transactions\n"); + return -ENODEV; + } + + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); + if (IS_ERR(regmap)) { + dev_err(dev, "failed to allocate register map\n"); + return PTR_ERR(regmap); + } + + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, + TMP103_CONFIG); + if (ret < 0) { + dev_err(&client->dev, "error writing config register\n"); + return ret; + } + + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, + regmap, tmp103_groups); + return PTR_ERR_OR_ZERO(hwmon_dev); +} + +#ifdef CONFIG_PM +static int tmp103_suspend(struct device *dev) +{ + struct regmap *regmap = dev_get_drvdata(dev); + + return regmap_update_bits(regmap, TMP103_CONF_REG, + TMP103_CONF_SD_MASK, 0); +} + +static int tmp103_resume(struct device *dev) +{ + struct regmap *regmap = dev_get_drvdata(dev); + + return regmap_update_bits(regmap, TMP103_CONF_REG, + TMP103_CONF_SD_MASK, TMP103_CONF_SD); +} + +static const struct dev_pm_ops tmp103_dev_pm_ops = { + .suspend = tmp103_suspend, + .resume = tmp103_resume, +}; + +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) +#else +#define TMP103_DEV_PM_OPS NULL +#endif /* CONFIG_PM */ + +static const struct i2c_device_id tmp103_id[] = { + { "tmp103", 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, tmp103_id); + +static struct i2c_driver tmp103_driver = { + .driver = { + .name = "tmp103", + .pm = TMP103_DEV_PM_OPS, + }, + .probe = tmp103_probe, + .id_table = tmp103_id, +}; + +module_i2c_driver(tmp103_driver); + +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); +MODULE_LICENSE("GPL"); -- 1.8.3.1 ^ permalink raw reply related [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 5:37 ` Heiko Schocher @ 2014-06-18 5:58 ` Varka Bhadram -1 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 5:46 UTC (permalink / raw) To: Heiko Schocher, lm-sensors Cc: Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland Hi, On 06/18/2014 11:07 AM, Heiko Schocher wrote: > Driver for the TI TMP103. > > The TI TMP103 is similar to the TMP102. It differs from the TMP102 > by having only 8 bit registers. > > Signed-off-by: Heiko Schocher <hs@denx.de> > > --- > > Cc: Jean Delvare <khali@linux-fr.org> > Cc: Guenter Roeck <linux@roeck-us.net> > Cc: linux-kernel@vger.kernel.org > Cc: devicetree@vger.kernel.org > Cc: linux-doc@vger.kernel.org > Cc: Mark Rutland <mark.rutland@arm.com> > > - change for v2: > - add comments from GuenterRoeck: > - remove Cc from commit subject > - add devicetree maintainer > - move Documentation to Documentation/hwmon/tmp103 > - remove devicetree bindings from Documentation > - add compatible string to > "Documentation/devicetree/bindings/i2c/trivial-devices.txt" > - remove CamelCase > - fix Codingstyle issues > - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups() > - remove unsused define TMP103_CONFIG_RD_ONLY > - restore config register when exit() > - use regmap > - changes for v3: > again a lot of fantastic tips how to use regmap efficiently > from Guenter Roeck: > - get rid of "struct tmp103" > - get rid of "static const u8 tmp103_reg[]" > - get rid of mutex lock > - drop config_orig entirely > - use regmap_update_bits() > - changes for v4: > - add comment from Guenter Roeck: > define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK > separately to ensure you catch all the to-be-cleared bits. > - changes for v5: > add comment from Guenter Roeck: > - use "#define TMP103_CONF_SD TMP103_CONF_M1" > add comment from Mark Rutland: > - use full string for DT compatible string matching, instead of > DRIVER_NAME. Get rid complete of DRIVER_NAME define. > > .../devicetree/bindings/i2c/trivial-devices.txt | 1 + > Documentation/hwmon/tmp103 | 28 +++ > drivers/hwmon/Kconfig | 10 + > drivers/hwmon/Makefile | 1 + > drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++ > 5 files changed, 245 insertions(+) > create mode 100644 Documentation/hwmon/tmp103 > create mode 100644 drivers/hwmon/tmp103.c > > diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt > index bef86e5..fc944e0 100644 > --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt > +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt > @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH ALARMS > taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface > ti,tsc2003 I2C Touch-Screen Controller > ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface > +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface > ti,tmp275 Digital Temperature Sensor > winbond,wpct301 i2c trusted platform module (TPM) > diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 > new file mode 100644 > index 0000000..ec00a15 > --- /dev/null > +++ b/Documentation/hwmon/tmp103 > @@ -0,0 +1,28 @@ > +Kernel driver tmp103 > +==================== > + > +Supported chips: > + * Texas Instruments TMP103 > + Prefix: 'tmp103' > + Addresses scanned: none > + Product info and datasheet: http://www.ti.com/product/tmp103 > + > +Author: > + Heiko Schocher <hs@denx.de> > + > +Description > +----------- > + > +The TMP103 is a digital output temperature sensor in a four-ball > +wafer chip-scale package (WCSP). The TMP103 is capable of reading > +temperatures to a resolution of 1°C. The TMP103 is specified for > +operation over a temperature range of –40°C to +125°C. > + > +Resolution: 8 Bits > +Accuracy: ±1°C Typ (–10°C to +100°C) > + > +The driver provides the common sysfs-interface for temperatures (see > +Documentation/hwmon/sysfs-interface under Temperatures). > + > +Please refer how to instantiate this driver: > +Documentation/i2c/instantiating-devices > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > index 08531a1..c882d4b 100644 > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -1391,6 +1391,16 @@ config SENSORS_TMP102 > This driver can also be built as a module. If so, the module > will be called tmp102. > > +config SENSORS_TMP103 > + tristate "Texas Instruments TMP103" > + depends on I2C > + help > + If you say yes here you get support for Texas Instruments TMP103 > + sensor chips. > + > + This driver can also be built as a module. If so, the module > + will be called tmp103. > + > config SENSORS_TMP401 > tristate "Texas Instruments TMP401 and compatibles" > depends on I2C > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > index 3dc0f02..cc0df1ef 100644 > --- a/drivers/hwmon/Makefile > +++ b/drivers/hwmon/Makefile > @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o > obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o > obj-$(CONFIG_SENSORS_THMC50) += thmc50.o > obj-$(CONFIG_SENSORS_TMP102) += tmp102.o > +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o > obj-$(CONFIG_SENSORS_TMP401) += tmp401.o > obj-$(CONFIG_SENSORS_TMP421) += tmp421.o > obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o > diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c > new file mode 100644 > index 0000000..e69dbca > --- /dev/null > +++ b/drivers/hwmon/tmp103.c > @@ -0,0 +1,205 @@ > +/* > + * Texas Instruments TMP103 SMBus temperature sensor driver > + * Copyright (C) 2014 Heiko Schocher <hs@denx.de> > + * > + * Based on: > + * Texas Instruments TMP102 SMBus temperature sensor driver > + * > + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + */ > + > +#include <linux/module.h> > +#include <linux/init.h> > +#include <linux/slab.h> > +#include <linux/i2c.h> > +#include <linux/hwmon.h> > +#include <linux/hwmon-sysfs.h> > +#include <linux/err.h> > +#include <linux/mutex.h> > +#include <linux/device.h> > +#include <linux/jiffies.h> > +#include <linux/regmap.h> > + > +#define TMP103_TEMP_REG 0x00 > +#define TMP103_CONF_REG 0x01 > +#define TMP103_TLOW_REG 0x02 > +#define TMP103_THIGH_REG 0x03 > + > +#define TMP103_CONF_M0 0x01 > +#define TMP103_CONF_M1 0x02 > +#define TMP103_CONF_LC 0x04 > +#define TMP103_CONF_FL 0x08 > +#define TMP103_CONF_FH 0x10 > +#define TMP103_CONF_CR0 0x20 > +#define TMP103_CONF_CR1 0x40 > +#define TMP103_CONF_ID 0x80 > +#define TMP103_CONF_SD (TMP103_CONF_M1) > +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) > + > +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) > +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ > + TMP103_CONF_M0 | TMP103_CONF_M1) > + > +static inline int tmp103_reg_to_mc(s8 val) > +{ > + return val * 1000; > +} > + > +static inline u8 tmp103_mc_to_reg(int val) > +{ > + return DIV_ROUND_CLOSEST(val, 1000); > +} > + > +static ssize_t tmp103_show_temp(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); > + struct regmap *regmap = dev_get_drvdata(dev); > + unsigned int regval; > + int ret; > + > + ret = regmap_read(regmap, sda->index, ®val); > + if (ret < 0) > + return ret; > + > + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); > +} > + > +static ssize_t tmp103_set_temp(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t count) > +{ > + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); > + struct regmap *regmap = dev_get_drvdata(dev); > + long val; > + int ret; > + > + if (kstrtol(buf, 10, &val) < 0) > + return -EINVAL; > + > + val = clamp_val(val, -55000, 127000); > + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); > + return ret ? ret : count; > +} > + > +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , > + TMP103_TEMP_REG); > + > +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp, > + tmp103_set_temp, TMP103_TLOW_REG); > + > +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, > + tmp103_set_temp, TMP103_THIGH_REG); > + > +static struct attribute *tmp103_attrs[] = { > + &sensor_dev_attr_temp1_input.dev_attr.attr, > + &sensor_dev_attr_temp1_min.dev_attr.attr, > + &sensor_dev_attr_temp1_max.dev_attr.attr, > + NULL > +}; > +ATTRIBUTE_GROUPS(tmp103); > + > +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg) > +{ > + return reg == TMP103_TEMP_REG; > +} > + > +static struct regmap_config tmp103_regmap_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = TMP103_THIGH_REG, > + .volatile_reg = tmp103_regmap_is_volatile, > +}; > + > +static int tmp103_probe(struct i2c_client *client, > + const struct i2c_device_id *id) > +{ > + struct device *dev = &client->dev; > + struct device *hwmon_dev; > + struct regmap *regmap; > + int ret; > + > + if (!i2c_check_functionality(client->adapter, > + I2C_FUNC_SMBUS_BYTE_DATA)) { > + dev_err(&client->dev, > + "adapter doesn't support SMBus byte transactions\n"); > + return -ENODEV; > + } > + > + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); > + if (IS_ERR(regmap)) { > + dev_err(dev, "failed to allocate register map\n"); > + return PTR_ERR(regmap); > + } > + > + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, > + TMP103_CONFIG); > + if (ret < 0) { > + dev_err(&client->dev, "error writing config register\n"); > + return ret; > + } > + > + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, > + regmap, tmp103_groups); > + return PTR_ERR_OR_ZERO(hwmon_dev); > +} > + > +#ifdef CONFIG_PM > +static int tmp103_suspend(struct device *dev) > +{ > + struct regmap *regmap = dev_get_drvdata(dev); > + > + return regmap_update_bits(regmap, TMP103_CONF_REG, > + TMP103_CONF_SD_MASK, 0); > +} > + > +static int tmp103_resume(struct device *dev) > +{ > + struct regmap *regmap = dev_get_drvdata(dev); > + > + return regmap_update_bits(regmap, TMP103_CONF_REG, > + TMP103_CONF_SD_MASK, TMP103_CONF_SD); > +} > + > +static const struct dev_pm_ops tmp103_dev_pm_ops = { > + .suspend = tmp103_suspend, > + .resume = tmp103_resume, > +}; > + > +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) > +#else > +#define TMP103_DEV_PM_OPS NULL > +#endif /* CONFIG_PM */ > + > +static const struct i2c_device_id tmp103_id[] = { > + { "tmp103", 0 }, > + { } > +}; In the bindings you are giving the compatible property as : ti,tmp103, but here only tmp103. Instead of using the i2c_device_id struct , use of_device_id struct for giving the compatible property value. compatble = "<manufacturer>,<model>" > +MODULE_DEVICE_TABLE(i2c, tmp103_id); > ++static struct i2c_driver tmp103_driver = { > + .driver = { > + .name = "tmp103", > + .pm = TMP103_DEV_PM_OPS, > + }, > + .probe = tmp103_probe, > + .id_table = tmp103_id, > +}; > + > +module_i2c_driver(tmp103_driver); > + > +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); > +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); > +MODULE_LICENSE("GPL"); ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 5:58 ` Varka Bhadram 0 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 5:58 UTC (permalink / raw) To: Heiko Schocher, lm-sensors Cc: Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland SGksCgpPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPiBEcml2 ZXIgZm9yIHRoZSBUSSBUTVAxMDMuCj4KPiBUaGUgVEkgVE1QMTAzIGlzIHNpbWlsYXIgdG8gdGhl IFRNUDEwMi4gIEl0IGRpZmZlcnMgZnJvbSB0aGUgVE1QMTAyCj4gYnkgaGF2aW5nIG9ubHkgOCBi aXQgcmVnaXN0ZXJzLgo+Cj4gU2lnbmVkLW9mZi1ieTogSGVpa28gU2Nob2NoZXIgPGhzQGRlbngu ZGU+Cj4KPiAtLS0KPgo+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4KPiBD YzogR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0Pgo+IENjOiBsaW51eC1rZXJuZWxA dmdlci5rZXJuZWwub3JnCj4gQ2M6IGRldmljZXRyZWVAdmdlci5rZXJuZWwub3JnCj4gQ2M6IGxp bnV4LWRvY0B2Z2VyLmtlcm5lbC5vcmcKPiBDYzogTWFyayBSdXRsYW5kIDxtYXJrLnJ1dGxhbmRA YXJtLmNvbT4KPgo+IC0gY2hhbmdlIGZvciB2MjoKPiAgICAtIGFkZCBjb21tZW50cyBmcm9tIEd1 ZW50ZXJSb2VjazoKPiAgICAgIC0gcmVtb3ZlIENjIGZyb20gY29tbWl0IHN1YmplY3QKPiAgICAg IC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5lcgo+ICAgICAgLSBtb3ZlIERvY3VtZW50YXRpb24g dG8gRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiAgICAgIC0gcmVtb3ZlIGRldmljZXRyZWUg YmluZGluZ3MgZnJvbSBEb2N1bWVudGF0aW9uCj4gICAgICAtIGFkZCBjb21wYXRpYmxlIHN0cmlu ZyB0bwo+ICAgICAgICAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2 aWFsLWRldmljZXMudHh0Igo+ICAgICAgLSByZW1vdmUgQ2FtZWxDYXNlCj4gICAgICAtIGZpeCBD b2RpbmdzdHlsZSBpc3N1ZXMKPiAgICAgIC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5kIGRldm1f aHdtb25fZGV2aWNlX3JlZ2lzdGVyX3dpdGhfZ3JvdXBzKCkKPiAgICAgIC0gcmVtb3ZlIHVuc3Vz ZWQgZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQo+ICAgICAgLSByZXN0b3JlIGNvbmZpZyBy ZWdpc3RlciB3aGVuIGV4aXQoKQo+ICAgICAgLSB1c2UgcmVnbWFwCj4gLSBjaGFuZ2VzIGZvciB2 MzoKPiAgICBhZ2FpbiBhIGxvdCBvZiBmYW50YXN0aWMgdGlwcyBob3cgdG8gdXNlIHJlZ21hcCBl ZmZpY2llbnRseQo+ICAgIGZyb20gR3VlbnRlciBSb2VjazoKPiAgICAtIGdldCByaWQgb2YgInN0 cnVjdCB0bXAxMDMiCj4gICAgLSBnZXQgcmlkIG9mICJzdGF0aWMgY29uc3QgdTggdG1wMTAzX3Jl Z1tdIgo+ICAgIC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4gICAgLSBkcm9wIGNvbmZpZ19vcmln IGVudGlyZWx5Cj4gICAgLSB1c2UgcmVnbWFwX3VwZGF0ZV9iaXRzKCkKPiAtIGNoYW5nZXMgZm9y IHY0Ogo+ICAgIC0gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ICAgICAgZGVmaW5l IFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZfU0RfTUFTSwo+ICAgICAgc2VwYXJh dGVseSB0byBlbnN1cmUgeW91IGNhdGNoIGFsbCB0aGUgdG8tYmUtY2xlYXJlZCBiaXRzLgo+IC0g Y2hhbmdlcyBmb3IgdjU6Cj4gICAgYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+ICAg IC0gdXNlICIjZGVmaW5lIFRNUDEwM19DT05GX1NEIFRNUDEwM19DT05GX00xIgo+ICAgIGFkZCBj b21tZW50IGZyb20gTWFyayBSdXRsYW5kOgo+ICAgIC0gdXNlIGZ1bGwgc3RyaW5nIGZvciBEVCBj b21wYXRpYmxlIHN0cmluZyBtYXRjaGluZywgaW5zdGVhZCBvZgo+ICAgICAgRFJJVkVSX05BTUUu IEdldCByaWQgY29tcGxldGUgb2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Cj4gICAuLi4vZGV2aWNl dHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCAgICB8ICAgMSArCj4gICBEb2N1 bWVudGF0aW9uL2h3bW9uL3RtcDEwMyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyOCArKysK PiAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDEwICsKPiAgIGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgICAxICsKPiAgIGRyaXZlcnMvaHdtb24vdG1wMTAzLmMgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgMjA1ICsrKysrKysrKysrKysrKysrKysrKwo+ICAgNSBmaWxlcyBjaGFuZ2Vk LCAyNDUgaW5zZXJ0aW9ucygrKQo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24v aHdtb24vdG1wMTAzCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9od21vbi90bXAxMDMu Ywo+Cj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMv dHJpdmlhbC1kZXZpY2VzLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9p MmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+IGluZGV4IGJlZjg2ZTUuLmZjOTQ0ZTAgMTAwNjQ0Cj4g LS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmlj ZXMudHh0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2 aWFsLWRldmljZXMudHh0Cj4gQEAgLTgzLDUgKzgzLDYgQEAgc3RtLG00MXQ4MAkJTTQxVDgwIC0g U0VSSUFMIEFDQ0VTUyBSVEMgV0lUSCBBTEFSTVMKPiAgIHRhb3MsdHNsMjU1MAkJQW1iaWVudCBM aWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4gICB0aSx0 c2MyMDAzCQlJMkMgVG91Y2gtU2NyZWVuIENvbnRyb2xsZXIKPiAgIHRpLHRtcDEwMgkJTG93IFBv d2VyIERpZ2l0YWwgVGVtcGVyYXR1cmUgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFs IEludGVyZmFjZQo+ICt0aSx0bXAxMDMJCUxvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNl bnNvciB3aXRoIFNNQlVTL1R3byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPiAgIHRpLHRtcDI3NQkJ RGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3IKPiAgIHdpbmJvbmQsd3BjdDMwMQkJaTJjIHRydXN0 ZWQgcGxhdGZvcm0gbW9kdWxlIChUUE0pCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdt b24vdG1wMTAzIGIvRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiBuZXcgZmlsZSBtb2RlIDEw MDY0NAo+IGluZGV4IDAwMDAwMDAuLmVjMDBhMTUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvRG9j dW1lbnRhdGlvbi9od21vbi90bXAxMDMKPiBAQCAtMCwwICsxLDI4IEBACj4gK0tlcm5lbCBkcml2 ZXIgdG1wMTAzCj4gKz09PT09PT09PT09PT09PT09PT09Cj4gKwo+ICtTdXBwb3J0ZWQgY2hpcHM6 Cj4gKyAgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKPiArICAgIFByZWZpeDogJ3RtcDEwMycK PiArICAgIEFkZHJlc3NlcyBzY2FubmVkOiBub25lCj4gKyAgICBQcm9kdWN0IGluZm8gYW5kIGRh dGFzaGVldDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPiArCj4gK0F1dGhvcjoK PiArCUhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ICsKPiArRGVzY3JpcHRpb24KPiArLS0t LS0tLS0tLS0KPiArCj4gK1RoZSBUTVAxMDMgaXMgYSBkaWdpdGFsIG91dHB1dCB0ZW1wZXJhdHVy ZSBzZW5zb3IgaW4gYSBmb3VyLWJhbGwKPiArd2FmZXIgY2hpcC1zY2FsZSBwYWNrYWdlIChXQ1NQ KS4gVGhlIFRNUDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPiArdGVtcGVyYXR1cmVzIHRvIGEg cmVzb2x1dGlvbiBvZiAxwrBDLiBUaGUgVE1QMTAzIGlzIHNwZWNpZmllZCBmb3IKPiArb3BlcmF0 aW9uIG92ZXIgYSB0ZW1wZXJhdHVyZSByYW5nZSBvZiDigJM0MMKwQyB0byArMTI1wrBDLgo+ICsK PiArUmVzb2x1dGlvbjogOCBCaXRzCj4gK0FjY3VyYWN5OiDCsTHCsEMgVHlwICjigJMxMMKwQyB0 byArMTAwwrBDKQo+ICsKPiArVGhlIGRyaXZlciBwcm92aWRlcyB0aGUgY29tbW9uIHN5c2ZzLWlu dGVyZmFjZSBmb3IgdGVtcGVyYXR1cmVzIChzZWUKPiArRG9jdW1lbnRhdGlvbi9od21vbi9zeXNm cy1pbnRlcmZhY2UgdW5kZXIgVGVtcGVyYXR1cmVzKS4KPiArCj4gK1BsZWFzZSByZWZlciBob3cg dG8gaW5zdGFudGlhdGUgdGhpcyBkcml2ZXI6Cj4gK0RvY3VtZW50YXRpb24vaTJjL2luc3RhbnRp YXRpbmctZGV2aWNlcwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcgYi9kcml2 ZXJzL2h3bW9uL0tjb25maWcKPiBpbmRleCAwODUzMWExLi5jODgyZDRiIDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IEBA IC0xMzkxLDYgKzEzOTEsMTYgQEAgY29uZmlnIFNFTlNPUlNfVE1QMTAyCj4gICAJICBUaGlzIGRy aXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCj4g ICAJICB3aWxsIGJlIGNhbGxlZCB0bXAxMDIuCj4gICAKPiArY29uZmlnIFNFTlNPUlNfVE1QMTAz Cj4gKwl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIgo+ICsJZGVwZW5kcyBvbiBJ MkMKPiArCWhlbHAKPiArCSAgSWYgeW91IHNheSB5ZXMgaGVyZSB5b3UgZ2V0IHN1cHBvcnQgZm9y IFRleGFzIEluc3RydW1lbnRzIFRNUDEwMwo+ICsJICBzZW5zb3IgY2hpcHMuCj4gKwo+ICsJICBU aGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9k dWxlCj4gKwkgIHdpbGwgYmUgY2FsbGVkIHRtcDEwMy4KPiArCj4gICBjb25maWcgU0VOU09SU19U TVA0MDEKPiAgIAl0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBjb21wYXRp YmxlcyIKPiAgIAlkZXBlbmRzIG9uIEkyQwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL01h a2VmaWxlIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+IGluZGV4IDNkYzBmMDIuLmNjMGRmMWVm IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL2h3 bW9uL01ha2VmaWxlCj4gQEAgLTEzNSw2ICsxMzUsNyBAQCBvYmotJChDT05GSUdfU0VOU09SU19T TVNDNDdNMTkyKSs9IHNtc2M0N20xOTIubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfQU1DNjgy MSkJKz0gYW1jNjgyMS5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19USE1DNTApCSs9IHRobWM1 MC5vCj4gICBvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpCSs9IHRtcDEwMi5vCj4gK29iai0k KENPTkZJR19TRU5TT1JTX1RNUDEwMykJKz0gdG1wMTAzLm8KPiAgIG9iai0kKENPTkZJR19TRU5T T1JTX1RNUDQwMSkJKz0gdG1wNDAxLm8KPiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkJ Kz0gdG1wNDIxLm8KPiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RXTDQwMzBfTUFEQykrPSB0d2w0 MDMwLW1hZGMtaHdtb24ubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jIGIv ZHJpdmVycy9od21vbi90bXAxMDMuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAw MDAwMC4uZTY5ZGJjYQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEw My5jCj4gQEAgLTAsMCArMSwyMDUgQEAKPiArLyoKPiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1Q MTAzIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPiArICogQ29weXJpZ2h0IChDKSAy MDE0IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+ICsgKgo+ICsgKiBCYXNlZCBvbjoKPiAr ICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAyIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2 ZXIKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBLaW5nIDxzZmtpbmdAZmR3 ZGMuY29tPgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQo+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQo+ICsgKiB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvcgo+ICsgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgo+ICsgKgo+ ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs IGJlIHVzZWZ1bCwKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+ICsgKgo+ICsgKi8KPiArCj4gKyNpbmNsdWRl IDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KPiArI2luY2x1ZGUg PGxpbnV4L3NsYWIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvaHdtb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2ppZmZpZXMuaD4KPiArI2luY2x1ZGUg PGxpbnV4L3JlZ21hcC5oPgo+ICsKPiArI2RlZmluZSBUTVAxMDNfVEVNUF9SRUcJCTB4MDAKPiAr I2RlZmluZSBUTVAxMDNfQ09ORl9SRUcJCTB4MDEKPiArI2RlZmluZSBUTVAxMDNfVExPV19SRUcJ CTB4MDIKPiArI2RlZmluZSBUTVAxMDNfVEhJR0hfUkVHCTB4MDMKPiArCj4gKyNkZWZpbmUgVE1Q MTAzX0NPTkZfTTAJCTB4MDEKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9NMQkJMHgwMgo+ICsjZGVm aW5lIFRNUDEwM19DT05GX0xDCQkweDA0Cj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwJCTB4MDgK PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GSAkJMHgxMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NS MAkJMHgyMAo+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMQkJMHg0MAo+ICsjZGVmaW5lIFRNUDEw M19DT05GX0lECQkweDgwCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfU0QJCShUTVAxMDNfQ09ORl9N MSkKPiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRF9NQVNLCShUTVAxMDNfQ09ORl9NMCB8IFRNUDEw M19DT05GX00xKQo+ICsKPiArI2RlZmluZSBUTVAxMDNfQ09ORklHCQkoVE1QMTAzX0NPTkZfQ1Ix IHwgVE1QMTAzX0NPTkZfTTEpCj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJR19NQVNLCShUTVAxMDNf Q09ORl9DUjAgfCBUTVAxMDNfQ09ORl9DUjEgfCBcCj4gKwkJCQkgVE1QMTAzX0NPTkZfTTAgfCBU TVAxMDNfQ09ORl9NMSkKPiArCj4gK3N0YXRpYyBpbmxpbmUgaW50IHRtcDEwM19yZWdfdG9fbWMo czggdmFsKQo+ICt7Cj4gKwlyZXR1cm4gdmFsICogMTAwMDsKPiArfQo+ICsKPiArc3RhdGljIGlu bGluZSB1OCB0bXAxMDNfbWNfdG9fcmVnKGludCB2YWwpCj4gK3sKPiArCXJldHVybiBESVZfUk9V TkRfQ0xPU0VTVCh2YWwsIDEwMDApOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNf c2hvd190ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCXN0cnVjdCBkZXZpY2VfYXR0cmli dXRlICphdHRyLAo+ICsJCQkJY2hhciAqYnVmKQo+ICt7Cj4gKwlzdHJ1Y3Qgc2Vuc29yX2Rldmlj ZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPiArCXN0cnVjdCBy ZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJdW5zaWduZWQgaW50IHJl Z3ZhbDsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gcmVnbWFwX3JlYWQocmVnbWFwLCBzZGEt PmluZGV4LCAmcmVndmFsKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ ICsJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIHRtcDEwM19yZWdfdG9fbWMocmVndmFsKSk7 Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90IHRtcDEwM19zZXRfdGVtcChzdHJ1Y3QgZGV2aWNl ICpkZXYsCj4gKwkJCSAgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJ ICAgICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQo+ICt7Cj4gKwlzdHJ1Y3Qgc2Vu c29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPiAr CXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJbG9uZyB2 YWw7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmIChrc3RydG9sKGJ1ZiwgMTAsICZ2YWwpIDwgMCkK PiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwl2YWwgPSBjbGFtcF92YWwodmFsLCAtNTUwMDAs IDEyNzAwMCk7Cj4gKwlyZXQgPSByZWdtYXBfd3JpdGUocmVnbWFwLCBzZGEtPmluZGV4LCB0bXAx MDNfbWNfdG9fcmVnKHZhbCkpOwo+ICsJcmV0dXJuIHJldCA/IHJldCA6IGNvdW50Owo+ICt9Cj4g Kwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAx MDNfc2hvd190ZW1wLCBOVUxMICwKPiArCQkJICBUTVAxMDNfVEVNUF9SRUcpOwo+ICsKPiArc3Rh dGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9taW4sIFNfSVdVU1IgfCBTX0lSVUdPLCB0bXAx MDNfc2hvd190ZW1wLAo+ICsJCQkgIHRtcDEwM19zZXRfdGVtcCwgVE1QMTAzX1RMT1dfUkVHKTsK PiArCj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19J UlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPiArCQkJICB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19U SElHSF9SRUcpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRtcDEwM19hdHRyc1td ID0gewo+ICsJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+ICsJ JnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9taW4uZGV2X2F0dHIuYXR0ciwKPiArCSZzZW5zb3JfZGV2 X2F0dHJfdGVtcDFfbWF4LmRldl9hdHRyLmF0dHIsCj4gKwlOVUxMCj4gK307Cj4gK0FUVFJJQlVU RV9HUk9VUFModG1wMTAzKTsKPiArCj4gK3N0YXRpYyBib29sIHRtcDEwM19yZWdtYXBfaXNfdm9s YXRpbGUoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgcmVnKQo+ICt7Cj4gKwlyZXR1 cm4gcmVnID09IFRNUDEwM19URU1QX1JFRzsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCByZWdt YXBfY29uZmlnIHRtcDEwM19yZWdtYXBfY29uZmlnID0gewo+ICsJLnJlZ19iaXRzID0gOCwKPiAr CS52YWxfYml0cyA9IDgsCj4gKwkubWF4X3JlZ2lzdGVyID0gVE1QMTAzX1RISUdIX1JFRywKPiAr CS52b2xhdGlsZV9yZWcgPSB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxlLAo+ICt9Owo+ICsKPiAr c3RhdGljIGludCB0bXAxMDNfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiArCQkJ Y29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQo+ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpk ZXYgPSAmY2xpZW50LT5kZXY7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7Cj4gKwlzdHJ1 Y3QgcmVnbWFwICpyZWdtYXA7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmICghaTJjX2NoZWNrX2Z1 bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+ICsJCQkJICAgICBJMkNfRlVOQ19TTUJVU19C WVRFX0RBVEEpKSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYsCj4gKwkJCSJhZGFwdGVyIGRv ZXNuJ3Qgc3VwcG9ydCBTTUJ1cyBieXRlIHRyYW5zYWN0aW9uc1xuIik7Cj4gKwkJcmV0dXJuIC1F Tk9ERVY7Cj4gKwl9Cj4gKwo+ICsJcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9pMmMoY2xpZW50 LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOwo+ICsJaWYgKElTX0VSUihyZWdtYXApKSB7Cj4gKwkJ ZGV2X2VycihkZXYsICJmYWlsZWQgdG8gYWxsb2NhdGUgcmVnaXN0ZXIgbWFwXG4iKTsKPiArCQly ZXR1cm4gUFRSX0VSUihyZWdtYXApOwo+ICsJfQo+ICsKPiArCXJldCA9IHJlZ21hcF91cGRhdGVf Yml0cyhyZWdtYXAsIFRNUDEwM19DT05GX1JFRywgVE1QMTAzX0NPTkZJR19NQVNLLAo+ICsJCQkJ IFRNUDEwM19DT05GSUcpOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKCZjbGllbnQt PmRldiwgImVycm9yIHdyaXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPiArCQlyZXR1cm4gcmV0 Owo+ICsJfQo+ICsKPiArCWh3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dy b3VwcyhkZXYsIGNsaWVudC0+bmFtZSwKPiArCQkJCQkJICAgICAgcmVnbWFwLCB0bXAxMDNfZ3Jv dXBzKTsKPiArCXJldHVybiBQVFJfRVJSX09SX1pFUk8oaHdtb25fZGV2KTsKPiArfQo+ICsKPiAr I2lmZGVmIENPTkZJR19QTQo+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0cnVjdCBkZXZp Y2UgKmRldikKPiArewo+ICsJc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRh KGRldik7Cj4gKwo+ICsJcmV0dXJuIHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAsIFRNUDEwM19D T05GX1JFRywKPiArCQkJCSAgVE1QMTAzX0NPTkZfU0RfTUFTSywgMCk7Cj4gK30KPiArCj4gK3N0 YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVj dCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsKPiArCXJldHVybiBy ZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsCj4gKwkJCQkgIFRNUDEw M19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0 IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+ICsJLnN1c3BlbmQJPSB0 bXAxMDNfc3VzcGVuZCwKPiArCS5yZXN1bWUJCT0gdG1wMTAzX3Jlc3VtZSwKPiArfTsKPiArCj4g KyNkZWZpbmUgVE1QMTAzX0RFVl9QTV9PUFMgKCZ0bXAxMDNfZGV2X3BtX29wcykKPiArI2Vsc2UK PiArI2RlZmluZQlUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4gKyNlbmRpZiAvKiBDT05GSUdfUE0g Ki8KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCB0bXAxMDNfaWRbXSA9 IHsKPiArCXsgInRtcDEwMyIsIDAgfSwKPiArCXsgfQo+ICt9OwoKSW4gdGhlIGJpbmRpbmdzIHlv dSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxlIHByb3BlcnR5IGFzIDogdGksdG1wMTAzLCBidXQg aGVyZSBvbmx5IHRtcDEwMy4KCkluc3RlYWQgb2YgdXNpbmcgdGhlIGkyY19kZXZpY2VfaWQgc3Ry dWN0ICwgdXNlIG9mX2RldmljZV9pZCBzdHJ1Y3QgZm9yIGdpdmluZyB0aGUKY29tcGF0aWJsZSBw cm9wZXJ0eSB2YWx1ZS4KY29tcGF0YmxlID0gIjxtYW51ZmFjdHVyZXI+LDxtb2RlbD4iCgo+ICtN T0RVTEVfREVWSUNFX1RBQkxFKGkyYywgdG1wMTAzX2lkKTsKPiArK3N0YXRpYyBzdHJ1Y3QgaTJj X2RyaXZlciB0bXAxMDNfZHJpdmVyID0gewo+ICsJLmRyaXZlciA9IHsKPiArCQkubmFtZQk9ICJ0 bXAxMDMiLAo+ICsJCS5wbQk9IFRNUDEwM19ERVZfUE1fT1BTLAo+ICsJfSwKPiArCS5wcm9iZQkJ PSB0bXAxMDNfcHJvYmUsCj4gKwkuaWRfdGFibGUJPSB0bXAxMDNfaWQsCj4gK307Cj4gKwo+ICtt b2R1bGVfaTJjX2RyaXZlcih0bXAxMDNfZHJpdmVyKTsKPiArCj4gK01PRFVMRV9BVVRIT1IoIkhl aWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPiIpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIlRleGFz IEluc3RydW1lbnRzIFRNUDEwMyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyIik7Cj4gK01PRFVM RV9MSUNFTlNFKCJHUEwiKTsKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMu b3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNv cnM ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 5:58 ` [lm-sensors] " Varka Bhadram @ 2014-06-18 6:12 ` Guenter Roeck -1 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 6:12 UTC (permalink / raw) To: Varka Bhadram, Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland T24gMDYvMTcvMjAxNCAxMDo0NiBQTSwgVmFya2EgQmhhZHJhbSB3cm90ZToKPiBIaSwKPgo+IE9u IDA2LzE4LzIwMTQgMTE6MDcgQU0sIEhlaWtvIFNjaG9jaGVyIHdyb3RlOgo+PiBEcml2ZXIgZm9y IHRoZSBUSSBUTVAxMDMuCj4+Cj4+IFRoZSBUSSBUTVAxMDMgaXMgc2ltaWxhciB0byB0aGUgVE1Q MTAyLiAgSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4gYnkgaGF2aW5nIG9ubHkgOCBiaXQg cmVnaXN0ZXJzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5k ZT4KPj4KPj4gLS0tCj4+Cj4+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4K Pj4gQ2M6IEd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVzLm5ldD4KPj4gQ2M6IGxpbnV4LWtl cm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4gQ2M6IGRldmljZXRyZWVAdmdlci5rZXJuZWwub3JnCj4+ IENjOiBsaW51eC1kb2NAdmdlci5rZXJuZWwub3JnCj4+IENjOiBNYXJrIFJ1dGxhbmQgPG1hcmsu cnV0bGFuZEBhcm0uY29tPgo+Pgo+PiAtIGNoYW5nZSBmb3IgdjI6Cj4+ICAgIC0gYWRkIGNvbW1l bnRzIGZyb20gR3VlbnRlclJvZWNrOgo+PiAgICAgIC0gcmVtb3ZlIENjIGZyb20gY29tbWl0IHN1 YmplY3QKPj4gICAgICAtIGFkZCBkZXZpY2V0cmVlIG1haW50YWluZXIKPj4gICAgICAtIG1vdmUg RG9jdW1lbnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+PiAgICAgIC0gcmVt b3ZlIGRldmljZXRyZWUgYmluZGluZ3MgZnJvbSBEb2N1bWVudGF0aW9uCj4+ICAgICAgLSBhZGQg Y29tcGF0aWJsZSBzdHJpbmcgdG8KPj4gICAgICAgICJEb2N1bWVudGF0aW9uL2RldmljZXRyZWUv YmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQiCj4+ICAgICAgLSByZW1vdmUgQ2FtZWxD YXNlCj4+ICAgICAgLSBmaXggQ29kaW5nc3R5bGUgaXNzdWVzCj4+ICAgICAgLSB1c2UgQVRUUklC VVRFX0dST1VQUyBhbmQgZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoKQo+ PiAgICAgIC0gcmVtb3ZlIHVuc3VzZWQgZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQo+PiAg ICAgIC0gcmVzdG9yZSBjb25maWcgcmVnaXN0ZXIgd2hlbiBleGl0KCkKPj4gICAgICAtIHVzZSBy ZWdtYXAKPj4gLSBjaGFuZ2VzIGZvciB2MzoKPj4gICAgYWdhaW4gYSBsb3Qgb2YgZmFudGFzdGlj IHRpcHMgaG93IHRvIHVzZSByZWdtYXAgZWZmaWNpZW50bHkKPj4gICAgZnJvbSBHdWVudGVyIFJv ZWNrOgo+PiAgICAtIGdldCByaWQgb2YgInN0cnVjdCB0bXAxMDMiCj4+ICAgIC0gZ2V0IHJpZCBv ZiAic3RhdGljIGNvbnN0IHU4IHRtcDEwM19yZWdbXSIKPj4gICAgLSBnZXQgcmlkIG9mIG11dGV4 IGxvY2sKPj4gICAgLSBkcm9wIGNvbmZpZ19vcmlnIGVudGlyZWx5Cj4+ICAgIC0gdXNlIHJlZ21h cF91cGRhdGVfYml0cygpCj4+IC0gY2hhbmdlcyBmb3IgdjQ6Cj4+ICAgIC0gYWRkIGNvbW1lbnQg ZnJvbSBHdWVudGVyIFJvZWNrOgo+PiAgICAgIGRlZmluZSBUTVAxMDNfQ09ORklHX01BU0sgYW5k IFRNUDEwM19DT05GX1NEX01BU0sKPj4gICAgICBzZXBhcmF0ZWx5IHRvIGVuc3VyZSB5b3UgY2F0 Y2ggYWxsIHRoZSB0by1iZS1jbGVhcmVkIGJpdHMuCj4+IC0gY2hhbmdlcyBmb3IgdjU6Cj4+ICAg IGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoKPj4gICAgLSB1c2UgIiNkZWZpbmUgVE1Q MTAzX0NPTkZfU0QgVE1QMTAzX0NPTkZfTTEiCj4+ICAgIGFkZCBjb21tZW50IGZyb20gTWFyayBS dXRsYW5kOgo+PiAgICAtIHVzZSBmdWxsIHN0cmluZyBmb3IgRFQgY29tcGF0aWJsZSBzdHJpbmcg bWF0Y2hpbmcsIGluc3RlYWQgb2YKPj4gICAgICBEUklWRVJfTkFNRS4gR2V0IHJpZCBjb21wbGV0 ZSBvZiBEUklWRVJfTkFNRSBkZWZpbmUuCj4+Cj4+ICAgLi4uL2RldmljZXRyZWUvYmluZGluZ3Mv aTJjL3RyaXZpYWwtZGV2aWNlcy50eHQgICAgfCAgIDEgKwo+PiAgIERvY3VtZW50YXRpb24vaHdt b24vdG1wMTAzICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDI4ICsrKwo+PiAgIGRyaXZlcnMv aHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDEwICsKPj4gICBk cml2ZXJzL2h3bW9uL01ha2VmaWxlICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMSAr Cj4+ICAgZHJpdmVycy9od21vbi90bXAxMDMuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAyMDUgKysrKysrKysrKysrKysrKysrKysrCj4+ICAgNSBmaWxlcyBjaGFuZ2VkLCAyNDUgaW5z ZXJ0aW9ucygrKQo+PiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2h3bW9uL3Rt cDEwMwo+PiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+Cj4+ IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZp YWwtZGV2aWNlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3Ry aXZpYWwtZGV2aWNlcy50eHQKPj4gaW5kZXggYmVmODZlNS4uZmM5NDRlMCAxMDA2NDQKPj4gLS0t IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMu dHh0Cj4+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlh bC1kZXZpY2VzLnR4dAo+PiBAQCAtODMsNSArODMsNiBAQCBzdG0sbTQxdDgwICAgICAgICBNNDFU ODAgLSBTRVJJQUwgQUNDRVNTIFJUQyBXSVRIIEFMQVJNUwo+PiAgIHRhb3MsdHNsMjU1MCAgICAg ICAgQW1iaWVudCBMaWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJm YWNlCj4+ICAgdGksdHNjMjAwMyAgICAgICAgSTJDIFRvdWNoLVNjcmVlbiBDb250cm9sbGVyCj4+ ICAgdGksdG1wMTAyICAgICAgICBMb3cgUG93ZXIgRGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3Ig d2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4+ICt0aSx0bXAxMDMgICAgICAg IExvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3byBXaXJl IFNlcmlhbCBJbnRlcmZhY2UKPj4gICB0aSx0bXAyNzUgICAgICAgIERpZ2l0YWwgVGVtcGVyYXR1 cmUgU2Vuc29yCj4+ICAgd2luYm9uZCx3cGN0MzAxICAgICAgICBpMmMgdHJ1c3RlZCBwbGF0Zm9y bSBtb2R1bGUgKFRQTSkKPj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdtb24vdG1wMTAz IGIvRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4g aW5kZXggMDAwMDAwMC4uZWMwMGExNQo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL0RvY3VtZW50 YXRpb24vaHdtb24vdG1wMTAzCj4+IEBAIC0wLDAgKzEsMjggQEAKPj4gK0tlcm5lbCBkcml2ZXIg dG1wMTAzCj4+ICs9PT09PT09PT09PT09PT09PT09PQo+PiArCj4+ICtTdXBwb3J0ZWQgY2hpcHM6 Cj4+ICsgICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4+ICsgICAgUHJlZml4OiAndG1wMTAz Jwo+PiArICAgIEFkZHJlc3NlcyBzY2FubmVkOiBub25lCj4+ICsgICAgUHJvZHVjdCBpbmZvIGFu ZCBkYXRhc2hlZXQ6IGh0dHA6Ly93d3cudGkuY29tL3Byb2R1Y3QvdG1wMTAzCj4+ICsKPj4gK0F1 dGhvcjoKPj4gKyAgICBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPj4gKwo+PiArRGVzY3Jp cHRpb24KPj4gKy0tLS0tLS0tLS0tCj4+ICsKPj4gK1RoZSBUTVAxMDMgaXMgYSBkaWdpdGFsIG91 dHB1dCB0ZW1wZXJhdHVyZSBzZW5zb3IgaW4gYSBmb3VyLWJhbGwKPj4gK3dhZmVyIGNoaXAtc2Nh bGUgcGFja2FnZSAoV0NTUCkuIFRoZSBUTVAxMDMgaXMgY2FwYWJsZSBvZiByZWFkaW5nCj4+ICt0 ZW1wZXJhdHVyZXMgdG8gYSByZXNvbHV0aW9uIG9mIDHCsEMuIFRoZSBUTVAxMDMgaXMgc3BlY2lm aWVkIGZvcgo+PiArb3BlcmF0aW9uIG92ZXIgYSB0ZW1wZXJhdHVyZSByYW5nZSBvZiDigJM0MMKw QyB0byArMTI1wrBDLgo+PiArCj4+ICtSZXNvbHV0aW9uOiA4IEJpdHMKPj4gK0FjY3VyYWN5OiDC sTHCsEMgVHlwICjigJMxMMKwQyB0byArMTAwwrBDKQo+PiArCj4+ICtUaGUgZHJpdmVyIHByb3Zp ZGVzIHRoZSBjb21tb24gc3lzZnMtaW50ZXJmYWNlIGZvciB0ZW1wZXJhdHVyZXMgKHNlZQo+PiAr RG9jdW1lbnRhdGlvbi9od21vbi9zeXNmcy1pbnRlcmZhY2UgdW5kZXIgVGVtcGVyYXR1cmVzKS4K Pj4gKwo+PiArUGxlYXNlIHJlZmVyIGhvdyB0byBpbnN0YW50aWF0ZSB0aGlzIGRyaXZlcjoKPj4g K0RvY3VtZW50YXRpb24vaTJjL2luc3RhbnRpYXRpbmctZGV2aWNlcwo+PiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21vbi9LY29uZmlnCj4+IGluZGV4IDA4 NTMxYTEuLmM4ODJkNGIgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+PiAr KysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKPj4gQEAgLTEzOTEsNiArMTM5MSwxNiBAQCBjb25m aWcgU0VOU09SU19UTVAxMDIKPj4gICAgICAgICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWls dCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCj4+ICAgICAgICAgd2lsbCBiZSBjYWxs ZWQgdG1wMTAyLgo+PiArY29uZmlnIFNFTlNPUlNfVE1QMTAzCj4+ICsgICAgdHJpc3RhdGUgIlRl eGFzIEluc3RydW1lbnRzIFRNUDEwMyIKPj4gKyAgICBkZXBlbmRzIG9uIEkyQwo+PiArICAgIGhl bHAKPj4gKyAgICAgIElmIHlvdSBzYXkgeWVzIGhlcmUgeW91IGdldCBzdXBwb3J0IGZvciBUZXhh cyBJbnN0cnVtZW50cyBUTVAxMDMKPj4gKyAgICAgIHNlbnNvciBjaGlwcy4KPj4gKwo+PiArICAg ICAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuICBJZiBzbywgdGhl IG1vZHVsZQo+PiArICAgICAgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+PiArCj4+ICAgY29uZmln IFNFTlNPUlNfVE1QNDAxCj4+ICAgICAgIHRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBUTVA0 MDEgYW5kIGNvbXBhdGlibGVzIgo+PiAgICAgICBkZXBlbmRzIG9uIEkyQwo+PiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9od21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKPj4gaW5k ZXggM2RjMGYwMi4uY2MwZGYxZWYgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZp bGUKPj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+PiBAQCAtMTM1LDYgKzEzNSw3IEBA IG9iai0kKENPTkZJR19TRU5TT1JTX1NNU0M0N00xOTIpKz0gc21zYzQ3bTE5Mi5vCj4+ICAgb2Jq LSQoQ09ORklHX1NFTlNPUlNfQU1DNjgyMSkgICAgKz0gYW1jNjgyMS5vCj4+ICAgb2JqLSQoQ09O RklHX1NFTlNPUlNfVEhNQzUwKSAgICArPSB0aG1jNTAubwo+PiAgIG9iai0kKENPTkZJR19TRU5T T1JTX1RNUDEwMikgICAgKz0gdG1wMTAyLm8KPj4gK29iai0kKENPTkZJR19TRU5TT1JTX1RNUDEw MykgICAgKz0gdG1wMTAzLm8KPj4gICBvYmotJChDT05GSUdfU0VOU09SU19UTVA0MDEpICAgICs9 IHRtcDQwMS5vCj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIxKSAgICArPSB0bXA0MjEu bwo+PiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RXTDQwMzBfTUFEQykrPSB0d2w0MDMwLW1hZGMt aHdtb24ubwo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi90bXAxMDMuYyBiL2RyaXZlcnMv aHdtb24vdG1wMTAzLmMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAwMC4u ZTY5ZGJjYQo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMK Pj4gQEAgLTAsMCArMSwyMDUgQEAKPj4gKy8qCj4+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAx MDMgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZlcgo+PiArICogQ29weXJpZ2h0IChDKSAy MDE0IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+PiArICoKPj4gKyAqIEJhc2VkIG9uOgo+ PiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAyIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBk cml2ZXIKPj4gKyAqCj4+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU3RldmVuIEtpbmcgPHNma2lu Z0BmZHdkYy5jb20+Cj4+ICsgKgo+PiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKPj4gKyAqIGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 Cj4+ICsgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9m IHRoZSBMaWNlbnNlLCBvcgo+PiArICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KPj4gKyAqCj4+ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKPj4gKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCj4+ICsgKiBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4+ICsgKiBH TlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+PiArICoKPj4gKyAq Lwo+PiArCj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgv aW5pdC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9p MmMuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2h3 bW9uLXN5c2ZzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5jbHVkZSA8bGlu dXgvbXV0ZXguaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPj4gKyNpbmNsdWRlIDxs aW51eC9qaWZmaWVzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4+ICsKPj4gKyNk ZWZpbmUgVE1QMTAzX1RFTVBfUkVHICAgICAgICAweDAwCj4+ICsjZGVmaW5lIFRNUDEwM19DT05G X1JFRyAgICAgICAgMHgwMQo+PiArI2RlZmluZSBUTVAxMDNfVExPV19SRUcgICAgICAgIDB4MDIK Pj4gKyNkZWZpbmUgVE1QMTAzX1RISUdIX1JFRyAgICAweDAzCj4+ICsKPj4gKyNkZWZpbmUgVE1Q MTAzX0NPTkZfTTAgICAgICAgIDB4MDEKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTTEgICAgICAg IDB4MDIKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTEMgICAgICAgIDB4MDQKPj4gKyNkZWZpbmUg VE1QMTAzX0NPTkZfRkwgICAgICAgIDB4MDgKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkggICAg ICAgIDB4MTAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwICAgICAgICAweDIwCj4+ICsjZGVm aW5lIFRNUDEwM19DT05GX0NSMSAgICAgICAgMHg0MAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9J RCAgICAgICAgMHg4MAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRCAgICAgICAgKFRNUDEwM19D T05GX00xKQo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRF9NQVNLICAgIChUTVAxMDNfQ09ORl9N MCB8IFRNUDEwM19DT05GX00xKQo+PiArCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GSUcgICAgICAg IChUTVAxMDNfQ09ORl9DUjEgfCBUTVAxMDNfQ09ORl9NMSkKPj4gKyNkZWZpbmUgVE1QMTAzX0NP TkZJR19NQVNLICAgIChUTVAxMDNfQ09ORl9DUjAgfCBUTVAxMDNfQ09ORl9DUjEgfCBcCj4+ICsg ICAgICAgICAgICAgICAgIFRNUDEwM19DT05GX00wIHwgVE1QMTAzX0NPTkZfTTEpCj4+ICsKPj4g K3N0YXRpYyBpbmxpbmUgaW50IHRtcDEwM19yZWdfdG9fbWMoczggdmFsKQo+PiArewo+PiArICAg IHJldHVybiB2YWwgKiAxMDAwOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW5saW5lIHU4IHRtcDEw M19tY190b19yZWcoaW50IHZhbCkKPj4gK3sKPj4gKyAgICByZXR1cm4gRElWX1JPVU5EX0NMT1NF U1QodmFsLCAxMDAwKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3Nob3df dGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4+ICsgICAgICAgICAgICAgICAgc3RydWN0IGRldmlj ZV9hdHRyaWJ1dGUgKmF0dHIsCj4+ICsgICAgICAgICAgICAgICAgY2hhciAqYnVmKQo+PiArewo+ PiArICAgIHN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAqc2RhID0gdG9fc2Vuc29yX2Rl dl9hdHRyKGF0dHIpOwo+PiArICAgIHN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2 ZGF0YShkZXYpOwo+PiArICAgIHVuc2lnbmVkIGludCByZWd2YWw7Cj4+ICsgICAgaW50IHJldDsK Pj4gKwo+PiArICAgIHJldCA9IHJlZ21hcF9yZWFkKHJlZ21hcCwgc2RhLT5pbmRleCwgJnJlZ3Zh bCk7Cj4+ICsgICAgaWYgKHJldCA8IDApCj4+ICsgICAgICAgIHJldHVybiByZXQ7Cj4+ICsKPj4g KyAgICByZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgdG1wMTAzX3JlZ190b19tYyhyZWd2YWwp KTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3NldF90ZW1wKHN0cnVjdCBk ZXZpY2UgKmRldiwKPj4gKyAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0 ZSAqYXR0ciwKPj4gKyAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBj b3VudCkKPj4gK3sKPj4gKyAgICBzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9 IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4gKyAgICBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAg PSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4gKyAgICBsb25nIHZhbDsKPj4gKyAgICBpbnQgcmV0 Owo+PiArCj4+ICsgICAgaWYgKGtzdHJ0b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+PiArICAgICAg ICByZXR1cm4gLUVJTlZBTDsKPj4gKwo+PiArICAgIHZhbCA9IGNsYW1wX3ZhbCh2YWwsIC01NTAw MCwgMTI3MDAwKTsKPj4gKyAgICByZXQgPSByZWdtYXBfd3JpdGUocmVnbWFwLCBzZGEtPmluZGV4 LCB0bXAxMDNfbWNfdG9fcmVnKHZhbCkpOwo+PiArICAgIHJldHVybiByZXQgPyByZXQgOiBjb3Vu dDsKPj4gK30KPj4gKwo+PiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwg U19JUlVHTywgdG1wMTAzX3Nob3dfdGVtcCwgTlVMTCAsCj4+ICsgICAgICAgICAgICAgIFRNUDEw M19URU1QX1JFRyk7Cj4+ICsKPj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWlu LCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPj4gKyAgICAgICAgICAgICAg dG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVExPV19SRUcpOwo+PiArCj4+ICtzdGF0aWMgU0VOU09S X0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEwM19zaG93X3Rl bXAsCj4+ICsgICAgICAgICAgICAgIHRtcDEwM19zZXRfdGVtcCwgVE1QMTAzX1RISUdIX1JFRyk7 Cj4+ICsKPj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNfYXR0cnNbXSA9IHsKPj4g KyAgICAmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIsCj4+ICsgICAg JnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9taW4uZGV2X2F0dHIuYXR0ciwKPj4gKyAgICAmc2Vuc29y X2Rldl9hdHRyX3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAo+PiArICAgIE5VTEwKPj4gK307Cj4+ ICtBVFRSSUJVVEVfR1JPVVBTKHRtcDEwMyk7Cj4+ICsKPj4gK3N0YXRpYyBib29sIHRtcDEwM19y ZWdtYXBfaXNfdm9sYXRpbGUoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgcmVnKQo+ PiArewo+PiArICAgIHJldHVybiByZWcgPT0gVE1QMTAzX1RFTVBfUkVHOwo+PiArfQo+PiArCj4+ ICtzdGF0aWMgc3RydWN0IHJlZ21hcF9jb25maWcgdG1wMTAzX3JlZ21hcF9jb25maWcgPSB7Cj4+ ICsgICAgLnJlZ19iaXRzID0gOCwKPj4gKyAgICAudmFsX2JpdHMgPSA4LAo+PiArICAgIC5tYXhf cmVnaXN0ZXIgPSBUTVAxMDNfVEhJR0hfUkVHLAo+PiArICAgIC52b2xhdGlsZV9yZWcgPSB0bXAx MDNfcmVnbWFwX2lzX3ZvbGF0aWxlLAo+PiArfTsKPj4gKwo+PiArc3RhdGljIGludCB0bXAxMDNf cHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPj4gKyAgICAgICAgICAgIGNvbnN0IHN0 cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPj4gK3sKPj4gKyAgICBzdHJ1Y3QgZGV2aWNlICpkZXYg PSAmY2xpZW50LT5kZXY7Cj4+ICsgICAgc3RydWN0IGRldmljZSAqaHdtb25fZGV2Owo+PiArICAg IHN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPj4gKyAgICBpbnQgcmV0Owo+PiArCj4+ICsgICAgaWYg KCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0ZXIsCj4+ICsgICAgICAgICAg ICAgICAgICAgICBJMkNfRlVOQ19TTUJVU19CWVRFX0RBVEEpKSB7Cj4+ICsgICAgICAgIGRldl9l cnIoJmNsaWVudC0+ZGV2LAo+PiArICAgICAgICAgICAgImFkYXB0ZXIgZG9lc24ndCBzdXBwb3J0 IFNNQnVzIGJ5dGUgdHJhbnNhY3Rpb25zXG4iKTsKPj4gKyAgICAgICAgcmV0dXJuIC1FTk9ERVY7 Cj4+ICsgICAgfQo+PiArCj4+ICsgICAgcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9pMmMoY2xp ZW50LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOwo+PiArICAgIGlmIChJU19FUlIocmVnbWFwKSkg ewo+PiArICAgICAgICBkZXZfZXJyKGRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSByZWdpc3RlciBt YXBcbiIpOwo+PiArICAgICAgICByZXR1cm4gUFRSX0VSUihyZWdtYXApOwo+PiArICAgIH0KPj4g Kwo+PiArICAgIHJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAsIFRNUDEwM19DT05GX1JF RywgVE1QMTAzX0NPTkZJR19NQVNLLAo+PiArICAgICAgICAgICAgICAgICBUTVAxMDNfQ09ORklH KTsKPj4gKyAgICBpZiAocmV0IDwgMCkgewo+PiArICAgICAgICBkZXZfZXJyKCZjbGllbnQtPmRl diwgImVycm9yIHdyaXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyAgICAgICAgcmV0dXJu IHJldDsKPj4gKyAgICB9Cj4+ICsKPj4gKyAgICBod21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVn aXN0ZXJfd2l0aF9ncm91cHMoZGV2LCBjbGllbnQtPm5hbWUsCj4+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZWdtYXAsIHRtcDEwM19ncm91cHMpOwo+PiArICAgIHJldHVybiBQVFJf RVJSX09SX1pFUk8oaHdtb25fZGV2KTsKPj4gK30KPj4gKwo+PiArI2lmZGVmIENPTkZJR19QTQo+ PiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICt7Cj4+ ICsgICAgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+ICsK Pj4gKyAgICByZXR1cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVH LAo+PiArICAgICAgICAgICAgICAgICAgVE1QMTAzX0NPTkZfU0RfTUFTSywgMCk7Cj4+ICt9Cj4+ ICsKPj4gK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICt7 Cj4+ICsgICAgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+ ICsKPj4gKyAgICByZXR1cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZf UkVHLAo+PiArICAgICAgICAgICAgICAgICAgVE1QMTAzX0NPTkZfU0RfTUFTSywgVE1QMTAzX0NP TkZfU0QpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgdG1w MTAzX2Rldl9wbV9vcHMgPSB7Cj4+ICsgICAgLnN1c3BlbmQgICAgPSB0bXAxMDNfc3VzcGVuZCwK Pj4gKyAgICAucmVzdW1lICAgICAgICA9IHRtcDEwM19yZXN1bWUsCj4+ICt9Owo+PiArCj4+ICsj ZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCj4+ICsjZWxzZQo+ PiArI2RlZmluZSAgICBUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4+ICsjZW5kaWYgLyogQ09ORklH X1BNICovCj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCB0bXAxMDNf aWRbXSA9IHsKPj4gKyAgICB7ICJ0bXAxMDMiLCAwIH0sCj4+ICsgICAgeyB9Cj4+ICt9Owo+Cj4g SW4gdGhlIGJpbmRpbmdzIHlvdSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxlIHByb3BlcnR5IGFz IDogdGksdG1wMTAzLCBidXQgaGVyZSBvbmx5IHRtcDEwMy4KPgo+IEluc3RlYWQgb2YgdXNpbmcg dGhlIGkyY19kZXZpY2VfaWQgc3RydWN0ICwgdXNlIG9mX2RldmljZV9pZCBzdHJ1Y3QgZm9yIGdp dmluZyB0aGUKPiBjb21wYXRpYmxlIHByb3BlcnR5IHZhbHVlLgo+IGNvbXBhdGJsZSA9ICI8bWFu dWZhY3R1cmVyPiw8bW9kZWw+Igo+CgpOby4gV2UgZG9uJ3QgZG8gdGhhdCBmb3Igb3RoZXIgaTJj IGRyaXZlcnMsIGFuZCB0aGUgaTJjIHN1YnN5c3RlbSBoYW5kbGVzCnRoaXMgY2FzZSwgc28gaXQg ZG9lcyBub3Qgc2Vuc2UgdG8gc3RhcnQgdGhhdCB3aXRoIHRoaXMgZHJpdmVyIGp1c3QKZm9yIHRo ZSBzYWtlIG9mIG1ha2luZyB0aGUgY29kZSBtb3JlIGNvbXBsaWNhdGVkIHRoYW4gaXQgaGFzIHRv IGJlLgoKVGhhbmtzLApHdWVudGVyCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KbG0tc2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5z b3JzLm9yZwpodHRwOi8vbGlzdHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1z ZW5zb3Jz ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 6:12 ` Guenter Roeck 0 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 6:12 UTC (permalink / raw) To: Varka Bhadram, Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/17/2014 10:46 PM, Varka Bhadram wrote: > Hi, > > On 06/18/2014 11:07 AM, Heiko Schocher wrote: >> Driver for the TI TMP103. >> >> The TI TMP103 is similar to the TMP102. It differs from the TMP102 >> by having only 8 bit registers. >> >> Signed-off-by: Heiko Schocher <hs@denx.de> >> >> --- >> >> Cc: Jean Delvare <khali@linux-fr.org> >> Cc: Guenter Roeck <linux@roeck-us.net> >> Cc: linux-kernel@vger.kernel.org >> Cc: devicetree@vger.kernel.org >> Cc: linux-doc@vger.kernel.org >> Cc: Mark Rutland <mark.rutland@arm.com> >> >> - change for v2: >> - add comments from GuenterRoeck: >> - remove Cc from commit subject >> - add devicetree maintainer >> - move Documentation to Documentation/hwmon/tmp103 >> - remove devicetree bindings from Documentation >> - add compatible string to >> "Documentation/devicetree/bindings/i2c/trivial-devices.txt" >> - remove CamelCase >> - fix Codingstyle issues >> - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups() >> - remove unsused define TMP103_CONFIG_RD_ONLY >> - restore config register when exit() >> - use regmap >> - changes for v3: >> again a lot of fantastic tips how to use regmap efficiently >> from Guenter Roeck: >> - get rid of "struct tmp103" >> - get rid of "static const u8 tmp103_reg[]" >> - get rid of mutex lock >> - drop config_orig entirely >> - use regmap_update_bits() >> - changes for v4: >> - add comment from Guenter Roeck: >> define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK >> separately to ensure you catch all the to-be-cleared bits. >> - changes for v5: >> add comment from Guenter Roeck: >> - use "#define TMP103_CONF_SD TMP103_CONF_M1" >> add comment from Mark Rutland: >> - use full string for DT compatible string matching, instead of >> DRIVER_NAME. Get rid complete of DRIVER_NAME define. >> >> .../devicetree/bindings/i2c/trivial-devices.txt | 1 + >> Documentation/hwmon/tmp103 | 28 +++ >> drivers/hwmon/Kconfig | 10 + >> drivers/hwmon/Makefile | 1 + >> drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++ >> 5 files changed, 245 insertions(+) >> create mode 100644 Documentation/hwmon/tmp103 >> create mode 100644 drivers/hwmon/tmp103.c >> >> diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >> index bef86e5..fc944e0 100644 >> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >> @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH ALARMS >> taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface >> ti,tsc2003 I2C Touch-Screen Controller >> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface >> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface >> ti,tmp275 Digital Temperature Sensor >> winbond,wpct301 i2c trusted platform module (TPM) >> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 >> new file mode 100644 >> index 0000000..ec00a15 >> --- /dev/null >> +++ b/Documentation/hwmon/tmp103 >> @@ -0,0 +1,28 @@ >> +Kernel driver tmp103 >> +==================== >> + >> +Supported chips: >> + * Texas Instruments TMP103 >> + Prefix: 'tmp103' >> + Addresses scanned: none >> + Product info and datasheet: http://www.ti.com/product/tmp103 >> + >> +Author: >> + Heiko Schocher <hs@denx.de> >> + >> +Description >> +----------- >> + >> +The TMP103 is a digital output temperature sensor in a four-ball >> +wafer chip-scale package (WCSP). The TMP103 is capable of reading >> +temperatures to a resolution of 1°C. The TMP103 is specified for >> +operation over a temperature range of –40°C to +125°C. >> + >> +Resolution: 8 Bits >> +Accuracy: ±1°C Typ (–10°C to +100°C) >> + >> +The driver provides the common sysfs-interface for temperatures (see >> +Documentation/hwmon/sysfs-interface under Temperatures). >> + >> +Please refer how to instantiate this driver: >> +Documentation/i2c/instantiating-devices >> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig >> index 08531a1..c882d4b 100644 >> --- a/drivers/hwmon/Kconfig >> +++ b/drivers/hwmon/Kconfig >> @@ -1391,6 +1391,16 @@ config SENSORS_TMP102 >> This driver can also be built as a module. If so, the module >> will be called tmp102. >> +config SENSORS_TMP103 >> + tristate "Texas Instruments TMP103" >> + depends on I2C >> + help >> + If you say yes here you get support for Texas Instruments TMP103 >> + sensor chips. >> + >> + This driver can also be built as a module. If so, the module >> + will be called tmp103. >> + >> config SENSORS_TMP401 >> tristate "Texas Instruments TMP401 and compatibles" >> depends on I2C >> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile >> index 3dc0f02..cc0df1ef 100644 >> --- a/drivers/hwmon/Makefile >> +++ b/drivers/hwmon/Makefile >> @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o >> obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o >> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o >> obj-$(CONFIG_SENSORS_TMP102) += tmp102.o >> +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o >> obj-$(CONFIG_SENSORS_TMP401) += tmp401.o >> obj-$(CONFIG_SENSORS_TMP421) += tmp421.o >> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o >> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c >> new file mode 100644 >> index 0000000..e69dbca >> --- /dev/null >> +++ b/drivers/hwmon/tmp103.c >> @@ -0,0 +1,205 @@ >> +/* >> + * Texas Instruments TMP103 SMBus temperature sensor driver >> + * Copyright (C) 2014 Heiko Schocher <hs@denx.de> >> + * >> + * Based on: >> + * Texas Instruments TMP102 SMBus temperature sensor driver >> + * >> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> >> + * >> + * This program is free software; you can redistribute it and/or modify >> + * it under the terms of the GNU General Public License as published by >> + * the Free Software Foundation; either version 2 of the License, or >> + * (at your option) any later version. >> + * >> + * This program is distributed in the hope that it will be useful, >> + * but WITHOUT ANY WARRANTY; without even the implied warranty of >> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> + * GNU General Public License for more details. >> + * >> + */ >> + >> +#include <linux/module.h> >> +#include <linux/init.h> >> +#include <linux/slab.h> >> +#include <linux/i2c.h> >> +#include <linux/hwmon.h> >> +#include <linux/hwmon-sysfs.h> >> +#include <linux/err.h> >> +#include <linux/mutex.h> >> +#include <linux/device.h> >> +#include <linux/jiffies.h> >> +#include <linux/regmap.h> >> + >> +#define TMP103_TEMP_REG 0x00 >> +#define TMP103_CONF_REG 0x01 >> +#define TMP103_TLOW_REG 0x02 >> +#define TMP103_THIGH_REG 0x03 >> + >> +#define TMP103_CONF_M0 0x01 >> +#define TMP103_CONF_M1 0x02 >> +#define TMP103_CONF_LC 0x04 >> +#define TMP103_CONF_FL 0x08 >> +#define TMP103_CONF_FH 0x10 >> +#define TMP103_CONF_CR0 0x20 >> +#define TMP103_CONF_CR1 0x40 >> +#define TMP103_CONF_ID 0x80 >> +#define TMP103_CONF_SD (TMP103_CONF_M1) >> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) >> + >> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) >> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ >> + TMP103_CONF_M0 | TMP103_CONF_M1) >> + >> +static inline int tmp103_reg_to_mc(s8 val) >> +{ >> + return val * 1000; >> +} >> + >> +static inline u8 tmp103_mc_to_reg(int val) >> +{ >> + return DIV_ROUND_CLOSEST(val, 1000); >> +} >> + >> +static ssize_t tmp103_show_temp(struct device *dev, >> + struct device_attribute *attr, >> + char *buf) >> +{ >> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >> + struct regmap *regmap = dev_get_drvdata(dev); >> + unsigned int regval; >> + int ret; >> + >> + ret = regmap_read(regmap, sda->index, ®val); >> + if (ret < 0) >> + return ret; >> + >> + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); >> +} >> + >> +static ssize_t tmp103_set_temp(struct device *dev, >> + struct device_attribute *attr, >> + const char *buf, size_t count) >> +{ >> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >> + struct regmap *regmap = dev_get_drvdata(dev); >> + long val; >> + int ret; >> + >> + if (kstrtol(buf, 10, &val) < 0) >> + return -EINVAL; >> + >> + val = clamp_val(val, -55000, 127000); >> + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); >> + return ret ? ret : count; >> +} >> + >> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , >> + TMP103_TEMP_REG); >> + >> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, TMP103_TLOW_REG); >> + >> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, TMP103_THIGH_REG); >> + >> +static struct attribute *tmp103_attrs[] = { >> + &sensor_dev_attr_temp1_input.dev_attr.attr, >> + &sensor_dev_attr_temp1_min.dev_attr.attr, >> + &sensor_dev_attr_temp1_max.dev_attr.attr, >> + NULL >> +}; >> +ATTRIBUTE_GROUPS(tmp103); >> + >> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg) >> +{ >> + return reg == TMP103_TEMP_REG; >> +} >> + >> +static struct regmap_config tmp103_regmap_config = { >> + .reg_bits = 8, >> + .val_bits = 8, >> + .max_register = TMP103_THIGH_REG, >> + .volatile_reg = tmp103_regmap_is_volatile, >> +}; >> + >> +static int tmp103_probe(struct i2c_client *client, >> + const struct i2c_device_id *id) >> +{ >> + struct device *dev = &client->dev; >> + struct device *hwmon_dev; >> + struct regmap *regmap; >> + int ret; >> + >> + if (!i2c_check_functionality(client->adapter, >> + I2C_FUNC_SMBUS_BYTE_DATA)) { >> + dev_err(&client->dev, >> + "adapter doesn't support SMBus byte transactions\n"); >> + return -ENODEV; >> + } >> + >> + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); >> + if (IS_ERR(regmap)) { >> + dev_err(dev, "failed to allocate register map\n"); >> + return PTR_ERR(regmap); >> + } >> + >> + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, >> + TMP103_CONFIG); >> + if (ret < 0) { >> + dev_err(&client->dev, "error writing config register\n"); >> + return ret; >> + } >> + >> + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, >> + regmap, tmp103_groups); >> + return PTR_ERR_OR_ZERO(hwmon_dev); >> +} >> + >> +#ifdef CONFIG_PM >> +static int tmp103_suspend(struct device *dev) >> +{ >> + struct regmap *regmap = dev_get_drvdata(dev); >> + >> + return regmap_update_bits(regmap, TMP103_CONF_REG, >> + TMP103_CONF_SD_MASK, 0); >> +} >> + >> +static int tmp103_resume(struct device *dev) >> +{ >> + struct regmap *regmap = dev_get_drvdata(dev); >> + >> + return regmap_update_bits(regmap, TMP103_CONF_REG, >> + TMP103_CONF_SD_MASK, TMP103_CONF_SD); >> +} >> + >> +static const struct dev_pm_ops tmp103_dev_pm_ops = { >> + .suspend = tmp103_suspend, >> + .resume = tmp103_resume, >> +}; >> + >> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) >> +#else >> +#define TMP103_DEV_PM_OPS NULL >> +#endif /* CONFIG_PM */ >> + >> +static const struct i2c_device_id tmp103_id[] = { >> + { "tmp103", 0 }, >> + { } >> +}; > > In the bindings you are giving the compatible property as : ti,tmp103, but here only tmp103. > > Instead of using the i2c_device_id struct , use of_device_id struct for giving the > compatible property value. > compatble = "<manufacturer>,<model>" > No. We don't do that for other i2c drivers, and the i2c subsystem handles this case, so it does not sense to start that with this driver just for the sake of making the code more complicated than it has to be. Thanks, Guenter ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 6:12 ` Guenter Roeck @ 2014-06-18 6:30 ` Varka Bhadram -1 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 6:18 UTC (permalink / raw) To: Guenter Roeck, Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/18/2014 11:42 AM, Guenter Roeck wrote: > On 06/17/2014 10:46 PM, Varka Bhadram wrote: >> Hi, >> >> On 06/18/2014 11:07 AM, Heiko Schocher wrote: >>> Driver for the TI TMP103. >>> >>> The TI TMP103 is similar to the TMP102. It differs from the TMP102 >>> by having only 8 bit registers. >>> >>> Signed-off-by: Heiko Schocher <hs@denx.de> >>> >>> --- >>> >>> Cc: Jean Delvare <khali@linux-fr.org> >>> Cc: Guenter Roeck <linux@roeck-us.net> >>> Cc: linux-kernel@vger.kernel.org >>> Cc: devicetree@vger.kernel.org >>> Cc: linux-doc@vger.kernel.org >>> Cc: Mark Rutland <mark.rutland@arm.com> >>> >>> - change for v2: >>> - add comments from GuenterRoeck: >>> - remove Cc from commit subject >>> - add devicetree maintainer >>> - move Documentation to Documentation/hwmon/tmp103 >>> - remove devicetree bindings from Documentation >>> - add compatible string to >>> "Documentation/devicetree/bindings/i2c/trivial-devices.txt" >>> - remove CamelCase >>> - fix Codingstyle issues >>> - use ATTRIBUTE_GROUPS and >>> devm_hwmon_device_register_with_groups() >>> - remove unsused define TMP103_CONFIG_RD_ONLY >>> - restore config register when exit() >>> - use regmap >>> - changes for v3: >>> again a lot of fantastic tips how to use regmap efficiently >>> from Guenter Roeck: >>> - get rid of "struct tmp103" >>> - get rid of "static const u8 tmp103_reg[]" >>> - get rid of mutex lock >>> - drop config_orig entirely >>> - use regmap_update_bits() >>> - changes for v4: >>> - add comment from Guenter Roeck: >>> define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK >>> separately to ensure you catch all the to-be-cleared bits. >>> - changes for v5: >>> add comment from Guenter Roeck: >>> - use "#define TMP103_CONF_SD TMP103_CONF_M1" >>> add comment from Mark Rutland: >>> - use full string for DT compatible string matching, instead of >>> DRIVER_NAME. Get rid complete of DRIVER_NAME define. >>> >>> .../devicetree/bindings/i2c/trivial-devices.txt | 1 + >>> Documentation/hwmon/tmp103 | 28 +++ >>> drivers/hwmon/Kconfig | 10 + >>> drivers/hwmon/Makefile | 1 + >>> drivers/hwmon/tmp103.c | 205 >>> +++++++++++++++++++++ >>> 5 files changed, 245 insertions(+) >>> create mode 100644 Documentation/hwmon/tmp103 >>> create mode 100644 drivers/hwmon/tmp103.c >>> >>> diff --git >>> a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> index bef86e5..fc944e0 100644 >>> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH >>> ALARMS >>> taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire >>> Serial Interface >>> ti,tsc2003 I2C Touch-Screen Controller >>> ti,tmp102 Low Power Digital Temperature Sensor with >>> SMBUS/Two Wire Serial Interface >>> +ti,tmp103 Low Power Digital Temperature Sensor with >>> SMBUS/Two Wire Serial Interface May i know about this binding compatible property ? >>> ti,tmp275 Digital Temperature Sensor >>> winbond,wpct301 i2c trusted platform module (TPM) >>> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 >>> new file mode 100644 >>> index 0000000..ec00a15 >>> --- /dev/null >>> +++ b/Documentation/hwmon/tmp103 >>> @@ -0,0 +1,28 @@ >>> +Kernel driver tmp103 >>> +==================== >>> + >>> +Supported chips: >>> + * Texas Instruments TMP103 >>> + Prefix: 'tmp103' >>> + Addresses scanned: none >>> + Product info and datasheet: http://www.ti.com/product/tmp103 >>> + >>> +Author: >>> + Heiko Schocher <hs@denx.de> >>> + >>> +Description >>> +----------- >>> + >>> +The TMP103 is a digital output temperature sensor in a four-ball >>> +wafer chip-scale package (WCSP). The TMP103 is capable of reading >>> +temperatures to a resolution of 1°C. The TMP103 is specified for >>> +operation over a temperature range of –40°C to +125°C. >>> + >>> +Resolution: 8 Bits >>> +Accuracy: ±1°C Typ (–10°C to +100°C) >>> + >>> +The driver provides the common sysfs-interface for temperatures (see >>> +Documentation/hwmon/sysfs-interface under Temperatures). >>> + >>> +Please refer how to instantiate this driver: >>> +Documentation/i2c/instantiating-devices >>> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig >>> index 08531a1..c882d4b 100644 >>> --- a/drivers/hwmon/Kconfig >>> +++ b/drivers/hwmon/Kconfig >>> @@ -1391,6 +1391,16 @@ config SENSORS_TMP102 >>> This driver can also be built as a module. If so, the module >>> will be called tmp102. >>> +config SENSORS_TMP103 >>> + tristate "Texas Instruments TMP103" >>> + depends on I2C >>> + help >>> + If you say yes here you get support for Texas Instruments TMP103 >>> + sensor chips. >>> + >>> + This driver can also be built as a module. If so, the module >>> + will be called tmp103. >>> + >>> config SENSORS_TMP401 >>> tristate "Texas Instruments TMP401 and compatibles" >>> depends on I2C >>> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile >>> index 3dc0f02..cc0df1ef 100644 >>> --- a/drivers/hwmon/Makefile >>> +++ b/drivers/hwmon/Makefile >>> @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o >>> obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o >>> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o >>> obj-$(CONFIG_SENSORS_TMP102) += tmp102.o >>> +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o >>> obj-$(CONFIG_SENSORS_TMP401) += tmp401.o >>> obj-$(CONFIG_SENSORS_TMP421) += tmp421.o >>> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o >>> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c >>> new file mode 100644 >>> index 0000000..e69dbca >>> --- /dev/null >>> +++ b/drivers/hwmon/tmp103.c >>> @@ -0,0 +1,205 @@ >>> +/* >>> + * Texas Instruments TMP103 SMBus temperature sensor driver >>> + * Copyright (C) 2014 Heiko Schocher <hs@denx.de> >>> + * >>> + * Based on: >>> + * Texas Instruments TMP102 SMBus temperature sensor driver >>> + * >>> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> >>> + * >>> + * This program is free software; you can redistribute it and/or >>> modify >>> + * it under the terms of the GNU General Public License as >>> published by >>> + * the Free Software Foundation; either version 2 of the License, or >>> + * (at your option) any later version. >>> + * >>> + * This program is distributed in the hope that it will be useful, >>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of >>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >>> + * GNU General Public License for more details. >>> + * >>> + */ >>> + >>> +#include <linux/module.h> >>> +#include <linux/init.h> >>> +#include <linux/slab.h> >>> +#include <linux/i2c.h> >>> +#include <linux/hwmon.h> >>> +#include <linux/hwmon-sysfs.h> >>> +#include <linux/err.h> >>> +#include <linux/mutex.h> >>> +#include <linux/device.h> >>> +#include <linux/jiffies.h> >>> +#include <linux/regmap.h> >>> + >>> +#define TMP103_TEMP_REG 0x00 >>> +#define TMP103_CONF_REG 0x01 >>> +#define TMP103_TLOW_REG 0x02 >>> +#define TMP103_THIGH_REG 0x03 >>> + >>> +#define TMP103_CONF_M0 0x01 >>> +#define TMP103_CONF_M1 0x02 >>> +#define TMP103_CONF_LC 0x04 >>> +#define TMP103_CONF_FL 0x08 >>> +#define TMP103_CONF_FH 0x10 >>> +#define TMP103_CONF_CR0 0x20 >>> +#define TMP103_CONF_CR1 0x40 >>> +#define TMP103_CONF_ID 0x80 >>> +#define TMP103_CONF_SD (TMP103_CONF_M1) >>> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) >>> + >>> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) >>> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ >>> + TMP103_CONF_M0 | TMP103_CONF_M1) >>> + >>> +static inline int tmp103_reg_to_mc(s8 val) >>> +{ >>> + return val * 1000; >>> +} >>> + >>> +static inline u8 tmp103_mc_to_reg(int val) >>> +{ >>> + return DIV_ROUND_CLOSEST(val, 1000); >>> +} >>> + >>> +static ssize_t tmp103_show_temp(struct device *dev, >>> + struct device_attribute *attr, >>> + char *buf) >>> +{ >>> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + unsigned int regval; >>> + int ret; >>> + >>> + ret = regmap_read(regmap, sda->index, ®val); >>> + if (ret < 0) >>> + return ret; >>> + >>> + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); >>> +} >>> + >>> +static ssize_t tmp103_set_temp(struct device *dev, >>> + struct device_attribute *attr, >>> + const char *buf, size_t count) >>> +{ >>> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + long val; >>> + int ret; >>> + >>> + if (kstrtol(buf, 10, &val) < 0) >>> + return -EINVAL; >>> + >>> + val = clamp_val(val, -55000, 127000); >>> + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); >>> + return ret ? ret : count; >>> +} >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, >>> NULL , >>> + TMP103_TEMP_REG); >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, >>> tmp103_show_temp, >>> + tmp103_set_temp, TMP103_TLOW_REG); >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, >>> tmp103_show_temp, >>> + tmp103_set_temp, TMP103_THIGH_REG); >>> + >>> +static struct attribute *tmp103_attrs[] = { >>> + &sensor_dev_attr_temp1_input.dev_attr.attr, >>> + &sensor_dev_attr_temp1_min.dev_attr.attr, >>> + &sensor_dev_attr_temp1_max.dev_attr.attr, >>> + NULL >>> +}; >>> +ATTRIBUTE_GROUPS(tmp103); >>> + >>> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned >>> int reg) >>> +{ >>> + return reg == TMP103_TEMP_REG; >>> +} >>> + >>> +static struct regmap_config tmp103_regmap_config = { >>> + .reg_bits = 8, >>> + .val_bits = 8, >>> + .max_register = TMP103_THIGH_REG, >>> + .volatile_reg = tmp103_regmap_is_volatile, >>> +}; >>> + >>> +static int tmp103_probe(struct i2c_client *client, >>> + const struct i2c_device_id *id) >>> +{ >>> + struct device *dev = &client->dev; >>> + struct device *hwmon_dev; >>> + struct regmap *regmap; >>> + int ret; >>> + >>> + if (!i2c_check_functionality(client->adapter, >>> + I2C_FUNC_SMBUS_BYTE_DATA)) { >>> + dev_err(&client->dev, >>> + "adapter doesn't support SMBus byte transactions\n"); >>> + return -ENODEV; >>> + } >>> + >>> + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); >>> + if (IS_ERR(regmap)) { >>> + dev_err(dev, "failed to allocate register map\n"); >>> + return PTR_ERR(regmap); >>> + } >>> + >>> + ret = regmap_update_bits(regmap, TMP103_CONF_REG, >>> TMP103_CONFIG_MASK, >>> + TMP103_CONFIG); >>> + if (ret < 0) { >>> + dev_err(&client->dev, "error writing config register\n"); >>> + return ret; >>> + } >>> + >>> + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, >>> + regmap, tmp103_groups); >>> + return PTR_ERR_OR_ZERO(hwmon_dev); >>> +} >>> + >>> +#ifdef CONFIG_PM >>> +static int tmp103_suspend(struct device *dev) >>> +{ >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + >>> + return regmap_update_bits(regmap, TMP103_CONF_REG, >>> + TMP103_CONF_SD_MASK, 0); >>> +} >>> + >>> +static int tmp103_resume(struct device *dev) >>> +{ >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + >>> + return regmap_update_bits(regmap, TMP103_CONF_REG, >>> + TMP103_CONF_SD_MASK, TMP103_CONF_SD); >>> +} >>> + >>> +static const struct dev_pm_ops tmp103_dev_pm_ops = { >>> + .suspend = tmp103_suspend, >>> + .resume = tmp103_resume, >>> +}; >>> + >>> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) >>> +#else >>> +#define TMP103_DEV_PM_OPS NULL >>> +#endif /* CONFIG_PM */ >>> + >>> +static const struct i2c_device_id tmp103_id[] = { >>> + { "tmp103", 0 }, >>> + { } >>> +}; >> >> In the bindings you are giving the compatible property as : >> ti,tmp103, but here only tmp103. >> >> Instead of using the i2c_device_id struct , use of_device_id struct >> for giving the >> compatible property value. >> compatble = "<manufacturer>,<model>" >> > > No. We don't do that for other i2c drivers, and the i2c subsystem handles > this case, so it does not sense to start that with this driver just > for the sake of making the code more complicated than it has to be. > > Thanks, > Guenter > ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 6:30 ` Varka Bhadram 0 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 6:30 UTC (permalink / raw) To: Guenter Roeck, Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland T24gMDYvMTgvMjAxNCAxMTo0MiBBTSwgR3VlbnRlciBSb2VjayB3cm90ZToKPiBPbiAwNi8xNy8y MDE0IDEwOjQ2IFBNLCBWYXJrYSBCaGFkcmFtIHdyb3RlOgo+PiBIaSwKPj4KPj4gT24gMDYvMTgv MjAxNCAxMTowNyBBTSwgSGVpa28gU2Nob2NoZXIgd3JvdGU6Cj4+PiBEcml2ZXIgZm9yIHRoZSBU SSBUTVAxMDMuCj4+Pgo+Pj4gVGhlIFRJIFRNUDEwMyBpcyBzaW1pbGFyIHRvIHRoZSBUTVAxMDIu ICBJdCBkaWZmZXJzIGZyb20gdGhlIFRNUDEwMgo+Pj4gYnkgaGF2aW5nIG9ubHkgOCBiaXQgcmVn aXN0ZXJzLgo+Pj4KPj4+IFNpZ25lZC1vZmYtYnk6IEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRl Pgo+Pj4KPj4+IC0tLQo+Pj4KPj4+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9y Zz4KPj4+IENjOiBHdWVudGVyIFJvZWNrIDxsaW51eEByb2Vjay11cy5uZXQ+Cj4+PiBDYzogbGlu dXgta2VybmVsQHZnZXIua2VybmVsLm9yZwo+Pj4gQ2M6IGRldmljZXRyZWVAdmdlci5rZXJuZWwu b3JnCj4+PiBDYzogbGludXgtZG9jQHZnZXIua2VybmVsLm9yZwo+Pj4gQ2M6IE1hcmsgUnV0bGFu ZCA8bWFyay5ydXRsYW5kQGFybS5jb20+Cj4+Pgo+Pj4gLSBjaGFuZ2UgZm9yIHYyOgo+Pj4gICAg LSBhZGQgY29tbWVudHMgZnJvbSBHdWVudGVyUm9lY2s6Cj4+PiAgICAgIC0gcmVtb3ZlIENjIGZy b20gY29tbWl0IHN1YmplY3QKPj4+ICAgICAgLSBhZGQgZGV2aWNldHJlZSBtYWludGFpbmVyCj4+ PiAgICAgIC0gbW92ZSBEb2N1bWVudGF0aW9uIHRvIERvY3VtZW50YXRpb24vaHdtb24vdG1wMTAz Cj4+PiAgICAgIC0gcmVtb3ZlIGRldmljZXRyZWUgYmluZGluZ3MgZnJvbSBEb2N1bWVudGF0aW9u Cj4+PiAgICAgIC0gYWRkIGNvbXBhdGlibGUgc3RyaW5nIHRvCj4+PiAiRG9jdW1lbnRhdGlvbi9k ZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMudHh0Igo+Pj4gICAgICAtIHJl bW92ZSBDYW1lbENhc2UKPj4+ICAgICAgLSBmaXggQ29kaW5nc3R5bGUgaXNzdWVzCj4+PiAgICAg IC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5kIAo+Pj4gZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0 ZXJfd2l0aF9ncm91cHMoKQo+Pj4gICAgICAtIHJlbW92ZSB1bnN1c2VkIGRlZmluZSBUTVAxMDNf Q09ORklHX1JEX09OTFkKPj4+ICAgICAgLSByZXN0b3JlIGNvbmZpZyByZWdpc3RlciB3aGVuIGV4 aXQoKQo+Pj4gICAgICAtIHVzZSByZWdtYXAKPj4+IC0gY2hhbmdlcyBmb3IgdjM6Cj4+PiAgICBh Z2FpbiBhIGxvdCBvZiBmYW50YXN0aWMgdGlwcyBob3cgdG8gdXNlIHJlZ21hcCBlZmZpY2llbnRs eQo+Pj4gICAgZnJvbSBHdWVudGVyIFJvZWNrOgo+Pj4gICAgLSBnZXQgcmlkIG9mICJzdHJ1Y3Qg dG1wMTAzIgo+Pj4gICAgLSBnZXQgcmlkIG9mICJzdGF0aWMgY29uc3QgdTggdG1wMTAzX3JlZ1td Igo+Pj4gICAgLSBnZXQgcmlkIG9mIG11dGV4IGxvY2sKPj4+ICAgIC0gZHJvcCBjb25maWdfb3Jp ZyBlbnRpcmVseQo+Pj4gICAgLSB1c2UgcmVnbWFwX3VwZGF0ZV9iaXRzKCkKPj4+IC0gY2hhbmdl cyBmb3IgdjQ6Cj4+PiAgICAtIGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoKPj4+ICAg ICAgZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZfU0RfTUFTSwo+Pj4g ICAgICBzZXBhcmF0ZWx5IHRvIGVuc3VyZSB5b3UgY2F0Y2ggYWxsIHRoZSB0by1iZS1jbGVhcmVk IGJpdHMuCj4+PiAtIGNoYW5nZXMgZm9yIHY1Ogo+Pj4gICAgYWRkIGNvbW1lbnQgZnJvbSBHdWVu dGVyIFJvZWNrOgo+Pj4gICAgLSB1c2UgIiNkZWZpbmUgVE1QMTAzX0NPTkZfU0QgVE1QMTAzX0NP TkZfTTEiCj4+PiAgICBhZGQgY29tbWVudCBmcm9tIE1hcmsgUnV0bGFuZDoKPj4+ICAgIC0gdXNl IGZ1bGwgc3RyaW5nIGZvciBEVCBjb21wYXRpYmxlIHN0cmluZyBtYXRjaGluZywgaW5zdGVhZCBv Zgo+Pj4gICAgICBEUklWRVJfTkFNRS4gR2V0IHJpZCBjb21wbGV0ZSBvZiBEUklWRVJfTkFNRSBk ZWZpbmUuCj4+Pgo+Pj4gICAuLi4vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZp Y2VzLnR4dCAgICB8ICAgMSArCj4+PiAgIERvY3VtZW50YXRpb24vaHdtb24vdG1wMTAzICAgICAg ICAgICAgICAgICAgICAgICAgIHwgIDI4ICsrKwo+Pj4gICBkcml2ZXJzL2h3bW9uL0tjb25maWcg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxMCArCj4+PiAgIGRyaXZlcnMvaHdtb24v TWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKPj4+ICAgZHJpdmVy cy9od21vbi90bXAxMDMuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAyMDUgCj4+PiAr KysrKysrKysrKysrKysrKysrKysKPj4+ICAgNSBmaWxlcyBjaGFuZ2VkLCAyNDUgaW5zZXJ0aW9u cygrKQo+Pj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMK Pj4+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4+Cj4+PiBk aWZmIC0tZ2l0IAo+Pj4gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3Ry aXZpYWwtZGV2aWNlcy50eHQgCj4+PiBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5n cy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dAo+Pj4gaW5kZXggYmVmODZlNS4uZmM5NDRlMCAxMDA2 NDQKPj4+IC0tLSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlh bC1kZXZpY2VzLnR4dAo+Pj4gKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdz L2kyYy90cml2aWFsLWRldmljZXMudHh0Cj4+PiBAQCAtODMsNSArODMsNiBAQCBzdG0sbTQxdDgw ICAgICAgICBNNDFUODAgLSBTRVJJQUwgQUNDRVNTIFJUQyBXSVRIIAo+Pj4gQUxBUk1TCj4+PiAg IHRhb3MsdHNsMjU1MCAgICAgICAgQW1iaWVudCBMaWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28g V2lyZSAKPj4+IFNlcmlhbCBJbnRlcmZhY2UKPj4+ICAgdGksdHNjMjAwMyAgICAgICAgSTJDIFRv dWNoLVNjcmVlbiBDb250cm9sbGVyCj4+PiAgIHRpLHRtcDEwMiAgICAgICAgTG93IFBvd2VyIERp Z2l0YWwgVGVtcGVyYXR1cmUgU2Vuc29yIHdpdGggCj4+PiBTTUJVUy9Ud28gV2lyZSBTZXJpYWwg SW50ZXJmYWNlCj4+PiArdGksdG1wMTAzICAgICAgICBMb3cgUG93ZXIgRGlnaXRhbCBUZW1wZXJh dHVyZSBTZW5zb3Igd2l0aCAKPj4+IFNNQlVTL1R3byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKTWF5 IGkga25vdyBhYm91dCB0aGlzIGJpbmRpbmcgY29tcGF0aWJsZSBwcm9wZXJ0eSA/Cj4+PiAgIHRp LHRtcDI3NSAgICAgICAgRGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3IKPj4+ICAgd2luYm9uZCx3 cGN0MzAxICAgICAgICBpMmMgdHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQTSkKPj4+IGRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMyBiL0RvY3VtZW50YXRpb24vaHdtb24v dG1wMTAzCj4+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+Pj4gaW5kZXggMDAwMDAwMC4uZWMwMGEx NQo+Pj4gLS0tIC9kZXYvbnVsbAo+Pj4gKysrIGIvRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMK Pj4+IEBAIC0wLDAgKzEsMjggQEAKPj4+ICtLZXJuZWwgZHJpdmVyIHRtcDEwMwo+Pj4gKz09PT09 PT09PT09PT09PT09PT09Cj4+PiArCj4+PiArU3VwcG9ydGVkIGNoaXBzOgo+Pj4gKyAgKiBUZXhh cyBJbnN0cnVtZW50cyBUTVAxMDMKPj4+ICsgICAgUHJlZml4OiAndG1wMTAzJwo+Pj4gKyAgICBB ZGRyZXNzZXMgc2Nhbm5lZDogbm9uZQo+Pj4gKyAgICBQcm9kdWN0IGluZm8gYW5kIGRhdGFzaGVl dDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPj4+ICsKPj4+ICtBdXRob3I6Cj4+ PiArICAgIEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+Pj4gKwo+Pj4gK0Rlc2NyaXB0aW9u Cj4+PiArLS0tLS0tLS0tLS0KPj4+ICsKPj4+ICtUaGUgVE1QMTAzIGlzIGEgZGlnaXRhbCBvdXRw dXQgdGVtcGVyYXR1cmUgc2Vuc29yIGluIGEgZm91ci1iYWxsCj4+PiArd2FmZXIgY2hpcC1zY2Fs ZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRNUDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPj4+ICt0 ZW1wZXJhdHVyZXMgdG8gYSByZXNvbHV0aW9uIG9mIDHCsEMuIFRoZSBUTVAxMDMgaXMgc3BlY2lm aWVkIGZvcgo+Pj4gK29wZXJhdGlvbiBvdmVyIGEgdGVtcGVyYXR1cmUgcmFuZ2Ugb2Yg4oCTNDDC sEMgdG8gKzEyNcKwQy4KPj4+ICsKPj4+ICtSZXNvbHV0aW9uOiA4IEJpdHMKPj4+ICtBY2N1cmFj eTogwrExwrBDIFR5cCAo4oCTMTDCsEMgdG8gKzEwMMKwQykKPj4+ICsKPj4+ICtUaGUgZHJpdmVy IHByb3ZpZGVzIHRoZSBjb21tb24gc3lzZnMtaW50ZXJmYWNlIGZvciB0ZW1wZXJhdHVyZXMgKHNl ZQo+Pj4gK0RvY3VtZW50YXRpb24vaHdtb24vc3lzZnMtaW50ZXJmYWNlIHVuZGVyIFRlbXBlcmF0 dXJlcykuCj4+PiArCj4+PiArUGxlYXNlIHJlZmVyIGhvdyB0byBpbnN0YW50aWF0ZSB0aGlzIGRy aXZlcjoKPj4+ICtEb2N1bWVudGF0aW9uL2kyYy9pbnN0YW50aWF0aW5nLWRldmljZXMKPj4+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcK Pj4+IGluZGV4IDA4NTMxYTEuLmM4ODJkNGIgMTAwNjQ0Cj4+PiAtLS0gYS9kcml2ZXJzL2h3bW9u L0tjb25maWcKPj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+Pj4gQEAgLTEzOTEsNiAr MTM5MSwxNiBAQCBjb25maWcgU0VOU09SU19UTVAxMDIKPj4+ICAgICAgICAgVGhpcyBkcml2ZXIg Y2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuICBJZiBzbywgdGhlIG1vZHVsZQo+Pj4gICAg ICAgICB3aWxsIGJlIGNhbGxlZCB0bXAxMDIuCj4+PiArY29uZmlnIFNFTlNPUlNfVE1QMTAzCj4+ PiArICAgIHRyaXN0YXRlICJUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMiCj4+PiArICAgIGRlcGVu ZHMgb24gSTJDCj4+PiArICAgIGhlbHAKPj4+ICsgICAgICBJZiB5b3Ugc2F5IHllcyBoZXJlIHlv dSBnZXQgc3VwcG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4+PiArICAgICAgc2Vu c29yIGNoaXBzLgo+Pj4gKwo+Pj4gKyAgICAgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0 IGFzIGEgbW9kdWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKPj4+ICsgICAgICB3aWxsIGJlIGNhbGxl ZCB0bXAxMDMuCj4+PiArCj4+PiAgIGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+Pj4gICAgICAgdHJp c3RhdGUgIlRleGFzIEluc3RydW1lbnRzIFRNUDQwMSBhbmQgY29tcGF0aWJsZXMiCj4+PiAgICAg ICBkZXBlbmRzIG9uIEkyQwo+Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUg Yi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+PiBpbmRleCAzZGMwZjAyLi5jYzBkZjFlZiAxMDA2 NDQKPj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKPj4+ICsrKyBiL2RyaXZlcnMvaHdt b24vTWFrZWZpbGUKPj4+IEBAIC0xMzUsNiArMTM1LDcgQEAgb2JqLSQoQ09ORklHX1NFTlNPUlNf U01TQzQ3TTE5MikrPSBzbXNjNDdtMTkyLm8KPj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfQU1D NjgyMSkgICAgKz0gYW1jNjgyMS5vCj4+PiAgIG9iai0kKENPTkZJR19TRU5TT1JTX1RITUM1MCkg ICAgKz0gdGhtYzUwLm8KPj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QMTAyKSAgICArPSB0 bXAxMDIubwo+Pj4gK29iai0kKENPTkZJR19TRU5TT1JTX1RNUDEwMykgICAgKz0gdG1wMTAzLm8K Pj4+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDAxKSAgICArPSB0bXA0MDEubwo+Pj4gICBv YmotJChDT05GSUdfU0VOU09SU19UTVA0MjEpICAgICs9IHRtcDQyMS5vCj4+PiAgIG9iai0kKENP TkZJR19TRU5TT1JTX1RXTDQwMzBfTUFEQykrPSB0d2w0MDMwLW1hZGMtaHdtb24ubwo+Pj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5j Cj4+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+Pj4gaW5kZXggMDAwMDAwMC4uZTY5ZGJjYQo+Pj4g LS0tIC9kZXYvbnVsbAo+Pj4gKysrIGIvZHJpdmVycy9od21vbi90bXAxMDMuYwo+Pj4gQEAgLTAs MCArMSwyMDUgQEAKPj4+ICsvKgo+Pj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMyBTTUJ1 cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJpdmVyCj4+PiArICogQ29weXJpZ2h0IChDKSAyMDE0IEhl aWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+Pj4gKyAqCj4+PiArICogQmFzZWQgb246Cj4+PiAr ICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAyIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2 ZXIKPj4+ICsgKgo+Pj4gKyAqIENvcHlyaWdodCAoQykgMjAxMCBTdGV2ZW4gS2luZyA8c2ZraW5n QGZkd2RjLmNvbT4KPj4+ICsgKgo+Pj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgCj4+PiBtb2RpZnkKPj4+ICsgKiBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIAo+Pj4g cHVibGlzaGVkIGJ5Cj4+PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPj4+ICsgKiAoYXQgeW91ciBvcHRpb24pIGFu eSBsYXRlciB2ZXJzaW9uLgo+Pj4gKyAqCj4+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+PiArICogYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPj4+ ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCj4+PiArICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KPj4+ICsgKgo+Pj4gKyAqLwo+Pj4gKwo+Pj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUu aD4KPj4+ICsjaW5jbHVkZSA8bGludXgvaW5pdC5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC9zbGFi Lmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC9od21v bi5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi1zeXNmcy5oPgo+Pj4gKyNpbmNsdWRlIDxs aW51eC9lcnIuaD4KPj4+ICsjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KPj4+ICsjaW5jbHVkZSA8 bGludXgvZGV2aWNlLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L2ppZmZpZXMuaD4KPj4+ICsjaW5j bHVkZSA8bGludXgvcmVnbWFwLmg+Cj4+PiArCj4+PiArI2RlZmluZSBUTVAxMDNfVEVNUF9SRUcg ICAgICAgIDB4MDAKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX1JFRyAgICAgICAgMHgwMQo+Pj4g KyNkZWZpbmUgVE1QMTAzX1RMT1dfUkVHICAgICAgICAweDAyCj4+PiArI2RlZmluZSBUTVAxMDNf VEhJR0hfUkVHICAgIDB4MDMKPj4+ICsKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX00wICAgICAg ICAweDAxCj4+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9NMSAgICAgICAgMHgwMgo+Pj4gKyNkZWZp bmUgVE1QMTAzX0NPTkZfTEMgICAgICAgIDB4MDQKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0ZM ICAgICAgICAweDA4Cj4+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GSCAgICAgICAgMHgxMAo+Pj4g KyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwICAgICAgICAweDIwCj4+PiArI2RlZmluZSBUTVAxMDNf Q09ORl9DUjEgICAgICAgIDB4NDAKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0lEICAgICAgICAw eDgwCj4+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRCAgICAgICAgKFRNUDEwM19DT05GX00xKQo+ Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfU0RfTUFTSyAgICAoVE1QMTAzX0NPTkZfTTAgfCBUTVAx MDNfQ09ORl9NMSkKPj4+ICsKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GSUcgICAgICAgIChUTVAx MDNfQ09ORl9DUjEgfCBUTVAxMDNfQ09ORl9NMSkKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GSUdf TUFTSyAgICAoVE1QMTAzX0NPTkZfQ1IwIHwgVE1QMTAzX0NPTkZfQ1IxIHwgXAo+Pj4gKyAgICAg ICAgICAgICAgICAgVE1QMTAzX0NPTkZfTTAgfCBUTVAxMDNfQ09ORl9NMSkKPj4+ICsKPj4+ICtz dGF0aWMgaW5saW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZhbCkKPj4+ICt7Cj4+PiArICAg IHJldHVybiB2YWwgKiAxMDAwOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgaW5saW5lIHU4IHRt cDEwM19tY190b19yZWcoaW50IHZhbCkKPj4+ICt7Cj4+PiArICAgIHJldHVybiBESVZfUk9VTkRf Q0xPU0VTVCh2YWwsIDEwMDApOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgc3NpemVfdCB0bXAx MDNfc2hvd190ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKPj4+ICsgICAgICAgICAgICAgICAgc3Ry dWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4+PiArICAgICAgICAgICAgICAgIGNoYXIgKmJ1 ZikKPj4+ICt7Cj4+PiArICAgIHN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAqc2RhID0g dG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpOwo+Pj4gKyAgICBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAg PSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4+ICsgICAgdW5zaWduZWQgaW50IHJlZ3ZhbDsKPj4+ ICsgICAgaW50IHJldDsKPj4+ICsKPj4+ICsgICAgcmV0ID0gcmVnbWFwX3JlYWQocmVnbWFwLCBz ZGEtPmluZGV4LCAmcmVndmFsKTsKPj4+ICsgICAgaWYgKHJldCA8IDApCj4+PiArICAgICAgICBy ZXR1cm4gcmV0Owo+Pj4gKwo+Pj4gKyAgICByZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgdG1w MTAzX3JlZ190b19tYyhyZWd2YWwpKTsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIHNzaXplX3Qg dG1wMTAzX3NldF90ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKPj4+ICsgICAgICAgICAgICAgICAg ICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4+PiArICAgICAgICAgICAgICAgICAg IGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQo+Pj4gK3sKPj4+ICsgICAgc3RydWN0IHNl bnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4+ PiArICAgIHN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+Pj4g KyAgICBsb25nIHZhbDsKPj4+ICsgICAgaW50IHJldDsKPj4+ICsKPj4+ICsgICAgaWYgKGtzdHJ0 b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+Pj4gKyAgICAgICAgcmV0dXJuIC1FSU5WQUw7Cj4+PiAr Cj4+PiArICAgIHZhbCA9IGNsYW1wX3ZhbCh2YWwsIC01NTAwMCwgMTI3MDAwKTsKPj4+ICsgICAg cmV0ID0gcmVnbWFwX3dyaXRlKHJlZ21hcCwgc2RhLT5pbmRleCwgdG1wMTAzX21jX3RvX3JlZyh2 YWwpKTsKPj4+ICsgICAgcmV0dXJuIHJldCA/IHJldCA6IGNvdW50Owo+Pj4gK30KPj4+ICsKPj4+ ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAxMDNf c2hvd190ZW1wLCAKPj4+IE5VTEwgLAo+Pj4gKyAgICAgICAgICAgICAgVE1QMTAzX1RFTVBfUkVH KTsKPj4+ICsKPj4+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21pbiwgU19JV1VT UiB8IFNfSVJVR08sIAo+Pj4gdG1wMTAzX3Nob3dfdGVtcCwKPj4+ICsgICAgICAgICAgICAgIHRt cDEwM19zZXRfdGVtcCwgVE1QMTAzX1RMT1dfUkVHKTsKPj4+ICsKPj4+ICtzdGF0aWMgU0VOU09S X0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIAo+Pj4gdG1wMTAzX3No b3dfdGVtcCwKPj4+ICsgICAgICAgICAgICAgIHRtcDEwM19zZXRfdGVtcCwgVE1QMTAzX1RISUdI X1JFRyk7Cj4+PiArCj4+PiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRtcDEwM19hdHRyc1td ID0gewo+Pj4gKyAgICAmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIs Cj4+PiArICAgICZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfbWluLmRldl9hdHRyLmF0dHIsCj4+PiAr ICAgICZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfbWF4LmRldl9hdHRyLmF0dHIsCj4+PiArICAgIE5V TEwKPj4+ICt9Owo+Pj4gK0FUVFJJQlVURV9HUk9VUFModG1wMTAzKTsKPj4+ICsKPj4+ICtzdGF0 aWMgYm9vbCB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxlKHN0cnVjdCBkZXZpY2UgKmRldiwgdW5z aWduZWQgCj4+PiBpbnQgcmVnKQo+Pj4gK3sKPj4+ICsgICAgcmV0dXJuIHJlZyA9PSBUTVAxMDNf VEVNUF9SRUc7Cj4+PiArfQo+Pj4gKwo+Pj4gK3N0YXRpYyBzdHJ1Y3QgcmVnbWFwX2NvbmZpZyB0 bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPj4+ICsgICAgLnJlZ19iaXRzID0gOCwKPj4+ICsgICAg LnZhbF9iaXRzID0gOCwKPj4+ICsgICAgLm1heF9yZWdpc3RlciA9IFRNUDEwM19USElHSF9SRUcs Cj4+PiArICAgIC52b2xhdGlsZV9yZWcgPSB0bXAxMDNfcmVnbWFwX2lzX3ZvbGF0aWxlLAo+Pj4g K307Cj4+PiArCj4+PiArc3RhdGljIGludCB0bXAxMDNfcHJvYmUoc3RydWN0IGkyY19jbGllbnQg KmNsaWVudCwKPj4+ICsgICAgICAgICAgICBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQp Cj4+PiArewo+Pj4gKyAgICBzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmY2xpZW50LT5kZXY7Cj4+PiAr ICAgIHN0cnVjdCBkZXZpY2UgKmh3bW9uX2RldjsKPj4+ICsgICAgc3RydWN0IHJlZ21hcCAqcmVn bWFwOwo+Pj4gKyAgICBpbnQgcmV0Owo+Pj4gKwo+Pj4gKyAgICBpZiAoIWkyY19jaGVja19mdW5j dGlvbmFsaXR5KGNsaWVudC0+YWRhcHRlciwKPj4+ICsgICAgICAgICAgICAgICAgICAgICBJMkNf RlVOQ19TTUJVU19CWVRFX0RBVEEpKSB7Cj4+PiArICAgICAgICBkZXZfZXJyKCZjbGllbnQtPmRl diwKPj4+ICsgICAgICAgICAgICAiYWRhcHRlciBkb2Vzbid0IHN1cHBvcnQgU01CdXMgYnl0ZSB0 cmFuc2FjdGlvbnNcbiIpOwo+Pj4gKyAgICAgICAgcmV0dXJuIC1FTk9ERVY7Cj4+PiArICAgIH0K Pj4+ICsKPj4+ICsgICAgcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9pMmMoY2xpZW50LCAmdG1w MTAzX3JlZ21hcF9jb25maWcpOwo+Pj4gKyAgICBpZiAoSVNfRVJSKHJlZ21hcCkpIHsKPj4+ICsg ICAgICAgIGRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxuIik7 Cj4+PiArICAgICAgICByZXR1cm4gUFRSX0VSUihyZWdtYXApOwo+Pj4gKyAgICB9Cj4+PiArCj4+ PiArICAgIHJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAsIFRNUDEwM19DT05GX1JFRywg Cj4+PiBUTVAxMDNfQ09ORklHX01BU0ssCj4+PiArICAgICAgICAgICAgICAgICBUTVAxMDNfQ09O RklHKTsKPj4+ICsgICAgaWYgKHJldCA8IDApIHsKPj4+ICsgICAgICAgIGRldl9lcnIoJmNsaWVu dC0+ZGV2LCAiZXJyb3Igd3JpdGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+Pj4gKyAgICAgICAg cmV0dXJuIHJldDsKPj4+ICsgICAgfQo+Pj4gKwo+Pj4gKyAgICBod21vbl9kZXYgPSBod21vbl9k ZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoZGV2LCBjbGllbnQtPm5hbWUsCj4+PiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmVnbWFwLCB0bXAxMDNfZ3JvdXBzKTsKPj4+ICsgICAg cmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9kZXYpOwo+Pj4gK30KPj4+ICsKPj4+ICsjaWZk ZWYgQ09ORklHX1BNCj4+PiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNl ICpkZXYpCj4+PiArewo+Pj4gKyAgICBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZfZ2V0X2Ry dmRhdGEoZGV2KTsKPj4+ICsKPj4+ICsgICAgcmV0dXJuIHJlZ21hcF91cGRhdGVfYml0cyhyZWdt YXAsIFRNUDEwM19DT05GX1JFRywKPj4+ICsgICAgICAgICAgICAgICAgICBUTVAxMDNfQ09ORl9T RF9NQVNLLCAwKTsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIGludCB0bXAxMDNfcmVzdW1lKHN0 cnVjdCBkZXZpY2UgKmRldikKPj4+ICt7Cj4+PiArICAgIHN0cnVjdCByZWdtYXAgKnJlZ21hcCA9 IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+Pj4gKwo+Pj4gKyAgICByZXR1cm4gcmVnbWFwX3VwZGF0 ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVHLAo+Pj4gKyAgICAgICAgICAgICAgICAgIFRN UDEwM19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPj4+ICt9Cj4+PiArCj4+PiArc3Rh dGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+Pj4gKyAg ICAuc3VzcGVuZCAgICA9IHRtcDEwM19zdXNwZW5kLAo+Pj4gKyAgICAucmVzdW1lICAgICAgICA9 IHRtcDEwM19yZXN1bWUsCj4+PiArfTsKPj4+ICsKPj4+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1f T1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCj4+PiArI2Vsc2UKPj4+ICsjZGVmaW5lICAgIFRNUDEw M19ERVZfUE1fT1BTIE5VTEwKPj4+ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4+PiArCj4+PiAr c3RhdGljIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkIHRtcDEwM19pZFtdID0gewo+Pj4gKyAg ICB7ICJ0bXAxMDMiLCAwIH0sCj4+PiArICAgIHsgfQo+Pj4gK307Cj4+Cj4+IEluIHRoZSBiaW5k aW5ncyB5b3UgYXJlIGdpdmluZyB0aGUgY29tcGF0aWJsZSBwcm9wZXJ0eSBhcyA6IAo+PiB0aSx0 bXAxMDMsIGJ1dCBoZXJlIG9ubHkgdG1wMTAzLgo+Pgo+PiBJbnN0ZWFkIG9mIHVzaW5nIHRoZSBp MmNfZGV2aWNlX2lkIHN0cnVjdCAsIHVzZSBvZl9kZXZpY2VfaWQgc3RydWN0IAo+PiBmb3IgZ2l2 aW5nIHRoZQo+PiBjb21wYXRpYmxlIHByb3BlcnR5IHZhbHVlLgo+PiBjb21wYXRibGUgPSAiPG1h bnVmYWN0dXJlcj4sPG1vZGVsPiIKPj4KPgo+IE5vLiBXZSBkb24ndCBkbyB0aGF0IGZvciBvdGhl ciBpMmMgZHJpdmVycywgYW5kIHRoZSBpMmMgc3Vic3lzdGVtIGhhbmRsZXMKPiB0aGlzIGNhc2Us IHNvIGl0IGRvZXMgbm90IHNlbnNlIHRvIHN0YXJ0IHRoYXQgd2l0aCB0aGlzIGRyaXZlciBqdXN0 Cj4gZm9yIHRoZSBzYWtlIG9mIG1ha2luZyB0aGUgY29kZSBtb3JlIGNvbXBsaWNhdGVkIHRoYW4g aXQgaGFzIHRvIGJlLgo+Cj4gVGhhbmtzLAo+IEd1ZW50ZXIKPgoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0Cmxt LXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxt YW4vbGlzdGluZm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 6:30 ` [lm-sensors] " Varka Bhadram @ 2014-06-18 6:41 ` Guenter Roeck -1 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 6:41 UTC (permalink / raw) To: Varka Bhadram, Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/17/2014 11:18 PM, Varka Bhadram wrote: >>>> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface >>>> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface > May i know about this binding compatible property ? At some point someone will have to document how trivial i2c device mappings work in detail. Every other time another trivial i2c device is added to this file, the same argument starts all over again. An attempt to document the trivial i2c device mappings implementation was rejected with the argument that it would be implementation (Linux) specific. The proposed patch [1] may however help understanding how it works. Hope that helps, Guenter --- [1] http://patchwork.ozlabs.org/patch/301938/ _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 6:41 ` Guenter Roeck 0 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 6:41 UTC (permalink / raw) To: Varka Bhadram, Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/17/2014 11:18 PM, Varka Bhadram wrote: >>>> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface >>>> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface > May i know about this binding compatible property ? At some point someone will have to document how trivial i2c device mappings work in detail. Every other time another trivial i2c device is added to this file, the same argument starts all over again. An attempt to document the trivial i2c device mappings implementation was rejected with the argument that it would be implementation (Linux) specific. The proposed patch [1] may however help understanding how it works. Hope that helps, Guenter --- [1] http://patchwork.ozlabs.org/patch/301938/ ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 5:58 ` [lm-sensors] " Varka Bhadram @ 2014-06-18 6:16 ` Heiko Schocher -1 siblings, 0 replies; 21+ messages in thread From: Heiko Schocher @ 2014-06-18 6:16 UTC (permalink / raw) To: Varka Bhadram Cc: lm-sensors, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland SGVsbG8gVmFya2EsCgpBbSAxOC4wNi4yMDE0IDA3OjQ2LCBzY2hyaWViIFZhcmthIEJoYWRyYW06 Cj4gSGksCj4KPiBPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToK Pj4gRHJpdmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+Pgo+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWls YXIgdG8gdGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4gYnkgaGF2aW5n IG9ubHkgOCBiaXQgcmVnaXN0ZXJzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hl ciA8aHNAZGVueC5kZT4KPj4KPj4gLS0tCj4+Cj4+IENjOiBKZWFuIERlbHZhcmUgPGtoYWxpQGxp bnV4LWZyLm9yZz4KPj4gQ2M6IEd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVzLm5ldD4KPj4g Q2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4gQ2M6IGRldmljZXRyZWVAdmdlci5r ZXJuZWwub3JnCj4+IENjOiBsaW51eC1kb2NAdmdlci5rZXJuZWwub3JnCj4+IENjOiBNYXJrIFJ1 dGxhbmQgPG1hcmsucnV0bGFuZEBhcm0uY29tPgo+Pgo+PiAtIGNoYW5nZSBmb3IgdjI6Cj4+IC0g YWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+PiAtIHJlbW92ZSBDYyBmcm9tIGNvbW1p dCBzdWJqZWN0Cj4+IC0gYWRkIGRldmljZXRyZWUgbWFpbnRhaW5lcgo+PiAtIG1vdmUgRG9jdW1l bnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+PiAtIHJlbW92ZSBkZXZpY2V0 cmVlIGJpbmRpbmdzIGZyb20gRG9jdW1lbnRhdGlvbgo+PiAtIGFkZCBjb21wYXRpYmxlIHN0cmlu ZyB0bwo+PiAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRl dmljZXMudHh0Igo+PiAtIHJlbW92ZSBDYW1lbENhc2UKPj4gLSBmaXggQ29kaW5nc3R5bGUgaXNz dWVzCj4+IC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5kIGRldm1faHdtb25fZGV2aWNlX3JlZ2lz dGVyX3dpdGhfZ3JvdXBzKCkKPj4gLSByZW1vdmUgdW5zdXNlZCBkZWZpbmUgVE1QMTAzX0NPTkZJ R19SRF9PTkxZCj4+IC0gcmVzdG9yZSBjb25maWcgcmVnaXN0ZXIgd2hlbiBleGl0KCkKPj4gLSB1 c2UgcmVnbWFwCj4+IC0gY2hhbmdlcyBmb3IgdjM6Cj4+IGFnYWluIGEgbG90IG9mIGZhbnRhc3Rp YyB0aXBzIGhvdyB0byB1c2UgcmVnbWFwIGVmZmljaWVudGx5Cj4+IGZyb20gR3VlbnRlciBSb2Vj azoKPj4gLSBnZXQgcmlkIG9mICJzdHJ1Y3QgdG1wMTAzIgo+PiAtIGdldCByaWQgb2YgInN0YXRp YyBjb25zdCB1OCB0bXAxMDNfcmVnW10iCj4+IC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4+IC0g ZHJvcCBjb25maWdfb3JpZyBlbnRpcmVseQo+PiAtIHVzZSByZWdtYXBfdXBkYXRlX2JpdHMoKQo+ PiAtIGNoYW5nZXMgZm9yIHY0Ogo+PiAtIGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoK Pj4gZGVmaW5lIFRNUDEwM19DT05GSUdfTUFTSyBhbmQgVE1QMTAzX0NPTkZfU0RfTUFTSwo+PiBz ZXBhcmF0ZWx5IHRvIGVuc3VyZSB5b3UgY2F0Y2ggYWxsIHRoZSB0by1iZS1jbGVhcmVkIGJpdHMu Cj4+IC0gY2hhbmdlcyBmb3IgdjU6Cj4+IGFkZCBjb21tZW50IGZyb20gR3VlbnRlciBSb2VjazoK Pj4gLSB1c2UgIiNkZWZpbmUgVE1QMTAzX0NPTkZfU0QgVE1QMTAzX0NPTkZfTTEiCj4+IGFkZCBj b21tZW50IGZyb20gTWFyayBSdXRsYW5kOgo+PiAtIHVzZSBmdWxsIHN0cmluZyBmb3IgRFQgY29t cGF0aWJsZSBzdHJpbmcgbWF0Y2hpbmcsIGluc3RlYWQgb2YKPj4gRFJJVkVSX05BTUUuIEdldCBy aWQgY29tcGxldGUgb2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Pgo+PiAuLi4vZGV2aWNldHJlZS9i aW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dCB8IDEgKwo+PiBEb2N1bWVudGF0aW9uL2h3 bW9uL3RtcDEwMyB8IDI4ICsrKwo+PiBkcml2ZXJzL2h3bW9uL0tjb25maWcgfCAxMCArCj4+IGRy aXZlcnMvaHdtb24vTWFrZWZpbGUgfCAxICsKPj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDIw NSArKysrKysrKysrKysrKysrKysrKysKPj4gNSBmaWxlcyBjaGFuZ2VkLCAyNDUgaW5zZXJ0aW9u cygrKQo+PiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPj4g Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4KPj4gZGlmZiAtLWdp dCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2Vz LnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZp Y2VzLnR4dAo+PiBpbmRleCBiZWY4NmU1Li5mYzk0NGUwIDEwMDY0NAo+PiAtLS0gYS9Eb2N1bWVu dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKPj4gKysr IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMu dHh0Cj4+IEBAIC04Myw1ICs4Myw2IEBAIHN0bSxtNDF0ODAgTTQxVDgwIC0gU0VSSUFMIEFDQ0VT UyBSVEMgV0lUSCBBTEFSTVMKPj4gdGFvcyx0c2wyNTUwIEFtYmllbnQgTGlnaHQgU2Vuc29yIHdp dGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQo+PiB0aSx0c2MyMDAzIEkyQyBUb3Vj aC1TY3JlZW4gQ29udHJvbGxlcgo+PiB0aSx0bXAxMDIgTG93IFBvd2VyIERpZ2l0YWwgVGVtcGVy YXR1cmUgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQo+PiArdGks dG1wMTAzIExvdyBQb3dlciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3 byBXaXJlIFNlcmlhbCBJbnRlcmZhY2UKPj4gdGksdG1wMjc1IERpZ2l0YWwgVGVtcGVyYXR1cmUg U2Vuc29yCj4+IHdpbmJvbmQsd3BjdDMwMSBpMmMgdHJ1c3RlZCBwbGF0Zm9ybSBtb2R1bGUgKFRQ TSkKPj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdtb24vdG1wMTAzIGIvRG9jdW1lbnRh dGlvbi9od21vbi90bXAxMDMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAw MC4uZWMwMGExNQo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL0RvY3VtZW50YXRpb24vaHdtb24v dG1wMTAzCj4+IEBAIC0wLDAgKzEsMjggQEAKPj4gK0tlcm5lbCBkcml2ZXIgdG1wMTAzCj4+ICs9 PT09PT09PT09PT09PT09PT09PQo+PiArCj4+ICtTdXBwb3J0ZWQgY2hpcHM6Cj4+ICsgKiBUZXhh cyBJbnN0cnVtZW50cyBUTVAxMDMKPj4gKyBQcmVmaXg6ICd0bXAxMDMnCj4+ICsgQWRkcmVzc2Vz IHNjYW5uZWQ6IG5vbmUKPj4gKyBQcm9kdWN0IGluZm8gYW5kIGRhdGFzaGVldDogaHR0cDovL3d3 dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPj4gKwo+PiArQXV0aG9yOgo+PiArIEhlaWtvIFNjaG9j aGVyIDxoc0BkZW54LmRlPgo+PiArCj4+ICtEZXNjcmlwdGlvbgo+PiArLS0tLS0tLS0tLS0KPj4g Kwo+PiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0cHV0IHRlbXBlcmF0dXJlIHNlbnNvciBp biBhIGZvdXItYmFsbAo+PiArd2FmZXIgY2hpcC1zY2FsZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRN UDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPj4gK3RlbXBlcmF0dXJlcyB0byBhIHJlc29sdXRp b24gb2YgMcKwQy4gVGhlIFRNUDEwMyBpcyBzcGVjaWZpZWQgZm9yCj4+ICtvcGVyYXRpb24gb3Zl ciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBDIHRvICsxMjXCsEMuCj4+ICsKPj4gK1Jl c29sdXRpb246IDggQml0cwo+PiArQWNjdXJhY3k6IMKxMcKwQyBUeXAgKOKAkzEwwrBDIHRvICsx MDDCsEMpCj4+ICsKPj4gK1RoZSBkcml2ZXIgcHJvdmlkZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRl cmZhY2UgZm9yIHRlbXBlcmF0dXJlcyAoc2VlCj4+ICtEb2N1bWVudGF0aW9uL2h3bW9uL3N5c2Zz LWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+PiArCj4+ICtQbGVhc2UgcmVmZXIgaG93 IHRvIGluc3RhbnRpYXRlIHRoaXMgZHJpdmVyOgo+PiArRG9jdW1lbnRhdGlvbi9pMmMvaW5zdGFu dGlhdGluZy1kZXZpY2VzCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcgYi9k cml2ZXJzL2h3bW9uL0tjb25maWcKPj4gaW5kZXggMDg1MzFhMS4uYzg4MmQ0YiAxMDA2NDQKPj4g LS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vS2NvbmZp Zwo+PiBAQCAtMTM5MSw2ICsxMzkxLDE2IEBAIGNvbmZpZyBTRU5TT1JTX1RNUDEwMgo+PiBUaGlz IGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUK Pj4gd2lsbCBiZSBjYWxsZWQgdG1wMTAyLgo+PiArY29uZmlnIFNFTlNPUlNfVE1QMTAzCj4+ICsg dHJpc3RhdGUgIlRleGFzIEluc3RydW1lbnRzIFRNUDEwMyIKPj4gKyBkZXBlbmRzIG9uIEkyQwo+ PiArIGhlbHAKPj4gKyBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgVGV4 YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4+ICsgc2Vuc29yIGNoaXBzLgo+PiArCj4+ICsgVGhpcyBk cml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUuIElmIHNvLCB0aGUgbW9kdWxlCj4+ ICsgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+PiArCj4+IGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+ PiB0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAxIGFuZCBjb21wYXRpYmxlcyIKPj4g ZGVwZW5kcyBvbiBJMkMKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9k cml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+IGluZGV4IDNkYzBmMDIuLmNjMGRmMWVmIDEwMDY0NAo+ PiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vTWFr ZWZpbGUKPj4gQEAgLTEzNSw2ICsxMzUsNyBAQCBvYmotJChDT05GSUdfU0VOU09SU19TTVNDNDdN MTkyKSs9IHNtc2M0N20xOTIubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19BTUM2ODIxKSArPSBh bWM2ODIxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVEhNQzUwKSArPSB0aG1jNTAubwo+PiBv YmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpICs9IHRtcDEwMi5vCj4+ICtvYmotJChDT05GSUdf U0VOU09SU19UTVAxMDMpICs9IHRtcDEwMy5vCj4+IG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQw MSkgKz0gdG1wNDAxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIxKSArPSB0bXA0MjEu bwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UV0w0MDMwX01BREMpKz0gdHdsNDAzMC1tYWRjLWh3 bW9uLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9kcml2ZXJzL2h3 bW9uL3RtcDEwMy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLmU2 OWRiY2EKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+ IEBAIC0wLDAgKzEsMjA1IEBACj4+ICsvKgo+PiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAz IFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPj4gKyAqIENvcHlyaWdodCAoQykgMjAx NCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPj4gKyAqCj4+ICsgKiBCYXNlZCBvbjoKPj4g KyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0ZW1wZXJhdHVyZSBzZW5zb3IgZHJp dmVyCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBLaW5nIDxzZmtpbmdA ZmR3ZGMuY29tPgo+PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5 b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4+ICsgKiBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQo+ PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IKPj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u Cj4+ICsgKgo+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+PiArICogTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCj4+ICsgKiBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+PiArICoKPj4gKyAqLwo+ PiArCj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvaW5p dC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9pMmMu aD4KPj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2h3bW9u LXN5c2ZzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgv bXV0ZXguaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPj4gKyNpbmNsdWRlIDxsaW51 eC9qaWZmaWVzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4+ICsKPj4gKyNkZWZp bmUgVE1QMTAzX1RFTVBfUkVHIDB4MDAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfUkVHIDB4MDEK Pj4gKyNkZWZpbmUgVE1QMTAzX1RMT1dfUkVHIDB4MDIKPj4gKyNkZWZpbmUgVE1QMTAzX1RISUdI X1JFRyAweDAzCj4+ICsKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTTAgMHgwMQo+PiArI2RlZmlu ZSBUTVAxMDNfQ09ORl9NMSAweDAyCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0xDIDB4MDQKPj4g KyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwgMHgwOAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GSCAw eDEwCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMCAweDIwCj4+ICsjZGVmaW5lIFRNUDEwM19D T05GX0NSMSAweDQwCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0lEIDB4ODAKPj4gKyNkZWZpbmUg VE1QMTAzX0NPTkZfU0QgKFRNUDEwM19DT05GX00xKQo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9T RF9NQVNLIChUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQo+PiArCj4+ICsjZGVmaW5l IFRNUDEwM19DT05GSUcgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQo+PiArI2Rl ZmluZSBUTVAxMDNfQ09ORklHX01BU0sgKFRNUDEwM19DT05GX0NSMCB8IFRNUDEwM19DT05GX0NS MSB8IFwKPj4gKyBUTVAxMDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQo+PiArCj4+ICtzdGF0 aWMgaW5saW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZhbCkKPj4gK3sKPj4gKyByZXR1cm4g dmFsICogMTAwMDsKPj4gK30KPj4gKwo+PiArc3RhdGljIGlubGluZSB1OCB0bXAxMDNfbWNfdG9f cmVnKGludCB2YWwpCj4+ICt7Cj4+ICsgcmV0dXJuIERJVl9ST1VORF9DTE9TRVNUKHZhbCwgMTAw MCk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBzc2l6ZV90IHRtcDEwM19zaG93X3RlbXAoc3RydWN0 IGRldmljZSAqZGV2LAo+PiArIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+PiArIGNo YXIgKmJ1ZikKPj4gK3sKPj4gKyBzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9 IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBk ZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4gKyB1bnNpZ25lZCBpbnQgcmVndmFsOwo+PiArIGludCBy ZXQ7Cj4+ICsKPj4gKyByZXQgPSByZWdtYXBfcmVhZChyZWdtYXAsIHNkYS0+aW5kZXgsICZyZWd2 YWwpOwo+PiArIGlmIChyZXQgPCAwKQo+PiArIHJldHVybiByZXQ7Cj4+ICsKPj4gKyByZXR1cm4g c3ByaW50ZihidWYsICIlZFxuIiwgdG1wMTAzX3JlZ190b19tYyhyZWd2YWwpKTsKPj4gK30KPj4g Kwo+PiArc3RhdGljIHNzaXplX3QgdG1wMTAzX3NldF90ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwK Pj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPj4gKyBjb25zdCBjaGFyICpidWYs IHNpemVfdCBjb3VudCkKPj4gK3sKPj4gKyBzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUg KnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdt YXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4gKyBsb25nIHZhbDsKPj4gKyBpbnQgcmV0Owo+ PiArCj4+ICsgaWYgKGtzdHJ0b2woYnVmLCAxMCwgJnZhbCkgPCAwKQo+PiArIHJldHVybiAtRUlO VkFMOwo+PiArCj4+ICsgdmFsID0gY2xhbXBfdmFsKHZhbCwgLTU1MDAwLCAxMjcwMDApOwo+PiAr IHJldCA9IHJlZ21hcF93cml0ZShyZWdtYXAsIHNkYS0+aW5kZXgsIHRtcDEwM19tY190b19yZWco dmFsKSk7Cj4+ICsgcmV0dXJuIHJldCA/IHJldCA6IGNvdW50Owo+PiArfQo+PiArCj4+ICtzdGF0 aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCB0bXAxMDNfc2hvd190 ZW1wLCBOVUxMICwKPj4gKyBUTVAxMDNfVEVNUF9SRUcpOwo+PiArCj4+ICtzdGF0aWMgU0VOU09S X0RFVklDRV9BVFRSKHRlbXAxX21pbiwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEwM19zaG93X3Rl bXAsCj4+ICsgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVExPV19SRUcpOwo+PiArCj4+ICtzdGF0 aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIHRtcDEw M19zaG93X3RlbXAsCj4+ICsgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVEhJR0hfUkVHKTsKPj4g Kwo+PiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnRtcDEwM19hdHRyc1tdID0gewo+PiArICZz ZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKPj4gKyAmc2Vuc29yX2Rl dl9hdHRyX3RlbXAxX21pbi5kZXZfYXR0ci5hdHRyLAo+PiArICZzZW5zb3JfZGV2X2F0dHJfdGVt cDFfbWF4LmRldl9hdHRyLmF0dHIsCj4+ICsgTlVMTAo+PiArfTsKPj4gK0FUVFJJQlVURV9HUk9V UFModG1wMTAzKTsKPj4gKwo+PiArc3RhdGljIGJvb2wgdG1wMTAzX3JlZ21hcF9pc192b2xhdGls ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGludCByZWcpCj4+ICt7Cj4+ICsgcmV0dXJu IHJlZyA9PSBUTVAxMDNfVEVNUF9SRUc7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBzdHJ1Y3QgcmVn bWFwX2NvbmZpZyB0bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPj4gKyAucmVnX2JpdHMgPSA4LAo+ PiArIC52YWxfYml0cyA9IDgsCj4+ICsgLm1heF9yZWdpc3RlciA9IFRNUDEwM19USElHSF9SRUcs Cj4+ICsgLnZvbGF0aWxlX3JlZyA9IHRtcDEwM19yZWdtYXBfaXNfdm9sYXRpbGUsCj4+ICt9Owo+ PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50 LAo+PiArIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPj4gK3sKPj4gKyBzdHJ1Y3Qg ZGV2aWNlICpkZXYgPSAmY2xpZW50LT5kZXY7Cj4+ICsgc3RydWN0IGRldmljZSAqaHdtb25fZGV2 Owo+PiArIHN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPj4gKyBpbnQgcmV0Owo+PiArCj4+ICsgaWYg KCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShjbGllbnQtPmFkYXB0ZXIsCj4+ICsgSTJDX0ZVTkNf U01CVVNfQllURV9EQVRBKSkgewo+PiArIGRldl9lcnIoJmNsaWVudC0+ZGV2LAo+PiArICJhZGFw dGVyIGRvZXNuJ3Qgc3VwcG9ydCBTTUJ1cyBieXRlIHRyYW5zYWN0aW9uc1xuIik7Cj4+ICsgcmV0 dXJuIC1FTk9ERVY7Cj4+ICsgfQo+PiArCj4+ICsgcmVnbWFwID0gZGV2bV9yZWdtYXBfaW5pdF9p MmMoY2xpZW50LCAmdG1wMTAzX3JlZ21hcF9jb25maWcpOwo+PiArIGlmIChJU19FUlIocmVnbWFw KSkgewo+PiArIGRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxu Iik7Cj4+ICsgcmV0dXJuIFBUUl9FUlIocmVnbWFwKTsKPj4gKyB9Cj4+ICsKPj4gKyByZXQgPSBy ZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNfQ09ORl9SRUcsIFRNUDEwM19DT05GSUdf TUFTSywKPj4gKyBUTVAxMDNfQ09ORklHKTsKPj4gKyBpZiAocmV0IDwgMCkgewo+PiArIGRldl9l cnIoJmNsaWVudC0+ZGV2LCAiZXJyb3Igd3JpdGluZyBjb25maWcgcmVnaXN0ZXJcbiIpOwo+PiAr IHJldHVybiByZXQ7Cj4+ICsgfQo+PiArCj4+ICsgaHdtb25fZGV2ID0gaHdtb25fZGV2aWNlX3Jl Z2lzdGVyX3dpdGhfZ3JvdXBzKGRldiwgY2xpZW50LT5uYW1lLAo+PiArIHJlZ21hcCwgdG1wMTAz X2dyb3Vwcyk7Cj4+ICsgcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9kZXYpOwo+PiArfQo+ PiArCj4+ICsjaWZkZWYgQ09ORklHX1BNCj4+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNwZW5kKHN0 cnVjdCBkZXZpY2UgKmRldikKPj4gK3sKPj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBkZXZf Z2V0X2RydmRhdGEoZGV2KTsKPj4gKwo+PiArIHJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVn bWFwLCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgVE1QMTAzX0NPTkZfU0RfTUFTSywgMCk7Cj4+ICt9 Cj4+ICsKPj4gK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ ICt7Cj4+ICsgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+ ICsKPj4gKyByZXR1cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVH LAo+PiArIFRNUDEwM19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPj4gK30KPj4gKwo+ PiArc3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+ PiArIC5zdXNwZW5kID0gdG1wMTAzX3N1c3BlbmQsCj4+ICsgLnJlc3VtZSA9IHRtcDEwM19yZXN1 bWUsCj4+ICt9Owo+PiArCj4+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rl dl9wbV9vcHMpCj4+ICsjZWxzZQo+PiArI2RlZmluZSBUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4+ ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJj X2RldmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKPj4gKyB7ICJ0bXAxMDMiLCAwIH0sCj4+ICsgeyB9 Cj4+ICt9Owo+Cj4gSW4gdGhlIGJpbmRpbmdzIHlvdSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxl IHByb3BlcnR5IGFzIDogdGksdG1wMTAzLCBidXQgaGVyZSBvbmx5IHRtcDEwMy4KPgo+IEluc3Rl YWQgb2YgdXNpbmcgdGhlIGkyY19kZXZpY2VfaWQgc3RydWN0ICwgdXNlIG9mX2RldmljZV9pZCBz dHJ1Y3QgZm9yIGdpdmluZyB0aGUKPiBjb21wYXRpYmxlIHByb3BlcnR5IHZhbHVlLgo+IGNvbXBh dGJsZSA9ICI8bWFudWZhY3R1cmVyPiw8bW9kZWw+IgoKVGhlcmUgYXJlIGEgbG90IG9mIGRyaXZl cnMgaW4gZHJpdmVycy9od21vbiB3aGljaCB1c2UgImkyY19kZXZpY2VfaWQgc3RydWN0IiwKYW5k IGZvciB0aGVtIG9ubHkgIm1vZGVsIiBpcyBuZWNlc3NhcnkgLi4uCgpBcyB0aGlzIGlzIG5vdCBh IHBsYXRmb3JtIGRyaXZlciwgSSBkbyBub3Qga25vdywgaWYgIm9mX2RldmljZV9pZCBzdHJ1Y3Qi CmlzIHBvc3NpYmxlIHRvIHVzZS4gRm9yIHRoYXQsIGl0IG11c3QgYmUgY29udmVydGVkIHRvIGEg cGxhdGZvcm0KZGV2aWNlIGRyaXZlciAuLi4KCmJ5ZSwKSGVpa28KPgo+PiArTU9EVUxFX0RFVklD RV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4+ICsrc3RhdGljIHN0cnVjdCBpMmNfZHJpdmVyIHRt cDEwM19kcml2ZXIgPSB7Cj4+ICsgLmRyaXZlciA9IHsKPj4gKyAubmFtZSA9ICJ0bXAxMDMiLAo+ PiArIC5wbSA9IFRNUDEwM19ERVZfUE1fT1BTLAo+PiArIH0sCj4+ICsgLnByb2JlID0gdG1wMTAz X3Byb2JlLAo+PiArIC5pZF90YWJsZSA9IHRtcDEwM19pZCwKPj4gK307Cj4+ICsKPj4gK21vZHVs ZV9pMmNfZHJpdmVyKHRtcDEwM19kcml2ZXIpOwo+PiArCj4+ICtNT0RVTEVfQVVUSE9SKCJIZWlr byBTY2hvY2hlciA8aHNAZGVueC5kZT4iKTsKPj4gK01PRFVMRV9ERVNDUklQVElPTigiVGV4YXMg SW5zdHJ1bWVudHMgVE1QMTAzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIiKTsKPj4gK01PRFVM RV9MSUNFTlNFKCJHUEwiKTsKPgo+Cj4KCi0tIApERU5YIFNvZnR3YXJlIEVuZ2luZWVyaW5nIEdt YkgsICAgICBNRDogV29sZmdhbmcgRGVuayAmIERldGxldiBadW5kZWwKSFJCIDE2NTIzNSBNdW5p Y2gsIE9mZmljZTogS2lyY2hlbnN0ci41LCBELTgyMTk0IEdyb2ViZW56ZWxsLCBHZXJtYW55Cgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3Jz IG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1z ZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 6:16 ` Heiko Schocher 0 siblings, 0 replies; 21+ messages in thread From: Heiko Schocher @ 2014-06-18 6:16 UTC (permalink / raw) To: Varka Bhadram Cc: lm-sensors, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland Hello Varka, Am 18.06.2014 07:46, schrieb Varka Bhadram: > Hi, > > On 06/18/2014 11:07 AM, Heiko Schocher wrote: >> Driver for the TI TMP103. >> >> The TI TMP103 is similar to the TMP102. It differs from the TMP102 >> by having only 8 bit registers. >> >> Signed-off-by: Heiko Schocher <hs@denx.de> >> >> --- >> >> Cc: Jean Delvare <khali@linux-fr.org> >> Cc: Guenter Roeck <linux@roeck-us.net> >> Cc: linux-kernel@vger.kernel.org >> Cc: devicetree@vger.kernel.org >> Cc: linux-doc@vger.kernel.org >> Cc: Mark Rutland <mark.rutland@arm.com> >> >> - change for v2: >> - add comments from GuenterRoeck: >> - remove Cc from commit subject >> - add devicetree maintainer >> - move Documentation to Documentation/hwmon/tmp103 >> - remove devicetree bindings from Documentation >> - add compatible string to >> "Documentation/devicetree/bindings/i2c/trivial-devices.txt" >> - remove CamelCase >> - fix Codingstyle issues >> - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups() >> - remove unsused define TMP103_CONFIG_RD_ONLY >> - restore config register when exit() >> - use regmap >> - changes for v3: >> again a lot of fantastic tips how to use regmap efficiently >> from Guenter Roeck: >> - get rid of "struct tmp103" >> - get rid of "static const u8 tmp103_reg[]" >> - get rid of mutex lock >> - drop config_orig entirely >> - use regmap_update_bits() >> - changes for v4: >> - add comment from Guenter Roeck: >> define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK >> separately to ensure you catch all the to-be-cleared bits. >> - changes for v5: >> add comment from Guenter Roeck: >> - use "#define TMP103_CONF_SD TMP103_CONF_M1" >> add comment from Mark Rutland: >> - use full string for DT compatible string matching, instead of >> DRIVER_NAME. Get rid complete of DRIVER_NAME define. >> >> .../devicetree/bindings/i2c/trivial-devices.txt | 1 + >> Documentation/hwmon/tmp103 | 28 +++ >> drivers/hwmon/Kconfig | 10 + >> drivers/hwmon/Makefile | 1 + >> drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++ >> 5 files changed, 245 insertions(+) >> create mode 100644 Documentation/hwmon/tmp103 >> create mode 100644 drivers/hwmon/tmp103.c >> >> diff --git a/Documentation/devicetree/bindings/i2c/trivial-devices.txt b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >> index bef86e5..fc944e0 100644 >> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >> @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH ALARMS >> taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface >> ti,tsc2003 I2C Touch-Screen Controller >> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface >> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire Serial Interface >> ti,tmp275 Digital Temperature Sensor >> winbond,wpct301 i2c trusted platform module (TPM) >> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 >> new file mode 100644 >> index 0000000..ec00a15 >> --- /dev/null >> +++ b/Documentation/hwmon/tmp103 >> @@ -0,0 +1,28 @@ >> +Kernel driver tmp103 >> +==================== >> + >> +Supported chips: >> + * Texas Instruments TMP103 >> + Prefix: 'tmp103' >> + Addresses scanned: none >> + Product info and datasheet: http://www.ti.com/product/tmp103 >> + >> +Author: >> + Heiko Schocher <hs@denx.de> >> + >> +Description >> +----------- >> + >> +The TMP103 is a digital output temperature sensor in a four-ball >> +wafer chip-scale package (WCSP). The TMP103 is capable of reading >> +temperatures to a resolution of 1°C. The TMP103 is specified for >> +operation over a temperature range of –40°C to +125°C. >> + >> +Resolution: 8 Bits >> +Accuracy: ±1°C Typ (–10°C to +100°C) >> + >> +The driver provides the common sysfs-interface for temperatures (see >> +Documentation/hwmon/sysfs-interface under Temperatures). >> + >> +Please refer how to instantiate this driver: >> +Documentation/i2c/instantiating-devices >> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig >> index 08531a1..c882d4b 100644 >> --- a/drivers/hwmon/Kconfig >> +++ b/drivers/hwmon/Kconfig >> @@ -1391,6 +1391,16 @@ config SENSORS_TMP102 >> This driver can also be built as a module. If so, the module >> will be called tmp102. >> +config SENSORS_TMP103 >> + tristate "Texas Instruments TMP103" >> + depends on I2C >> + help >> + If you say yes here you get support for Texas Instruments TMP103 >> + sensor chips. >> + >> + This driver can also be built as a module. If so, the module >> + will be called tmp103. >> + >> config SENSORS_TMP401 >> tristate "Texas Instruments TMP401 and compatibles" >> depends on I2C >> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile >> index 3dc0f02..cc0df1ef 100644 >> --- a/drivers/hwmon/Makefile >> +++ b/drivers/hwmon/Makefile >> @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o >> obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o >> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o >> obj-$(CONFIG_SENSORS_TMP102) += tmp102.o >> +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o >> obj-$(CONFIG_SENSORS_TMP401) += tmp401.o >> obj-$(CONFIG_SENSORS_TMP421) += tmp421.o >> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o >> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c >> new file mode 100644 >> index 0000000..e69dbca >> --- /dev/null >> +++ b/drivers/hwmon/tmp103.c >> @@ -0,0 +1,205 @@ >> +/* >> + * Texas Instruments TMP103 SMBus temperature sensor driver >> + * Copyright (C) 2014 Heiko Schocher <hs@denx.de> >> + * >> + * Based on: >> + * Texas Instruments TMP102 SMBus temperature sensor driver >> + * >> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> >> + * >> + * This program is free software; you can redistribute it and/or modify >> + * it under the terms of the GNU General Public License as published by >> + * the Free Software Foundation; either version 2 of the License, or >> + * (at your option) any later version. >> + * >> + * This program is distributed in the hope that it will be useful, >> + * but WITHOUT ANY WARRANTY; without even the implied warranty of >> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> + * GNU General Public License for more details. >> + * >> + */ >> + >> +#include <linux/module.h> >> +#include <linux/init.h> >> +#include <linux/slab.h> >> +#include <linux/i2c.h> >> +#include <linux/hwmon.h> >> +#include <linux/hwmon-sysfs.h> >> +#include <linux/err.h> >> +#include <linux/mutex.h> >> +#include <linux/device.h> >> +#include <linux/jiffies.h> >> +#include <linux/regmap.h> >> + >> +#define TMP103_TEMP_REG 0x00 >> +#define TMP103_CONF_REG 0x01 >> +#define TMP103_TLOW_REG 0x02 >> +#define TMP103_THIGH_REG 0x03 >> + >> +#define TMP103_CONF_M0 0x01 >> +#define TMP103_CONF_M1 0x02 >> +#define TMP103_CONF_LC 0x04 >> +#define TMP103_CONF_FL 0x08 >> +#define TMP103_CONF_FH 0x10 >> +#define TMP103_CONF_CR0 0x20 >> +#define TMP103_CONF_CR1 0x40 >> +#define TMP103_CONF_ID 0x80 >> +#define TMP103_CONF_SD (TMP103_CONF_M1) >> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) >> + >> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) >> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ >> + TMP103_CONF_M0 | TMP103_CONF_M1) >> + >> +static inline int tmp103_reg_to_mc(s8 val) >> +{ >> + return val * 1000; >> +} >> + >> +static inline u8 tmp103_mc_to_reg(int val) >> +{ >> + return DIV_ROUND_CLOSEST(val, 1000); >> +} >> + >> +static ssize_t tmp103_show_temp(struct device *dev, >> + struct device_attribute *attr, >> + char *buf) >> +{ >> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >> + struct regmap *regmap = dev_get_drvdata(dev); >> + unsigned int regval; >> + int ret; >> + >> + ret = regmap_read(regmap, sda->index, ®val); >> + if (ret < 0) >> + return ret; >> + >> + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); >> +} >> + >> +static ssize_t tmp103_set_temp(struct device *dev, >> + struct device_attribute *attr, >> + const char *buf, size_t count) >> +{ >> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >> + struct regmap *regmap = dev_get_drvdata(dev); >> + long val; >> + int ret; >> + >> + if (kstrtol(buf, 10, &val) < 0) >> + return -EINVAL; >> + >> + val = clamp_val(val, -55000, 127000); >> + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); >> + return ret ? ret : count; >> +} >> + >> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , >> + TMP103_TEMP_REG); >> + >> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, TMP103_TLOW_REG); >> + >> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp, >> + tmp103_set_temp, TMP103_THIGH_REG); >> + >> +static struct attribute *tmp103_attrs[] = { >> + &sensor_dev_attr_temp1_input.dev_attr.attr, >> + &sensor_dev_attr_temp1_min.dev_attr.attr, >> + &sensor_dev_attr_temp1_max.dev_attr.attr, >> + NULL >> +}; >> +ATTRIBUTE_GROUPS(tmp103); >> + >> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg) >> +{ >> + return reg == TMP103_TEMP_REG; >> +} >> + >> +static struct regmap_config tmp103_regmap_config = { >> + .reg_bits = 8, >> + .val_bits = 8, >> + .max_register = TMP103_THIGH_REG, >> + .volatile_reg = tmp103_regmap_is_volatile, >> +}; >> + >> +static int tmp103_probe(struct i2c_client *client, >> + const struct i2c_device_id *id) >> +{ >> + struct device *dev = &client->dev; >> + struct device *hwmon_dev; >> + struct regmap *regmap; >> + int ret; >> + >> + if (!i2c_check_functionality(client->adapter, >> + I2C_FUNC_SMBUS_BYTE_DATA)) { >> + dev_err(&client->dev, >> + "adapter doesn't support SMBus byte transactions\n"); >> + return -ENODEV; >> + } >> + >> + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); >> + if (IS_ERR(regmap)) { >> + dev_err(dev, "failed to allocate register map\n"); >> + return PTR_ERR(regmap); >> + } >> + >> + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, >> + TMP103_CONFIG); >> + if (ret < 0) { >> + dev_err(&client->dev, "error writing config register\n"); >> + return ret; >> + } >> + >> + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, >> + regmap, tmp103_groups); >> + return PTR_ERR_OR_ZERO(hwmon_dev); >> +} >> + >> +#ifdef CONFIG_PM >> +static int tmp103_suspend(struct device *dev) >> +{ >> + struct regmap *regmap = dev_get_drvdata(dev); >> + >> + return regmap_update_bits(regmap, TMP103_CONF_REG, >> + TMP103_CONF_SD_MASK, 0); >> +} >> + >> +static int tmp103_resume(struct device *dev) >> +{ >> + struct regmap *regmap = dev_get_drvdata(dev); >> + >> + return regmap_update_bits(regmap, TMP103_CONF_REG, >> + TMP103_CONF_SD_MASK, TMP103_CONF_SD); >> +} >> + >> +static const struct dev_pm_ops tmp103_dev_pm_ops = { >> + .suspend = tmp103_suspend, >> + .resume = tmp103_resume, >> +}; >> + >> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) >> +#else >> +#define TMP103_DEV_PM_OPS NULL >> +#endif /* CONFIG_PM */ >> + >> +static const struct i2c_device_id tmp103_id[] = { >> + { "tmp103", 0 }, >> + { } >> +}; > > In the bindings you are giving the compatible property as : ti,tmp103, but here only tmp103. > > Instead of using the i2c_device_id struct , use of_device_id struct for giving the > compatible property value. > compatble = "<manufacturer>,<model>" There are a lot of drivers in drivers/hwmon which use "i2c_device_id struct", and for them only "model" is necessary ... As this is not a platform driver, I do not know, if "of_device_id struct" is possible to use. For that, it must be converted to a platform device driver ... bye, Heiko > >> +MODULE_DEVICE_TABLE(i2c, tmp103_id); >> ++static struct i2c_driver tmp103_driver = { >> + .driver = { >> + .name = "tmp103", >> + .pm = TMP103_DEV_PM_OPS, >> + }, >> + .probe = tmp103_probe, >> + .id_table = tmp103_id, >> +}; >> + >> +module_i2c_driver(tmp103_driver); >> + >> +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); >> +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver"); >> +MODULE_LICENSE("GPL"); > > > -- DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 6:16 ` Heiko Schocher @ 2014-06-18 7:10 ` Varka Bhadram -1 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 6:58 UTC (permalink / raw) To: hs Cc: lm-sensors, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/18/2014 11:46 AM, Heiko Schocher wrote: > Hello Varka, > > Am 18.06.2014 07:46, schrieb Varka Bhadram: >> Hi, >> >> On 06/18/2014 11:07 AM, Heiko Schocher wrote: >>> Driver for the TI TMP103. >>> >>> The TI TMP103 is similar to the TMP102. It differs from the TMP102 >>> by having only 8 bit registers. >>> >>> Signed-off-by: Heiko Schocher <hs@denx.de> >>> >>> --- >>> >>> Cc: Jean Delvare <khali@linux-fr.org> >>> Cc: Guenter Roeck <linux@roeck-us.net> >>> Cc: linux-kernel@vger.kernel.org >>> Cc: devicetree@vger.kernel.org >>> Cc: linux-doc@vger.kernel.org >>> Cc: Mark Rutland <mark.rutland@arm.com> >>> >>> - change for v2: >>> - add comments from GuenterRoeck: >>> - remove Cc from commit subject >>> - add devicetree maintainer >>> - move Documentation to Documentation/hwmon/tmp103 >>> - remove devicetree bindings from Documentation >>> - add compatible string to >>> "Documentation/devicetree/bindings/i2c/trivial-devices.txt" >>> - remove CamelCase >>> - fix Codingstyle issues >>> - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups() >>> - remove unsused define TMP103_CONFIG_RD_ONLY >>> - restore config register when exit() >>> - use regmap >>> - changes for v3: >>> again a lot of fantastic tips how to use regmap efficiently >>> from Guenter Roeck: >>> - get rid of "struct tmp103" >>> - get rid of "static const u8 tmp103_reg[]" >>> - get rid of mutex lock >>> - drop config_orig entirely >>> - use regmap_update_bits() >>> - changes for v4: >>> - add comment from Guenter Roeck: >>> define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK >>> separately to ensure you catch all the to-be-cleared bits. >>> - changes for v5: >>> add comment from Guenter Roeck: >>> - use "#define TMP103_CONF_SD TMP103_CONF_M1" >>> add comment from Mark Rutland: >>> - use full string for DT compatible string matching, instead of >>> DRIVER_NAME. Get rid complete of DRIVER_NAME define. >>> >>> .../devicetree/bindings/i2c/trivial-devices.txt | 1 + >>> Documentation/hwmon/tmp103 | 28 +++ >>> drivers/hwmon/Kconfig | 10 + >>> drivers/hwmon/Makefile | 1 + >>> drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++ >>> 5 files changed, 245 insertions(+) >>> create mode 100644 Documentation/hwmon/tmp103 >>> create mode 100644 drivers/hwmon/tmp103.c >>> >>> diff --git >>> a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> index bef86e5..fc944e0 100644 >>> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH ALARMS >>> taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface >>> ti,tsc2003 I2C Touch-Screen Controller >>> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire >>> Serial Interface >>> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire >>> Serial Interface >>> ti,tmp275 Digital Temperature Sensor >>> winbond,wpct301 i2c trusted platform module (TPM) >>> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 >>> new file mode 100644 >>> index 0000000..ec00a15 >>> --- /dev/null >>> +++ b/Documentation/hwmon/tmp103 >>> @@ -0,0 +1,28 @@ >>> +Kernel driver tmp103 >>> +==================== >>> + >>> +Supported chips: >>> + * Texas Instruments TMP103 >>> + Prefix: 'tmp103' >>> + Addresses scanned: none >>> + Product info and datasheet: http://www.ti.com/product/tmp103 >>> + >>> +Author: >>> + Heiko Schocher <hs@denx.de> >>> + >>> +Description >>> +----------- >>> + >>> +The TMP103 is a digital output temperature sensor in a four-ball >>> +wafer chip-scale package (WCSP). The TMP103 is capable of reading >>> +temperatures to a resolution of 1°C. The TMP103 is specified for >>> +operation over a temperature range of –40°C to +125°C. >>> + >>> +Resolution: 8 Bits >>> +Accuracy: ±1°C Typ (–10°C to +100°C) >>> + >>> +The driver provides the common sysfs-interface for temperatures (see >>> +Documentation/hwmon/sysfs-interface under Temperatures). >>> + >>> +Please refer how to instantiate this driver: >>> +Documentation/i2c/instantiating-devices >>> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig >>> index 08531a1..c882d4b 100644 >>> --- a/drivers/hwmon/Kconfig >>> +++ b/drivers/hwmon/Kconfig >>> @@ -1391,6 +1391,16 @@ config SENSORS_TMP102 >>> This driver can also be built as a module. If so, the module >>> will be called tmp102. >>> +config SENSORS_TMP103 >>> + tristate "Texas Instruments TMP103" >>> + depends on I2C >>> + help >>> + If you say yes here you get support for Texas Instruments TMP103 >>> + sensor chips. >>> + >>> + This driver can also be built as a module. If so, the module >>> + will be called tmp103. >>> + >>> config SENSORS_TMP401 >>> tristate "Texas Instruments TMP401 and compatibles" >>> depends on I2C >>> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile >>> index 3dc0f02..cc0df1ef 100644 >>> --- a/drivers/hwmon/Makefile >>> +++ b/drivers/hwmon/Makefile >>> @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o >>> obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o >>> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o >>> obj-$(CONFIG_SENSORS_TMP102) += tmp102.o >>> +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o >>> obj-$(CONFIG_SENSORS_TMP401) += tmp401.o >>> obj-$(CONFIG_SENSORS_TMP421) += tmp421.o >>> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o >>> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c >>> new file mode 100644 >>> index 0000000..e69dbca >>> --- /dev/null >>> +++ b/drivers/hwmon/tmp103.c >>> @@ -0,0 +1,205 @@ >>> +/* >>> + * Texas Instruments TMP103 SMBus temperature sensor driver >>> + * Copyright (C) 2014 Heiko Schocher <hs@denx.de> >>> + * >>> + * Based on: >>> + * Texas Instruments TMP102 SMBus temperature sensor driver >>> + * >>> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> >>> + * >>> + * This program is free software; you can redistribute it and/or >>> modify >>> + * it under the terms of the GNU General Public License as >>> published by >>> + * the Free Software Foundation; either version 2 of the License, or >>> + * (at your option) any later version. >>> + * >>> + * This program is distributed in the hope that it will be useful, >>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of >>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >>> + * GNU General Public License for more details. >>> + * >>> + */ >>> + >>> +#include <linux/module.h> >>> +#include <linux/init.h> >>> +#include <linux/slab.h> >>> +#include <linux/i2c.h> >>> +#include <linux/hwmon.h> >>> +#include <linux/hwmon-sysfs.h> >>> +#include <linux/err.h> >>> +#include <linux/mutex.h> >>> +#include <linux/device.h> >>> +#include <linux/jiffies.h> >>> +#include <linux/regmap.h> >>> + >>> +#define TMP103_TEMP_REG 0x00 >>> +#define TMP103_CONF_REG 0x01 >>> +#define TMP103_TLOW_REG 0x02 >>> +#define TMP103_THIGH_REG 0x03 >>> + >>> +#define TMP103_CONF_M0 0x01 >>> +#define TMP103_CONF_M1 0x02 >>> +#define TMP103_CONF_LC 0x04 >>> +#define TMP103_CONF_FL 0x08 >>> +#define TMP103_CONF_FH 0x10 >>> +#define TMP103_CONF_CR0 0x20 >>> +#define TMP103_CONF_CR1 0x40 >>> +#define TMP103_CONF_ID 0x80 >>> +#define TMP103_CONF_SD (TMP103_CONF_M1) >>> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) >>> + >>> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) >>> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ >>> + TMP103_CONF_M0 | TMP103_CONF_M1) >>> + >>> +static inline int tmp103_reg_to_mc(s8 val) >>> +{ >>> + return val * 1000; >>> +} >>> + >>> +static inline u8 tmp103_mc_to_reg(int val) >>> +{ >>> + return DIV_ROUND_CLOSEST(val, 1000); >>> +} >>> + >>> +static ssize_t tmp103_show_temp(struct device *dev, >>> + struct device_attribute *attr, >>> + char *buf) >>> +{ >>> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + unsigned int regval; >>> + int ret; >>> + >>> + ret = regmap_read(regmap, sda->index, ®val); >>> + if (ret < 0) >>> + return ret; >>> + >>> + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); >>> +} >>> + >>> +static ssize_t tmp103_set_temp(struct device *dev, >>> + struct device_attribute *attr, >>> + const char *buf, size_t count) >>> +{ >>> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + long val; >>> + int ret; >>> + >>> + if (kstrtol(buf, 10, &val) < 0) >>> + return -EINVAL; >>> + >>> + val = clamp_val(val, -55000, 127000); >>> + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); >>> + return ret ? ret : count; >>> +} >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, >>> NULL , >>> + TMP103_TEMP_REG); >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, >>> tmp103_show_temp, >>> + tmp103_set_temp, TMP103_TLOW_REG); >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, >>> tmp103_show_temp, >>> + tmp103_set_temp, TMP103_THIGH_REG); >>> + >>> +static struct attribute *tmp103_attrs[] = { >>> + &sensor_dev_attr_temp1_input.dev_attr.attr, >>> + &sensor_dev_attr_temp1_min.dev_attr.attr, >>> + &sensor_dev_attr_temp1_max.dev_attr.attr, >>> + NULL >>> +}; >>> +ATTRIBUTE_GROUPS(tmp103); >>> + >>> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned >>> int reg) >>> +{ >>> + return reg == TMP103_TEMP_REG; >>> +} >>> + >>> +static struct regmap_config tmp103_regmap_config = { >>> + .reg_bits = 8, >>> + .val_bits = 8, >>> + .max_register = TMP103_THIGH_REG, >>> + .volatile_reg = tmp103_regmap_is_volatile, >>> +}; >>> + >>> +static int tmp103_probe(struct i2c_client *client, >>> + const struct i2c_device_id *id) >>> +{ >>> + struct device *dev = &client->dev; >>> + struct device *hwmon_dev; >>> + struct regmap *regmap; >>> + int ret; >>> + >>> + if (!i2c_check_functionality(client->adapter, >>> + I2C_FUNC_SMBUS_BYTE_DATA)) { >>> + dev_err(&client->dev, >>> + "adapter doesn't support SMBus byte transactions\n"); >>> + return -ENODEV; >>> + } >>> + >>> + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); >>> + if (IS_ERR(regmap)) { >>> + dev_err(dev, "failed to allocate register map\n"); >>> + return PTR_ERR(regmap); >>> + } >>> + >>> + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, >>> + TMP103_CONFIG); >>> + if (ret < 0) { >>> + dev_err(&client->dev, "error writing config register\n"); >>> + return ret; >>> + } >>> + >>> + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, >>> + regmap, tmp103_groups); >>> + return PTR_ERR_OR_ZERO(hwmon_dev); >>> +} >>> + >>> +#ifdef CONFIG_PM >>> +static int tmp103_suspend(struct device *dev) >>> +{ >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + >>> + return regmap_update_bits(regmap, TMP103_CONF_REG, >>> + TMP103_CONF_SD_MASK, 0); >>> +} >>> + >>> +static int tmp103_resume(struct device *dev) >>> +{ >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + >>> + return regmap_update_bits(regmap, TMP103_CONF_REG, >>> + TMP103_CONF_SD_MASK, TMP103_CONF_SD); >>> +} >>> + >>> +static const struct dev_pm_ops tmp103_dev_pm_ops = { >>> + .suspend = tmp103_suspend, >>> + .resume = tmp103_resume, >>> +}; >>> + >>> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) >>> +#else >>> +#define TMP103_DEV_PM_OPS NULL >>> +#endif /* CONFIG_PM */ >>> + >>> +static const struct i2c_device_id tmp103_id[] = { >>> + { "tmp103", 0 }, >>> + { } >>> +}; >> >> In the bindings you are giving the compatible property as : >> ti,tmp103, but here only tmp103. >> >> Instead of using the i2c_device_id struct , use of_device_id struct >> for giving the >> compatible property value. >> compatble = "<manufacturer>,<model>" > > There are a lot of drivers in drivers/hwmon which use "i2c_device_id > struct", > and for them only "model" is necessary ... > > As this is not a platform driver, I do not know, if "of_device_id struct" > is possible to use. For that, it must be converted to a platform > device driver ... > I thought your are using the devicetree source to load the driver. In that case it need not to be platform driver. we can use "of_device_id struct" which matches the bindings in your trivial-devices.txt Thanks Varka Bhadram > bye, > Heiko >> >>> +MODULE_DEVICE_TABLE(i2c, tmp103_id); >>> ++static struct i2c_driver tmp103_driver = { >>> + .driver = { >>> + .name = "tmp103", >>> + .pm = TMP103_DEV_PM_OPS, >>> + }, >>> + .probe = tmp103_probe, >>> + .id_table = tmp103_id, >>> +}; >>> + >>> +module_i2c_driver(tmp103_driver); >>> + >>> +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); >>> +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor >>> driver"); >>> +MODULE_LICENSE("GPL"); >> >> >> > ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 7:10 ` Varka Bhadram 0 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 7:10 UTC (permalink / raw) To: hs Cc: lm-sensors, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland T24gMDYvMTgvMjAxNCAxMTo0NiBBTSwgSGVpa28gU2Nob2NoZXIgd3JvdGU6Cj4gSGVsbG8gVmFy a2EsCj4KPiBBbSAxOC4wNi4yMDE0IDA3OjQ2LCBzY2hyaWViIFZhcmthIEJoYWRyYW06Cj4+IEhp LAo+Pgo+PiBPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPj4+ IERyaXZlciBmb3IgdGhlIFRJIFRNUDEwMy4KPj4+Cj4+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWls YXIgdG8gdGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4+IGJ5IGhhdmlu ZyBvbmx5IDggYml0IHJlZ2lzdGVycy4KPj4+Cj4+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hv Y2hlciA8aHNAZGVueC5kZT4KPj4+Cj4+PiAtLS0KPj4+Cj4+PiBDYzogSmVhbiBEZWx2YXJlIDxr aGFsaUBsaW51eC1mci5vcmc+Cj4+PiBDYzogR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMu bmV0Pgo+Pj4gQ2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4+IENjOiBkZXZpY2V0 cmVlQHZnZXIua2VybmVsLm9yZwo+Pj4gQ2M6IGxpbnV4LWRvY0B2Z2VyLmtlcm5lbC5vcmcKPj4+ IENjOiBNYXJrIFJ1dGxhbmQgPG1hcmsucnV0bGFuZEBhcm0uY29tPgo+Pj4KPj4+IC0gY2hhbmdl IGZvciB2MjoKPj4+IC0gYWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+Pj4gLSByZW1v dmUgQ2MgZnJvbSBjb21taXQgc3ViamVjdAo+Pj4gLSBhZGQgZGV2aWNldHJlZSBtYWludGFpbmVy Cj4+PiAtIG1vdmUgRG9jdW1lbnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+ Pj4gLSByZW1vdmUgZGV2aWNldHJlZSBiaW5kaW5ncyBmcm9tIERvY3VtZW50YXRpb24KPj4+IC0g YWRkIGNvbXBhdGlibGUgc3RyaW5nIHRvCj4+PiAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2Jp bmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMudHh0Igo+Pj4gLSByZW1vdmUgQ2FtZWxDYXNlCj4+ PiAtIGZpeCBDb2RpbmdzdHlsZSBpc3N1ZXMKPj4+IC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5k IGRldm1faHdtb25fZGV2aWNlX3JlZ2lzdGVyX3dpdGhfZ3JvdXBzKCkKPj4+IC0gcmVtb3ZlIHVu c3VzZWQgZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQo+Pj4gLSByZXN0b3JlIGNvbmZpZyBy ZWdpc3RlciB3aGVuIGV4aXQoKQo+Pj4gLSB1c2UgcmVnbWFwCj4+PiAtIGNoYW5nZXMgZm9yIHYz Ogo+Pj4gYWdhaW4gYSBsb3Qgb2YgZmFudGFzdGljIHRpcHMgaG93IHRvIHVzZSByZWdtYXAgZWZm aWNpZW50bHkKPj4+IGZyb20gR3VlbnRlciBSb2VjazoKPj4+IC0gZ2V0IHJpZCBvZiAic3RydWN0 IHRtcDEwMyIKPj4+IC0gZ2V0IHJpZCBvZiAic3RhdGljIGNvbnN0IHU4IHRtcDEwM19yZWdbXSIK Pj4+IC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4+PiAtIGRyb3AgY29uZmlnX29yaWcgZW50aXJl bHkKPj4+IC0gdXNlIHJlZ21hcF91cGRhdGVfYml0cygpCj4+PiAtIGNoYW5nZXMgZm9yIHY0Ogo+ Pj4gLSBhZGQgY29tbWVudCBmcm9tIEd1ZW50ZXIgUm9lY2s6Cj4+PiBkZWZpbmUgVE1QMTAzX0NP TkZJR19NQVNLIGFuZCBUTVAxMDNfQ09ORl9TRF9NQVNLCj4+PiBzZXBhcmF0ZWx5IHRvIGVuc3Vy ZSB5b3UgY2F0Y2ggYWxsIHRoZSB0by1iZS1jbGVhcmVkIGJpdHMuCj4+PiAtIGNoYW5nZXMgZm9y IHY1Ogo+Pj4gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+Pj4gLSB1c2UgIiNkZWZp bmUgVE1QMTAzX0NPTkZfU0QgVE1QMTAzX0NPTkZfTTEiCj4+PiBhZGQgY29tbWVudCBmcm9tIE1h cmsgUnV0bGFuZDoKPj4+IC0gdXNlIGZ1bGwgc3RyaW5nIGZvciBEVCBjb21wYXRpYmxlIHN0cmlu ZyBtYXRjaGluZywgaW5zdGVhZCBvZgo+Pj4gRFJJVkVSX05BTUUuIEdldCByaWQgY29tcGxldGUg b2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Pj4KPj4+IC4uLi9kZXZpY2V0cmVlL2JpbmRpbmdzL2ky Yy90cml2aWFsLWRldmljZXMudHh0IHwgMSArCj4+PiBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw MyB8IDI4ICsrKwo+Pj4gZHJpdmVycy9od21vbi9LY29uZmlnIHwgMTAgKwo+Pj4gZHJpdmVycy9o d21vbi9NYWtlZmlsZSB8IDEgKwo+Pj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDIwNSArKysr KysrKysrKysrKysrKysrKysKPj4+IDUgZmlsZXMgY2hhbmdlZCwgMjQ1IGluc2VydGlvbnMoKykK Pj4+IGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+Pj4gY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4+Cj4+PiBkaWZmIC0tZ2l0 IAo+Pj4gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2 aWNlcy50eHQgCj4+PiBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJp dmlhbC1kZXZpY2VzLnR4dAo+Pj4gaW5kZXggYmVmODZlNS4uZmM5NDRlMCAxMDA2NDQKPj4+IC0t LSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2Vz LnR4dAo+Pj4gKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2 aWFsLWRldmljZXMudHh0Cj4+PiBAQCAtODMsNSArODMsNiBAQCBzdG0sbTQxdDgwIE00MVQ4MCAt IFNFUklBTCBBQ0NFU1MgUlRDIFdJVEggQUxBUk1TCj4+PiB0YW9zLHRzbDI1NTAgQW1iaWVudCBM aWdodCBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSBTZXJpYWwgSW50ZXJmYWNlCj4+PiB0aSx0 c2MyMDAzIEkyQyBUb3VjaC1TY3JlZW4gQ29udHJvbGxlcgo+Pj4gdGksdG1wMTAyIExvdyBQb3dl ciBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvciB3aXRoIFNNQlVTL1R3byBXaXJlIAo+Pj4gU2Vy aWFsIEludGVyZmFjZQo+Pj4gK3RpLHRtcDEwMyBMb3cgUG93ZXIgRGlnaXRhbCBUZW1wZXJhdHVy ZSBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZSAKPj4+IFNlcmlhbCBJbnRlcmZhY2UKPj4+IHRp LHRtcDI3NSBEaWdpdGFsIFRlbXBlcmF0dXJlIFNlbnNvcgo+Pj4gd2luYm9uZCx3cGN0MzAxIGky YyB0cnVzdGVkIHBsYXRmb3JtIG1vZHVsZSAoVFBNKQo+Pj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vaHdtb24vdG1wMTAzIGIvRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMKPj4+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4+PiBpbmRleCAwMDAwMDAwLi5lYzAwYTE1Cj4+PiAtLS0gL2Rldi9u dWxsCj4+PiArKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+Pj4gQEAgLTAsMCArMSwy OCBAQAo+Pj4gK0tlcm5lbCBkcml2ZXIgdG1wMTAzCj4+PiArPT09PT09PT09PT09PT09PT09PT0K Pj4+ICsKPj4+ICtTdXBwb3J0ZWQgY2hpcHM6Cj4+PiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1Q MTAzCj4+PiArIFByZWZpeDogJ3RtcDEwMycKPj4+ICsgQWRkcmVzc2VzIHNjYW5uZWQ6IG5vbmUK Pj4+ICsgUHJvZHVjdCBpbmZvIGFuZCBkYXRhc2hlZXQ6IGh0dHA6Ly93d3cudGkuY29tL3Byb2R1 Y3QvdG1wMTAzCj4+PiArCj4+PiArQXV0aG9yOgo+Pj4gKyBIZWlrbyBTY2hvY2hlciA8aHNAZGVu eC5kZT4KPj4+ICsKPj4+ICtEZXNjcmlwdGlvbgo+Pj4gKy0tLS0tLS0tLS0tCj4+PiArCj4+PiAr VGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0cHV0IHRlbXBlcmF0dXJlIHNlbnNvciBpbiBhIGZv dXItYmFsbAo+Pj4gK3dhZmVyIGNoaXAtc2NhbGUgcGFja2FnZSAoV0NTUCkuIFRoZSBUTVAxMDMg aXMgY2FwYWJsZSBvZiByZWFkaW5nCj4+PiArdGVtcGVyYXR1cmVzIHRvIGEgcmVzb2x1dGlvbiBv ZiAxwrBDLiBUaGUgVE1QMTAzIGlzIHNwZWNpZmllZCBmb3IKPj4+ICtvcGVyYXRpb24gb3ZlciBh IHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBDIHRvICsxMjXCsEMuCj4+PiArCj4+PiArUmVz b2x1dGlvbjogOCBCaXRzCj4+PiArQWNjdXJhY3k6IMKxMcKwQyBUeXAgKOKAkzEwwrBDIHRvICsx MDDCsEMpCj4+PiArCj4+PiArVGhlIGRyaXZlciBwcm92aWRlcyB0aGUgY29tbW9uIHN5c2ZzLWlu dGVyZmFjZSBmb3IgdGVtcGVyYXR1cmVzIChzZWUKPj4+ICtEb2N1bWVudGF0aW9uL2h3bW9uL3N5 c2ZzLWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+Pj4gKwo+Pj4gK1BsZWFzZSByZWZl ciBob3cgdG8gaW5zdGFudGlhdGUgdGhpcyBkcml2ZXI6Cj4+PiArRG9jdW1lbnRhdGlvbi9pMmMv aW5zdGFudGlhdGluZy1kZXZpY2VzCj4+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29u ZmlnIGIvZHJpdmVycy9od21vbi9LY29uZmlnCj4+PiBpbmRleCAwODUzMWExLi5jODgyZDRiIDEw MDY0NAo+Pj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4+PiArKysgYi9kcml2ZXJzL2h3 bW9uL0tjb25maWcKPj4+IEBAIC0xMzkxLDYgKzEzOTEsMTYgQEAgY29uZmlnIFNFTlNPUlNfVE1Q MTAyCj4+PiBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28s IHRoZSBtb2R1bGUKPj4+IHdpbGwgYmUgY2FsbGVkIHRtcDEwMi4KPj4+ICtjb25maWcgU0VOU09S U19UTVAxMDMKPj4+ICsgdHJpc3RhdGUgIlRleGFzIEluc3RydW1lbnRzIFRNUDEwMyIKPj4+ICsg ZGVwZW5kcyBvbiBJMkMKPj4+ICsgaGVscAo+Pj4gKyBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBn ZXQgc3VwcG9ydCBmb3IgVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzCj4+PiArIHNlbnNvciBjaGlw cy4KPj4+ICsKPj4+ICsgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1bGUu IElmIHNvLCB0aGUgbW9kdWxlCj4+PiArIHdpbGwgYmUgY2FsbGVkIHRtcDEwMy4KPj4+ICsKPj4+ IGNvbmZpZyBTRU5TT1JTX1RNUDQwMQo+Pj4gdHJpc3RhdGUgIlRleGFzIEluc3RydW1lbnRzIFRN UDQwMSBhbmQgY29tcGF0aWJsZXMiCj4+PiBkZXBlbmRzIG9uIEkyQwo+Pj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+PiBpbmRl eCAzZGMwZjAyLi5jYzBkZjFlZiAxMDA2NDQKPj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZp bGUKPj4+ICsrKyBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKPj4+IEBAIC0xMzUsNiArMTM1LDcg QEAgb2JqLSQoQ09ORklHX1NFTlNPUlNfU01TQzQ3TTE5MikrPSBzbXNjNDdtMTkyLm8KPj4+IG9i ai0kKENPTkZJR19TRU5TT1JTX0FNQzY4MjEpICs9IGFtYzY4MjEubwo+Pj4gb2JqLSQoQ09ORklH X1NFTlNPUlNfVEhNQzUwKSArPSB0aG1jNTAubwo+Pj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1Q MTAyKSArPSB0bXAxMDIubwo+Pj4gK29iai0kKENPTkZJR19TRU5TT1JTX1RNUDEwMykgKz0gdG1w MTAzLm8KPj4+IG9iai0kKENPTkZJR19TRU5TT1JTX1RNUDQwMSkgKz0gdG1wNDAxLm8KPj4+IG9i ai0kKENPTkZJR19TRU5TT1JTX1RNUDQyMSkgKz0gdG1wNDIxLm8KPj4+IG9iai0kKENPTkZJR19T RU5TT1JTX1RXTDQwMzBfTUFEQykrPSB0d2w0MDMwLW1hZGMtaHdtb24ubwo+Pj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMgYi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+PiBu ZXcgZmlsZSBtb2RlIDEwMDY0NAo+Pj4gaW5kZXggMDAwMDAwMC4uZTY5ZGJjYQo+Pj4gLS0tIC9k ZXYvbnVsbAo+Pj4gKysrIGIvZHJpdmVycy9od21vbi90bXAxMDMuYwo+Pj4gQEAgLTAsMCArMSwy MDUgQEAKPj4+ICsvKgo+Pj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMyBTTUJ1cyB0ZW1w ZXJhdHVyZSBzZW5zb3IgZHJpdmVyCj4+PiArICogQ29weXJpZ2h0IChDKSAyMDE0IEhlaWtvIFNj aG9jaGVyIDxoc0BkZW54LmRlPgo+Pj4gKyAqCj4+PiArICogQmFzZWQgb246Cj4+PiArICogVGV4 YXMgSW5zdHJ1bWVudHMgVE1QMTAyIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPj4+ ICsgKgo+Pj4gKyAqIENvcHlyaWdodCAoQykgMjAxMCBTdGV2ZW4gS2luZyA8c2ZraW5nQGZkd2Rj LmNvbT4KPj4+ICsgKgo+Pj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgCj4+PiBtb2RpZnkKPj4+ICsgKiBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIAo+Pj4gcHVibGlz aGVkIGJ5Cj4+PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPj4+ICsgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgo+Pj4gKyAqCj4+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+PiArICogYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPj4+ICsgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0 aGUKPj4+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+ Pj4gKyAqCj4+PiArICovCj4+PiArCj4+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+Pj4g KyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4+ ICsjaW5jbHVkZSA8bGludXgvaTJjLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+Cj4+ PiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L2Vy ci5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC9k ZXZpY2UuaD4KPj4+ICsjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgo+Pj4gKyNpbmNsdWRlIDxs aW51eC9yZWdtYXAuaD4KPj4+ICsKPj4+ICsjZGVmaW5lIFRNUDEwM19URU1QX1JFRyAweDAwCj4+ PiArI2RlZmluZSBUTVAxMDNfQ09ORl9SRUcgMHgwMQo+Pj4gKyNkZWZpbmUgVE1QMTAzX1RMT1df UkVHIDB4MDIKPj4+ICsjZGVmaW5lIFRNUDEwM19USElHSF9SRUcgMHgwMwo+Pj4gKwo+Pj4gKyNk ZWZpbmUgVE1QMTAzX0NPTkZfTTAgMHgwMQo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTTEgMHgw Mgo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTEMgMHgwNAo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NP TkZfRkwgMHgwOAo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkggMHgxMAo+Pj4gKyNkZWZpbmUg VE1QMTAzX0NPTkZfQ1IwIDB4MjAKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMSAweDQwCj4+ PiArI2RlZmluZSBUTVAxMDNfQ09ORl9JRCAweDgwCj4+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9T RCAoVE1QMTAzX0NPTkZfTTEpCj4+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRF9NQVNLIChUTVAx MDNfQ09ORl9NMCB8IFRNUDEwM19DT05GX00xKQo+Pj4gKwo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NP TkZJRyAoVE1QMTAzX0NPTkZfQ1IxIHwgVE1QMTAzX0NPTkZfTTEpCj4+PiArI2RlZmluZSBUTVAx MDNfQ09ORklHX01BU0sgKFRNUDEwM19DT05GX0NSMCB8IFRNUDEwM19DT05GX0NSMSB8IFwKPj4+ ICsgVE1QMTAzX0NPTkZfTTAgfCBUTVAxMDNfQ09ORl9NMSkKPj4+ICsKPj4+ICtzdGF0aWMgaW5s aW5lIGludCB0bXAxMDNfcmVnX3RvX21jKHM4IHZhbCkKPj4+ICt7Cj4+PiArIHJldHVybiB2YWwg KiAxMDAwOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgaW5saW5lIHU4IHRtcDEwM19tY190b19y ZWcoaW50IHZhbCkKPj4+ICt7Cj4+PiArIHJldHVybiBESVZfUk9VTkRfQ0xPU0VTVCh2YWwsIDEw MDApOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2hvd190ZW1wKHN0 cnVjdCBkZXZpY2UgKmRldiwKPj4+ICsgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4+ PiArIGNoYXIgKmJ1ZikKPj4+ICt7Cj4+PiArIHN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0 ZSAqc2RhID0gdG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpOwo+Pj4gKyBzdHJ1Y3QgcmVnbWFwICpy ZWdtYXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4+ICsgdW5zaWduZWQgaW50IHJlZ3ZhbDsK Pj4+ICsgaW50IHJldDsKPj4+ICsKPj4+ICsgcmV0ID0gcmVnbWFwX3JlYWQocmVnbWFwLCBzZGEt PmluZGV4LCAmcmVndmFsKTsKPj4+ICsgaWYgKHJldCA8IDApCj4+PiArIHJldHVybiByZXQ7Cj4+ PiArCj4+PiArIHJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDNfcmVnX3RvX21jKHJl Z3ZhbCkpOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAo c3RydWN0IGRldmljZSAqZGV2LAo+Pj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwK Pj4+ICsgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCj4+PiArewo+Pj4gKyBzdHJ1Y3Qg c2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsK Pj4+ICsgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+PiAr IGxvbmcgdmFsOwo+Pj4gKyBpbnQgcmV0Owo+Pj4gKwo+Pj4gKyBpZiAoa3N0cnRvbChidWYsIDEw LCAmdmFsKSA8IDApCj4+PiArIHJldHVybiAtRUlOVkFMOwo+Pj4gKwo+Pj4gKyB2YWwgPSBjbGFt cF92YWwodmFsLCAtNTUwMDAsIDEyNzAwMCk7Cj4+PiArIHJldCA9IHJlZ21hcF93cml0ZShyZWdt YXAsIHNkYS0+aW5kZXgsIHRtcDEwM19tY190b19yZWcodmFsKSk7Cj4+PiArIHJldHVybiByZXQg PyByZXQgOiBjb3VudDsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRU Uih0ZW1wMV9pbnB1dCwgU19JUlVHTywgdG1wMTAzX3Nob3dfdGVtcCwgCj4+PiBOVUxMICwKPj4+ ICsgVE1QMTAzX1RFTVBfUkVHKTsKPj4+ICsKPj4+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRS KHRlbXAxX21pbiwgU19JV1VTUiB8IFNfSVJVR08sIAo+Pj4gdG1wMTAzX3Nob3dfdGVtcCwKPj4+ ICsgdG1wMTAzX3NldF90ZW1wLCBUTVAxMDNfVExPV19SRUcpOwo+Pj4gKwo+Pj4gK3N0YXRpYyBT RU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgCj4+PiB0bXAx MDNfc2hvd190ZW1wLAo+Pj4gKyB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19USElHSF9SRUcpOwo+ Pj4gKwo+Pj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNfYXR0cnNbXSA9IHsKPj4+ ICsgJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+Pj4gKyAmc2Vu c29yX2Rldl9hdHRyX3RlbXAxX21pbi5kZXZfYXR0ci5hdHRyLAo+Pj4gKyAmc2Vuc29yX2Rldl9h dHRyX3RlbXAxX21heC5kZXZfYXR0ci5hdHRyLAo+Pj4gKyBOVUxMCj4+PiArfTsKPj4+ICtBVFRS SUJVVEVfR1JPVVBTKHRtcDEwMyk7Cj4+PiArCj4+PiArc3RhdGljIGJvb2wgdG1wMTAzX3JlZ21h cF9pc192b2xhdGlsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIAo+Pj4gaW50IHJlZykK Pj4+ICt7Cj4+PiArIHJldHVybiByZWcgPT0gVE1QMTAzX1RFTVBfUkVHOwo+Pj4gK30KPj4+ICsK Pj4+ICtzdGF0aWMgc3RydWN0IHJlZ21hcF9jb25maWcgdG1wMTAzX3JlZ21hcF9jb25maWcgPSB7 Cj4+PiArIC5yZWdfYml0cyA9IDgsCj4+PiArIC52YWxfYml0cyA9IDgsCj4+PiArIC5tYXhfcmVn aXN0ZXIgPSBUTVAxMDNfVEhJR0hfUkVHLAo+Pj4gKyAudm9sYXRpbGVfcmVnID0gdG1wMTAzX3Jl Z21hcF9pc192b2xhdGlsZSwKPj4+ICt9Owo+Pj4gKwo+Pj4gK3N0YXRpYyBpbnQgdG1wMTAzX3By b2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4+PiArIGNvbnN0IHN0cnVjdCBpMmNfZGV2 aWNlX2lkICppZCkKPj4+ICt7Cj4+PiArIHN0cnVjdCBkZXZpY2UgKmRldiA9ICZjbGllbnQtPmRl djsKPj4+ICsgc3RydWN0IGRldmljZSAqaHdtb25fZGV2Owo+Pj4gKyBzdHJ1Y3QgcmVnbWFwICpy ZWdtYXA7Cj4+PiArIGludCByZXQ7Cj4+PiArCj4+PiArIGlmICghaTJjX2NoZWNrX2Z1bmN0aW9u YWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+Pj4gKyBJMkNfRlVOQ19TTUJVU19CWVRFX0RBVEEpKSB7 Cj4+PiArIGRldl9lcnIoJmNsaWVudC0+ZGV2LAo+Pj4gKyAiYWRhcHRlciBkb2Vzbid0IHN1cHBv cnQgU01CdXMgYnl0ZSB0cmFuc2FjdGlvbnNcbiIpOwo+Pj4gKyByZXR1cm4gLUVOT0RFVjsKPj4+ ICsgfQo+Pj4gKwo+Pj4gKyByZWdtYXAgPSBkZXZtX3JlZ21hcF9pbml0X2kyYyhjbGllbnQsICZ0 bXAxMDNfcmVnbWFwX2NvbmZpZyk7Cj4+PiArIGlmIChJU19FUlIocmVnbWFwKSkgewo+Pj4gKyBk ZXZfZXJyKGRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSByZWdpc3RlciBtYXBcbiIpOwo+Pj4gKyBy ZXR1cm4gUFRSX0VSUihyZWdtYXApOwo+Pj4gKyB9Cj4+PiArCj4+PiArIHJldCA9IHJlZ21hcF91 cGRhdGVfYml0cyhyZWdtYXAsIFRNUDEwM19DT05GX1JFRywgVE1QMTAzX0NPTkZJR19NQVNLLAo+ Pj4gKyBUTVAxMDNfQ09ORklHKTsKPj4+ICsgaWYgKHJldCA8IDApIHsKPj4+ICsgZGV2X2Vycigm Y2xpZW50LT5kZXYsICJlcnJvciB3cml0aW5nIGNvbmZpZyByZWdpc3RlclxuIik7Cj4+PiArIHJl dHVybiByZXQ7Cj4+PiArIH0KPj4+ICsKPj4+ICsgaHdtb25fZGV2ID0gaHdtb25fZGV2aWNlX3Jl Z2lzdGVyX3dpdGhfZ3JvdXBzKGRldiwgY2xpZW50LT5uYW1lLAo+Pj4gKyByZWdtYXAsIHRtcDEw M19ncm91cHMpOwo+Pj4gKyByZXR1cm4gUFRSX0VSUl9PUl9aRVJPKGh3bW9uX2Rldik7Cj4+PiAr fQo+Pj4gKwo+Pj4gKyNpZmRlZiBDT05GSUdfUE0KPj4+ICtzdGF0aWMgaW50IHRtcDEwM19zdXNw ZW5kKHN0cnVjdCBkZXZpY2UgKmRldikKPj4+ICt7Cj4+PiArIHN0cnVjdCByZWdtYXAgKnJlZ21h cCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+Pj4gKwo+Pj4gKyByZXR1cm4gcmVnbWFwX3VwZGF0 ZV9iaXRzKHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVHLAo+Pj4gKyBUTVAxMDNfQ09ORl9TRF9NQVNL LCAwKTsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIGludCB0bXAxMDNfcmVzdW1lKHN0cnVjdCBk ZXZpY2UgKmRldikKPj4+ICt7Cj4+PiArIHN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGRldl9nZXRf ZHJ2ZGF0YShkZXYpOwo+Pj4gKwo+Pj4gKyByZXR1cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21h cCwgVE1QMTAzX0NPTkZfUkVHLAo+Pj4gKyBUTVAxMDNfQ09ORl9TRF9NQVNLLCBUTVAxMDNfQ09O Rl9TRCk7Cj4+PiArfQo+Pj4gKwo+Pj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyB0 bXAxMDNfZGV2X3BtX29wcyA9IHsKPj4+ICsgLnN1c3BlbmQgPSB0bXAxMDNfc3VzcGVuZCwKPj4+ ICsgLnJlc3VtZSA9IHRtcDEwM19yZXN1bWUsCj4+PiArfTsKPj4+ICsKPj4+ICsjZGVmaW5lIFRN UDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9wbV9vcHMpCj4+PiArI2Vsc2UKPj4+ICsjZGVm aW5lIFRNUDEwM19ERVZfUE1fT1BTIE5VTEwKPj4+ICsjZW5kaWYgLyogQ09ORklHX1BNICovCj4+ PiArCj4+PiArc3RhdGljIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkIHRtcDEwM19pZFtdID0g ewo+Pj4gKyB7ICJ0bXAxMDMiLCAwIH0sCj4+PiArIHsgfQo+Pj4gK307Cj4+Cj4+IEluIHRoZSBi aW5kaW5ncyB5b3UgYXJlIGdpdmluZyB0aGUgY29tcGF0aWJsZSBwcm9wZXJ0eSBhcyA6IAo+PiB0 aSx0bXAxMDMsIGJ1dCBoZXJlIG9ubHkgdG1wMTAzLgo+Pgo+PiBJbnN0ZWFkIG9mIHVzaW5nIHRo ZSBpMmNfZGV2aWNlX2lkIHN0cnVjdCAsIHVzZSBvZl9kZXZpY2VfaWQgc3RydWN0IAo+PiBmb3Ig Z2l2aW5nIHRoZQo+PiBjb21wYXRpYmxlIHByb3BlcnR5IHZhbHVlLgo+PiBjb21wYXRibGUgPSAi PG1hbnVmYWN0dXJlcj4sPG1vZGVsPiIKPgo+IFRoZXJlIGFyZSBhIGxvdCBvZiBkcml2ZXJzIGlu IGRyaXZlcnMvaHdtb24gd2hpY2ggdXNlICJpMmNfZGV2aWNlX2lkIAo+IHN0cnVjdCIsCj4gYW5k IGZvciB0aGVtIG9ubHkgIm1vZGVsIiBpcyBuZWNlc3NhcnkgLi4uCj4KPiBBcyB0aGlzIGlzIG5v dCBhIHBsYXRmb3JtIGRyaXZlciwgSSBkbyBub3Qga25vdywgaWYgIm9mX2RldmljZV9pZCBzdHJ1 Y3QiCj4gaXMgcG9zc2libGUgdG8gdXNlLiBGb3IgdGhhdCwgaXQgbXVzdCBiZSBjb252ZXJ0ZWQg dG8gYSBwbGF0Zm9ybQo+IGRldmljZSBkcml2ZXIgLi4uCj4KSSB0aG91Z2h0IHlvdXIgYXJlIHVz aW5nIHRoZSBkZXZpY2V0cmVlIHNvdXJjZSB0byBsb2FkIHRoZSBkcml2ZXIuIEluIAp0aGF0IGNh c2UgaXQgbmVlZCBub3QgdG8gYmUgcGxhdGZvcm0gZHJpdmVyLgp3ZSBjYW4gdXNlICJvZl9kZXZp Y2VfaWQgc3RydWN0IiB3aGljaCBtYXRjaGVzIHRoZSBiaW5kaW5ncyBpbiB5b3VyIAp0cml2aWFs LWRldmljZXMudHh0CgpUaGFua3MKVmFya2EgQmhhZHJhbQo+IGJ5ZSwKPiBIZWlrbwo+Pgo+Pj4g K01PRFVMRV9ERVZJQ0VfVEFCTEUoaTJjLCB0bXAxMDNfaWQpOwo+Pj4gKytzdGF0aWMgc3RydWN0 IGkyY19kcml2ZXIgdG1wMTAzX2RyaXZlciA9IHsKPj4+ICsgLmRyaXZlciA9IHsKPj4+ICsgLm5h bWUgPSAidG1wMTAzIiwKPj4+ICsgLnBtID0gVE1QMTAzX0RFVl9QTV9PUFMsCj4+PiArIH0sCj4+ PiArIC5wcm9iZSA9IHRtcDEwM19wcm9iZSwKPj4+ICsgLmlkX3RhYmxlID0gdG1wMTAzX2lkLAo+ Pj4gK307Cj4+PiArCj4+PiArbW9kdWxlX2kyY19kcml2ZXIodG1wMTAzX2RyaXZlcik7Cj4+PiAr Cj4+PiArTU9EVUxFX0FVVEhPUigiSGVpa28gU2Nob2NoZXIgPGhzQGRlbnguZGU+Iik7Cj4+PiAr TU9EVUxFX0RFU0NSSVBUSU9OKCJUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMgdGVtcGVyYXR1cmUg c2Vuc29yIAo+Pj4gZHJpdmVyIik7Cj4+PiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo+Pgo+Pgo+ Pgo+CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbG0t c2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9yZwpodHRwOi8vbGlz dHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 7:10 ` [lm-sensors] " Varka Bhadram @ 2014-06-18 13:02 ` Guenter Roeck -1 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 13:02 UTC (permalink / raw) To: Varka Bhadram, hs Cc: lm-sensors, Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/17/2014 11:58 PM, Varka Bhadram wrote: > On 06/18/2014 11:46 AM, Heiko Schocher wrote: ... >>> >>> In the bindings you are giving the compatible property as : ti,tmp103, but here only tmp103. >>> >>> Instead of using the i2c_device_id struct , use of_device_id struct for giving the >>> compatible property value. >>> compatble = "<manufacturer>,<model>" >> >> There are a lot of drivers in drivers/hwmon which use "i2c_device_id struct", >> and for them only "model" is necessary ... >> >> As this is not a platform driver, I do not know, if "of_device_id struct" >> is possible to use. For that, it must be converted to a platform >> device driver ... >> > I thought your are using the devicetree source to load the driver. In that case it need not to be platform driver. > we can use "of_device_id struct" which matches the bindings in your trivial-devices.txt > This would be unnecessary. The bindings will work just fine as-is. I am starting to repeat myself, as do you. May I kindly suggest that you spend some time educating yourself ? Thanks, Guenter _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 13:02 ` Guenter Roeck 0 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 13:02 UTC (permalink / raw) To: Varka Bhadram, hs Cc: lm-sensors, Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/17/2014 11:58 PM, Varka Bhadram wrote: > On 06/18/2014 11:46 AM, Heiko Schocher wrote: ... >>> >>> In the bindings you are giving the compatible property as : ti,tmp103, but here only tmp103. >>> >>> Instead of using the i2c_device_id struct , use of_device_id struct for giving the >>> compatible property value. >>> compatble = "<manufacturer>,<model>" >> >> There are a lot of drivers in drivers/hwmon which use "i2c_device_id struct", >> and for them only "model" is necessary ... >> >> As this is not a platform driver, I do not know, if "of_device_id struct" >> is possible to use. For that, it must be converted to a platform >> device driver ... >> > I thought your are using the devicetree source to load the driver. In that case it need not to be platform driver. > we can use "of_device_id struct" which matches the bindings in your trivial-devices.txt > This would be unnecessary. The bindings will work just fine as-is. I am starting to repeat myself, as do you. May I kindly suggest that you spend some time educating yourself ? Thanks, Guenter ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor 2014-06-18 6:16 ` Heiko Schocher @ 2014-06-18 7:19 ` Varka Bhadram -1 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 7:07 UTC (permalink / raw) To: hs Cc: lm-sensors, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/18/2014 11:46 AM, Heiko Schocher wrote: > Hello Varka, > > Am 18.06.2014 07:46, schrieb Varka Bhadram: >> Hi, >> >> On 06/18/2014 11:07 AM, Heiko Schocher wrote: >>> Driver for the TI TMP103. >>> >>> The TI TMP103 is similar to the TMP102. It differs from the TMP102 >>> by having only 8 bit registers. >>> >>> Signed-off-by: Heiko Schocher <hs@denx.de> >>> >>> --- >>> >>> Cc: Jean Delvare <khali@linux-fr.org> >>> Cc: Guenter Roeck <linux@roeck-us.net> >>> Cc: linux-kernel@vger.kernel.org >>> Cc: devicetree@vger.kernel.org >>> Cc: linux-doc@vger.kernel.org >>> Cc: Mark Rutland <mark.rutland@arm.com> >>> >>> - change for v2: >>> - add comments from GuenterRoeck: >>> - remove Cc from commit subject >>> - add devicetree maintainer >>> - move Documentation to Documentation/hwmon/tmp103 >>> - remove devicetree bindings from Documentation >>> - add compatible string to >>> "Documentation/devicetree/bindings/i2c/trivial-devices.txt" >>> - remove CamelCase >>> - fix Codingstyle issues >>> - use ATTRIBUTE_GROUPS and devm_hwmon_device_register_with_groups() >>> - remove unsused define TMP103_CONFIG_RD_ONLY >>> - restore config register when exit() >>> - use regmap >>> - changes for v3: >>> again a lot of fantastic tips how to use regmap efficiently >>> from Guenter Roeck: >>> - get rid of "struct tmp103" >>> - get rid of "static const u8 tmp103_reg[]" >>> - get rid of mutex lock >>> - drop config_orig entirely >>> - use regmap_update_bits() >>> - changes for v4: >>> - add comment from Guenter Roeck: >>> define TMP103_CONFIG_MASK and TMP103_CONF_SD_MASK >>> separately to ensure you catch all the to-be-cleared bits. >>> - changes for v5: >>> add comment from Guenter Roeck: >>> - use "#define TMP103_CONF_SD TMP103_CONF_M1" >>> add comment from Mark Rutland: >>> - use full string for DT compatible string matching, instead of >>> DRIVER_NAME. Get rid complete of DRIVER_NAME define. >>> >>> .../devicetree/bindings/i2c/trivial-devices.txt | 1 + >>> Documentation/hwmon/tmp103 | 28 +++ >>> drivers/hwmon/Kconfig | 10 + >>> drivers/hwmon/Makefile | 1 + >>> drivers/hwmon/tmp103.c | 205 +++++++++++++++++++++ >>> 5 files changed, 245 insertions(+) >>> create mode 100644 Documentation/hwmon/tmp103 >>> create mode 100644 drivers/hwmon/tmp103.c >>> >>> diff --git >>> a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> index bef86e5..fc944e0 100644 >>> --- a/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> +++ b/Documentation/devicetree/bindings/i2c/trivial-devices.txt >>> @@ -83,5 +83,6 @@ stm,m41t80 M41T80 - SERIAL ACCESS RTC WITH ALARMS >>> taos,tsl2550 Ambient Light Sensor with SMBUS/Two Wire Serial Interface >>> ti,tsc2003 I2C Touch-Screen Controller >>> ti,tmp102 Low Power Digital Temperature Sensor with SMBUS/Two Wire >>> Serial Interface >>> +ti,tmp103 Low Power Digital Temperature Sensor with SMBUS/Two Wire >>> Serial Interface >>> ti,tmp275 Digital Temperature Sensor >>> winbond,wpct301 i2c trusted platform module (TPM) >>> diff --git a/Documentation/hwmon/tmp103 b/Documentation/hwmon/tmp103 >>> new file mode 100644 >>> index 0000000..ec00a15 >>> --- /dev/null >>> +++ b/Documentation/hwmon/tmp103 >>> @@ -0,0 +1,28 @@ >>> +Kernel driver tmp103 >>> +==================== >>> + >>> +Supported chips: >>> + * Texas Instruments TMP103 >>> + Prefix: 'tmp103' >>> + Addresses scanned: none >>> + Product info and datasheet: http://www.ti.com/product/tmp103 >>> + >>> +Author: >>> + Heiko Schocher <hs@denx.de> >>> + >>> +Description >>> +----------- >>> + >>> +The TMP103 is a digital output temperature sensor in a four-ball >>> +wafer chip-scale package (WCSP). The TMP103 is capable of reading >>> +temperatures to a resolution of 1°C. The TMP103 is specified for >>> +operation over a temperature range of –40°C to +125°C. >>> + >>> +Resolution: 8 Bits >>> +Accuracy: ±1°C Typ (–10°C to +100°C) >>> + >>> +The driver provides the common sysfs-interface for temperatures (see >>> +Documentation/hwmon/sysfs-interface under Temperatures). >>> + >>> +Please refer how to instantiate this driver: >>> +Documentation/i2c/instantiating-devices >>> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig >>> index 08531a1..c882d4b 100644 >>> --- a/drivers/hwmon/Kconfig >>> +++ b/drivers/hwmon/Kconfig >>> @@ -1391,6 +1391,16 @@ config SENSORS_TMP102 >>> This driver can also be built as a module. If so, the module >>> will be called tmp102. >>> +config SENSORS_TMP103 >>> + tristate "Texas Instruments TMP103" >>> + depends on I2C >>> + help >>> + If you say yes here you get support for Texas Instruments TMP103 >>> + sensor chips. >>> + >>> + This driver can also be built as a module. If so, the module >>> + will be called tmp103. >>> + >>> config SENSORS_TMP401 >>> tristate "Texas Instruments TMP401 and compatibles" >>> depends on I2C >>> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile >>> index 3dc0f02..cc0df1ef 100644 >>> --- a/drivers/hwmon/Makefile >>> +++ b/drivers/hwmon/Makefile >>> @@ -135,6 +135,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o >>> obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o >>> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o >>> obj-$(CONFIG_SENSORS_TMP102) += tmp102.o >>> +obj-$(CONFIG_SENSORS_TMP103) += tmp103.o >>> obj-$(CONFIG_SENSORS_TMP401) += tmp401.o >>> obj-$(CONFIG_SENSORS_TMP421) += tmp421.o >>> obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o >>> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c >>> new file mode 100644 >>> index 0000000..e69dbca >>> --- /dev/null >>> +++ b/drivers/hwmon/tmp103.c >>> @@ -0,0 +1,205 @@ >>> +/* >>> + * Texas Instruments TMP103 SMBus temperature sensor driver >>> + * Copyright (C) 2014 Heiko Schocher <hs@denx.de> >>> + * >>> + * Based on: >>> + * Texas Instruments TMP102 SMBus temperature sensor driver >>> + * >>> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com> >>> + * >>> + * This program is free software; you can redistribute it and/or >>> modify >>> + * it under the terms of the GNU General Public License as >>> published by >>> + * the Free Software Foundation; either version 2 of the License, or >>> + * (at your option) any later version. >>> + * >>> + * This program is distributed in the hope that it will be useful, >>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of >>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >>> + * GNU General Public License for more details. >>> + * >>> + */ >>> + >>> +#include <linux/module.h> >>> +#include <linux/init.h> >>> +#include <linux/slab.h> >>> +#include <linux/i2c.h> >>> +#include <linux/hwmon.h> >>> +#include <linux/hwmon-sysfs.h> >>> +#include <linux/err.h> >>> +#include <linux/mutex.h> >>> +#include <linux/device.h> >>> +#include <linux/jiffies.h> >>> +#include <linux/regmap.h> >>> + >>> +#define TMP103_TEMP_REG 0x00 >>> +#define TMP103_CONF_REG 0x01 >>> +#define TMP103_TLOW_REG 0x02 >>> +#define TMP103_THIGH_REG 0x03 >>> + >>> +#define TMP103_CONF_M0 0x01 >>> +#define TMP103_CONF_M1 0x02 >>> +#define TMP103_CONF_LC 0x04 >>> +#define TMP103_CONF_FL 0x08 >>> +#define TMP103_CONF_FH 0x10 >>> +#define TMP103_CONF_CR0 0x20 >>> +#define TMP103_CONF_CR1 0x40 >>> +#define TMP103_CONF_ID 0x80 >>> +#define TMP103_CONF_SD (TMP103_CONF_M1) >>> +#define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1) >>> + >>> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1) >>> +#define TMP103_CONFIG_MASK (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \ >>> + TMP103_CONF_M0 | TMP103_CONF_M1) >>> + >>> +static inline int tmp103_reg_to_mc(s8 val) >>> +{ >>> + return val * 1000; >>> +} >>> + >>> +static inline u8 tmp103_mc_to_reg(int val) >>> +{ >>> + return DIV_ROUND_CLOSEST(val, 1000); >>> +} >>> + >>> +static ssize_t tmp103_show_temp(struct device *dev, >>> + struct device_attribute *attr, >>> + char *buf) >>> +{ >>> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + unsigned int regval; >>> + int ret; >>> + >>> + ret = regmap_read(regmap, sda->index, ®val); >>> + if (ret < 0) >>> + return ret; >>> + >>> + return sprintf(buf, "%d\n", tmp103_reg_to_mc(regval)); >>> +} >>> + >>> +static ssize_t tmp103_set_temp(struct device *dev, >>> + struct device_attribute *attr, >>> + const char *buf, size_t count) >>> +{ >>> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + long val; >>> + int ret; >>> + >>> + if (kstrtol(buf, 10, &val) < 0) >>> + return -EINVAL; >>> + >>> + val = clamp_val(val, -55000, 127000); >>> + ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); >>> + return ret ? ret : count; >>> +} >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, >>> NULL , >>> + TMP103_TEMP_REG); >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, >>> tmp103_show_temp, >>> + tmp103_set_temp, TMP103_TLOW_REG); >>> + >>> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, >>> tmp103_show_temp, >>> + tmp103_set_temp, TMP103_THIGH_REG); >>> + >>> +static struct attribute *tmp103_attrs[] = { >>> + &sensor_dev_attr_temp1_input.dev_attr.attr, >>> + &sensor_dev_attr_temp1_min.dev_attr.attr, >>> + &sensor_dev_attr_temp1_max.dev_attr.attr, >>> + NULL >>> +}; >>> +ATTRIBUTE_GROUPS(tmp103); >>> + >>> +static bool tmp103_regmap_is_volatile(struct device *dev, unsigned >>> int reg) >>> +{ >>> + return reg == TMP103_TEMP_REG; >>> +} >>> + >>> +static struct regmap_config tmp103_regmap_config = { >>> + .reg_bits = 8, >>> + .val_bits = 8, >>> + .max_register = TMP103_THIGH_REG, >>> + .volatile_reg = tmp103_regmap_is_volatile, >>> +}; >>> + >>> +static int tmp103_probe(struct i2c_client *client, >>> + const struct i2c_device_id *id) >>> +{ >>> + struct device *dev = &client->dev; >>> + struct device *hwmon_dev; >>> + struct regmap *regmap; >>> + int ret; >>> + >>> + if (!i2c_check_functionality(client->adapter, >>> + I2C_FUNC_SMBUS_BYTE_DATA)) { >>> + dev_err(&client->dev, >>> + "adapter doesn't support SMBus byte transactions\n"); >>> + return -ENODEV; >>> + } >>> + >>> + regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); >>> + if (IS_ERR(regmap)) { >>> + dev_err(dev, "failed to allocate register map\n"); >>> + return PTR_ERR(regmap); >>> + } >>> + >>> + ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, >>> + TMP103_CONFIG); >>> + if (ret < 0) { >>> + dev_err(&client->dev, "error writing config register\n"); >>> + return ret; >>> + } >>> + >>> + hwmon_dev = hwmon_device_register_with_groups(dev, client->name, >>> + regmap, tmp103_groups); >>> + return PTR_ERR_OR_ZERO(hwmon_dev); >>> +} >>> + >>> +#ifdef CONFIG_PM >>> +static int tmp103_suspend(struct device *dev) >>> +{ >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + >>> + return regmap_update_bits(regmap, TMP103_CONF_REG, >>> + TMP103_CONF_SD_MASK, 0); >>> +} >>> + >>> +static int tmp103_resume(struct device *dev) >>> +{ >>> + struct regmap *regmap = dev_get_drvdata(dev); >>> + >>> + return regmap_update_bits(regmap, TMP103_CONF_REG, >>> + TMP103_CONF_SD_MASK, TMP103_CONF_SD); >>> +} >>> + >>> +static const struct dev_pm_ops tmp103_dev_pm_ops = { >>> + .suspend = tmp103_suspend, >>> + .resume = tmp103_resume, >>> +}; >>> + >>> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops) >>> +#else >>> +#define TMP103_DEV_PM_OPS NULL >>> +#endif /* CONFIG_PM */ >>> + >>> +static const struct i2c_device_id tmp103_id[] = { >>> + { "tmp103", 0 }, >>> + { } >>> +}; >> >> In the bindings you are giving the compatible property as : >> ti,tmp103, but here only tmp103. >> >> Instead of using the i2c_device_id struct , use of_device_id struct >> for giving the >> compatible property value. >> compatble = "<manufacturer>,<model>" > > There are a lot of drivers in drivers/hwmon which use "i2c_device_id > struct", > and for them only "model" is necessary ... > > As this is not a platform driver, I do not know, if "of_device_id struct" > is possible to use. For that, it must be converted to a platform > device driver ... > I thought your are using the devicetree source to load the driver. In that case it need not to be platform driver. we can use "of_device_id struct" which matches the bindings in your trivial-devices.txt Thanks Varka Bhadram > bye, > Heiko >> >>> +MODULE_DEVICE_TABLE(i2c, tmp103_id); >>> ++static struct i2c_driver tmp103_driver = { >>> + .driver = { >>> + .name = "tmp103", >>> + .pm = TMP103_DEV_PM_OPS, >>> + }, >>> + .probe = tmp103_probe, >>> + .id_table = tmp103_id, >>> +}; >>> + >>> +module_i2c_driver(tmp103_driver); >>> + >>> +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>"); >>> +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor >>> driver"); >>> +MODULE_LICENSE("GPL"); >> >> >> > ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 7:19 ` Varka Bhadram 0 siblings, 0 replies; 21+ messages in thread From: Varka Bhadram @ 2014-06-18 7:19 UTC (permalink / raw) To: hs Cc: lm-sensors, Jean Delvare, Guenter Roeck, linux-kernel, devicetree, linux-doc, Mark Rutland T24gMDYvMTgvMjAxNCAxMTo0NiBBTSwgSGVpa28gU2Nob2NoZXIgd3JvdGU6Cj4gSGVsbG8gVmFy a2EsCj4KPiBBbSAxOC4wNi4yMDE0IDA3OjQ2LCBzY2hyaWViIFZhcmthIEJoYWRyYW06Cj4+IEhp LAo+Pgo+PiBPbiAwNi8xOC8yMDE0IDExOjA3IEFNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPj4+ IERyaXZlciBmb3IgdGhlIFRJIFRNUDEwMy4KPj4+Cj4+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWls YXIgdG8gdGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4+IGJ5IGhhdmlu ZyBvbmx5IDggYml0IHJlZ2lzdGVycy4KPj4+Cj4+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hv Y2hlciA8aHNAZGVueC5kZT4KPj4+Cj4+PiAtLS0KPj4+Cj4+PiBDYzogSmVhbiBEZWx2YXJlIDxr aGFsaUBsaW51eC1mci5vcmc+Cj4+PiBDYzogR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMu bmV0Pgo+Pj4gQ2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4+IENjOiBkZXZpY2V0 cmVlQHZnZXIua2VybmVsLm9yZwo+Pj4gQ2M6IGxpbnV4LWRvY0B2Z2VyLmtlcm5lbC5vcmcKPj4+ IENjOiBNYXJrIFJ1dGxhbmQgPG1hcmsucnV0bGFuZEBhcm0uY29tPgo+Pj4KPj4+IC0gY2hhbmdl IGZvciB2MjoKPj4+IC0gYWRkIGNvbW1lbnRzIGZyb20gR3VlbnRlclJvZWNrOgo+Pj4gLSByZW1v dmUgQ2MgZnJvbSBjb21taXQgc3ViamVjdAo+Pj4gLSBhZGQgZGV2aWNldHJlZSBtYWludGFpbmVy Cj4+PiAtIG1vdmUgRG9jdW1lbnRhdGlvbiB0byBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+ Pj4gLSByZW1vdmUgZGV2aWNldHJlZSBiaW5kaW5ncyBmcm9tIERvY3VtZW50YXRpb24KPj4+IC0g YWRkIGNvbXBhdGlibGUgc3RyaW5nIHRvCj4+PiAiRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2Jp bmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMudHh0Igo+Pj4gLSByZW1vdmUgQ2FtZWxDYXNlCj4+ PiAtIGZpeCBDb2RpbmdzdHlsZSBpc3N1ZXMKPj4+IC0gdXNlIEFUVFJJQlVURV9HUk9VUFMgYW5k IGRldm1faHdtb25fZGV2aWNlX3JlZ2lzdGVyX3dpdGhfZ3JvdXBzKCkKPj4+IC0gcmVtb3ZlIHVu c3VzZWQgZGVmaW5lIFRNUDEwM19DT05GSUdfUkRfT05MWQo+Pj4gLSByZXN0b3JlIGNvbmZpZyBy ZWdpc3RlciB3aGVuIGV4aXQoKQo+Pj4gLSB1c2UgcmVnbWFwCj4+PiAtIGNoYW5nZXMgZm9yIHYz Ogo+Pj4gYWdhaW4gYSBsb3Qgb2YgZmFudGFzdGljIHRpcHMgaG93IHRvIHVzZSByZWdtYXAgZWZm aWNpZW50bHkKPj4+IGZyb20gR3VlbnRlciBSb2VjazoKPj4+IC0gZ2V0IHJpZCBvZiAic3RydWN0 IHRtcDEwMyIKPj4+IC0gZ2V0IHJpZCBvZiAic3RhdGljIGNvbnN0IHU4IHRtcDEwM19yZWdbXSIK Pj4+IC0gZ2V0IHJpZCBvZiBtdXRleCBsb2NrCj4+PiAtIGRyb3AgY29uZmlnX29yaWcgZW50aXJl bHkKPj4+IC0gdXNlIHJlZ21hcF91cGRhdGVfYml0cygpCj4+PiAtIGNoYW5nZXMgZm9yIHY0Ogo+ Pj4gLSBhZGQgY29tbWVudCBmcm9tIEd1ZW50ZXIgUm9lY2s6Cj4+PiBkZWZpbmUgVE1QMTAzX0NP TkZJR19NQVNLIGFuZCBUTVAxMDNfQ09ORl9TRF9NQVNLCj4+PiBzZXBhcmF0ZWx5IHRvIGVuc3Vy ZSB5b3UgY2F0Y2ggYWxsIHRoZSB0by1iZS1jbGVhcmVkIGJpdHMuCj4+PiAtIGNoYW5nZXMgZm9y IHY1Ogo+Pj4gYWRkIGNvbW1lbnQgZnJvbSBHdWVudGVyIFJvZWNrOgo+Pj4gLSB1c2UgIiNkZWZp bmUgVE1QMTAzX0NPTkZfU0QgVE1QMTAzX0NPTkZfTTEiCj4+PiBhZGQgY29tbWVudCBmcm9tIE1h cmsgUnV0bGFuZDoKPj4+IC0gdXNlIGZ1bGwgc3RyaW5nIGZvciBEVCBjb21wYXRpYmxlIHN0cmlu ZyBtYXRjaGluZywgaW5zdGVhZCBvZgo+Pj4gRFJJVkVSX05BTUUuIEdldCByaWQgY29tcGxldGUg b2YgRFJJVkVSX05BTUUgZGVmaW5lLgo+Pj4KPj4+IC4uLi9kZXZpY2V0cmVlL2JpbmRpbmdzL2ky Yy90cml2aWFsLWRldmljZXMudHh0IHwgMSArCj4+PiBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEw MyB8IDI4ICsrKwo+Pj4gZHJpdmVycy9od21vbi9LY29uZmlnIHwgMTAgKwo+Pj4gZHJpdmVycy9o d21vbi9NYWtlZmlsZSB8IDEgKwo+Pj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDIwNSArKysr KysrKysrKysrKysrKysrKysKPj4+IDUgZmlsZXMgY2hhbmdlZCwgMjQ1IGluc2VydGlvbnMoKykK Pj4+IGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+Pj4gY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4+Cj4+PiBkaWZmIC0tZ2l0 Cj4+PiBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZp Y2VzLnR4dAo+Pj4gYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZp YWwtZGV2aWNlcy50eHQKPj4+IGluZGV4IGJlZjg2ZTUuLmZjOTQ0ZTAgMTAwNjQ0Cj4+PiAtLS0g YS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50 eHQKPj4+ICsrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlh bC1kZXZpY2VzLnR4dAo+Pj4gQEAgLTgzLDUgKzgzLDYgQEAgc3RtLG00MXQ4MCBNNDFUODAgLSBT RVJJQUwgQUNDRVNTIFJUQyBXSVRIIEFMQVJNUwo+Pj4gdGFvcyx0c2wyNTUwIEFtYmllbnQgTGln aHQgU2Vuc29yIHdpdGggU01CVVMvVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZQo+Pj4gdGksdHNj MjAwMyBJMkMgVG91Y2gtU2NyZWVuIENvbnRyb2xsZXIKPj4+IHRpLHRtcDEwMiBMb3cgUG93ZXIg RGlnaXRhbCBUZW1wZXJhdHVyZSBTZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZQo+Pj4gU2VyaWFs IEludGVyZmFjZQo+Pj4gK3RpLHRtcDEwMyBMb3cgUG93ZXIgRGlnaXRhbCBUZW1wZXJhdHVyZSBT ZW5zb3Igd2l0aCBTTUJVUy9Ud28gV2lyZQo+Pj4gU2VyaWFsIEludGVyZmFjZQo+Pj4gdGksdG1w Mjc1IERpZ2l0YWwgVGVtcGVyYXR1cmUgU2Vuc29yCj4+PiB3aW5ib25kLHdwY3QzMDEgaTJjIHRy dXN0ZWQgcGxhdGZvcm0gbW9kdWxlIChUUE0pCj4+PiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlv bi9od21vbi90bXAxMDMgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3RtcDEwMwo+Pj4gbmV3IGZpbGUg bW9kZSAxMDA2NDQKPj4+IGluZGV4IDAwMDAwMDAuLmVjMDBhMTUKPj4+IC0tLSAvZGV2L251bGwK Pj4+ICsrKyBiL0RvY3VtZW50YXRpb24vaHdtb24vdG1wMTAzCj4+PiBAQCAtMCwwICsxLDI4IEBA Cj4+PiArS2VybmVsIGRyaXZlciB0bXAxMDMKPj4+ICs9PT09PT09PT09PT09PT09PT09PQo+Pj4g Kwo+Pj4gK1N1cHBvcnRlZCBjaGlwczoKPj4+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMK Pj4+ICsgUHJlZml4OiAndG1wMTAzJwo+Pj4gKyBBZGRyZXNzZXMgc2Nhbm5lZDogbm9uZQo+Pj4g KyBQcm9kdWN0IGluZm8gYW5kIGRhdGFzaGVldDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90 bXAxMDMKPj4+ICsKPj4+ICtBdXRob3I6Cj4+PiArIEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRl Pgo+Pj4gKwo+Pj4gK0Rlc2NyaXB0aW9uCj4+PiArLS0tLS0tLS0tLS0KPj4+ICsKPj4+ICtUaGUg VE1QMTAzIGlzIGEgZGlnaXRhbCBvdXRwdXQgdGVtcGVyYXR1cmUgc2Vuc29yIGluIGEgZm91ci1i YWxsCj4+PiArd2FmZXIgY2hpcC1zY2FsZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRNUDEwMyBpcyBj YXBhYmxlIG9mIHJlYWRpbmcKPj4+ICt0ZW1wZXJhdHVyZXMgdG8gYSByZXNvbHV0aW9uIG9mIDHC sEMuIFRoZSBUTVAxMDMgaXMgc3BlY2lmaWVkIGZvcgo+Pj4gK29wZXJhdGlvbiBvdmVyIGEgdGVt cGVyYXR1cmUgcmFuZ2Ugb2Yg4oCTNDDCsEMgdG8gKzEyNcKwQy4KPj4+ICsKPj4+ICtSZXNvbHV0 aW9uOiA4IEJpdHMKPj4+ICtBY2N1cmFjeTogwrExwrBDIFR5cCAo4oCTMTDCsEMgdG8gKzEwMMKw QykKPj4+ICsKPj4+ICtUaGUgZHJpdmVyIHByb3ZpZGVzIHRoZSBjb21tb24gc3lzZnMtaW50ZXJm YWNlIGZvciB0ZW1wZXJhdHVyZXMgKHNlZQo+Pj4gK0RvY3VtZW50YXRpb24vaHdtb24vc3lzZnMt aW50ZXJmYWNlIHVuZGVyIFRlbXBlcmF0dXJlcykuCj4+PiArCj4+PiArUGxlYXNlIHJlZmVyIGhv dyB0byBpbnN0YW50aWF0ZSB0aGlzIGRyaXZlcjoKPj4+ICtEb2N1bWVudGF0aW9uL2kyYy9pbnN0 YW50aWF0aW5nLWRldmljZXMKPj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL0tjb25maWcg Yi9kcml2ZXJzL2h3bW9uL0tjb25maWcKPj4+IGluZGV4IDA4NTMxYTEuLmM4ODJkNGIgMTAwNjQ0 Cj4+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcKPj4+ICsrKyBiL2RyaXZlcnMvaHdtb24v S2NvbmZpZwo+Pj4gQEAgLTEzOTEsNiArMTM5MSwxNiBAQCBjb25maWcgU0VOU09SU19UTVAxMDIK Pj4+IFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9kdWxlLiBJZiBzbywgdGhl IG1vZHVsZQo+Pj4gd2lsbCBiZSBjYWxsZWQgdG1wMTAyLgo+Pj4gK2NvbmZpZyBTRU5TT1JTX1RN UDEwMwo+Pj4gKyB0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIgo+Pj4gKyBkZXBl bmRzIG9uIEkyQwo+Pj4gKyBoZWxwCj4+PiArIElmIHlvdSBzYXkgeWVzIGhlcmUgeW91IGdldCBz dXBwb3J0IGZvciBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKPj4+ICsgc2Vuc29yIGNoaXBzLgo+ Pj4gKwo+Pj4gKyBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYg c28sIHRoZSBtb2R1bGUKPj4+ICsgd2lsbCBiZSBjYWxsZWQgdG1wMTAzLgo+Pj4gKwo+Pj4gY29u ZmlnIFNFTlNPUlNfVE1QNDAxCj4+PiB0cmlzdGF0ZSAiVGV4YXMgSW5zdHJ1bWVudHMgVE1QNDAx IGFuZCBjb21wYXRpYmxlcyIKPj4+IGRlcGVuZHMgb24gSTJDCj4+PiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9od21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKPj4+IGluZGV4IDNk YzBmMDIuLmNjMGRmMWVmIDEwMDY0NAo+Pj4gLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+ Pj4gKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+Pj4gQEAgLTEzNSw2ICsxMzUsNyBAQCBv YmotJChDT05GSUdfU0VOU09SU19TTVNDNDdNMTkyKSs9IHNtc2M0N20xOTIubwo+Pj4gb2JqLSQo Q09ORklHX1NFTlNPUlNfQU1DNjgyMSkgKz0gYW1jNjgyMS5vCj4+PiBvYmotJChDT05GSUdfU0VO U09SU19USE1DNTApICs9IHRobWM1MC5vCj4+PiBvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDIp ICs9IHRtcDEwMi5vCj4+PiArb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QMTAzKSArPSB0bXAxMDMu bwo+Pj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDAxKSArPSB0bXA0MDEubwo+Pj4gb2JqLSQo Q09ORklHX1NFTlNPUlNfVE1QNDIxKSArPSB0bXA0MjEubwo+Pj4gb2JqLSQoQ09ORklHX1NFTlNP UlNfVFdMNDAzMF9NQURDKSs9IHR3bDQwMzAtbWFkYy1od21vbi5vCj4+PiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9od21vbi90bXAxMDMuYyBiL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4+PiBpbmRleCAwMDAwMDAwLi5lNjlkYmNhCj4+PiAtLS0gL2Rldi9u dWxsCj4+PiArKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+PiBAQCAtMCwwICsxLDIwNSBA QAo+Pj4gKy8qCj4+PiArICogVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIFNNQnVzIHRlbXBlcmF0 dXJlIHNlbnNvciBkcml2ZXIKPj4+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTQgSGVpa28gU2Nob2No ZXIgPGhzQGRlbnguZGU+Cj4+PiArICoKPj4+ICsgKiBCYXNlZCBvbjoKPj4+ICsgKiBUZXhhcyBJ bnN0cnVtZW50cyBUTVAxMDIgU01CdXMgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZlcgo+Pj4gKyAq Cj4+PiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBLaW5nIDxzZmtpbmdAZmR3ZGMuY29t Pgo+Pj4gKyAqCj4+PiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgo+Pj4gbW9kaWZ5Cj4+PiArICogaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcwo+Pj4gcHVibGlzaGVkIGJ5 Cj4+PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IKPj4+ICsgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgo+Pj4gKyAqCj4+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+PiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPj4+ICsgKiBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUKPj4+ ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+Pj4gKyAq Cj4+PiArICovCj4+PiArCj4+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+Pj4gKyNpbmNs dWRlIDxsaW51eC9pbml0Lmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4+ICsjaW5j bHVkZSA8bGludXgvaTJjLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+Cj4+PiArI2lu Y2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgo+ Pj4gKyNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2Uu aD4KPj4+ICsjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC9y ZWdtYXAuaD4KPj4+ICsKPj4+ICsjZGVmaW5lIFRNUDEwM19URU1QX1JFRyAweDAwCj4+PiArI2Rl ZmluZSBUTVAxMDNfQ09ORl9SRUcgMHgwMQo+Pj4gKyNkZWZpbmUgVE1QMTAzX1RMT1dfUkVHIDB4 MDIKPj4+ICsjZGVmaW5lIFRNUDEwM19USElHSF9SRUcgMHgwMwo+Pj4gKwo+Pj4gKyNkZWZpbmUg VE1QMTAzX0NPTkZfTTAgMHgwMQo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfTTEgMHgwMgo+Pj4g KyNkZWZpbmUgVE1QMTAzX0NPTkZfTEMgMHgwNAo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkwg MHgwOAo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfRkggMHgxMAo+Pj4gKyNkZWZpbmUgVE1QMTAz X0NPTkZfQ1IwIDB4MjAKPj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX0NSMSAweDQwCj4+PiArI2Rl ZmluZSBUTVAxMDNfQ09ORl9JRCAweDgwCj4+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRCAoVE1Q MTAzX0NPTkZfTTEpCj4+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRF9NQVNLIChUTVAxMDNfQ09O Rl9NMCB8IFRNUDEwM19DT05GX00xKQo+Pj4gKwo+Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZJRyAo VE1QMTAzX0NPTkZfQ1IxIHwgVE1QMTAzX0NPTkZfTTEpCj4+PiArI2RlZmluZSBUTVAxMDNfQ09O RklHX01BU0sgKFRNUDEwM19DT05GX0NSMCB8IFRNUDEwM19DT05GX0NSMSB8IFwKPj4+ICsgVE1Q MTAzX0NPTkZfTTAgfCBUTVAxMDNfQ09ORl9NMSkKPj4+ICsKPj4+ICtzdGF0aWMgaW5saW5lIGlu dCB0bXAxMDNfcmVnX3RvX21jKHM4IHZhbCkKPj4+ICt7Cj4+PiArIHJldHVybiB2YWwgKiAxMDAw Owo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgaW5saW5lIHU4IHRtcDEwM19tY190b19yZWcoaW50 IHZhbCkKPj4+ICt7Cj4+PiArIHJldHVybiBESVZfUk9VTkRfQ0xPU0VTVCh2YWwsIDEwMDApOwo+ Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2hvd190ZW1wKHN0cnVjdCBk ZXZpY2UgKmRldiwKPj4+ICsgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4+PiArIGNo YXIgKmJ1ZikKPj4+ICt7Cj4+PiArIHN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAqc2Rh ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpOwo+Pj4gKyBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAg PSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4+ICsgdW5zaWduZWQgaW50IHJlZ3ZhbDsKPj4+ICsg aW50IHJldDsKPj4+ICsKPj4+ICsgcmV0ID0gcmVnbWFwX3JlYWQocmVnbWFwLCBzZGEtPmluZGV4 LCAmcmVndmFsKTsKPj4+ICsgaWYgKHJldCA8IDApCj4+PiArIHJldHVybiByZXQ7Cj4+PiArCj4+ PiArIHJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDNfcmVnX3RvX21jKHJlZ3ZhbCkp Owo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAoc3RydWN0 IGRldmljZSAqZGV2LAo+Pj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPj4+ICsg Y29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCj4+PiArewo+Pj4gKyBzdHJ1Y3Qgc2Vuc29y X2RldmljZV9hdHRyaWJ1dGUgKnNkYSA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKTsKPj4+ICsg c3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+PiArIGxvbmcg dmFsOwo+Pj4gKyBpbnQgcmV0Owo+Pj4gKwo+Pj4gKyBpZiAoa3N0cnRvbChidWYsIDEwLCAmdmFs KSA8IDApCj4+PiArIHJldHVybiAtRUlOVkFMOwo+Pj4gKwo+Pj4gKyB2YWwgPSBjbGFtcF92YWwo dmFsLCAtNTUwMDAsIDEyNzAwMCk7Cj4+PiArIHJldCA9IHJlZ21hcF93cml0ZShyZWdtYXAsIHNk YS0+aW5kZXgsIHRtcDEwM19tY190b19yZWcodmFsKSk7Cj4+PiArIHJldHVybiByZXQgPyByZXQg OiBjb3VudDsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1w MV9pbnB1dCwgU19JUlVHTywgdG1wMTAzX3Nob3dfdGVtcCwKPj4+IE5VTEwgLAo+Pj4gKyBUTVAx MDNfVEVNUF9SRUcpOwo+Pj4gKwo+Pj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFf bWluLCBTX0lXVVNSIHwgU19JUlVHTywKPj4+IHRtcDEwM19zaG93X3RlbXAsCj4+PiArIHRtcDEw M19zZXRfdGVtcCwgVE1QMTAzX1RMT1dfUkVHKTsKPj4+ICsKPj4+ICtzdGF0aWMgU0VOU09SX0RF VklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sCj4+PiB0bXAxMDNfc2hvd190 ZW1wLAo+Pj4gKyB0bXAxMDNfc2V0X3RlbXAsIFRNUDEwM19USElHSF9SRUcpOwo+Pj4gKwo+Pj4g K3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp0bXAxMDNfYXR0cnNbXSA9IHsKPj4+ICsgJnNlbnNv cl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAo+Pj4gKyAmc2Vuc29yX2Rldl9h dHRyX3RlbXAxX21pbi5kZXZfYXR0ci5hdHRyLAo+Pj4gKyAmc2Vuc29yX2Rldl9hdHRyX3RlbXAx X21heC5kZXZfYXR0ci5hdHRyLAo+Pj4gKyBOVUxMCj4+PiArfTsKPj4+ICtBVFRSSUJVVEVfR1JP VVBTKHRtcDEwMyk7Cj4+PiArCj4+PiArc3RhdGljIGJvb2wgdG1wMTAzX3JlZ21hcF9pc192b2xh dGlsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkCj4+PiBpbnQgcmVnKQo+Pj4gK3sKPj4+ ICsgcmV0dXJuIHJlZyA9PSBUTVAxMDNfVEVNUF9SRUc7Cj4+PiArfQo+Pj4gKwo+Pj4gK3N0YXRp YyBzdHJ1Y3QgcmVnbWFwX2NvbmZpZyB0bXAxMDNfcmVnbWFwX2NvbmZpZyA9IHsKPj4+ICsgLnJl Z19iaXRzID0gOCwKPj4+ICsgLnZhbF9iaXRzID0gOCwKPj4+ICsgLm1heF9yZWdpc3RlciA9IFRN UDEwM19USElHSF9SRUcsCj4+PiArIC52b2xhdGlsZV9yZWcgPSB0bXAxMDNfcmVnbWFwX2lzX3Zv bGF0aWxlLAo+Pj4gK307Cj4+PiArCj4+PiArc3RhdGljIGludCB0bXAxMDNfcHJvYmUoc3RydWN0 IGkyY19jbGllbnQgKmNsaWVudCwKPj4+ICsgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlk KQo+Pj4gK3sKPj4+ICsgc3RydWN0IGRldmljZSAqZGV2ID0gJmNsaWVudC0+ZGV2Owo+Pj4gKyBz dHJ1Y3QgZGV2aWNlICpod21vbl9kZXY7Cj4+PiArIHN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPj4+ ICsgaW50IHJldDsKPj4+ICsKPj4+ICsgaWYgKCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShjbGll bnQtPmFkYXB0ZXIsCj4+PiArIEkyQ19GVU5DX1NNQlVTX0JZVEVfREFUQSkpIHsKPj4+ICsgZGV2 X2VycigmY2xpZW50LT5kZXYsCj4+PiArICJhZGFwdGVyIGRvZXNuJ3Qgc3VwcG9ydCBTTUJ1cyBi eXRlIHRyYW5zYWN0aW9uc1xuIik7Cj4+PiArIHJldHVybiAtRU5PREVWOwo+Pj4gKyB9Cj4+PiAr Cj4+PiArIHJlZ21hcCA9IGRldm1fcmVnbWFwX2luaXRfaTJjKGNsaWVudCwgJnRtcDEwM19yZWdt YXBfY29uZmlnKTsKPj4+ICsgaWYgKElTX0VSUihyZWdtYXApKSB7Cj4+PiArIGRldl9lcnIoZGV2 LCAiZmFpbGVkIHRvIGFsbG9jYXRlIHJlZ2lzdGVyIG1hcFxuIik7Cj4+PiArIHJldHVybiBQVFJf RVJSKHJlZ21hcCk7Cj4+PiArIH0KPj4+ICsKPj4+ICsgcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRz KHJlZ21hcCwgVE1QMTAzX0NPTkZfUkVHLCBUTVAxMDNfQ09ORklHX01BU0ssCj4+PiArIFRNUDEw M19DT05GSUcpOwo+Pj4gKyBpZiAocmV0IDwgMCkgewo+Pj4gKyBkZXZfZXJyKCZjbGllbnQtPmRl diwgImVycm9yIHdyaXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4+ICsgcmV0dXJuIHJldDsK Pj4+ICsgfQo+Pj4gKwo+Pj4gKyBod21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0 aF9ncm91cHMoZGV2LCBjbGllbnQtPm5hbWUsCj4+PiArIHJlZ21hcCwgdG1wMTAzX2dyb3Vwcyk7 Cj4+PiArIHJldHVybiBQVFJfRVJSX09SX1pFUk8oaHdtb25fZGV2KTsKPj4+ICt9Cj4+PiArCj4+ PiArI2lmZGVmIENPTkZJR19QTQo+Pj4gK3N0YXRpYyBpbnQgdG1wMTAzX3N1c3BlbmQoc3RydWN0 IGRldmljZSAqZGV2KQo+Pj4gK3sKPj4+ICsgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dl dF9kcnZkYXRhKGRldik7Cj4+PiArCj4+PiArIHJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVn bWFwLCBUTVAxMDNfQ09ORl9SRUcsCj4+PiArIFRNUDEwM19DT05GX1NEX01BU0ssIDApOwo+Pj4g K30KPj4+ICsKPj4+ICtzdGF0aWMgaW50IHRtcDEwM19yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2 KQo+Pj4gK3sKPj4+ICsgc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gZGV2X2dldF9kcnZkYXRhKGRl dik7Cj4+PiArCj4+PiArIHJldHVybiByZWdtYXBfdXBkYXRlX2JpdHMocmVnbWFwLCBUTVAxMDNf Q09ORl9SRUcsCj4+PiArIFRNUDEwM19DT05GX1NEX01BU0ssIFRNUDEwM19DT05GX1NEKTsKPj4+ ICt9Cj4+PiArCj4+PiArc3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZf cG1fb3BzID0gewo+Pj4gKyAuc3VzcGVuZCA9IHRtcDEwM19zdXNwZW5kLAo+Pj4gKyAucmVzdW1l ID0gdG1wMTAzX3Jlc3VtZSwKPj4+ICt9Owo+Pj4gKwo+Pj4gKyNkZWZpbmUgVE1QMTAzX0RFVl9Q TV9PUFMgKCZ0bXAxMDNfZGV2X3BtX29wcykKPj4+ICsjZWxzZQo+Pj4gKyNkZWZpbmUgVE1QMTAz X0RFVl9QTV9PUFMgTlVMTAo+Pj4gKyNlbmRpZiAvKiBDT05GSUdfUE0gKi8KPj4+ICsKPj4+ICtz dGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgdG1wMTAzX2lkW10gPSB7Cj4+PiArIHsg InRtcDEwMyIsIDAgfSwKPj4+ICsgeyB9Cj4+PiArfTsKPj4KPj4gSW4gdGhlIGJpbmRpbmdzIHlv dSBhcmUgZ2l2aW5nIHRoZSBjb21wYXRpYmxlIHByb3BlcnR5IGFzIDoKPj4gdGksdG1wMTAzLCBi dXQgaGVyZSBvbmx5IHRtcDEwMy4KPj4KPj4gSW5zdGVhZCBvZiB1c2luZyB0aGUgaTJjX2Rldmlj ZV9pZCBzdHJ1Y3QgLCB1c2Ugb2ZfZGV2aWNlX2lkIHN0cnVjdAo+PiBmb3IgZ2l2aW5nIHRoZQo+ PiBjb21wYXRpYmxlIHByb3BlcnR5IHZhbHVlLgo+PiBjb21wYXRibGUgPSAiPG1hbnVmYWN0dXJl cj4sPG1vZGVsPiIKPgo+IFRoZXJlIGFyZSBhIGxvdCBvZiBkcml2ZXJzIGluIGRyaXZlcnMvaHdt b24gd2hpY2ggdXNlICJpMmNfZGV2aWNlX2lkCj4gc3RydWN0IiwKPiBhbmQgZm9yIHRoZW0gb25s eSAibW9kZWwiIGlzIG5lY2Vzc2FyeSAuLi4KPgo+IEFzIHRoaXMgaXMgbm90IGEgcGxhdGZvcm0g ZHJpdmVyLCBJIGRvIG5vdCBrbm93LCBpZiAib2ZfZGV2aWNlX2lkIHN0cnVjdCIKPiBpcyBwb3Nz aWJsZSB0byB1c2UuIEZvciB0aGF0LCBpdCBtdXN0IGJlIGNvbnZlcnRlZCB0byBhIHBsYXRmb3Jt Cj4gZGV2aWNlIGRyaXZlciAuLi4KPgpJIHRob3VnaHQgeW91ciBhcmUgdXNpbmcgdGhlIGRldmlj ZXRyZWUgc291cmNlIHRvIGxvYWQgdGhlIGRyaXZlci4gSW4gCnRoYXQgY2FzZSBpdCBuZWVkIG5v dCB0byBiZSBwbGF0Zm9ybSBkcml2ZXIuCndlIGNhbiB1c2UgIm9mX2RldmljZV9pZCBzdHJ1Y3Qi IHdoaWNoIG1hdGNoZXMgdGhlIGJpbmRpbmdzIGluIHlvdXIgCnRyaXZpYWwtZGV2aWNlcy50eHQK ClRoYW5rcwpWYXJrYSBCaGFkcmFtCj4gYnllLAo+IEhlaWtvCj4+Cj4+PiArTU9EVUxFX0RFVklD RV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4+PiArK3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciB0 bXAxMDNfZHJpdmVyID0gewo+Pj4gKyAuZHJpdmVyID0gewo+Pj4gKyAubmFtZSA9ICJ0bXAxMDMi LAo+Pj4gKyAucG0gPSBUTVAxMDNfREVWX1BNX09QUywKPj4+ICsgfSwKPj4+ICsgLnByb2JlID0g dG1wMTAzX3Byb2JlLAo+Pj4gKyAuaWRfdGFibGUgPSB0bXAxMDNfaWQsCj4+PiArfTsKPj4+ICsK Pj4+ICttb2R1bGVfaTJjX2RyaXZlcih0bXAxMDNfZHJpdmVyKTsKPj4+ICsKPj4+ICtNT0RVTEVf QVVUSE9SKCJIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4iKTsKPj4+ICtNT0RVTEVfREVTQ1JJ UFRJT04oIlRleGFzIEluc3RydW1lbnRzIFRNUDEwMyB0ZW1wZXJhdHVyZSBzZW5zb3IKPj4+IGRy aXZlciIpOwo+Pj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKPj4KPj4KPj4KPgoKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGlu ZyBsaXN0CmxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMu b3JnL21haWxtYW4vbGlzdGluZm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 6:15 ` Guenter Roeck 0 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 6:15 UTC (permalink / raw) To: Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/17/2014 10:37 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> > Looks pretty good now. Applied. Thanks, Guenter _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 6:15 ` Guenter Roeck 0 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 6:15 UTC (permalink / raw) To: Heiko Schocher, lm-sensors Cc: Jean Delvare, linux-kernel, devicetree, linux-doc, Mark Rutland On 06/17/2014 10:37 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> > Looks pretty good now. Applied. Thanks, Guenter ^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor @ 2014-06-18 6:15 ` Guenter Roeck 0 siblings, 0 replies; 21+ messages in thread From: Guenter Roeck @ 2014-06-18 6:15 UTC (permalink / raw) To: Heiko Schocher, lm-sensors-GZX6beZjE8VD60Wz+7aTrA Cc: Jean Delvare, linux-kernel-u79uwXL29TY76Z2rM5mHXA, devicetree-u79uwXL29TY76Z2rM5mHXA, linux-doc-u79uwXL29TY76Z2rM5mHXA, Mark Rutland On 06/17/2014 10:37 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-ynQEQJNshbs@public.gmane.org> > Looks pretty good now. Applied. Thanks, Guenter -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org More majordomo info at http://vger.kernel.org/majordomo-info.html ^ permalink raw reply [flat|nested] 21+ messages in thread
end of thread, other threads:[~2014-06-18 13:02 UTC | newest] Thread overview: 21+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2014-06-18 5:37 [lm-sensors] [PATCH v5] hwmon: Driver for TI TMP103 temperature sensor Heiko Schocher 2014-06-18 5:37 ` Heiko Schocher 2014-06-18 5:46 ` Varka Bhadram 2014-06-18 5:58 ` [lm-sensors] " Varka Bhadram 2014-06-18 6:12 ` Guenter Roeck 2014-06-18 6:12 ` Guenter Roeck 2014-06-18 6:18 ` Varka Bhadram 2014-06-18 6:30 ` [lm-sensors] " Varka Bhadram 2014-06-18 6:41 ` Guenter Roeck 2014-06-18 6:41 ` Guenter Roeck 2014-06-18 6:16 ` [lm-sensors] " Heiko Schocher 2014-06-18 6:16 ` Heiko Schocher 2014-06-18 6:58 ` Varka Bhadram 2014-06-18 7:10 ` [lm-sensors] " Varka Bhadram 2014-06-18 13:02 ` Guenter Roeck 2014-06-18 13:02 ` Guenter Roeck 2014-06-18 7:07 ` Varka Bhadram 2014-06-18 7:19 ` [lm-sensors] " Varka Bhadram 2014-06-18 6:15 ` Guenter Roeck 2014-06-18 6:15 ` Guenter Roeck 2014-06-18 6:15 ` 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.