From: Neelesh Gupta <neelegup@linux.vnet.ibm.com>
To: linuxppc-dev@lists.ozlabs.org, linux@roeck-us.net,
jdelvare@suse.de, lm-sensors@lm-sensors.org
Cc: sbhat@linux.vnet.ibm.com
Subject: [lm-sensors] [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperature
Date: Fri, 04 Jul 2014 11:14:56 +0000 [thread overview]
Message-ID: <20140704105343.22437.52125.stgit@localhost.localdomain> (raw)
VGhpcyBwYXRjaCBhZGRzIGJhc2ljIGtlcm5lbCBzdXBwb3J0IGZvciByZWFkaW5nIHBvd2VyIHZh
bHVlcywgZmFuCnNwZWVkIHJwbSwgdm9sdGFnZSBhbmQgdGVtcGVyYXR1cmUgZGF0YSBvbiBwb3dl
cm52IHBsYXRmb3JtcyB3aGljaCB3aWxsCmJlIGV4cG9ydGVkIHRvIHVzZXIgc3BhY2UgdGhyb3Vn
aCBzeXNmcyBpbnRlcmZhY2UuCgpUZXN0IHJlc3VsdHM6Ci0tLS0tLS0tLS0tLS0KW3Jvb3RAdHVs
MTYzcDEgfl0jIHNlbnNvcnMKaWJtcG93ZXJudi1pc2EtMDAwMApBZGFwdGVyOiBJU0EgYWRhcHRl
cgpmYW4xOiAgICAgICAgNTU2NyBSUE0gIChtaW4gPSAgICAwIFJQTSkKZmFuMjogICAgICAgIDUy
MzIgUlBNICAobWluID0gICAgMCBSUE0pCmZhbjM6ICAgICAgICA1NTMyIFJQTSAgKG1pbiA9ICAg
IDAgUlBNKQpmYW40OiAgICAgICAgNDk0NSBSUE0gIChtaW4gPSAgICAwIFJQTSkKZmFuNTogICAg
ICAgICAgIDAgUlBNICAobWluID0gICAgMCBSUE0pCmZhbjY6ICAgICAgICAgICAwIFJQTSAgKG1p
biA9ICAgIDAgUlBNKQpmYW43OiAgICAgICAgNzM5MiBSUE0gIChtaW4gPSAgICAwIFJQTSkKZmFu
ODogICAgICAgIDc5MzYgUlBNICAobWluID0gICAgMCBSUE0pCnRlbXAxOiAgICAgICAgKzM5LjDC
sEMgIChoaWdoID0gICswLjDCsEMpCnBvd2VyMTogICAgICAxOTEuMDAgVwoKW3Jvb3RAdHVsMTYz
cDEgfl0jIGxzIC9zeXMvZGV2aWNlcy9wbGF0Zm9ybS8KYWxhcm10aW1lciAgaWJtcG93ZXJudi4w
ICBwb3dlciAgcnRjLWdlbmVyaWMgIHNlcmlhbDgyNTAgIHVldmVudApbcm9vdEB0dWwxNjNwMSB+
XSMgbHMgL3N5cy9kZXZpY2VzL3BsYXRmb3JtL2libXBvd2VybnYuMC9od21vbi9od21vbjAvCmRl
dmljZQkgICAgZmFuMl9taW4JZmFuNF9taW4gICAgZmFuNl9taW4JZmFuOF9taW4gICBwb3dlcgpm
YW4xX2ZhdWx0ICBmYW4zX2ZhdWx0CWZhbjVfZmF1bHQgIGZhbjdfZmF1bHQJaW4xX2ZhdWx0ICBw
b3dlcjFfaW5wdXQKZmFuMV9pbnB1dCAgZmFuM19pbnB1dAlmYW41X2lucHV0ICBmYW43X2lucHV0
CWluMl9mYXVsdCAgc3Vic3lzdGVtCmZhbjFfbWluICAgIGZhbjNfbWluCWZhbjVfbWluICAgIGZh
bjdfbWluCWluM19mYXVsdCAgdGVtcDFfaW5wdXQKZmFuMl9mYXVsdCAgZmFuNF9mYXVsdAlmYW42
X2ZhdWx0ICBmYW44X2ZhdWx0CWluNF9mYXVsdCAgdGVtcDFfbWF4CmZhbjJfaW5wdXQgIGZhbjRf
aW5wdXQJZmFuNl9pbnB1dCAgZmFuOF9pbnB1dAluYW1lCSAgIHVldmVudApbcm9vdEB0dWwxNjNw
MSB+XSMgCltyb290QHR1bDE2M3AxIH5dIyBscyAvc3lzL2NsYXNzL2h3bW9uL2h3bW9uMC8KZGV2
aWNlCSAgICBmYW4yX21pbglmYW40X21pbiAgICBmYW42X21pbglmYW44X21pbiAgIHBvd2VyCmZh
bjFfZmF1bHQgIGZhbjNfZmF1bHQJZmFuNV9mYXVsdCAgZmFuN19mYXVsdAlpbjFfZmF1bHQgIHBv
d2VyMV9pbnB1dApmYW4xX2lucHV0ICBmYW4zX2lucHV0CWZhbjVfaW5wdXQgIGZhbjdfaW5wdXQJ
aW4yX2ZhdWx0ICBzdWJzeXN0ZW0KZmFuMV9taW4gICAgZmFuM19taW4JZmFuNV9taW4gICAgZmFu
N19taW4JaW4zX2ZhdWx0ICB0ZW1wMV9pbnB1dApmYW4yX2ZhdWx0ICBmYW40X2ZhdWx0CWZhbjZf
ZmF1bHQgIGZhbjhfZmF1bHQJaW40X2ZhdWx0ICB0ZW1wMV9tYXgKZmFuMl9pbnB1dCAgZmFuNF9p
bnB1dAlmYW42X2lucHV0ICBmYW44X2lucHV0CW5hbWUJICAgdWV2ZW50Cltyb290QHR1bDE2M3Ax
IH5dIwoKU2lnbmVkLW9mZi1ieTogTmVlbGVzaCBHdXB0YSA8bmVlbGVndXBAbGludXgudm5ldC5p
Ym0uY29tPgotLS0KCkNoYW5nZXMgaW4gdjQKPT09PT09PT09PT09PQotIFJlcGxhY2VkIHByX2Vy
cigpIHdpdGggZGV2X2VycigpIGZvciBsb2dnaW4gcHJpbnQgbWVzc2FnZXMuCi0gVXNpbmcga3N0
cnRvdTMyKCkgZnVuY3Rpb24gZm9yIGNvbnZlcnRpbmcgc3RyaW5nIHRvIHUzMiBpbnN0ZWFkIG9m
IHNzY2FuZigpLgoKQ2hhbmdlcyBpbiB2Mwo9PT09PT09PT09PT09Ci0gRml4ZWQgYW4gZW5kaWFu
bmVzcyBidWcgbGVhZGluZyB0aGUgZHJpdmVyIHRvIGJyZWFrIG9uIExFLgotIEZpeGVkIGEgYnVn
IHRoYXQgd2hlbiBvbmUgb2YgdGhlICdhdHRyaWJ1dGVfZ3JvdXAnIG5vdCBwb3B1bGF0ZWQsIGZv
bGxvd2luZwogIGdyb3VwcyBhdHRyaWJ1dGVzIHdlcmUgZHJvcHBlZC4KLSBSZXdyaXRlIHRoZSBn
ZXRfc2Vuc29yX2luZGV4X2F0dHIoKSBmdW5jdGlvbiB0byBoYW5kbGUgYWxsIHRoZSBlcnJvciBz
Y2VuYXJpb3MKICBsaWtlICdzc2NhbmYnIGV0Yy4KLSBGaXhlZCBhbGwgdGhlIGVycm9ycy93YXJu
aW5ncyByZWxhdGVkIHRvIGNvZGluZyBzdHlsZS93aGl0ZXNwYWNlLgotIEFkZGVkICdEb2N1bWVu
dGF0aW9uJyBmaWxlcy4KLSBBZGRyZXNzZWQgcmVtYWluaW5nIHJldmlldyBjb21tZW50cyBvbiBW
Mi4KCkNoYW5nZXMgaW4gdjIKPT09PT09PT09PT09PQotIEdlbmVyaWMgdXNlIG9mIGRldm1fKiBm
dW5jdGlvbnMgaW4gaHdtb24gbGlrZSB1c2luZyBkZXZtX2t6YWxsb2MoKSBmb3IgZHluYW1pYwog
IG1lbW9yeSByZXF1ZXN0LCBhdm9pZGluZyB0aGUgbmVlZCB0byBleHBsaWNpdCBmcmVlIG9mIG1l
bW9yeS4KICBBZGRpbmcgJ3N0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAnIGFzIG1lbWJlciBvZiBwbGF0
Zm9ybSBkYXRhIHN0cnVjdHVyZSB0byBiZQogIHBvcHVsYXRlZCBhbmQgdGhlbiBwYXNzZWQgdG8g
ZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoKS4KCiAgTm90ZTogSGF2aW5n
IGFuIGFycmF5IG9mIHBvaW50ZXJzIG9mICdhdHRyaWJ1dGVfZ3JvdXAnIGFuZCBlYWNoIGdyb3Vw
CiAgY29ycmVzcG9uZHMgdG8gJ2VudW0gc2Vuc29ycycgdHlwZS4gTm90IGNvbXBsZXRlbHkgc3Vy
ZSwgaWYgaXQncyBpZGVhbCBvcgogIGNvdWxkIGhhdmUganVzdCBvbmUgZ3JvdXAgcG9wdWxhdGVk
IHdpdGggYXR0cmlidXRlcyBvZiBzZW5zb3IgdHlwZXM/CgotICdpYm1wb3dlcm52JyBpcyBub3Qg
aG90LXBsdWdnYWJsZSBkZXZpY2Ugc28gbW92aW5nICdwbGF0Zm9ybV9kcml2ZXInIGNhbGxiYWNr
CiAgZnVuY3Rpb24gKHByb2JlKSBhcyBwYXJ0IG9mIF9faW5pdCBjb2RlLgotIEZpeGVkIGlzc3Vl
cyByZWxhdGVkIHRvIGNvZGluZyBzdHlsZS4KLSBPdGhlciBnZW5lcmFsIGNvbW1lbnRzIGluIHYx
LgoKIC4uLi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL2libXBvd2VybnYudHh0ICAgICAgIHwg
ICAyNyArCiBEb2N1bWVudGF0aW9uL2h3bW9uL2libXBvd2VybnYgICAgICAgICAgICAgICAgICAg
ICB8ICAgNDEgKysKIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAg
ICAgICAgIHwgICAxMSArCiBkcml2ZXJzL2h3bW9uL01ha2VmaWxlICAgICAgICAgICAgICAgICAg
ICAgICAgICAgICB8ICAgIDEgCiBkcml2ZXJzL2h3bW9uL2libXBvd2VybnYuYyAgICAgICAgICAg
ICAgICAgICAgICAgICB8ICAzNjIgKysrKysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdl
ZCwgNDQyIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2Rl
dmljZXRyZWUvYmluZGluZ3MvaHdtb24vaWJtcG93ZXJudi50eHQKIGNyZWF0ZSBtb2RlIDEwMDY0
NCBEb2N1bWVudGF0aW9uL2h3bW9uL2libXBvd2VybnYKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2
ZXJzL2h3bW9uL2libXBvd2VybnYuYwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNl
dHJlZS9iaW5kaW5ncy9od21vbi9pYm1wb3dlcm52LnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNl
dHJlZS9iaW5kaW5ncy9od21vbi9pYm1wb3dlcm52LnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp
bmRleCAwMDAwMDAwLi5lM2JkMWViCi0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9k
ZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL2libXBvd2VybnYudHh0CkBAIC0wLDAgKzEsMjcgQEAK
K0lCTSBQT1dFUk5WIHBsYXRmb3JtIHNlbnNvcnMKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0KKworUmVxdWlyZWQgbm9kZSBwcm9wZXJ0aWVzOgorLSBjb21wYXRpYmxlOiBtdXN0IGJlIG9u
ZSBvZgorCQkiaWJtLG9wYWwtc2Vuc29yLWNvb2xpbmctZmFuIgorCQkiaWJtLG9wYWwtc2Vuc29y
LWFtYi10ZW1wIgorCQkiaWJtLG9wYWwtc2Vuc29yLXBvd2VyLXN1cHBseSIKKwkJImlibSxvcGFs
LXNlbnNvci1wb3dlciIKKy0gc2Vuc29yLWlkOiBhbiBvcGFxdWUgaWQgcHJvdmlkZWQgYnkgdGhl
IGZpcm13YXJlIHRvIHRoZSBrZXJuZWwsIGlkZW50aWZpZXMgYQorCSAgICAgZ2l2ZW4gc2Vuc29y
IGFuZCBpdHMgYXR0cmlidXRlIGRhdGEKKworRXhhbXBsZSBzZW5zb3JzIG5vZGU6CisKK2Nvb2xp
bmctZmFuIzgtZGF0YSB7CisJc2Vuc29yLWlkID0gPDB4NzA1MjEwNz47CisJcGhhbmRsZSA9IDww
eDEwMDAwMDI4PjsKKwlsaW51eCxwaGFuZGxlID0gPDB4MTAwMDAwMjg+OworCWNvbXBhdGlibGUg
PSAiaWJtLG9wYWwtc2Vuc29yLWNvb2xpbmctZmFuIjsKK307CisKK2FtYi10ZW1wIzEtdGhycyB7
CisJc2Vuc29yLWlkID0gPDB4NTA5NjAwMD47CisJcGhhbmRsZSA9IDwweDEwMDAwMDE3PjsKKwls
aW51eCxwaGFuZGxlID0gPDB4MTAwMDAwMTc+OworCWNvbXBhdGlibGUgPSAiaWJtLG9wYWwtc2Vu
c29yLWFtYi10ZW1wIjsKK307CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2h3bW9uL2libXBv
d2VybnYgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL2libXBvd2VybnYKbmV3IGZpbGUgbW9kZSAxMDA2
NDQKaW5kZXggMDAwMDAwMC4uNjQ0MjQ1YQotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRp
b24vaHdtb24vaWJtcG93ZXJudgpAQCAtMCwwICsxLDQxIEBACitLZXJuZWwgRHJpdmVyIElCTVBP
V0VOVgorPT09PT09PT09PT09PT09PT09PT09PT0KKworU3VwcG9ydGVkIHN5c3RlbXM6CisgICog
QW55IHJlY2VudCBJQk0gUCBzZXJ2ZXJzIGJhc2VkIG9uIFBPV0VSTlYgcGxhdGZvcm0KKworQXV0
aG9yOiBOZWVsZXNoIEd1cHRhCisKK0Rlc2NyaXB0aW9uCistLS0tLS0tLS0tLQorCitUaGlzIGRy
aXZlciBpbXBsZW1lbnRzIHJlYWRpbmcgdGhlIHBsYXRmb3JtIHNlbnNvcnMgZGF0YSBsaWtlIHRl
bXBlcmF0dXJlL2Zhbi8KK3ZvbHRhZ2UvcG93ZXIgZm9yICdQT1dFUk5WJyBwbGF0Zm9ybS4KKwor
VGhlIGRyaXZlciB1c2VzIHRoZSBwbGF0Zm9ybSBkZXZpY2UgaW5mcmFzdHJ1Y3R1cmUuIEl0IHBy
b2JlcyB0aGUgZGV2aWNlIHRyZWUKK2ZvciBzZW5zb3IgZGV2aWNlcyBkdXJpbmcgdGhlIF9faW5p
dCBwaGFzZSBhbmQgcmVnaXN0ZXJzIHRoZW0gd2l0aCB0aGUgJ2h3bW9uJy4KKydod21vbicgcG9w
dWxhdGVzIHRoZSAnc3lzZnMnIHRyZWUgaGF2aW5nIGF0dHJpYnV0ZSBmaWxlcywgZWFjaCBmb3Ig
YSBnaXZlbgorc2Vuc29yIHR5cGUgYW5kIGl0cyBhdHRyaWJ1dGUgZGF0YS4KKworQWxsIHRoZSBu
b2RlcyBpbiB0aGUgRFQgYXBwZWFyIHVuZGVyICIvaWJtLG9wYWwvc2Vuc29ycyIgYW5kIGVhY2gg
dmFsaWQgbm9kZSBpbgordGhlIERUIG1hcHMgdG8gYW4gYXR0cmlidXRlIGZpbGUgaW4gJ3N5c2Zz
Jy4gVGhlIG5vZGUgZXhwb3J0cyB1bmlxdWUgJ3NlbnNvci1pZCcKK3doaWNoIHRoZSBkcml2ZXIg
dXNlcyB0byBtYWtlIGFuIE9QQUwgY2FsbCB0byB0aGUgZmlybXdhcmUuCisKK1VzYWdlIG5vdGVz
CistLS0tLS0tLS0tLQorVGhlIGRyaXZlciBpcyBidWlsdCBzdGF0aWNhbGx5IHdpdGggdGhlIGtl
cm5lbCBieSBlbmFibGluZyB0aGUgY29uZmlnCitDT05GSUdfU0VOU09SU19JQk1QT1dFUk5WLiBJ
dCBjYW4gYWxzbyBiZSBidWlsdCBhcyBtb2R1bGUgJ2libXBvd2VybnYnLgorCitTeXNmcyBhdHRy
aWJ1dGVzCistLS0tLS0tLS0tLS0tLS0tCisKK2ZhblhfaW5wdXQJCU1lYXN1cmVkIFJQTSB2YWx1
ZS4KK2ZhblhfbWluCQlUaHJlc2hvbGQgUlBNIGZvciBhbGVydCBnZW5lcmF0aW9uLgorZmFuWF9m
YXVsdAkJMDogTm8gZmFpbCBjb25kaXRpb24KKwkJCTE6IEZhaWxpbmcgZmFuCit0ZW1wWF9pbnB1
dAkJTWVhc3VyZWQgYW1iaWVudCB0ZW1wZXJhdHVyZS4KK3RlbXBYX21heAkJVGhyZXNob2xkIGFt
YmllbnQgdGVtcGVyYXR1cmUgZm9yIGFsZXJ0IGdlbmVyYXRpb24uCitpblhfaW5wdXQJCU1lYXN1
cmVkIHBvd2VyIHN1cHBseSB2b2x0YWdlCitpblhfZmF1bHQJCTA6IE5vIGZhaWwgY29uZGl0aW9u
LgorCQkJMTogRmFpbGluZyBwb3dlciBzdXBwbHkuCitwb3dlcjFfaW5wdXQJCVN5c3RlbSBwb3dl
ciBjb25zdW1wdGlvbiAobWljcm9XYXR0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29u
ZmlnIGIvZHJpdmVycy9od21vbi9LY29uZmlnCmluZGV4IDAyZDNkODUuLjI5YzNmY2IgMTAwNjQ0
Ci0tLSBhL2RyaXZlcnMvaHdtb24vS2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcK
QEAgLTU1NCw2ICs1NTQsMTcgQEAgY29uZmlnIFNFTlNPUlNfSUJNUEVYCiAJICBUaGlzIGRyaXZl
ciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCiAJICB3
aWxsIGJlIGNhbGxlZCBpYm1wZXguCiAKK2NvbmZpZyBTRU5TT1JTX0lCTVBPV0VSTlYKKwl0cmlz
dGF0ZSAiSUJNIFBPV0VSTlYgcGxhdGZvcm0gc2Vuc29ycyIKKwlkZXBlbmRzIG9uIFBQQ19QT1dF
Uk5WCisJZGVmYXVsdCB5CisJaGVscAorCSAgSWYgeW91IHNheSB5ZXMgaGVyZSB5b3UgZ2V0IHN1
cHBvcnQgZm9yIHRoZSB0ZW1wZXJhdHVyZS9mYW4vcG93ZXIKKwkgIHNlbnNvcnMgb24geW91ciBQ
b3dlck5WIHBsYXRmb3JtLgorCisJICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBh
IG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUKKwkgIHdpbGwgYmUgY2FsbGVkIGlibXBvd2VybnYu
CisKIGNvbmZpZyBTRU5TT1JTX0lJT19IV01PTgogCXRyaXN0YXRlICJId21vbiBkcml2ZXIgdGhh
dCB1c2VzIGNoYW5uZWxzIHNwZWNpZmllZCB2aWEgaWlvIG1hcHMiCiAJZGVwZW5kcyBvbiBJSU8K
ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2Vm
aWxlCmluZGV4IDNkYzBmMDIuLmZjNGVkMjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vTWFr
ZWZpbGUKKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQpAQCAtNzEsNiArNzEsNyBAQCBvYmot
JChDT05GSUdfU0VOU09SU19VTFRSQTQ1KQkrPSB1bHRyYTQ1X2Vudi5vCiBvYmotJChDT05GSUdf
U0VOU09SU19JNUtfQU1CKQkrPSBpNWtfYW1iLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0lCTUFF
TSkJKz0gaWJtYWVtLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0lCTVBFWCkJKz0gaWJtcGV4Lm8K
K29iai0kKENPTkZJR19TRU5TT1JTX0lCTVBPV0VSTlYpKz0gaWJtcG93ZXJudi5vCiBvYmotJChD
T05GSUdfU0VOU09SU19JSU9fSFdNT04pICs9IGlpb19od21vbi5vCiBvYmotJChDT05GSUdfU0VO
U09SU19JTkEyMDkpCSs9IGluYTIwOS5vCiBvYmotJChDT05GSUdfU0VOU09SU19JTkEyWFgpCSs9
IGluYTJ4eC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2libXBvd2VybnYuYyBiL2RyaXZl
cnMvaHdtb24vaWJtcG93ZXJudi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu
LjQ0ZGNkOTkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2h3bW9uL2libXBvd2VybnYuYwpA
QCAtMCwwICsxLDM2MiBAQAorLyoKKyAqIElCTSBQb3dlck5WIHBsYXRmb3JtIHNlbnNvcnMgZm9y
IHRlbXBlcmF0dXJlL2Zhbi92b2x0YWdlL3Bvd2VyCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQgSUJN
CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli
dXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdl
bmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2Fy
ZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0
IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMg
ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBX
SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m
CisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu
ICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz
LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5l
cmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4KKyAqLworCisj
ZGVmaW5lIERSVk5BTUUJCSJpYm1wb3dlcm52IgorI2RlZmluZSBwcl9mbXQoZm10KQlEUlZOQU1F
ICI6ICIgZm10CisKKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvbW9k
dWxlLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvaHdtb24u
aD4KKyNpbmNsdWRlIDxsaW51eC9od21vbi1zeXNmcy5oPgorI2luY2x1ZGUgPGxpbnV4L29mLmg+
CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorCisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2
aWNlLmg+CisjaW5jbHVkZSA8YXNtL29wYWwuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKwor
I2RlZmluZSBNQVhfQVRUUl9MRU4JMzIKKworLyogU2Vuc29yIHN1ZmZpeCBuYW1lIGZyb20gRFQg
Ki8KKyNkZWZpbmUgRFRfRkFVTFRfQVRUUl9TVUZGSVgJCSJmYXVsdGVkIgorI2RlZmluZSBEVF9E
QVRBX0FUVFJfU1VGRklYCQkiZGF0YSIKKyNkZWZpbmUgRFRfVEhSRVNIT0xEX0FUVFJfU1VGRklY
CSJ0aHJzIgorCisvKgorICogRW51bWVyYXRlcyBhbGwgdGhlIHR5cGVzIG9mIHNlbnNvcnMgaW4g
dGhlIFBPV0VSTlYgcGxhdGZvcm0gYW5kIGRvZXMgaW5kZXgKKyAqIGludG8gJ3N0cnVjdCBzZW5z
b3JfZ3JvdXAnCisgKi8KK2VudW0gc2Vuc29ycyB7CisJRkFOLAorCUFNQklFTlRfVEVNUCwKKwlQ
T1dFUl9TVVBQTFksCisJUE9XRVJfSU5QVVQsCisJTUFYX1NFTlNPUl9UWVBFLAorfTsKKworc3Rh
dGljIHN0cnVjdCBzZW5zb3JfZ3JvdXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgY2hh
ciAqY29tcGF0aWJsZTsKKwlzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGdyb3VwOworCXUzMiBhdHRy
X2NvdW50OworfSBzZW5zb3JfZ3JvdXBzW10gPSB7CisJeyJmYW4iLCAiaWJtLG9wYWwtc2Vuc29y
LWNvb2xpbmctZmFuIn0sCisJeyJ0ZW1wIiwgImlibSxvcGFsLXNlbnNvci1hbWItdGVtcCJ9LAor
CXsiaW4iLCAiaWJtLG9wYWwtc2Vuc29yLXBvd2VyLXN1cHBseSJ9LAorCXsicG93ZXIiLCAiaWJt
LG9wYWwtc2Vuc29yLXBvd2VyIn0KK307CisKK3N0cnVjdCBzZW5zb3JfZGF0YSB7CisJdTMyIGlk
OyAvKiBBbiBvcGFxdWUgaWQgb2YgdGhlIGZpcm13YXJlIGZvciBlYWNoIHNlbnNvciAqLworCWVu
dW0gc2Vuc29ycyB0eXBlOworCWNoYXIgbmFtZVtNQVhfQVRUUl9MRU5dOworCXN0cnVjdCBkZXZp
Y2VfYXR0cmlidXRlIGRldl9hdHRyOworfTsKKworc3RydWN0IHBsYXRmb3JtX2RhdGEgeworCWNv
bnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKmF0dHJfZ3JvdXBzW01BWF9TRU5TT1JfVFlQRSAr
IDFdOworCXUzMiBzZW5zb3JzX2NvdW50OyAvKiBUb3RhbCBjb3VudCBvZiBzZW5zb3JzIGZyb20g
ZWFjaCBncm91cCAqLworfTsKKworLyogUGxhdGZvcm0gZGV2aWNlIHJlcHJlc2VudGluZyBhbGwg
dGhlIGlibXBvd2VybnYgc2Vuc29ycyAqLworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug
KnBkZXZpY2U7CisKK3N0YXRpYyBzc2l6ZV90IHNob3dfc2Vuc29yKHN0cnVjdCBkZXZpY2UgKmRl
diwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCisJCQkgICBjaGFyICpidWYpCit7
CisJc3RydWN0IHNlbnNvcl9kYXRhICpzZGF0YSA9IGNvbnRhaW5lcl9vZihkZXZhdHRyLCBzdHJ1
Y3Qgc2Vuc29yX2RhdGEsCisJCQkJCQkgZGV2X2F0dHIpOworCXNzaXplX3QgcmV0OworCXUzMiB4
OworCisJcmV0ID0gb3BhbF9nZXRfc2Vuc29yX2RhdGEoc2RhdGEtPmlkLCAmeCk7CisJaWYgKHJl
dCkKKwkJcmV0dXJuIHJldDsKKworCS8qIENvbnZlcnQgdGVtcGVyYXR1cmUgdG8gbWlsbGktZGVn
cmVlcyAqLworCWlmIChzZGF0YS0+dHlwZSA9PSBBTUJJRU5UX1RFTVApCisJCXggKj0gMTAwMDsK
KwkvKiBDb252ZXJ0IHBvd2VyIHRvIG1pY3JvLXdhdHRzICovCisJZWxzZSBpZiAoc2RhdGEtPnR5
cGUgPT0gUE9XRVJfSU5QVVQpCisJCXggKj0gMTAwMDAwMDsKKworCXJldHVybiBzcHJpbnRmKGJ1
ZiwgIiV1XG4iLCB4KTsKK30KKworc3RhdGljIGludCBfX2luaXQgZ2V0X3NlbnNvcl9pbmRleF9h
dHRyKGNvbnN0IGNoYXIgKm5hbWUsIHUzMiAqaW5kZXgsCisJCQkJCWNoYXIgKmF0dHIpCit7CisJ
Y2hhciAqaGFzaF9wb3MgPSBzdHJjaHIobmFtZSwgJyMnKTsKKwljaGFyIGJ1Zls4XSA9IHsgMCB9
OworCWNoYXIgKmRhc2hfcG9zOworCXUzMiBjb3B5X2xlbjsKKworCWlmICghaGFzaF9wb3MpCisJ
CXJldHVybiAtRUlOVkFMOworCisJZGFzaF9wb3MgPSBzdHJjaHIoaGFzaF9wb3MsICctJyk7CisJ
aWYgKCFkYXNoX3BvcykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwljb3B5X2xlbiA9IGRhc2hfcG9z
IC0gaGFzaF9wb3MgLSAxOworCWlmIChjb3B5X2xlbiA+PSBzaXplb2YoYnVmKSkKKwkJcmV0dXJu
IC1FSU5WQUw7CisKKwlzdHJuY3B5KGJ1ZiwgaGFzaF9wb3MgKyAxLCBjb3B5X2xlbik7CisKKwlp
ZiAoa3N0cnRvdTMyKGJ1ZiwgMTAsIGluZGV4KSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzdHJu
Y3B5KGF0dHIsIGRhc2hfcG9zICsgMSwgTUFYX0FUVFJfTEVOKTsKKworCXJldHVybiAwOworfQor
CisvKgorICogVGhpcyBmdW5jdGlvbiB0cmFuc2xhdGVzIHRoZSBEVCBub2RlIG5hbWUgaW50byB0
aGUgJ2h3bW9uJyBhdHRyaWJ1dGUgbmFtZS4KKyAqIElCTVBPV0VSTlYgZGV2aWNlIG5vZGUgYXBw
ZWFyIGxpa2UgY29vbGluZy1mYW4jMi1kYXRhLCBhbWItdGVtcCMxLXRocnMgZXRjLgorICogd2hp
Y2ggbmVlZCB0byBiZSBtYXBwZWQgYXMgZmFuMl9pbnB1dCwgdGVtcDFfbWF4IHJlc3BlY3RpdmVs
eSBiZWZvcmUKKyAqIHBvcHVsYXRpbmcgdGhlbSBpbnNpZGUgaHdtb24gZGV2aWNlIGNsYXNzLgor
ICovCitzdGF0aWMgaW50IF9faW5pdCBjcmVhdGVfaHdtb25fYXR0cl9uYW1lKHN0cnVjdCBkZXZp
Y2UgKmRldiwgZW51bSBzZW5zb3JzIHR5cGUsCisJCQkJCSBjb25zdCBjaGFyICpub2RlX25hbWUs
CisJCQkJCSBjaGFyICpod21vbl9hdHRyX25hbWUpCit7CisJY2hhciBhdHRyX3N1ZmZpeFtNQVhf
QVRUUl9MRU5dOworCWNoYXIgKmF0dHJfbmFtZTsKKwl1MzIgaW5kZXg7CisJaW50IGVycjsKKwor
CWVyciA9IGdldF9zZW5zb3JfaW5kZXhfYXR0cihub2RlX25hbWUsICZpbmRleCwgYXR0cl9zdWZm
aXgpOworCWlmIChlcnIpIHsKKwkJZGV2X2VycihkZXYsICJTZW5zb3IgZGV2aWNlIG5vZGUgbmFt
ZSAnJXMnIGlzIGludmFsaWRcbiIsCisJCQlub2RlX25hbWUpOworCQlyZXR1cm4gZXJyOworCX0K
KworCWlmICghc3RyY21wKGF0dHJfc3VmZml4LCBEVF9GQVVMVF9BVFRSX1NVRkZJWCkpIHsKKwkJ
YXR0cl9uYW1lID0gImZhdWx0IjsKKwl9IGVsc2UgaWYgKCFzdHJjbXAoYXR0cl9zdWZmaXgsIERU
X0RBVEFfQVRUUl9TVUZGSVgpKSB7CisJCWF0dHJfbmFtZSA9ICJpbnB1dCI7CisJfSBlbHNlIGlm
ICghc3RyY21wKGF0dHJfc3VmZml4LCBEVF9USFJFU0hPTERfQVRUUl9TVUZGSVgpKSB7CisJCWlm
ICh0eXBlID09IEFNQklFTlRfVEVNUCkKKwkJCWF0dHJfbmFtZSA9ICJtYXgiOworCQllbHNlIGlm
ICh0eXBlID09IEZBTikKKwkJCWF0dHJfbmFtZSA9ICJtaW4iOworCQllbHNlCisJCQlyZXR1cm4g
LUVOT0VOVDsKKwl9IGVsc2UgeworCQlyZXR1cm4gLUVOT0VOVDsKKwl9CisKKwlzbnByaW50Ziho
d21vbl9hdHRyX25hbWUsIE1BWF9BVFRSX0xFTiwgIiVzJWRfJXMiLAorCQkgc2Vuc29yX2dyb3Vw
c1t0eXBlXS5uYW1lLCBpbmRleCwgYXR0cl9uYW1lKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGlj
IGludCBfX2luaXQgcG9wdWxhdGVfYXR0cl9ncm91cHMoc3RydWN0IHBsYXRmb3JtX2RldmljZSAq
cGRldikKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGF0YSAqcGRhdGEgPSBwbGF0Zm9ybV9nZXRfZHJ2
ZGF0YShwZGV2KTsKKwljb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICoqcGdyb3VwcyA9IHBk
YXRhLT5hdHRyX2dyb3VwczsKKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKm9wYWwsICpucDsKKwllbnVt
IHNlbnNvcnMgdHlwZTsKKworCW9wYWwgPSBvZl9maW5kX25vZGVfYnlfcGF0aCgiL2libSxvcGFs
L3NlbnNvcnMiKTsKKwlpZiAoIW9wYWwpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiT3BhbCBu
b2RlICdzZW5zb3JzJyBub3QgZm91bmRcbiIpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlm
b3JfZWFjaF9jaGlsZF9vZl9ub2RlKG9wYWwsIG5wKSB7CisJCWlmIChucC0+bmFtZSA9PSBOVUxM
KQorCQkJY29udGludWU7CisKKwkJZm9yICh0eXBlID0gMDsgdHlwZSA8IE1BWF9TRU5TT1JfVFlQ
RTsgdHlwZSsrKQorCQkJaWYgKG9mX2RldmljZV9pc19jb21wYXRpYmxlKG5wLAorCQkJCQlzZW5z
b3JfZ3JvdXBzW3R5cGVdLmNvbXBhdGlibGUpKSB7CisJCQkJc2Vuc29yX2dyb3Vwc1t0eXBlXS5h
dHRyX2NvdW50Kys7CisJCQkJYnJlYWs7CisJCQl9CisJfQorCisJb2Zfbm9kZV9wdXQob3BhbCk7
CisKKwlmb3IgKHR5cGUgPSAwOyB0eXBlIDwgTUFYX1NFTlNPUl9UWVBFOyB0eXBlKyspIHsKKwkJ
c2Vuc29yX2dyb3Vwc1t0eXBlXS5ncm91cC5hdHRycyA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2
LAorCQkJCQlzaXplb2Yoc3RydWN0IGF0dHJpYnV0ZSAqKSAqCisJCQkJCShzZW5zb3JfZ3JvdXBz
W3R5cGVdLmF0dHJfY291bnQgKyAxKSwKKwkJCQkJR0ZQX0tFUk5FTCk7CisJCWlmICghc2Vuc29y
X2dyb3Vwc1t0eXBlXS5ncm91cC5hdHRycykKKwkJCXJldHVybiAtRU5PTUVNOworCisJCXBncm91
cHNbdHlwZV0gPSAmc2Vuc29yX2dyb3Vwc1t0eXBlXS5ncm91cDsKKwkJcGRhdGEtPnNlbnNvcnNf
Y291bnQgKz0gc2Vuc29yX2dyb3Vwc1t0eXBlXS5hdHRyX2NvdW50OworCQlzZW5zb3JfZ3JvdXBz
W3R5cGVdLmF0dHJfY291bnQgPSAwOworCX0KKworCXJldHVybiAwOworfQorCisvKgorICogSXRl
cmF0ZSB0aHJvdWdoIHRoZSBkZXZpY2UgdHJlZSBmb3IgZWFjaCBjaGlsZCBvZiAnc2Vuc29ycycg
bm9kZSwgY3JlYXRlCisgKiBhIHN5c2ZzIGF0dHJpYnV0ZSBmaWxlLCB0aGUgZmlsZSBpcyBuYW1l
ZCBieSB0cmFuc2xhdGluZyB0aGUgRFQgbm9kZSBuYW1lCisgKiB0byB0aGUgbmFtZSByZXF1aXJl
ZCBieSB0aGUgaGlnaGVyICdod21vbicgZHJpdmVyIGxpa2UgZmFuMV9pbnB1dCwgdGVtcDFfbWF4
CisgKiBldGMuLgorICovCitzdGF0aWMgaW50IF9faW5pdCBjcmVhdGVfZGV2aWNlX2F0dHJzKHN0
cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IHBsYXRmb3JtX2RhdGEgKnBk
YXRhID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisJY29uc3Qgc3RydWN0IGF0dHJpYnV0
ZV9ncm91cCAqKnBncm91cHMgPSBwZGF0YS0+YXR0cl9ncm91cHM7CisJc3RydWN0IGRldmljZV9u
b2RlICpvcGFsLCAqbnA7CisJc3RydWN0IHNlbnNvcl9kYXRhICpzZGF0YTsKKwljb25zdCBfX2Jl
MzIgKnNlbnNvcl9pZDsKKwllbnVtIHNlbnNvcnMgdHlwZTsKKwl1MzIgY291bnQgPSAwOworCWlu
dCBlcnIgPSAwOworCisJb3BhbCA9IG9mX2ZpbmRfbm9kZV9ieV9wYXRoKCIvaWJtLG9wYWwvc2Vu
c29ycyIpOworCXNkYXRhID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHBkYXRhLT5zZW5zb3Jz
X2NvdW50ICogc2l6ZW9mKCpzZGF0YSksCisJCQkgICAgIEdGUF9LRVJORUwpOworCWlmICghc2Rh
dGEpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBleGl0X3B1dF9ub2RlOworCX0KKworCWZv
cl9lYWNoX2NoaWxkX29mX25vZGUob3BhbCwgbnApIHsKKwkJaWYgKG5wLT5uYW1lID09IE5VTEwp
CisJCQljb250aW51ZTsKKworCQlmb3IgKHR5cGUgPSAwOyB0eXBlIDwgTUFYX1NFTlNPUl9UWVBF
OyB0eXBlKyspCisJCQlpZiAob2ZfZGV2aWNlX2lzX2NvbXBhdGlibGUobnAsCisJCQkJCXNlbnNv
cl9ncm91cHNbdHlwZV0uY29tcGF0aWJsZSkpCisJCQkJYnJlYWs7CisKKwkJaWYgKHR5cGUgPT0g
TUFYX1NFTlNPUl9UWVBFKQorCQkJY29udGludWU7CisKKwkJc2Vuc29yX2lkID0gb2ZfZ2V0X3By
b3BlcnR5KG5wLCAic2Vuc29yLWlkIiwgTlVMTCk7CisJCWlmICghc2Vuc29yX2lkKSB7CisJCQlk
ZXZfaW5mbygmcGRldi0+ZGV2LAorCQkJCSAiJ3NlbnNvci1pZCcgbWlzc2luZyBpbiB0aGUgbm9k
ZSAnJXMnXG4iLAorCQkJCSBucC0+bmFtZSk7CisJCQljb250aW51ZTsKKwkJfQorCisJCXNkYXRh
W2NvdW50XS5pZCA9IGJlMzJfdG9fY3B1cChzZW5zb3JfaWQpOworCQlzZGF0YVtjb3VudF0udHlw
ZSA9IHR5cGU7CisJCWVyciA9IGNyZWF0ZV9od21vbl9hdHRyX25hbWUoJnBkZXYtPmRldiwgdHlw
ZSwgbnAtPm5hbWUsCisJCQkJCSAgICAgc2RhdGFbY291bnRdLm5hbWUpOworCQlpZiAoZXJyKQor
CQkJZ290byBleGl0X3B1dF9ub2RlOworCisJCXN5c2ZzX2F0dHJfaW5pdCgmc2RhdGFbY291bnRd
LmRldl9hdHRyLmF0dHIpOworCQlzZGF0YVtjb3VudF0uZGV2X2F0dHIuYXR0ci5uYW1lID0gc2Rh
dGFbY291bnRdLm5hbWU7CisJCXNkYXRhW2NvdW50XS5kZXZfYXR0ci5hdHRyLm1vZGUgPSBTX0lS
VUdPOworCQlzZGF0YVtjb3VudF0uZGV2X2F0dHIuc2hvdyA9IHNob3dfc2Vuc29yOworCisJCXBn
cm91cHNbdHlwZV0tPmF0dHJzW3NlbnNvcl9ncm91cHNbdHlwZV0uYXR0cl9jb3VudCsrXSA9CisJ
CQkJJnNkYXRhW2NvdW50KytdLmRldl9hdHRyLmF0dHI7CisJfQorCitleGl0X3B1dF9ub2RlOgor
CW9mX25vZGVfcHV0KG9wYWwpOworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0
IGlibXBvd2VybnZfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1
Y3QgcGxhdGZvcm1fZGF0YSAqcGRhdGE7CisJc3RydWN0IGRldmljZSAqaHdtb25fZGV2OworCWlu
dCBlcnI7CisKKwlwZGF0YSA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKnBkYXRh
KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwZGF0YSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlwbGF0
Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBwZGF0YSk7CisJcGRhdGEtPnNlbnNvcnNfY291bnQgPSAw
OworCWVyciA9IHBvcHVsYXRlX2F0dHJfZ3JvdXBzKHBkZXYpOworCWlmIChlcnIpCisJCXJldHVy
biBlcnI7CisKKwkvKiBDcmVhdGUgc3lzZnMgYXR0cmlidXRlIGRhdGEgZm9yIGVhY2ggc2Vuc29y
IGZvdW5kIGluIHRoZSBEVCAqLworCWVyciA9IGNyZWF0ZV9kZXZpY2VfYXR0cnMocGRldik7CisJ
aWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCS8qIEZpbmFsbHksIHJlZ2lzdGVyIHdpdGggaHdt
b24gKi8KKwlod21vbl9kZXYgPSBkZXZtX2h3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dyb3Vw
cygmcGRldi0+ZGV2LCBEUlZOQU1FLAorCQkJCQkJCSAgIHBkYXRhLAorCQkJCQkJCSAgIHBkYXRh
LT5hdHRyX2dyb3Vwcyk7CisKKwlyZXR1cm4gUFRSX0VSUl9PUl9aRVJPKGh3bW9uX2Rldik7Cit9
CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGlibXBvd2VybnZfZHJpdmVyID0gewor
CS5kcml2ZXIgPSB7CisJCS5vd25lciA9IFRISVNfTU9EVUxFLAorCQkubmFtZSA9IERSVk5BTUUs
CisJfSwKK307CisKK3N0YXRpYyBpbnQgX19pbml0IGlibXBvd2VybnZfaW5pdCh2b2lkKQorewor
CWludCBlcnI7CisKKwlwZGV2aWNlID0gcGxhdGZvcm1fZGV2aWNlX2FsbG9jKERSVk5BTUUsIDAp
OworCWlmICghcGRldmljZSkgeworCQlwcl9lcnIoIkRldmljZSBhbGxvY2F0aW9uIGZhaWxlZFxu
Iik7CisJCWVyciA9IC1FTk9NRU07CisJCWdvdG8gZXhpdDsKKwl9CisKKwllcnIgPSBwbGF0Zm9y
bV9kZXZpY2VfYWRkKHBkZXZpY2UpOworCWlmIChlcnIpIHsKKwkJcHJfZXJyKCJEZXZpY2UgYWRk
aXRpb24gZmFpbGVkICglZClcbiIsIGVycik7CisJCWdvdG8gZXhpdF9kZXZpY2VfcHV0OworCX0K
KworCWVyciA9IHBsYXRmb3JtX2RyaXZlcl9wcm9iZSgmaWJtcG93ZXJudl9kcml2ZXIsIGlibXBv
d2VybnZfcHJvYmUpOworCWlmIChlcnIpIHsKKwkJcHJfZXJyKCJQbGF0ZnJvbSBkcml2ZXIgcHJv
YmUgZmFpbGVkXG4iKTsKKwkJZ290byBleGl0X2RldmljZV9kZWw7CisJfQorCisJcmV0dXJuIDA7
CisKK2V4aXRfZGV2aWNlX2RlbDoKKwlwbGF0Zm9ybV9kZXZpY2VfZGVsKHBkZXZpY2UpOworZXhp
dF9kZXZpY2VfcHV0OgorCXBsYXRmb3JtX2RldmljZV9wdXQocGRldmljZSk7CitleGl0OgorCXJl
dHVybiBlcnI7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBpYm1wb3dlcm52X2V4aXQodm9pZCkK
K3sKKwlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmaWJtcG93ZXJudl9kcml2ZXIpOworCXBs
YXRmb3JtX2RldmljZV91bnJlZ2lzdGVyKHBkZXZpY2UpOworfQorCitNT0RVTEVfQVVUSE9SKCJO
ZWVsZXNoIEd1cHRhIDxuZWVsZWd1cEBsaW51eC52bmV0LmlibS5jb20+Iik7CitNT0RVTEVfREVT
Q1JJUFRJT04oIklCTSBQT1dFUk5WIHBsYXRmb3JtIHNlbnNvcnMiKTsKK01PRFVMRV9MSUNFTlNF
KCJHUEwiKTsKKworbW9kdWxlX2luaXQoaWJtcG93ZXJudl9pbml0KTsKK21vZHVsZV9leGl0KGli
bXBvd2VybnZfZXhpdCk7CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f
X19fX19fX18KbG0tc2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9y
ZwpodHRwOi8vbGlzdHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz
WARNING: multiple messages have this Message-ID (diff)
From: Neelesh Gupta <neelegup@linux.vnet.ibm.com>
To: linuxppc-dev@lists.ozlabs.org, linux@roeck-us.net,
jdelvare@suse.de, lm-sensors@lm-sensors.org
Cc: sbhat@linux.vnet.ibm.com
Subject: [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperature
Date: Fri, 04 Jul 2014 16:32:56 +0530 [thread overview]
Message-ID: <20140704105343.22437.52125.stgit@localhost.localdomain> (raw)
This patch adds basic kernel support for reading power values, fan
speed rpm, voltage and temperature data on powernv platforms which will
be exported to user space through sysfs interface.
Test results:
-------------
[root@tul163p1 ~]# sensors
ibmpowernv-isa-0000
Adapter: ISA adapter
fan1: 5567 RPM (min = 0 RPM)
fan2: 5232 RPM (min = 0 RPM)
fan3: 5532 RPM (min = 0 RPM)
fan4: 4945 RPM (min = 0 RPM)
fan5: 0 RPM (min = 0 RPM)
fan6: 0 RPM (min = 0 RPM)
fan7: 7392 RPM (min = 0 RPM)
fan8: 7936 RPM (min = 0 RPM)
temp1: +39.0°C (high = +0.0°C)
power1: 191.00 W
[root@tul163p1 ~]# ls /sys/devices/platform/
alarmtimer ibmpowernv.0 power rtc-generic serial8250 uevent
[root@tul163p1 ~]# ls /sys/devices/platform/ibmpowernv.0/hwmon/hwmon0/
device fan2_min fan4_min fan6_min fan8_min power
fan1_fault fan3_fault fan5_fault fan7_fault in1_fault power1_input
fan1_input fan3_input fan5_input fan7_input in2_fault subsystem
fan1_min fan3_min fan5_min fan7_min in3_fault temp1_input
fan2_fault fan4_fault fan6_fault fan8_fault in4_fault temp1_max
fan2_input fan4_input fan6_input fan8_input name uevent
[root@tul163p1 ~]#
[root@tul163p1 ~]# ls /sys/class/hwmon/hwmon0/
device fan2_min fan4_min fan6_min fan8_min power
fan1_fault fan3_fault fan5_fault fan7_fault in1_fault power1_input
fan1_input fan3_input fan5_input fan7_input in2_fault subsystem
fan1_min fan3_min fan5_min fan7_min in3_fault temp1_input
fan2_fault fan4_fault fan6_fault fan8_fault in4_fault temp1_max
fan2_input fan4_input fan6_input fan8_input name uevent
[root@tul163p1 ~]#
Signed-off-by: Neelesh Gupta <neelegup@linux.vnet.ibm.com>
---
Changes in v4
=============
- Replaced pr_err() with dev_err() for loggin print messages.
- Using kstrtou32() function for converting string to u32 instead of sscanf().
Changes in v3
=============
- Fixed an endianness bug leading the driver to break on LE.
- Fixed a bug that when one of the 'attribute_group' not populated, following
groups attributes were dropped.
- Rewrite the get_sensor_index_attr() function to handle all the error scenarios
like 'sscanf' etc.
- Fixed all the errors/warnings related to coding style/whitespace.
- Added 'Documentation' files.
- Addressed remaining review comments on V2.
Changes in v2
=============
- Generic use of devm_* functions in hwmon like using devm_kzalloc() for dynamic
memory request, avoiding the need to explicit free of memory.
Adding 'struct attribute_group' as member of platform data structure to be
populated and then passed to devm_hwmon_device_register_with_groups().
Note: Having an array of pointers of 'attribute_group' and each group
corresponds to 'enum sensors' type. Not completely sure, if it's ideal or
could have just one group populated with attributes of sensor types?
- 'ibmpowernv' is not hot-pluggable device so moving 'platform_driver' callback
function (probe) as part of __init code.
- Fixed issues related to coding style.
- Other general comments in v1.
.../devicetree/bindings/hwmon/ibmpowernv.txt | 27 +
Documentation/hwmon/ibmpowernv | 41 ++
drivers/hwmon/Kconfig | 11 +
drivers/hwmon/Makefile | 1
drivers/hwmon/ibmpowernv.c | 362 ++++++++++++++++++++
5 files changed, 442 insertions(+)
create mode 100644 Documentation/devicetree/bindings/hwmon/ibmpowernv.txt
create mode 100644 Documentation/hwmon/ibmpowernv
create mode 100644 drivers/hwmon/ibmpowernv.c
diff --git a/Documentation/devicetree/bindings/hwmon/ibmpowernv.txt b/Documentation/devicetree/bindings/hwmon/ibmpowernv.txt
new file mode 100644
index 0000000..e3bd1eb
--- /dev/null
+++ b/Documentation/devicetree/bindings/hwmon/ibmpowernv.txt
@@ -0,0 +1,27 @@
+IBM POWERNV platform sensors
+----------------------------
+
+Required node properties:
+- compatible: must be one of
+ "ibm,opal-sensor-cooling-fan"
+ "ibm,opal-sensor-amb-temp"
+ "ibm,opal-sensor-power-supply"
+ "ibm,opal-sensor-power"
+- sensor-id: an opaque id provided by the firmware to the kernel, identifies a
+ given sensor and its attribute data
+
+Example sensors node:
+
+cooling-fan#8-data {
+ sensor-id = <0x7052107>;
+ phandle = <0x10000028>;
+ linux,phandle = <0x10000028>;
+ compatible = "ibm,opal-sensor-cooling-fan";
+};
+
+amb-temp#1-thrs {
+ sensor-id = <0x5096000>;
+ phandle = <0x10000017>;
+ linux,phandle = <0x10000017>;
+ compatible = "ibm,opal-sensor-amb-temp";
+};
diff --git a/Documentation/hwmon/ibmpowernv b/Documentation/hwmon/ibmpowernv
new file mode 100644
index 0000000..644245a
--- /dev/null
+++ b/Documentation/hwmon/ibmpowernv
@@ -0,0 +1,41 @@
+Kernel Driver IBMPOWENV
+=======================
+
+Supported systems:
+ * Any recent IBM P servers based on POWERNV platform
+
+Author: Neelesh Gupta
+
+Description
+-----------
+
+This driver implements reading the platform sensors data like temperature/fan/
+voltage/power for 'POWERNV' platform.
+
+The driver uses the platform device infrastructure. It probes the device tree
+for sensor devices during the __init phase and registers them with the 'hwmon'.
+'hwmon' populates the 'sysfs' tree having attribute files, each for a given
+sensor type and its attribute data.
+
+All the nodes in the DT appear under "/ibm,opal/sensors" and each valid node in
+the DT maps to an attribute file in 'sysfs'. The node exports unique 'sensor-id'
+which the driver uses to make an OPAL call to the firmware.
+
+Usage notes
+-----------
+The driver is built statically with the kernel by enabling the config
+CONFIG_SENSORS_IBMPOWERNV. It can also be built as module 'ibmpowernv'.
+
+Sysfs attributes
+----------------
+
+fanX_input Measured RPM value.
+fanX_min Threshold RPM for alert generation.
+fanX_fault 0: No fail condition
+ 1: Failing fan
+tempX_input Measured ambient temperature.
+tempX_max Threshold ambient temperature for alert generation.
+inX_input Measured power supply voltage
+inX_fault 0: No fail condition.
+ 1: Failing power supply.
+power1_input System power consumption (microWatt)
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 02d3d85..29c3fcb 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -554,6 +554,17 @@ config SENSORS_IBMPEX
This driver can also be built as a module. If so, the module
will be called ibmpex.
+config SENSORS_IBMPOWERNV
+ tristate "IBM POWERNV platform sensors"
+ depends on PPC_POWERNV
+ default y
+ help
+ If you say yes here you get support for the temperature/fan/power
+ sensors on your PowerNV platform.
+
+ This driver can also be built as a module. If so, the module
+ will be called ibmpowernv.
+
config SENSORS_IIO_HWMON
tristate "Hwmon driver that uses channels specified via iio maps"
depends on IIO
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 3dc0f02..fc4ed26 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -71,6 +71,7 @@ obj-$(CONFIG_SENSORS_ULTRA45) += ultra45_env.o
obj-$(CONFIG_SENSORS_I5K_AMB) += i5k_amb.o
obj-$(CONFIG_SENSORS_IBMAEM) += ibmaem.o
obj-$(CONFIG_SENSORS_IBMPEX) += ibmpex.o
+obj-$(CONFIG_SENSORS_IBMPOWERNV)+= ibmpowernv.o
obj-$(CONFIG_SENSORS_IIO_HWMON) += iio_hwmon.o
obj-$(CONFIG_SENSORS_INA209) += ina209.o
obj-$(CONFIG_SENSORS_INA2XX) += ina2xx.o
diff --git a/drivers/hwmon/ibmpowernv.c b/drivers/hwmon/ibmpowernv.c
new file mode 100644
index 0000000..44dcd99
--- /dev/null
+++ b/drivers/hwmon/ibmpowernv.c
@@ -0,0 +1,362 @@
+/*
+ * IBM PowerNV platform sensors for temperature/fan/voltage/power
+ * Copyright (C) 2014 IBM
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.
+ */
+
+#define DRVNAME "ibmpowernv"
+#define pr_fmt(fmt) DRVNAME ": " fmt
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/of.h>
+#include <linux/slab.h>
+
+#include <linux/platform_device.h>
+#include <asm/opal.h>
+#include <linux/err.h>
+
+#define MAX_ATTR_LEN 32
+
+/* Sensor suffix name from DT */
+#define DT_FAULT_ATTR_SUFFIX "faulted"
+#define DT_DATA_ATTR_SUFFIX "data"
+#define DT_THRESHOLD_ATTR_SUFFIX "thrs"
+
+/*
+ * Enumerates all the types of sensors in the POWERNV platform and does index
+ * into 'struct sensor_group'
+ */
+enum sensors {
+ FAN,
+ AMBIENT_TEMP,
+ POWER_SUPPLY,
+ POWER_INPUT,
+ MAX_SENSOR_TYPE,
+};
+
+static struct sensor_group {
+ const char *name;
+ const char *compatible;
+ struct attribute_group group;
+ u32 attr_count;
+} sensor_groups[] = {
+ {"fan", "ibm,opal-sensor-cooling-fan"},
+ {"temp", "ibm,opal-sensor-amb-temp"},
+ {"in", "ibm,opal-sensor-power-supply"},
+ {"power", "ibm,opal-sensor-power"}
+};
+
+struct sensor_data {
+ u32 id; /* An opaque id of the firmware for each sensor */
+ enum sensors type;
+ char name[MAX_ATTR_LEN];
+ struct device_attribute dev_attr;
+};
+
+struct platform_data {
+ const struct attribute_group *attr_groups[MAX_SENSOR_TYPE + 1];
+ u32 sensors_count; /* Total count of sensors from each group */
+};
+
+/* Platform device representing all the ibmpowernv sensors */
+static struct platform_device *pdevice;
+
+static ssize_t show_sensor(struct device *dev, struct device_attribute *devattr,
+ char *buf)
+{
+ struct sensor_data *sdata = container_of(devattr, struct sensor_data,
+ dev_attr);
+ ssize_t ret;
+ u32 x;
+
+ ret = opal_get_sensor_data(sdata->id, &x);
+ if (ret)
+ return ret;
+
+ /* Convert temperature to milli-degrees */
+ if (sdata->type == AMBIENT_TEMP)
+ x *= 1000;
+ /* Convert power to micro-watts */
+ else if (sdata->type == POWER_INPUT)
+ x *= 1000000;
+
+ return sprintf(buf, "%u\n", x);
+}
+
+static int __init get_sensor_index_attr(const char *name, u32 *index,
+ char *attr)
+{
+ char *hash_pos = strchr(name, '#');
+ char buf[8] = { 0 };
+ char *dash_pos;
+ u32 copy_len;
+
+ if (!hash_pos)
+ return -EINVAL;
+
+ dash_pos = strchr(hash_pos, '-');
+ if (!dash_pos)
+ return -EINVAL;
+
+ copy_len = dash_pos - hash_pos - 1;
+ if (copy_len >= sizeof(buf))
+ return -EINVAL;
+
+ strncpy(buf, hash_pos + 1, copy_len);
+
+ if (kstrtou32(buf, 10, index))
+ return -EINVAL;
+
+ strncpy(attr, dash_pos + 1, MAX_ATTR_LEN);
+
+ return 0;
+}
+
+/*
+ * This function translates the DT node name into the 'hwmon' attribute name.
+ * IBMPOWERNV device node appear like cooling-fan#2-data, amb-temp#1-thrs etc.
+ * which need to be mapped as fan2_input, temp1_max respectively before
+ * populating them inside hwmon device class.
+ */
+static int __init create_hwmon_attr_name(struct device *dev, enum sensors type,
+ const char *node_name,
+ char *hwmon_attr_name)
+{
+ char attr_suffix[MAX_ATTR_LEN];
+ char *attr_name;
+ u32 index;
+ int err;
+
+ err = get_sensor_index_attr(node_name, &index, attr_suffix);
+ if (err) {
+ dev_err(dev, "Sensor device node name '%s' is invalid\n",
+ node_name);
+ return err;
+ }
+
+ if (!strcmp(attr_suffix, DT_FAULT_ATTR_SUFFIX)) {
+ attr_name = "fault";
+ } else if (!strcmp(attr_suffix, DT_DATA_ATTR_SUFFIX)) {
+ attr_name = "input";
+ } else if (!strcmp(attr_suffix, DT_THRESHOLD_ATTR_SUFFIX)) {
+ if (type == AMBIENT_TEMP)
+ attr_name = "max";
+ else if (type == FAN)
+ attr_name = "min";
+ else
+ return -ENOENT;
+ } else {
+ return -ENOENT;
+ }
+
+ snprintf(hwmon_attr_name, MAX_ATTR_LEN, "%s%d_%s",
+ sensor_groups[type].name, index, attr_name);
+ return 0;
+}
+
+static int __init populate_attr_groups(struct platform_device *pdev)
+{
+ struct platform_data *pdata = platform_get_drvdata(pdev);
+ const struct attribute_group **pgroups = pdata->attr_groups;
+ struct device_node *opal, *np;
+ enum sensors type;
+
+ opal = of_find_node_by_path("/ibm,opal/sensors");
+ if (!opal) {
+ dev_err(&pdev->dev, "Opal node 'sensors' not found\n");
+ return -ENODEV;
+ }
+
+ for_each_child_of_node(opal, np) {
+ if (np->name == NULL)
+ continue;
+
+ for (type = 0; type < MAX_SENSOR_TYPE; type++)
+ if (of_device_is_compatible(np,
+ sensor_groups[type].compatible)) {
+ sensor_groups[type].attr_count++;
+ break;
+ }
+ }
+
+ of_node_put(opal);
+
+ for (type = 0; type < MAX_SENSOR_TYPE; type++) {
+ sensor_groups[type].group.attrs = devm_kzalloc(&pdev->dev,
+ sizeof(struct attribute *) *
+ (sensor_groups[type].attr_count + 1),
+ GFP_KERNEL);
+ if (!sensor_groups[type].group.attrs)
+ return -ENOMEM;
+
+ pgroups[type] = &sensor_groups[type].group;
+ pdata->sensors_count += sensor_groups[type].attr_count;
+ sensor_groups[type].attr_count = 0;
+ }
+
+ return 0;
+}
+
+/*
+ * Iterate through the device tree for each child of 'sensors' node, create
+ * a sysfs attribute file, the file is named by translating the DT node name
+ * to the name required by the higher 'hwmon' driver like fan1_input, temp1_max
+ * etc..
+ */
+static int __init create_device_attrs(struct platform_device *pdev)
+{
+ struct platform_data *pdata = platform_get_drvdata(pdev);
+ const struct attribute_group **pgroups = pdata->attr_groups;
+ struct device_node *opal, *np;
+ struct sensor_data *sdata;
+ const __be32 *sensor_id;
+ enum sensors type;
+ u32 count = 0;
+ int err = 0;
+
+ opal = of_find_node_by_path("/ibm,opal/sensors");
+ sdata = devm_kzalloc(&pdev->dev, pdata->sensors_count * sizeof(*sdata),
+ GFP_KERNEL);
+ if (!sdata) {
+ err = -ENOMEM;
+ goto exit_put_node;
+ }
+
+ for_each_child_of_node(opal, np) {
+ if (np->name == NULL)
+ continue;
+
+ for (type = 0; type < MAX_SENSOR_TYPE; type++)
+ if (of_device_is_compatible(np,
+ sensor_groups[type].compatible))
+ break;
+
+ if (type == MAX_SENSOR_TYPE)
+ continue;
+
+ sensor_id = of_get_property(np, "sensor-id", NULL);
+ if (!sensor_id) {
+ dev_info(&pdev->dev,
+ "'sensor-id' missing in the node '%s'\n",
+ np->name);
+ continue;
+ }
+
+ sdata[count].id = be32_to_cpup(sensor_id);
+ sdata[count].type = type;
+ err = create_hwmon_attr_name(&pdev->dev, type, np->name,
+ sdata[count].name);
+ if (err)
+ goto exit_put_node;
+
+ sysfs_attr_init(&sdata[count].dev_attr.attr);
+ sdata[count].dev_attr.attr.name = sdata[count].name;
+ sdata[count].dev_attr.attr.mode = S_IRUGO;
+ sdata[count].dev_attr.show = show_sensor;
+
+ pgroups[type]->attrs[sensor_groups[type].attr_count++] =
+ &sdata[count++].dev_attr.attr;
+ }
+
+exit_put_node:
+ of_node_put(opal);
+ return err;
+}
+
+static int __init ibmpowernv_probe(struct platform_device *pdev)
+{
+ struct platform_data *pdata;
+ struct device *hwmon_dev;
+ int err;
+
+ pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+ if (!pdata)
+ return -ENOMEM;
+
+ platform_set_drvdata(pdev, pdata);
+ pdata->sensors_count = 0;
+ err = populate_attr_groups(pdev);
+ if (err)
+ return err;
+
+ /* Create sysfs attribute data for each sensor found in the DT */
+ err = create_device_attrs(pdev);
+ if (err)
+ return err;
+
+ /* Finally, register with hwmon */
+ hwmon_dev = devm_hwmon_device_register_with_groups(&pdev->dev, DRVNAME,
+ pdata,
+ pdata->attr_groups);
+
+ return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+
+static struct platform_driver ibmpowernv_driver = {
+ .driver = {
+ .owner = THIS_MODULE,
+ .name = DRVNAME,
+ },
+};
+
+static int __init ibmpowernv_init(void)
+{
+ int err;
+
+ pdevice = platform_device_alloc(DRVNAME, 0);
+ if (!pdevice) {
+ pr_err("Device allocation failed\n");
+ err = -ENOMEM;
+ goto exit;
+ }
+
+ err = platform_device_add(pdevice);
+ if (err) {
+ pr_err("Device addition failed (%d)\n", err);
+ goto exit_device_put;
+ }
+
+ err = platform_driver_probe(&ibmpowernv_driver, ibmpowernv_probe);
+ if (err) {
+ pr_err("Platfrom driver probe failed\n");
+ goto exit_device_del;
+ }
+
+ return 0;
+
+exit_device_del:
+ platform_device_del(pdevice);
+exit_device_put:
+ platform_device_put(pdevice);
+exit:
+ return err;
+}
+
+static void __exit ibmpowernv_exit(void)
+{
+ platform_driver_unregister(&ibmpowernv_driver);
+ platform_device_unregister(pdevice);
+}
+
+MODULE_AUTHOR("Neelesh Gupta <neelegup@linux.vnet.ibm.com>");
+MODULE_DESCRIPTION("IBM POWERNV platform sensors");
+MODULE_LICENSE("GPL");
+
+module_init(ibmpowernv_init);
+module_exit(ibmpowernv_exit);
next reply other threads:[~2014-07-04 11:14 UTC|newest]
Thread overview: 11+ messages / expand[flat|nested] mbox.gz Atom feed top
2014-07-04 11:02 Neelesh Gupta [this message]
2014-07-04 11:14 ` [lm-sensors] [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperature Neelesh Gupta
[not found] ` <20140704105343.22437.52125.stgit-bi+AKbBUZKY6gyzm1THtWbp2dZbC/Bob@public.gmane.org>
2014-07-05 2:25 ` [lm-sensors] [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperatur Guenter Roeck
2014-07-05 2:25 ` [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperature Guenter Roeck
2014-07-05 2:25 ` Guenter Roeck
2014-07-07 6:56 ` [lm-sensors] [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperatur Benjamin Herrenschmidt
2014-07-07 6:56 ` [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperature Benjamin Herrenschmidt
2014-07-07 6:56 ` Benjamin Herrenschmidt
2014-07-07 12:59 ` [lm-sensors] [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperatur Guenter Roeck
2014-07-07 12:59 ` [PATCH v4] powerpc/powernv: hwmon driver for power, fan rpm, voltage and temperature Guenter Roeck
2014-07-07 12:59 ` Guenter Roeck
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20140704105343.22437.52125.stgit@localhost.localdomain \
--to=neelegup@linux.vnet.ibm.com \
--cc=jdelvare@suse.de \
--cc=linux@roeck-us.net \
--cc=linuxppc-dev@lists.ozlabs.org \
--cc=lm-sensors@lm-sensors.org \
--cc=sbhat@linux.vnet.ibm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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.