* [lm-sensors] [PATCH 0/2] i8k.c => dell-smm-hwmon.c @ 2015-03-28 10:24 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 10:24 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBwYXRjaCBzZXJpZXMgbW92ZXMgZHJpdmVycy9jaGFyL2k4ay5jIHRvIGRyaXZlcnMvaHdt b24vZGVsbC1zbW0taHdtb24uYwphbmQgYWxsb3dzIHRvIGNvbXBpbGUgaHdtb24gZHJpdmVyIHdp dGhvdXQgL3Byb2MvaThrIGZpbGUuCgpQYWxpIFJvaMOhciAoMik6CiAgaHdtb246IFJlbmFtZSBp OGsgZHJpdmVyIHRvIGRlbGwtc21tLWh3bW9uIGFuZCBtb3ZlIGl0IHRvIGh3bW9uIHRyZWUKICBo d21vbjogQWxsb3cgdG8gY29tcGlsZSBkZWxsLXNtbS1od21vbiBkcml2ZXIgd2l0aG91dCAvcHJv Yy9pOGsKCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgfCAgICAzICstCiBhcmNoL3g4 Ni9LY29uZmlnICAgICAgICAgICAgICAgfCAgIDI1ICstCiBkcml2ZXJzL2NoYXIvTWFrZWZpbGUg ICAgICAgICAgfCAgICAxIC0KIGRyaXZlcnMvY2hhci9pOGsuYyAgICAgICAgICAgICB8IDEwMDUg LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2h3bW9uL0tj b25maWcgICAgICAgICAgfCAgIDExICsKIGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgICAgICAgICB8 ICAgIDEgKwogZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIHwgMTAxOSArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiA3IGZpbGVzIGNoYW5nZWQsIDEwNDIgaW5z ZXJ0aW9ucygrKSwgMTAyMyBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L2NoYXIvaThrLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3 bW9uLmMKCi0tIAoxLjcuOS41CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KbG0tc2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3Jz Lm9yZwpodHRwOi8vbGlzdHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5z b3Jz ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH 0/2] i8k.c => dell-smm-hwmon.c @ 2015-03-28 10:24 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 10:24 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c and allows to compile hwmon driver without /proc/i8k file. Pali Rohár (2): hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k MAINTAINERS | 3 +- arch/x86/Kconfig | 25 +- drivers/char/Makefile | 1 - drivers/char/i8k.c | 1005 --------------------------------------- drivers/hwmon/Kconfig | 11 + drivers/hwmon/Makefile | 1 + drivers/hwmon/dell-smm-hwmon.c | 1019 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 1042 insertions(+), 1023 deletions(-) delete mode 100644 drivers/char/i8k.c create mode 100644 drivers/hwmon/dell-smm-hwmon.c -- 1.7.9.5 ^ permalink raw reply [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree 2015-03-28 10:24 ` Pali Rohár @ 2015-03-28 10:24 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 10:24 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBjb21taXQgbW92ZXMgaThrIGRyaXZlciB0byBod21vbiB0cmVlIHVuZGVyIG5hbWUgZGVs bC1zbW0taHdtb24gd2hpY2ggaXMKYmV0dGVyIG5hbWUgdGhlbiBhYmJyZXZpYXRpb24gaThrLiBG b3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSBpcyBhZGRlZCBtYWNybwpNT0RVTEVfQUxJQVMoImk4 ayIpIHNvIG1vZHByb2JlIHdpbGwgbG9hZCBkcml2ZXIgYWxzbyBvbGQgbmFtZSBpOGsuIENPTkZJ R19JOEsKY29tcGlsZSBvcHRpb24gd2FzIG5vdCBjaGFuZ2VkLgoKVGhpcyBjb21taXQgYWxzbyBh ZGRzIG1lIGFzIG1haW50YWluZXIgb2YgdGhpcyBuZXcgZGVsbC1zbW0taHdtb24gZHJpdmVyLgoK U2lnbmVkLW9mZi1ieTogUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPgotLS0KIE1B SU5UQUlORVJTICAgICAgICAgICAgICAgICAgICB8ICAgIDMgKy0KIGRyaXZlcnMvY2hhci9NYWtl ZmlsZSAgICAgICAgICB8ICAgIDEgLQogZHJpdmVycy9jaGFyL2k4ay5jICAgICAgICAgICAgIHwg MTAwNSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvaHdt b24vTWFrZWZpbGUgICAgICAgICB8ICAgIDEgKwogZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21v bi5jIHwgMTAwNyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiA1IGZp bGVzIGNoYW5nZWQsIDEwMTAgaW5zZXJ0aW9ucygrKSwgMTAwNyBkZWxldGlvbnMoLSkKIGRlbGV0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2NoYXIvaThrLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMKCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01B SU5UQUlORVJTCmluZGV4IDg4YzA5Y2EuLmJmNWJiMDUgMTAwNjQ0Ci0tLSBhL01BSU5UQUlORVJT CisrKyBiL01BSU5UQUlORVJTCkBAIC0zMDY0LDggKzMwNjQsOSBAQCBGOglkcml2ZXJzL3BsYXRm b3JtL3g4Ni9kZWxsLWxhcHRvcC5jCiAKIERFTEwgTEFQVE9QIFNNTSBEUklWRVIKIE06CUd1ZW50 ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVzLm5ldD4KK006CVBhbGkgUm9ow6FyIDxwYWxpLnJvaGFy QGdtYWlsLmNvbT4KIFM6CU1haW50YWluZWQKLUY6CWRyaXZlcnMvY2hhci9pOGsuYworRjoJZHJp dmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jCiBGOglpbmNsdWRlL3VhcGkvbGludXgvaThrLmgK IAogREVMTCBTWVNURU1TIE1BTkFHRU1FTlQgQkFTRSBEUklWRVIgKGRjZGJhcykKZGlmZiAtLWdp dCBhL2RyaXZlcnMvY2hhci9NYWtlZmlsZSBiL2RyaXZlcnMvY2hhci9NYWtlZmlsZQppbmRleCBk MDZjZGUyNi4uMWQ5Y2YwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL01ha2VmaWxlCisrKyBi L2RyaXZlcnMvY2hhci9NYWtlZmlsZQpAQCAtMzYsNyArMzYsNiBAQCBlbHNlCiAgIG9iai0kKENP TkZJR19OVlJBTSkJKz0gbnZyYW0ubwogZW5kaWYKIG9iai0kKENPTkZJR19UT1NISUJBKQkJKz0g dG9zaGliYS5vCi1vYmotJChDT05GSUdfSThLKQkJKz0gaThrLm8KIG9iai0kKENPTkZJR19EUzE2 MjApCQkrPSBkczE2MjAubwogb2JqLSQoQ09ORklHX0hXX1JBTkRPTSkJCSs9IGh3X3JhbmRvbS8K IG9iai0kKENPTkZJR19QUERFVikJCSs9IHBwZGV2Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hh ci9pOGsuYyBiL2RyaXZlcnMvY2hhci9pOGsuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMjRjYzRlZC4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL2NoYXIvaThrLmMKKysrIC9kZXYvbnVs bApAQCAtMSwxMDA1ICswLDAgQEAKLS8qCi0gKiBpOGsuYyAtLSBMaW51eCBkcml2ZXIgZm9yIGFj Y2Vzc2luZyB0aGUgU01NIEJJT1Mgb24gRGVsbCBsYXB0b3BzLgotICoKLSAqIENvcHlyaWdodCAo QykgMjAwMSAgTWFzc2ltbyBEYWwgWm90dG8gPGR6QGRlYmlhbi5vcmc+Ci0gKgotICogSHdtb24g aW50ZWdyYXRpb246Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgIEplYW4gRGVsdmFyZSA8amRlbHZh cmVAc3VzZS5kZT4KLSAqIENvcHlyaWdodCAoQykgMjAxMywgMjAxNCAgR3VlbnRlciBSb2VjayA8 bGludXhAcm9lY2stdXMubmV0PgotICogQ29weXJpZ2h0IChDKSAyMDE0ICBQYWxpIFJvaMOhciA8 cGFsaS5yb2hhckBnbWFpbC5jb20+Ci0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKLSAqIHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZQotICogRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAo YXQgeW91ciBvcHRpb24pIGFueQotICogbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dy YW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0 Ci0gKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQotICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgotICovCi0KLSNkZWZpbmUgcHJfZm10KGZtdCkgS0JVSUxEX01PRE5BTUUgIjogIiBm bXQKLQotI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Ci0jaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ Ci0jaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KLSNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Ci0jaW5j bHVkZSA8bGludXgvcHJvY19mcy5oPgotI2luY2x1ZGUgPGxpbnV4L3NlcV9maWxlLmg+Ci0jaW5j bHVkZSA8bGludXgvZG1pLmg+Ci0jaW5jbHVkZSA8bGludXgvY2FwYWJpbGl0eS5oPgotI2luY2x1 ZGUgPGxpbnV4L211dGV4Lmg+Ci0jaW5jbHVkZSA8bGludXgvaHdtb24uaD4KLSNpbmNsdWRlIDxs aW51eC9od21vbi1zeXNmcy5oPgotI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KLSNpbmNsdWRl IDxsaW51eC9pby5oPgotI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+Ci0KLSNpbmNsdWRlIDxsaW51 eC9pOGsuaD4KLQotI2RlZmluZSBJOEtfU01NX0ZOX1NUQVRVUwkweDAwMjUKLSNkZWZpbmUgSThL X1NNTV9QT1dFUl9TVEFUVVMJMHgwMDY5Ci0jZGVmaW5lIEk4S19TTU1fU0VUX0ZBTgkJMHgwMWEz Ci0jZGVmaW5lIEk4S19TTU1fR0VUX0ZBTgkJMHgwMGEzCi0jZGVmaW5lIEk4S19TTU1fR0VUX1NQ RUVECTB4MDJhMwotI2RlZmluZSBJOEtfU01NX0dFVF9GQU5fVFlQRQkweDAzYTMKLSNkZWZpbmUg SThLX1NNTV9HRVRfTk9NX1NQRUVECTB4MDRhMwotI2RlZmluZSBJOEtfU01NX0dFVF9URU1QCTB4 MTBhMwotI2RlZmluZSBJOEtfU01NX0dFVF9URU1QX1RZUEUJMHgxMWEzCi0jZGVmaW5lIEk4S19T TU1fR0VUX0RFTExfU0lHMQkweGZlYTMKLSNkZWZpbmUgSThLX1NNTV9HRVRfREVMTF9TSUcyCTB4 ZmZhMwotCi0jZGVmaW5lIEk4S19GQU5fTVVMVAkJMzAKLSNkZWZpbmUgSThLX0ZBTl9NQVhfUlBN CQkzMDAwMAotI2RlZmluZSBJOEtfTUFYX1RFTVAJCTEyNwotCi0jZGVmaW5lIEk4S19GTl9OT05F CQkweDAwCi0jZGVmaW5lIEk4S19GTl9VUAkJMHgwMQotI2RlZmluZSBJOEtfRk5fRE9XTgkJMHgw MgotI2RlZmluZSBJOEtfRk5fTVVURQkJMHgwNAotI2RlZmluZSBJOEtfRk5fTUFTSwkJMHgwNwot I2RlZmluZSBJOEtfRk5fU0hJRlQJCTgKLQotI2RlZmluZSBJOEtfUE9XRVJfQUMJCTB4MDUKLSNk ZWZpbmUgSThLX1BPV0VSX0JBVFRFUlkJMHgwMQotCi1zdGF0aWMgREVGSU5FX01VVEVYKGk4a19t dXRleCk7Ci1zdGF0aWMgY2hhciBiaW9zX3ZlcnNpb25bNF07Ci1zdGF0aWMgc3RydWN0IGRldmlj ZSAqaThrX2h3bW9uX2RldjsKLXN0YXRpYyB1MzIgaThrX2h3bW9uX2ZsYWdzOwotc3RhdGljIHVp bnQgaThrX2Zhbl9tdWx0ID0gSThLX0ZBTl9NVUxUOwotc3RhdGljIHVpbnQgaThrX3B3bV9tdWx0 Owotc3RhdGljIHVpbnQgaThrX2Zhbl9tYXggPSBJOEtfRkFOX0hJR0g7Ci0KLSNkZWZpbmUgSThL X0hXTU9OX0hBVkVfVEVNUDEJKDEgPDwgMCkKLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDIJ KDEgPDwgMSkKLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDMJKDEgPDwgMikKLSNkZWZpbmUg SThLX0hXTU9OX0hBVkVfVEVNUDQJKDEgPDwgMykKLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfRkFO MQkoMSA8PCA0KQotI2RlZmluZSBJOEtfSFdNT05fSEFWRV9GQU4yCSgxIDw8IDUpCi0KLU1PRFVM RV9BVVRIT1IoIk1hc3NpbW8gRGFsIFpvdHRvIChkekBkZWJpYW4ub3JnKSIpOwotTU9EVUxFX0RF U0NSSVBUSU9OKCJEcml2ZXIgZm9yIGFjY2Vzc2luZyBTTU0gQklPUyBvbiBEZWxsIGxhcHRvcHMi KTsKLU1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKLQotc3RhdGljIGJvb2wgZm9yY2U7Ci1tb2R1bGVf cGFyYW0oZm9yY2UsIGJvb2wsIDApOwotTU9EVUxFX1BBUk1fREVTQyhmb3JjZSwgIkZvcmNlIGxv YWRpbmcgd2l0aG91dCBjaGVja2luZyBmb3Igc3VwcG9ydGVkIG1vZGVscyIpOwotCi1zdGF0aWMg Ym9vbCBpZ25vcmVfZG1pOwotbW9kdWxlX3BhcmFtKGlnbm9yZV9kbWksIGJvb2wsIDApOwotTU9E VUxFX1BBUk1fREVTQyhpZ25vcmVfZG1pLCAiQ29udGludWUgcHJvYmluZyBoYXJkd2FyZSBldmVu IGlmIERNSSBkYXRhIGRvZXMgbm90IG1hdGNoIik7Ci0KLXN0YXRpYyBib29sIHJlc3RyaWN0ZWQ7 Ci1tb2R1bGVfcGFyYW0ocmVzdHJpY3RlZCwgYm9vbCwgMCk7Ci1NT0RVTEVfUEFSTV9ERVNDKHJl c3RyaWN0ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJpbGl0eSBzZXQi KTsKLQotc3RhdGljIGJvb2wgcG93ZXJfc3RhdHVzOwotbW9kdWxlX3BhcmFtKHBvd2VyX3N0YXR1 cywgYm9vbCwgMDYwMCk7Ci1NT0RVTEVfUEFSTV9ERVNDKHBvd2VyX3N0YXR1cywgIlJlcG9ydCBw b3dlciBzdGF0dXMgaW4gL3Byb2MvaThrIik7Ci0KLXN0YXRpYyB1aW50IGZhbl9tdWx0OwotbW9k dWxlX3BhcmFtKGZhbl9tdWx0LCB1aW50LCAwKTsKLU1PRFVMRV9QQVJNX0RFU0MoZmFuX211bHQs ICJGYWN0b3IgdG8gbXVsdGlwbHkgZmFuIHNwZWVkIHdpdGggKGRlZmF1bHQ6IGF1dG9kZXRlY3Qp Iik7Ci0KLXN0YXRpYyB1aW50IGZhbl9tYXg7Ci1tb2R1bGVfcGFyYW0oZmFuX21heCwgdWludCwg MCk7Ci1NT0RVTEVfUEFSTV9ERVNDKGZhbl9tYXgsICJNYXhpbXVtIGNvbmZpZ3VyYWJsZSBmYW4g c3BlZWQgKGRlZmF1bHQ6IGF1dG9kZXRlY3QpIik7Ci0KLXN0YXRpYyBpbnQgaThrX29wZW5fZnMo c3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpOwotc3RhdGljIGxvbmcgaThr X2lvY3RsKHN0cnVjdCBmaWxlICosIHVuc2lnbmVkIGludCwgdW5zaWduZWQgbG9uZyk7Ci0KLXN0 YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGk4a19mb3BzID0gewotCS5vd25lcgkJ PSBUSElTX01PRFVMRSwKLQkub3BlbgkJPSBpOGtfb3Blbl9mcywKLQkucmVhZAkJPSBzZXFfcmVh ZCwKLQkubGxzZWVrCQk9IHNlcV9sc2VlaywKLQkucmVsZWFzZQk9IHNpbmdsZV9yZWxlYXNlLAot CS51bmxvY2tlZF9pb2N0bAk9IGk4a19pb2N0bCwKLX07Ci0KLXN0cnVjdCBzbW1fcmVncyB7Ci0J dW5zaWduZWQgaW50IGVheDsKLQl1bnNpZ25lZCBpbnQgZWJ4IF9fcGFja2VkOwotCXVuc2lnbmVk IGludCBlY3ggX19wYWNrZWQ7Ci0JdW5zaWduZWQgaW50IGVkeCBfX3BhY2tlZDsKLQl1bnNpZ25l ZCBpbnQgZXNpIF9fcGFja2VkOwotCXVuc2lnbmVkIGludCBlZGkgX19wYWNrZWQ7Ci19OwotCi1z dGF0aWMgaW5saW5lIGNvbnN0IGNoYXIgKmk4a19nZXRfZG1pX2RhdGEoaW50IGZpZWxkKQotewot CWNvbnN0IGNoYXIgKmRtaV9kYXRhID0gZG1pX2dldF9zeXN0ZW1faW5mbyhmaWVsZCk7Ci0KLQly ZXR1cm4gZG1pX2RhdGEgJiYgKmRtaV9kYXRhID8gZG1pX2RhdGEgOiAiPyI7Ci19Ci0KLS8qCi0g KiBDYWxsIHRoZSBTeXN0ZW0gTWFuYWdlbWVudCBNb2RlIEJJT1MuIENvZGUgcHJvdmlkZWQgYnkg Sm9uYXRoYW4gQnV6emFyZC4KLSAqLwotc3RhdGljIGludCBpOGtfc21tKHN0cnVjdCBzbW1fcmVn cyAqcmVncykKLXsKLQlpbnQgcmM7Ci0JaW50IGVheCA9IHJlZ3MtPmVheDsKLQljcHVtYXNrX3Zh cl90IG9sZF9tYXNrOwotCi0JLyogU01NIHJlcXVpcmVzIENQVSAwICovCi0JaWYgKCFhbGxvY19j cHVtYXNrX3Zhcigmb2xkX21hc2ssIEdGUF9LRVJORUwpKQotCQlyZXR1cm4gLUVOT01FTTsKLQlj cHVtYXNrX2NvcHkob2xkX21hc2ssICZjdXJyZW50LT5jcHVzX2FsbG93ZWQpOwotCXJjID0gc2V0 X2NwdXNfYWxsb3dlZF9wdHIoY3VycmVudCwgY3B1bWFza19vZigwKSk7Ci0JaWYgKHJjKQotCQln b3RvIG91dDsKLQlpZiAoc21wX3Byb2Nlc3Nvcl9pZCgpICE9IDApIHsKLQkJcmMgPSAtRUJVU1k7 Ci0JCWdvdG8gb3V0OwotCX0KLQotI2lmIGRlZmluZWQoQ09ORklHX1g4Nl82NCkKLQlhc20gdm9s YXRpbGUoInB1c2hxICUlcmF4XG5cdCIKLQkJIm1vdmwgMCglJXJheCksJSVlZHhcblx0IgotCQki cHVzaHEgJSVyZHhcblx0IgotCQkibW92bCA0KCUlcmF4KSwlJWVieFxuXHQiCi0JCSJtb3ZsIDgo JSVyYXgpLCUlZWN4XG5cdCIKLQkJIm1vdmwgMTIoJSVyYXgpLCUlZWR4XG5cdCIKLQkJIm1vdmwg MTYoJSVyYXgpLCUlZXNpXG5cdCIKLQkJIm1vdmwgMjAoJSVyYXgpLCUlZWRpXG5cdCIKLQkJInBv cHEgJSVyYXhcblx0IgotCQkib3V0ICUlYWwsJDB4YjJcblx0IgotCQkib3V0ICUlYWwsJDB4ODRc blx0IgotCQkieGNoZ3EgJSVyYXgsKCUlcnNwKVxuXHQiCi0JCSJtb3ZsICUlZWJ4LDQoJSVyYXgp XG5cdCIKLQkJIm1vdmwgJSVlY3gsOCglJXJheClcblx0IgotCQkibW92bCAlJWVkeCwxMiglJXJh eClcblx0IgotCQkibW92bCAlJWVzaSwxNiglJXJheClcblx0IgotCQkibW92bCAlJWVkaSwyMCgl JXJheClcblx0IgotCQkicG9wcSAlJXJkeFxuXHQiCi0JCSJtb3ZsICUlZWR4LDAoJSVyYXgpXG5c dCIKLQkJInB1c2hmcVxuXHQiCi0JCSJwb3BxICUlcmF4XG5cdCIKLQkJImFuZGwgJDEsJSVlYXhc biIKLQkJOiAiPWEiKHJjKQotCQk6ICAgICJhIihyZWdzKQotCQk6ICAgICIlZWJ4IiwgIiVlY3gi LCAiJWVkeCIsICIlZXNpIiwgIiVlZGkiLCAibWVtb3J5Iik7Ci0jZWxzZQotCWFzbSB2b2xhdGls ZSgicHVzaGwgJSVlYXhcblx0IgotCSAgICAibW92bCAwKCUlZWF4KSwlJWVkeFxuXHQiCi0JICAg ICJwdXNoICUlZWR4XG5cdCIKLQkgICAgIm1vdmwgNCglJWVheCksJSVlYnhcblx0IgotCSAgICAi bW92bCA4KCUlZWF4KSwlJWVjeFxuXHQiCi0JICAgICJtb3ZsIDEyKCUlZWF4KSwlJWVkeFxuXHQi Ci0JICAgICJtb3ZsIDE2KCUlZWF4KSwlJWVzaVxuXHQiCi0JICAgICJtb3ZsIDIwKCUlZWF4KSwl JWVkaVxuXHQiCi0JICAgICJwb3BsICUlZWF4XG5cdCIKLQkgICAgIm91dCAlJWFsLCQweGIyXG5c dCIKLQkgICAgIm91dCAlJWFsLCQweDg0XG5cdCIKLQkgICAgInhjaGdsICUlZWF4LCglJWVzcClc blx0IgotCSAgICAibW92bCAlJWVieCw0KCUlZWF4KVxuXHQiCi0JICAgICJtb3ZsICUlZWN4LDgo JSVlYXgpXG5cdCIKLQkgICAgIm1vdmwgJSVlZHgsMTIoJSVlYXgpXG5cdCIKLQkgICAgIm1vdmwg JSVlc2ksMTYoJSVlYXgpXG5cdCIKLQkgICAgIm1vdmwgJSVlZGksMjAoJSVlYXgpXG5cdCIKLQkg ICAgInBvcGwgJSVlZHhcblx0IgotCSAgICAibW92bCAlJWVkeCwwKCUlZWF4KVxuXHQiCi0JICAg ICJsYWhmXG5cdCIKLQkgICAgInNocmwgJDgsJSVlYXhcblx0IgotCSAgICAiYW5kbCAkMSwlJWVh eFxuIgotCSAgICA6ICI9YSIocmMpCi0JICAgIDogICAgImEiKHJlZ3MpCi0JICAgIDogICAgIiVl YngiLCAiJWVjeCIsICIlZWR4IiwgIiVlc2kiLCAiJWVkaSIsICJtZW1vcnkiKTsKLSNlbmRpZgot CWlmIChyYyAhPSAwIHx8IChyZWdzLT5lYXggJiAweGZmZmYpID09IDB4ZmZmZiB8fCByZWdzLT5l YXggPT0gZWF4KQotCQlyYyA9IC1FSU5WQUw7Ci0KLW91dDoKLQlzZXRfY3B1c19hbGxvd2VkX3B0 cihjdXJyZW50LCBvbGRfbWFzayk7Ci0JZnJlZV9jcHVtYXNrX3ZhcihvbGRfbWFzayk7Ci0JcmV0 dXJuIHJjOwotfQotCi0vKgotICogUmVhZCB0aGUgRm4ga2V5IHN0YXR1cy4KLSAqLwotc3RhdGlj IGludCBpOGtfZ2V0X2ZuX3N0YXR1cyh2b2lkKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0g eyAuZWF4ID0gSThLX1NNTV9GTl9TVEFUVVMsIH07Ci0JaW50IHJjOwotCi0JcmMgPSBpOGtfc21t KCZyZWdzKTsKLQlpZiAocmMgPCAwKQotCQlyZXR1cm4gcmM7Ci0KLQlzd2l0Y2ggKChyZWdzLmVh eCA+PiBJOEtfRk5fU0hJRlQpICYgSThLX0ZOX01BU0spIHsKLQljYXNlIEk4S19GTl9VUDoKLQkJ cmV0dXJuIEk4S19WT0xfVVA7Ci0JY2FzZSBJOEtfRk5fRE9XTjoKLQkJcmV0dXJuIEk4S19WT0xf RE9XTjsKLQljYXNlIEk4S19GTl9NVVRFOgotCQlyZXR1cm4gSThLX1ZPTF9NVVRFOwotCWRlZmF1 bHQ6Ci0JCXJldHVybiAwOwotCX0KLX0KLQotLyoKLSAqIFJlYWQgdGhlIHBvd2VyIHN0YXR1cy4K LSAqLwotc3RhdGljIGludCBpOGtfZ2V0X3Bvd2VyX3N0YXR1cyh2b2lkKQotewotCXN0cnVjdCBz bW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9QT1dFUl9TVEFUVVMsIH07Ci0JaW50IHJj OwotCi0JcmMgPSBpOGtfc21tKCZyZWdzKTsKLQlpZiAocmMgPCAwKQotCQlyZXR1cm4gcmM7Ci0K LQlyZXR1cm4gKHJlZ3MuZWF4ICYgMHhmZikgPT0gSThLX1BPV0VSX0FDID8gSThLX0FDIDogSThL X0JBVFRFUlk7Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBmYW4gc3RhdHVzLgotICovCi1zdGF0aWMg aW50IGk4a19nZXRfZmFuX3N0YXR1cyhpbnQgZmFuKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdz ID0geyAuZWF4ID0gSThLX1NNTV9HRVRfRkFOLCB9OwotCi0JcmVncy5lYnggPSBmYW4gJiAweGZm OwotCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAweGZmOwotfQotCi0vKgot ICogUmVhZCB0aGUgZmFuIHNwZWVkIGluIFJQTS4KLSAqLwotc3RhdGljIGludCBpOGtfZ2V0X2Zh bl9zcGVlZChpbnQgZmFuKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThL X1NNTV9HRVRfU1BFRUQsIH07Ci0KLQlyZWdzLmVieCA9IGZhbiAmIDB4ZmY7Ci0JcmV0dXJuIGk4 a19zbW0oJnJlZ3MpID8gOiAocmVncy5lYXggJiAweGZmZmYpICogaThrX2Zhbl9tdWx0OwotfQot Ci0vKgotICogUmVhZCB0aGUgZmFuIHR5cGUuCi0gKi8KLXN0YXRpYyBpbnQgaThrX2dldF9mYW5f dHlwZShpbnQgZmFuKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NN TV9HRVRfRkFOX1RZUEUsIH07Ci0KLQlyZWdzLmVieCA9IGZhbiAmIDB4ZmY7Ci0JcmV0dXJuIGk4 a19zbW0oJnJlZ3MpID8gOiByZWdzLmVheCAmIDB4ZmY7Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBm YW4gbm9taW5hbCBycG0gZm9yIHNwZWNpZmljIGZhbiBzcGVlZC4KLSAqLwotc3RhdGljIGludCBp OGtfZ2V0X2Zhbl9ub21pbmFsX3NwZWVkKGludCBmYW4sIGludCBzcGVlZCkKLXsKLQlzdHJ1Y3Qg c21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fR0VUX05PTV9TUEVFRCwgfTsKLQotCXJl Z3MuZWJ4ID0gKGZhbiAmIDB4ZmYpIHwgKHNwZWVkIDw8IDgpOwotCXJldHVybiBpOGtfc21tKCZy ZWdzKSA/IDogKHJlZ3MuZWF4ICYgMHhmZmZmKSAqIGk4a19mYW5fbXVsdDsKLX0KLQotLyoKLSAq IFNldCB0aGUgZmFuIHNwZWVkIChvZmYsIGxvdywgaGlnaCkuIFJldHVybnMgdGhlIG5ldyBmYW4g c3RhdHVzLgotICovCi1zdGF0aWMgaW50IGk4a19zZXRfZmFuKGludCBmYW4sIGludCBzcGVlZCkK LXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fU0VUX0ZBTiwgfTsK LQotCXNwZWVkID0gKHNwZWVkIDwgMCkgPyAwIDogKChzcGVlZCA+IGk4a19mYW5fbWF4KSA/IGk4 a19mYW5fbWF4IDogc3BlZWQpOwotCXJlZ3MuZWJ4ID0gKGZhbiAmIDB4ZmYpIHwgKHNwZWVkIDw8 IDgpOwotCi0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiBpOGtfZ2V0X2Zhbl9zdGF0dXMoZmFu KTsKLX0KLQotc3RhdGljIGludCBpOGtfZ2V0X3RlbXBfdHlwZShpbnQgc2Vuc29yKQotewotCXN0 cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfVEVNUF9UWVBFLCB9Owot Ci0JcmVncy5lYnggPSBzZW5zb3IgJiAweGZmOwotCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDog cmVncy5lYXggJiAweGZmOwotfQotCi0vKgotICogUmVhZCB0aGUgY3B1IHRlbXBlcmF0dXJlLgot ICovCi1zdGF0aWMgaW50IF9pOGtfZ2V0X3RlbXAoaW50IHNlbnNvcikKLXsKLQlzdHJ1Y3Qgc21t X3JlZ3MgcmVncyA9IHsKLQkJLmVheCA9IEk4S19TTU1fR0VUX1RFTVAsCi0JCS5lYnggPSBzZW5z b3IgJiAweGZmLAotCX07Ci0KLQlyZXR1cm4gaThrX3NtbSgmcmVncykgPyA6IHJlZ3MuZWF4ICYg MHhmZjsKLX0KLQotc3RhdGljIGludCBpOGtfZ2V0X3RlbXAoaW50IHNlbnNvcikKLXsKLQlpbnQg dGVtcCA9IF9pOGtfZ2V0X3RlbXAoc2Vuc29yKTsKLQotCS8qCi0JICogU29tZXRpbWVzIHRoZSB0 ZW1wZXJhdHVyZSBzZW5zb3IgcmV0dXJucyAweDk5LCB3aGljaCBpcyBvdXQgb2YgcmFuZ2UuCi0J ICogSW4gdGhpcyBjYXNlIHdlIHJldHJ5IChvbmNlKSBiZWZvcmUgcmV0dXJuaW5nIGFuIGVycm9y LgotCSAjIDEwMDM2NTUxMzcgMDAwMDAwNTggMDAwMDVhNGIKLQkgIyAxMDAzNjU1MTM4IDAwMDAw MDk5IDAwMDAzYTgwIDwtLS0gMHg5OSA9IDE1MyBkZWdyZWVzCi0JICMgMTAwMzY1NTEzOSAwMDAw MDA1NCAwMDAwNWM1MgotCSAqLwotCWlmICh0ZW1wID09IDB4OTkpIHsKLQkJbXNsZWVwKDEwMCk7 Ci0JCXRlbXAgPSBfaThrX2dldF90ZW1wKHNlbnNvcik7Ci0JfQotCS8qCi0JICogUmV0dXJuIC1F Tk9EQVRBIGZvciBhbGwgaW52YWxpZCB0ZW1wZXJhdHVyZXMuCi0JICoKLQkgKiBLbm93biBpbnN0 YW5jZXMgYXJlIHRoZSAweDk5IHZhbHVlIGFzIHNlZW4gYWJvdmUgYXMgd2VsbCBhcwotCSAqIDB4 YzEgKDE5MyksIHdoaWNoIG1heSBiZSByZXR1cm5lZCB3aGVuIHRyeWluZyB0byByZWFkIHRoZSBH UFUKLQkgKiB0ZW1wZXJhdHVyZSBpZiB0aGUgc3lzdGVtIHN1cHBvcnRzIGEgR1BVIGFuZCBpdCBp cyBjdXJyZW50bHkKLQkgKiB0dXJuZWQgb2ZmLgotCSAqLwotCWlmICh0ZW1wID4gSThLX01BWF9U RU1QKQotCQlyZXR1cm4gLUVOT0RBVEE7Ci0KLQlyZXR1cm4gdGVtcDsKLX0KLQotc3RhdGljIGlu dCBpOGtfZ2V0X2RlbGxfc2lnbmF0dXJlKGludCByZXFfZm4pCi17Ci0Jc3RydWN0IHNtbV9yZWdz IHJlZ3MgPSB7IC5lYXggPSByZXFfZm4sIH07Ci0JaW50IHJjOwotCi0JcmMgPSBpOGtfc21tKCZy ZWdzKTsKLQlpZiAocmMgPCAwKQotCQlyZXR1cm4gcmM7Ci0KLQlyZXR1cm4gcmVncy5lYXggPT0g MTE0NTY1MTUyNyAmJiByZWdzLmVkeCA9PSAxMTQ1MzkyMjA0ID8gMCA6IC0xOwotfQotCi1zdGF0 aWMgaW50Ci1pOGtfaW9jdGxfdW5sb2NrZWQoc3RydWN0IGZpbGUgKmZwLCB1bnNpZ25lZCBpbnQg Y21kLCB1bnNpZ25lZCBsb25nIGFyZykKLXsKLQlpbnQgdmFsID0gMDsKLQlpbnQgc3BlZWQ7Ci0J dW5zaWduZWQgY2hhciBidWZmWzE2XTsKLQlpbnQgX191c2VyICphcmdwID0gKGludCBfX3VzZXIg Kilhcmc7Ci0KLQlpZiAoIWFyZ3ApCi0JCXJldHVybiAtRUlOVkFMOwotCi0Jc3dpdGNoIChjbWQp IHsKLQljYXNlIEk4S19CSU9TX1ZFUlNJT046Ci0JCXZhbCA9IChiaW9zX3ZlcnNpb25bMF0gPDwg MTYpIHwKLQkJCQkoYmlvc192ZXJzaW9uWzFdIDw8IDgpIHwgYmlvc192ZXJzaW9uWzJdOwotCQli cmVhazsKLQotCWNhc2UgSThLX01BQ0hJTkVfSUQ6Ci0JCW1lbXNldChidWZmLCAwLCAxNik7Ci0J CXN0cmxjcHkoYnVmZiwgaThrX2dldF9kbWlfZGF0YShETUlfUFJPRFVDVF9TRVJJQUwpLAotCQkJ c2l6ZW9mKGJ1ZmYpKTsKLQkJYnJlYWs7Ci0KLQljYXNlIEk4S19GTl9TVEFUVVM6Ci0JCXZhbCA9 IGk4a19nZXRfZm5fc3RhdHVzKCk7Ci0JCWJyZWFrOwotCi0JY2FzZSBJOEtfUE9XRVJfU1RBVFVT OgotCQl2YWwgPSBpOGtfZ2V0X3Bvd2VyX3N0YXR1cygpOwotCQlicmVhazsKLQotCWNhc2UgSThL X0dFVF9URU1QOgotCQl2YWwgPSBpOGtfZ2V0X3RlbXAoMCk7Ci0JCWJyZWFrOwotCi0JY2FzZSBJ OEtfR0VUX1NQRUVEOgotCQlpZiAoY29weV9mcm9tX3VzZXIoJnZhbCwgYXJncCwgc2l6ZW9mKGlu dCkpKQotCQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQkJdmFsID0gaThrX2dldF9mYW5fc3BlZWQodmFs KTsKLQkJYnJlYWs7Ci0KLQljYXNlIEk4S19HRVRfRkFOOgotCQlpZiAoY29weV9mcm9tX3VzZXIo JnZhbCwgYXJncCwgc2l6ZW9mKGludCkpKQotCQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQkJdmFsID0g aThrX2dldF9mYW5fc3RhdHVzKHZhbCk7Ci0JCWJyZWFrOwotCi0JY2FzZSBJOEtfU0VUX0ZBTjoK LQkJaWYgKHJlc3RyaWN0ZWQgJiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCi0JCQlyZXR1cm4g LUVQRVJNOwotCi0JCWlmIChjb3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBzaXplb2YoaW50KSkp Ci0JCQlyZXR1cm4gLUVGQVVMVDsKLQotCQlpZiAoY29weV9mcm9tX3VzZXIoJnNwZWVkLCBhcmdw ICsgMSwgc2l6ZW9mKGludCkpKQotCQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQkJdmFsID0gaThrX3Nl dF9mYW4odmFsLCBzcGVlZCk7Ci0JCWJyZWFrOwotCi0JZGVmYXVsdDoKLQkJcmV0dXJuIC1FSU5W QUw7Ci0JfQotCi0JaWYgKHZhbCA8IDApCi0JCXJldHVybiB2YWw7Ci0KLQlzd2l0Y2ggKGNtZCkg ewotCWNhc2UgSThLX0JJT1NfVkVSU0lPTjoKLQkJaWYgKGNvcHlfdG9fdXNlcihhcmdwLCAmdmFs LCA0KSkKLQkJCXJldHVybiAtRUZBVUxUOwotCi0JCWJyZWFrOwotCWNhc2UgSThLX01BQ0hJTkVf SUQ6Ci0JCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgYnVmZiwgMTYpKQotCQkJcmV0dXJuIC1FRkFV TFQ7Ci0KLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJaWYgKGNvcHlfdG9fdXNlcihhcmdwLCAmdmFs LCBzaXplb2YoaW50KSkpCi0JCQlyZXR1cm4gLUVGQVVMVDsKLQotCQlicmVhazsKLQl9Ci0KLQly ZXR1cm4gMDsKLX0KLQotc3RhdGljIGxvbmcgaThrX2lvY3RsKHN0cnVjdCBmaWxlICpmcCwgdW5z aWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCi17Ci0JbG9uZyByZXQ7Ci0KLQltdXRl eF9sb2NrKCZpOGtfbXV0ZXgpOwotCXJldCA9IGk4a19pb2N0bF91bmxvY2tlZChmcCwgY21kLCBh cmcpOwotCW11dGV4X3VubG9jaygmaThrX211dGV4KTsKLQotCXJldHVybiByZXQ7Ci19Ci0KLS8q Ci0gKiBQcmludCB0aGUgaW5mb3JtYXRpb24gZm9yIC9wcm9jL2k4ay4KLSAqLwotc3RhdGljIGlu dCBpOGtfcHJvY19zaG93KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICpvZmZzZXQpCi17Ci0J aW50IGZuX2tleSwgY3B1X3RlbXAsIGFjX3Bvd2VyOwotCWludCBsZWZ0X2ZhbiwgcmlnaHRfZmFu LCBsZWZ0X3NwZWVkLCByaWdodF9zcGVlZDsKLQotCWNwdV90ZW1wCT0gaThrX2dldF90ZW1wKDAp OwkJCS8qIDExMTAwIMK1cyAqLwotCWxlZnRfZmFuCT0gaThrX2dldF9mYW5fc3RhdHVzKEk4S19G QU5fTEVGVCk7CS8qICAgNTgwIMK1cyAqLwotCXJpZ2h0X2Zhbgk9IGk4a19nZXRfZmFuX3N0YXR1 cyhJOEtfRkFOX1JJR0hUKTsJLyogICA1ODAgwrVzICovCi0JbGVmdF9zcGVlZAk9IGk4a19nZXRf ZmFuX3NwZWVkKEk4S19GQU5fTEVGVCk7CS8qICAgNTgwIMK1cyAqLwotCXJpZ2h0X3NwZWVkCT0g aThrX2dldF9mYW5fc3BlZWQoSThLX0ZBTl9SSUdIVCk7CS8qICAgNTgwIMK1cyAqLwotCWZuX2tl eQkJPSBpOGtfZ2V0X2ZuX3N0YXR1cygpOwkJCS8qICAgNzUwIMK1cyAqLwotCWlmIChwb3dlcl9z dGF0dXMpCi0JCWFjX3Bvd2VyID0gaThrX2dldF9wb3dlcl9zdGF0dXMoKTsJCS8qIDE0NzAwIMK1 cyAqLwotCWVsc2UKLQkJYWNfcG93ZXIgPSAtMTsKLQotCS8qCi0JICogSW5mbzoKLQkgKgotCSAq IDEpICBGb3JtYXQgdmVyc2lvbiAodGhpcyB3aWxsIGNoYW5nZSBpZiBmb3JtYXQgY2hhbmdlcykK LQkgKiAyKSAgQklPUyB2ZXJzaW9uCi0JICogMykgIEJJT1MgbWFjaGluZSBJRAotCSAqIDQpICBD cHUgdGVtcGVyYXR1cmUKLQkgKiA1KSAgTGVmdCBmYW4gc3RhdHVzCi0JICogNikgIFJpZ2h0IGZh biBzdGF0dXMKLQkgKiA3KSAgTGVmdCBmYW4gc3BlZWQKLQkgKiA4KSAgUmlnaHQgZmFuIHNwZWVk Ci0JICogOSkgIEFDIHBvd2VyCi0JICogMTApIEZuIEtleSBzdGF0dXMKLQkgKi8KLQlyZXR1cm4g c2VxX3ByaW50ZihzZXEsICIlcyAlcyAlcyAlZCAlZCAlZCAlZCAlZCAlZCAlZFxuIiwKLQkJCSAg SThLX1BST0NfRk1ULAotCQkJICBiaW9zX3ZlcnNpb24sCi0JCQkgIGk4a19nZXRfZG1pX2RhdGEo RE1JX1BST0RVQ1RfU0VSSUFMKSwKLQkJCSAgY3B1X3RlbXAsCi0JCQkgIGxlZnRfZmFuLCByaWdo dF9mYW4sIGxlZnRfc3BlZWQsIHJpZ2h0X3NwZWVkLAotCQkJICBhY19wb3dlciwgZm5fa2V5KTsK LX0KLQotc3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3Qg ZmlsZSAqZmlsZSkKLXsKLQlyZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgaThrX3Byb2Nfc2hvdywg TlVMTCk7Ci19Ci0KLQotLyoKLSAqIEh3bW9uIGludGVyZmFjZQotICovCi0KLXN0YXRpYyBzc2l6 ZV90IGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwoc3RydWN0IGRldmljZSAqZGV2LAotCQkJCQkg c3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCi0JCQkJCSBjaGFyICpidWYpCi17Ci0J c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBsYWJlbHNbXSA9IHsKLQkJIkNQVSIsCi0JCSJHUFUi LAotCQkiU09ESU1NIiwKLQkJIk90aGVyIiwKLQkJIkFtYmllbnQiLAotCQkiT3RoZXIiLAotCX07 Ci0JaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKLQlpbnQg dHlwZTsKLQotCXR5cGUgPSBpOGtfZ2V0X3RlbXBfdHlwZShpbmRleCk7Ci0JaWYgKHR5cGUgPCAw KQotCQlyZXR1cm4gdHlwZTsKLQlpZiAodHlwZSA+PSBBUlJBWV9TSVpFKGxhYmVscykpCi0JCXR5 cGUgPSBBUlJBWV9TSVpFKGxhYmVscykgLSAxOwotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4i LCBsYWJlbHNbdHlwZV0pOwotfQotCi1zdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2hvd190ZW1w KHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCQkgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2 YXR0ciwKLQkJCQkgICBjaGFyICpidWYpCi17Ci0JaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9h dHRyKGRldmF0dHIpLT5pbmRleDsKLQlpbnQgdGVtcDsKLQotCXRlbXAgPSBpOGtfZ2V0X3RlbXAo aW5kZXgpOwotCWlmICh0ZW1wIDwgMCkKLQkJcmV0dXJuIHRlbXA7Ci0JcmV0dXJuIHNwcmludGYo YnVmLCAiJWRcbiIsIHRlbXAgKiAxMDAwKTsKLX0KLQotc3RhdGljIHNzaXplX3QgaThrX2h3bW9u X3Nob3dfZmFuX2xhYmVsKHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCQkJc3RydWN0IGRldmljZV9h dHRyaWJ1dGUgKmRldmF0dHIsCi0JCQkJCWNoYXIgKmJ1ZikKLXsKLQlzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IGxhYmVsc1tdID0gewotCQkiUHJvY2Vzc29yIEZhbiIsCi0JCSJNb3RoZXJib2Fy ZCBGYW4iLAotCQkiVmlkZW8gRmFuIiwKLQkJIlBvd2VyIFN1cHBseSBGYW4iLAotCQkiQ2hpcHNl dCBGYW4iLAotCQkiT3RoZXIgRmFuIiwKLQl9OwotCWludCBpbmRleCA9IHRvX3NlbnNvcl9kZXZf YXR0cihkZXZhdHRyKS0+aW5kZXg7Ci0JYm9vbCBkb2NrID0gZmFsc2U7Ci0JaW50IHR5cGU7Ci0K LQl0eXBlID0gaThrX2dldF9mYW5fdHlwZShpbmRleCk7Ci0JaWYgKHR5cGUgPCAwKQotCQlyZXR1 cm4gdHlwZTsKLQotCWlmICh0eXBlICYgMHgxMCkgewotCQlkb2NrID0gdHJ1ZTsKLQkJdHlwZSAm PSAweDBGOwotCX0KLQotCWlmICh0eXBlID49IEFSUkFZX1NJWkUobGFiZWxzKSkKLQkJdHlwZSA9 IChBUlJBWV9TSVpFKGxhYmVscykgLSAxKTsKLQotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzJXNc biIsIChkb2NrID8gIkRvY2tpbmcgIiA6ICIiKSwgbGFiZWxzW3R5cGVdKTsKLX0KLQotc3RhdGlj IHNzaXplX3QgaThrX2h3bW9uX3Nob3dfZmFuKHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCQkgIHN0 cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLAotCQkJCSAgY2hhciAqYnVmKQotewotCWlu dCBpbmRleCA9IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+aW5kZXg7Ci0JaW50IGZhbl9z cGVlZDsKLQotCWZhbl9zcGVlZCA9IGk4a19nZXRfZmFuX3NwZWVkKGluZGV4KTsKLQlpZiAoZmFu X3NwZWVkIDwgMCkKLQkJcmV0dXJuIGZhbl9zcGVlZDsKLQlyZXR1cm4gc3ByaW50ZihidWYsICIl ZFxuIiwgZmFuX3NwZWVkKTsKLX0KLQotc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3dfcHdt KHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCQkgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZh dHRyLAotCQkJCSAgY2hhciAqYnVmKQotewotCWludCBpbmRleCA9IHRvX3NlbnNvcl9kZXZfYXR0 cihkZXZhdHRyKS0+aW5kZXg7Ci0JaW50IHN0YXR1czsKLQotCXN0YXR1cyA9IGk4a19nZXRfZmFu X3N0YXR1cyhpbmRleCk7Ci0JaWYgKHN0YXR1cyA8IDApCi0JCXJldHVybiAtRUlPOwotCXJldHVy biBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBjbGFtcF92YWwoc3RhdHVzICogaThrX3B3bV9tdWx0LCAw LCAyNTUpKTsKLX0KLQotc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3NldF9wd20oc3RydWN0IGRl dmljZSAqZGV2LAotCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKLQkJCQkgY29u c3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCi17Ci0JaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rl dl9hdHRyKGF0dHIpLT5pbmRleDsKLQl1bnNpZ25lZCBsb25nIHZhbDsKLQlpbnQgZXJyOwotCi0J ZXJyID0ga3N0cnRvdWwoYnVmLCAxMCwgJnZhbCk7Ci0JaWYgKGVycikKLQkJcmV0dXJuIGVycjsK LQl2YWwgPSBjbGFtcF92YWwoRElWX1JPVU5EX0NMT1NFU1QodmFsLCBpOGtfcHdtX211bHQpLCAw LCBpOGtfZmFuX21heCk7Ci0KLQltdXRleF9sb2NrKCZpOGtfbXV0ZXgpOwotCWVyciA9IGk4a19z ZXRfZmFuKGluZGV4LCB2YWwpOwotCW11dGV4X3VubG9jaygmaThrX211dGV4KTsKLQotCXJldHVy biBlcnIgPCAwID8gLUVJTyA6IGNvdW50OwotfQotCi1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRS KHRlbXAxX2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAwKTsKLXN0 YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9z aG93X3RlbXBfbGFiZWwsIE5VTEwsCi0JCQkgIDApOwotc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRU Uih0ZW1wMl9pbnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcCwgTlVMTCwgMSk7Ci1z dGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAyX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25f c2hvd190ZW1wX2xhYmVsLCBOVUxMLAotCQkJICAxKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FU VFIodGVtcDNfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXAsIE5VTEwsIDIpOwot c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wM19sYWJlbCwgU19JUlVHTywgaThrX2h3bW9u X3Nob3dfdGVtcF9sYWJlbCwgTlVMTCwKLQkJCSAgMik7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9B VFRSKHRlbXA0X2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAzKTsK LXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDRfbGFiZWwsIFNfSVJVR08sIGk4a19od21v bl9zaG93X3RlbXBfbGFiZWwsIE5VTEwsCi0JCQkgIDMpOwotc3RhdGljIFNFTlNPUl9ERVZJQ0Vf QVRUUihmYW4xX2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd19mYW4sIE5VTEwsIDApOwot c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4xX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25f c2hvd19mYW5fbGFiZWwsIE5VTEwsCi0JCQkgIDApOwotc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRU Uihwd20xLCBTX0lSVUdPIHwgU19JV1VTUiwgaThrX2h3bW9uX3Nob3dfcHdtLAotCQkJICBpOGtf aHdtb25fc2V0X3B3bSwgMCk7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGZhbjJfaW5wdXQs IFNfSVJVR08sIGk4a19od21vbl9zaG93X2ZhbiwgTlVMTCwKLQkJCSAgMSk7Ci1zdGF0aWMgU0VO U09SX0RFVklDRV9BVFRSKGZhbjJfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9zaG93X2Zhbl9s YWJlbCwgTlVMTCwKLQkJCSAgMSk7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHB3bTIsIFNf SVJVR08gfCBTX0lXVVNSLCBpOGtfaHdtb25fc2hvd19wd20sCi0JCQkgIGk4a19od21vbl9zZXRf cHdtLCAxKTsKLQotc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmk4a19hdHRyc1tdID0gewotCSZz ZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogMCAqLwotCSZzZW5z b3JfZGV2X2F0dHJfdGVtcDFfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogMSAqLwotCSZzZW5zb3Jf ZGV2X2F0dHJfdGVtcDJfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogMiAqLwotCSZzZW5zb3JfZGV2 X2F0dHJfdGVtcDJfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogMyAqLwotCSZzZW5zb3JfZGV2X2F0 dHJfdGVtcDNfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogNCAqLwotCSZzZW5zb3JfZGV2X2F0dHJf dGVtcDNfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogNSAqLwotCSZzZW5zb3JfZGV2X2F0dHJfdGVt cDRfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogNiAqLwotCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDRf bGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogNyAqLwotCSZzZW5zb3JfZGV2X2F0dHJfZmFuMV9pbnB1 dC5kZXZfYXR0ci5hdHRyLAkvKiA4ICovCi0JJnNlbnNvcl9kZXZfYXR0cl9mYW4xX2xhYmVsLmRl dl9hdHRyLmF0dHIsCS8qIDkgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX3B3bTEuZGV2X2F0dHIuYXR0 ciwJCS8qIDEwICovCi0JJnNlbnNvcl9kZXZfYXR0cl9mYW4yX2lucHV0LmRldl9hdHRyLmF0dHIs CS8qIDExICovCi0JJnNlbnNvcl9kZXZfYXR0cl9mYW4yX2xhYmVsLmRldl9hdHRyLmF0dHIsCS8q IDEyICovCi0JJnNlbnNvcl9kZXZfYXR0cl9wd20yLmRldl9hdHRyLmF0dHIsCQkvKiAxMyAqLwot CU5VTEwKLX07Ci0KLXN0YXRpYyB1bW9kZV90IGk4a19pc192aXNpYmxlKHN0cnVjdCBrb2JqZWN0 ICprb2JqLCBzdHJ1Y3QgYXR0cmlidXRlICphdHRyLAotCQkJICAgICAgaW50IGluZGV4KQotewot CWlmIChpbmRleCA+PSAwICYmIGluZGV4IDw9IDEgJiYKLQkgICAgIShpOGtfaHdtb25fZmxhZ3Mg JiBJOEtfSFdNT05fSEFWRV9URU1QMSkpCi0JCXJldHVybiAwOwotCWlmIChpbmRleCA+PSAyICYm IGluZGV4IDw9IDMgJiYKLQkgICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9U RU1QMikpCi0JCXJldHVybiAwOwotCWlmIChpbmRleCA+PSA0ICYmIGluZGV4IDw9IDUgJiYKLQkg ICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9URU1QMykpCi0JCXJldHVybiAw OwotCWlmIChpbmRleCA+PSA2ICYmIGluZGV4IDw9IDcgJiYKLQkgICAgIShpOGtfaHdtb25fZmxh Z3MgJiBJOEtfSFdNT05fSEFWRV9URU1QNCkpCi0JCXJldHVybiAwOwotCWlmIChpbmRleCA+PSA4 ICYmIGluZGV4IDw9IDEwICYmCi0JICAgICEoaThrX2h3bW9uX2ZsYWdzICYgSThLX0hXTU9OX0hB VkVfRkFOMSkpCi0JCXJldHVybiAwOwotCWlmIChpbmRleCA+PSAxMSAmJiBpbmRleCA8PSAxMyAm JgotCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX0ZBTjIpKQotCQlyZXR1 cm4gMDsKLQotCXJldHVybiBhdHRyLT5tb2RlOwotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGF0 dHJpYnV0ZV9ncm91cCBpOGtfZ3JvdXAgPSB7Ci0JLmF0dHJzID0gaThrX2F0dHJzLAotCS5pc192 aXNpYmxlID0gaThrX2lzX3Zpc2libGUsCi19OwotX19BVFRSSUJVVEVfR1JPVVBTKGk4ayk7Ci0K LXN0YXRpYyBpbnQgX19pbml0IGk4a19pbml0X2h3bW9uKHZvaWQpCi17Ci0JaW50IGVycjsKLQot CWk4a19od21vbl9mbGFncyA9IDA7Ci0KLQkvKiBDUFUgdGVtcGVyYXR1cmUgYXR0cmlidXRlcywg aWYgdGVtcGVyYXR1cmUgdHlwZSBpcyBPSyAqLwotCWVyciA9IGk4a19nZXRfdGVtcF90eXBlKDAp OwotCWlmIChlcnIgPj0gMCkKLQkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RF TVAxOwotCS8qIGNoZWNrIGZvciBhZGRpdGlvbmFsIHRlbXBlcmF0dXJlIHNlbnNvcnMgKi8KLQll cnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgxKTsKLQlpZiAoZXJyID49IDApCi0JCWk4a19od21vbl9m bGFncyB8PSBJOEtfSFdNT05fSEFWRV9URU1QMjsKLQllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgy KTsKLQlpZiAoZXJyID49IDApCi0JCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9U RU1QMzsKLQllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgzKTsKLQlpZiAoZXJyID49IDApCi0JCWk4 a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9URU1QNDsKLQotCS8qIEZpcnN0IGZhbiBh dHRyaWJ1dGVzLCBpZiBmYW4gdHlwZSBpcyBPSyAqLwotCWVyciA9IGk4a19nZXRfZmFuX3R5cGUo MCk7Ci0JaWYgKGVyciA+PSAwKQotCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVf RkFOMTsKLQotCS8qIFNlY29uZCBmYW4gYXR0cmlidXRlcywgaWYgZmFuIHR5cGUgaXMgT0sgKi8K LQllcnIgPSBpOGtfZ2V0X2Zhbl90eXBlKDEpOwotCWlmIChlcnIgPj0gMCkKLQkJaThrX2h3bW9u X2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX0ZBTjI7Ci0KLQlpOGtfaHdtb25fZGV2ID0gaHdtb25f ZGV2aWNlX3JlZ2lzdGVyX3dpdGhfZ3JvdXBzKE5VTEwsICJpOGsiLCBOVUxMLAotCQkJCQkJCSAg aThrX2dyb3Vwcyk7Ci0JaWYgKElTX0VSUihpOGtfaHdtb25fZGV2KSkgewotCQllcnIgPSBQVFJf RVJSKGk4a19od21vbl9kZXYpOwotCQlpOGtfaHdtb25fZGV2ID0gTlVMTDsKLQkJcHJfZXJyKCJo d21vbiByZWdpc3RyYXRpb24gZmFpbGVkICglZClcbiIsIGVycik7Ci0JCXJldHVybiBlcnI7Ci0J fQotCXJldHVybiAwOwotfQotCi1zdHJ1Y3QgaThrX2NvbmZpZ19kYXRhIHsKLQl1aW50IGZhbl9t dWx0OwotCXVpbnQgZmFuX21heDsKLX07Ci0KLWVudW0gaThrX2NvbmZpZ3MgewotCURFTExfTEFU SVRVREVfRDUyMCwKLQlERUxMX1BSRUNJU0lPTl80OTAsCi0JREVMTF9TVFVESU8sCi0JREVMTF9Y UFMsCi19OwotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGk4a19jb25maWdfZGF0YSBpOGtfY29uZmln X2RhdGFbXSA9IHsKLQlbREVMTF9MQVRJVFVERV9ENTIwXSA9IHsKLQkJLmZhbl9tdWx0ID0gMSwK LQkJLmZhbl9tYXggPSBJOEtfRkFOX1RVUkJPLAotCX0sCi0JW0RFTExfUFJFQ0lTSU9OXzQ5MF0g PSB7Ci0JCS5mYW5fbXVsdCA9IDEsCi0JCS5mYW5fbWF4ID0gSThLX0ZBTl9UVVJCTywKLQl9LAot CVtERUxMX1NUVURJT10gPSB7Ci0JCS5mYW5fbXVsdCA9IDEsCi0JCS5mYW5fbWF4ID0gSThLX0ZB Tl9ISUdILAotCX0sCi0JW0RFTExfWFBTXSA9IHsKLQkJLmZhbl9tdWx0ID0gMSwKLQkJLmZhbl9t YXggPSBJOEtfRkFOX0hJR0gsCi0JfSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgZG1pX3N5c3RlbV9p ZCBpOGtfZG1pX3RhYmxlW10gX19pbml0ZGF0YSA9IHsKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIElu c3Bpcm9uIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJE ZWxsIENvbXB1dGVyIiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkluc3Bpcm9u IiksCi0JCX0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIExhdGl0dWRlIiwKLQkJLm1hdGNo ZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIENvbXB1dGVyIiksCi0J CQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkxhdGl0dWRlIiksCi0JCX0sCi0JfSwKLQl7 Ci0JCS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIDIiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9N QVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9E VUNUX05BTUUsICJJbnNwaXJvbiIpLAotCQl9LAotCX0sCi0JewotCQkuaWRlbnQgPSAiRGVsbCBM YXRpdHVkZSBENTIwIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5E T1IsICJEZWxsIEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTGF0aXR1 ZGUgRDUyMCIpLAotCQl9LAotCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2Rh dGFbREVMTF9MQVRJVFVERV9ENTIwXSwKLQl9LAotCXsKLQkJLmlkZW50ID0gIkRlbGwgTGF0aXR1 ZGUgMiIsCi0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVs bCBJbmMuIiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkxhdGl0dWRlIiksCi0J CX0sCi0JfSwKLQl7CS8qIFVLIEluc3Bpcm9uIDY0MDAgICovCi0JCS5pZGVudCA9ICJEZWxsIElu c3Bpcm9uIDMiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwg IkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJNTTA2MSIpLAot CQl9LAotCX0sCi0JewotCQkuaWRlbnQgPSAiRGVsbCBJbnNwaXJvbiAzIiwKLQkJLm1hdGNoZXMg PSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKLQkJCURNSV9N QVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTVAwNjEiKSwKLQkJfSwKLQl9LAotCXsKLQkJLmlkZW50 ID0gIkRlbGwgUHJlY2lzaW9uIDQ5MCIsCi0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERN SV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFN RSwKLQkJCQkgICJQcmVjaXNpb24gV29ya1N0YXRpb24gNDkwIiksCi0JCX0sCi0JCS5kcml2ZXJf ZGF0YSA9ICh2b2lkICopJmk4a19jb25maWdfZGF0YVtERUxMX1BSRUNJU0lPTl80OTBdLAotCX0s Ci0JewotCQkuaWRlbnQgPSAiRGVsbCBQcmVjaXNpb24iLAotCQkubWF0Y2hlcyA9IHsKLQkJCURN SV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9Q Uk9EVUNUX05BTUUsICJQcmVjaXNpb24iKSwKLQkJfSwKLQl9LAotCXsKLQkJLmlkZW50ID0gIkRl bGwgVm9zdHJvIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1Is ICJEZWxsIEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiVm9zdHJvIiks Ci0JCX0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIFhQUzQyMSIsCi0JCS5tYXRjaGVzID0g ewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCi0JCQlETUlfTUFU Q0goRE1JX1BST0RVQ1RfTkFNRSwgIlhQUyBMNDIxWCIpLAotCQl9LAotCX0sCi0JewotCQkuaWRl bnQgPSAiRGVsbCBTdHVkaW8iLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lT X1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJT dHVkaW8iKSwKLQkJfSwKLQkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRh W0RFTExfU1RVRElPXSwKLQl9LAotCXsKLQkJLmlkZW50ID0gIkRlbGwgWFBTIDEzIiwKLQkJLm1h dGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKLQkJ CURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiWFBTMTMiKSwKLQkJfSwKLQkJLmRyaXZlcl9k YXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfWFBTXSwKLQl9LAotCXsKLQkJLmlk ZW50ID0gIkRlbGwgWFBTIE0xNDAiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlf U1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUs ICJNWEMwNTEiKSwKLQkJfSwKLQkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19k YXRhW0RFTExfWFBTXSwKLQl9LAotCXsgfQotfTsKLQotTU9EVUxFX0RFVklDRV9UQUJMRShkbWks IGk4a19kbWlfdGFibGUpOwotCi0vKgotICogUHJvYmUgZm9yIHRoZSBwcmVzZW5jZSBvZiBhIHN1 cHBvcnRlZCBsYXB0b3AuCi0gKi8KLXN0YXRpYyBpbnQgX19pbml0IGk4a19wcm9iZSh2b2lkKQot ewotCWNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkICppZDsKLQlpbnQgZmFuLCByZXQ7Ci0KLQkv KgotCSAqIEdldCBETUkgaW5mb3JtYXRpb24KLQkgKi8KLQlpZiAoIWRtaV9jaGVja19zeXN0ZW0o aThrX2RtaV90YWJsZSkpIHsKLQkJaWYgKCFpZ25vcmVfZG1pICYmICFmb3JjZSkKLQkJCXJldHVy biAtRU5PREVWOwotCi0JCXByX2luZm8oIm5vdCBydW5uaW5nIG9uIGEgc3VwcG9ydGVkIERlbGwg c3lzdGVtLlxuIik7Ci0JCXByX2luZm8oInZlbmRvcj0lcywgbW9kZWw9JXMsIHZlcnNpb249JXNc biIsCi0JCQlpOGtfZ2V0X2RtaV9kYXRhKERNSV9TWVNfVkVORE9SKSwKLQkJCWk4a19nZXRfZG1p X2RhdGEoRE1JX1BST0RVQ1RfTkFNRSksCi0JCQlpOGtfZ2V0X2RtaV9kYXRhKERNSV9CSU9TX1ZF UlNJT04pKTsKLQl9Ci0KLQlzdHJsY3B5KGJpb3NfdmVyc2lvbiwgaThrX2dldF9kbWlfZGF0YShE TUlfQklPU19WRVJTSU9OKSwKLQkJc2l6ZW9mKGJpb3NfdmVyc2lvbikpOwotCi0JLyoKLQkgKiBH ZXQgU01NIERlbGwgc2lnbmF0dXJlCi0JICovCi0JaWYgKGk4a19nZXRfZGVsbF9zaWduYXR1cmUo SThLX1NNTV9HRVRfREVMTF9TSUcxKSAmJgotCSAgICBpOGtfZ2V0X2RlbGxfc2lnbmF0dXJlKEk4 S19TTU1fR0VUX0RFTExfU0lHMikpIHsKLQkJcHJfZXJyKCJ1bmFibGUgdG8gZ2V0IFNNTSBEZWxs IHNpZ25hdHVyZVxuIik7Ci0JCWlmICghZm9yY2UpCi0JCQlyZXR1cm4gLUVOT0RFVjsKLQl9Ci0K LQkvKgotCSAqIFNldCBmYW4gbXVsdGlwbGllciBhbmQgbWF4aW1hbCBmYW4gc3BlZWQgZnJvbSBk bWkgY29uZmlnCi0JICogVmFsdWVzIHNwZWNpZmllZCBpbiBtb2R1bGUgcGFyYW1ldGVycyBvdmVy cmlkZSB2YWx1ZXMgZnJvbSBkbWkKLQkgKi8KLQlpZCA9IGRtaV9maXJzdF9tYXRjaChpOGtfZG1p X3RhYmxlKTsKLQlpZiAoaWQgJiYgaWQtPmRyaXZlcl9kYXRhKSB7Ci0JCWNvbnN0IHN0cnVjdCBp OGtfY29uZmlnX2RhdGEgKmNvbmYgPSBpZC0+ZHJpdmVyX2RhdGE7Ci0JCWlmICghZmFuX211bHQg JiYgY29uZi0+ZmFuX211bHQpCi0JCQlmYW5fbXVsdCA9IGNvbmYtPmZhbl9tdWx0OwotCQlpZiAo IWZhbl9tYXggJiYgY29uZi0+ZmFuX21heCkKLQkJCWZhbl9tYXggPSBjb25mLT5mYW5fbWF4Owot CX0KLQotCWk4a19mYW5fbWF4ID0gZmFuX21heCA/IDogSThLX0ZBTl9ISUdIOwkvKiBNdXN0IG5v dCBiZSAwICovCi0JaThrX3B3bV9tdWx0ID0gRElWX1JPVU5EX1VQKDI1NSwgaThrX2Zhbl9tYXgp OwotCi0JaWYgKCFmYW5fbXVsdCkgewotCQkvKgotCQkgKiBBdXRvZGV0ZWN0IGZhbiBtdWx0aXBs aWVyIGJhc2VkIG9uIG5vbWluYWwgcnBtCi0JCSAqIElmIGZhbiByZXBvcnRzIHJwbSB2YWx1ZSB0 b28gaGlnaCB0aGVuIHNldCBtdWx0aXBsaWVyIHRvIDEKLQkJICovCi0JCWZvciAoZmFuID0gMDsg ZmFuIDwgMjsgKytmYW4pIHsKLQkJCXJldCA9IGk4a19nZXRfZmFuX25vbWluYWxfc3BlZWQoZmFu LCBpOGtfZmFuX21heCk7Ci0JCQlpZiAocmV0IDwgMCkKLQkJCQljb250aW51ZTsKLQkJCWlmIChy ZXQgPiBJOEtfRkFOX01BWF9SUE0pCi0JCQkJaThrX2Zhbl9tdWx0ID0gMTsKLQkJCWJyZWFrOwot CQl9Ci0JfSBlbHNlIHsKLQkJLyogRmFuIG11bHRpcGxpZXIgd2FzIHNwZWNpZmllZCBpbiBtb2R1 bGUgcGFyYW0gb3IgaW4gZG1pICovCi0JCWk4a19mYW5fbXVsdCA9IGZhbl9tdWx0OwotCX0KLQot CXJldHVybiAwOwotfQotCi1zdGF0aWMgaW50IF9faW5pdCBpOGtfaW5pdCh2b2lkKQotewotCXN0 cnVjdCBwcm9jX2Rpcl9lbnRyeSAqcHJvY19pOGs7Ci0JaW50IGVycjsKLQotCS8qIEFyZSB3ZSBy dW5uaW5nIG9uIGFuIHN1cHBvcnRlZCBsYXB0b3A/ICovCi0JaWYgKGk4a19wcm9iZSgpKQotCQly ZXR1cm4gLUVOT0RFVjsKLQotCS8qIFJlZ2lzdGVyIHRoZSBwcm9jIGVudHJ5ICovCi0JcHJvY19p OGsgPSBwcm9jX2NyZWF0ZSgiaThrIiwgMCwgTlVMTCwgJmk4a19mb3BzKTsKLQlpZiAoIXByb2Nf aThrKQotCQlyZXR1cm4gLUVOT0VOVDsKLQotCWVyciA9IGk4a19pbml0X2h3bW9uKCk7Ci0JaWYg KGVycikKLQkJZ290byBleGl0X3JlbW92ZV9wcm9jOwotCi0JcmV0dXJuIDA7Ci0KLSBleGl0X3Jl bW92ZV9wcm9jOgotCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBOVUxMKTsKLQlyZXR1cm4gZXJy OwotfQotCi1zdGF0aWMgdm9pZCBfX2V4aXQgaThrX2V4aXQodm9pZCkKLXsKLQlod21vbl9kZXZp Y2VfdW5yZWdpc3RlcihpOGtfaHdtb25fZGV2KTsKLQlyZW1vdmVfcHJvY19lbnRyeSgiaThrIiwg TlVMTCk7Ci19Ci0KLW1vZHVsZV9pbml0KGk4a19pbml0KTsKLW1vZHVsZV9leGl0KGk4a19leGl0 KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01h a2VmaWxlCmluZGV4IDZjOTQxNDcuLjFjM2U0NTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24v TWFrZWZpbGUKKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQpAQCAtMTU1LDYgKzE1NSw3IEBA IG9iai0kKENPTkZJR19TRU5TT1JTX1c4M0w3ODVUUykJKz0gdzgzbDc4NXRzLm8KIG9iai0kKENP TkZJR19TRU5TT1JTX1c4M0w3ODZORykJKz0gdzgzbDc4Nm5nLm8KIG9iai0kKENPTkZJR19TRU5T T1JTX1dNODMxWCkJKz0gd204MzF4LWh3bW9uLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX1dNODM1 MCkJKz0gd204MzUwLWh3bW9uLm8KK29iai0kKENPTkZJR19JOEspCQkrPSBkZWxsLXNtbS1od21v bi5vCiAKIG9iai0kKENPTkZJR19QTUJVUykJCSs9IHBtYnVzLwogCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMgYi9kcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9u LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmIwNGU0ZgotLS0gL2Rldi9u dWxsCisrKyBiL2RyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwpAQCAtMCwwICsxLDEwMDcg QEAKKy8qCisgKiBkZWxsLXNtbS1od21vbi5jIC0tIExpbnV4IGRyaXZlciBmb3IgYWNjZXNzaW5n IHRoZSBTTU0gQklPUyBvbiBEZWxsIGxhcHRvcHMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDAx ICBNYXNzaW1vIERhbCBab3R0byA8ZHpAZGViaWFuLm9yZz4KKyAqCisgKiBId21vbiBpbnRlZ3Jh dGlvbjoKKyAqIENvcHlyaWdodCAoQykgMjAxMSAgSmVhbiBEZWx2YXJlIDxqZGVsdmFyZUBzdXNl LmRlPgorICogQ29weXJpZ2h0IChDKSAyMDEzLCAyMDE0ICBHdWVudGVyIFJvZWNrIDxsaW51eEBy b2Vjay11cy5uZXQ+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTQsIDIwMTUgIFBhbGkgUm9ow6FyIDxw YWxpLnJvaGFyQGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlCisgKiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55CisgKiBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3Jh bSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQK KyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKi8KKworI2RlZmluZSBwcl9mbXQoZm10KSBLQlVJTERfTU9ETkFNRSAiOiAiIGZt dAorCisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4K KyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNs dWRlIDxsaW51eC9wcm9jX2ZzLmg+CisjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KKyNpbmNs dWRlIDxsaW51eC9kbWkuaD4KKyNpbmNsdWRlIDxsaW51eC9jYXBhYmlsaXR5Lmg+CisjaW5jbHVk ZSA8bGludXgvbXV0ZXguaD4KKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgorI2luY2x1ZGUgPGxp bnV4L2h3bW9uLXN5c2ZzLmg+CisjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgorI2luY2x1ZGUg PGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKworI2luY2x1ZGUgPGxpbnV4 L2k4ay5oPgorCisjZGVmaW5lIEk4S19TTU1fRk5fU1RBVFVTCTB4MDAyNQorI2RlZmluZSBJOEtf U01NX1BPV0VSX1NUQVRVUwkweDAwNjkKKyNkZWZpbmUgSThLX1NNTV9TRVRfRkFOCQkweDAxYTMK KyNkZWZpbmUgSThLX1NNTV9HRVRfRkFOCQkweDAwYTMKKyNkZWZpbmUgSThLX1NNTV9HRVRfU1BF RUQJMHgwMmEzCisjZGVmaW5lIEk4S19TTU1fR0VUX0ZBTl9UWVBFCTB4MDNhMworI2RlZmluZSBJ OEtfU01NX0dFVF9OT01fU1BFRUQJMHgwNGEzCisjZGVmaW5lIEk4S19TTU1fR0VUX1RFTVAJMHgx MGEzCisjZGVmaW5lIEk4S19TTU1fR0VUX1RFTVBfVFlQRQkweDExYTMKKyNkZWZpbmUgSThLX1NN TV9HRVRfREVMTF9TSUcxCTB4ZmVhMworI2RlZmluZSBJOEtfU01NX0dFVF9ERUxMX1NJRzIJMHhm ZmEzCisKKyNkZWZpbmUgSThLX0ZBTl9NVUxUCQkzMAorI2RlZmluZSBJOEtfRkFOX01BWF9SUE0J CTMwMDAwCisjZGVmaW5lIEk4S19NQVhfVEVNUAkJMTI3CisKKyNkZWZpbmUgSThLX0ZOX05PTkUJ CTB4MDAKKyNkZWZpbmUgSThLX0ZOX1VQCQkweDAxCisjZGVmaW5lIEk4S19GTl9ET1dOCQkweDAy CisjZGVmaW5lIEk4S19GTl9NVVRFCQkweDA0CisjZGVmaW5lIEk4S19GTl9NQVNLCQkweDA3Cisj ZGVmaW5lIEk4S19GTl9TSElGVAkJOAorCisjZGVmaW5lIEk4S19QT1dFUl9BQwkJMHgwNQorI2Rl ZmluZSBJOEtfUE9XRVJfQkFUVEVSWQkweDAxCisKK3N0YXRpYyBERUZJTkVfTVVURVgoaThrX211 dGV4KTsKK3N0YXRpYyBjaGFyIGJpb3NfdmVyc2lvbls0XTsKK3N0YXRpYyBzdHJ1Y3QgZGV2aWNl ICppOGtfaHdtb25fZGV2Oworc3RhdGljIHUzMiBpOGtfaHdtb25fZmxhZ3M7CitzdGF0aWMgdWlu dCBpOGtfZmFuX211bHQgPSBJOEtfRkFOX01VTFQ7CitzdGF0aWMgdWludCBpOGtfcHdtX211bHQ7 CitzdGF0aWMgdWludCBpOGtfZmFuX21heCA9IEk4S19GQU5fSElHSDsKKworI2RlZmluZSBJOEtf SFdNT05fSEFWRV9URU1QMQkoMSA8PCAwKQorI2RlZmluZSBJOEtfSFdNT05fSEFWRV9URU1QMgko MSA8PCAxKQorI2RlZmluZSBJOEtfSFdNT05fSEFWRV9URU1QMwkoMSA8PCAyKQorI2RlZmluZSBJ OEtfSFdNT05fSEFWRV9URU1QNAkoMSA8PCAzKQorI2RlZmluZSBJOEtfSFdNT05fSEFWRV9GQU4x CSgxIDw8IDQpCisjZGVmaW5lIEk4S19IV01PTl9IQVZFX0ZBTjIJKDEgPDwgNSkKKworTU9EVUxF X0FVVEhPUigiTWFzc2ltbyBEYWwgWm90dG8gKGR6QGRlYmlhbi5vcmcpIik7CitNT0RVTEVfQVVU SE9SKCJQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Iik7CitNT0RVTEVfREVTQ1JJ UFRJT04oIkRyaXZlciBmb3IgYWNjZXNzaW5nIFNNTSBCSU9TIG9uIERlbGwgbGFwdG9wcyIpOwor TU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFTKCJpOGsiKTsKKworc3RhdGljIGJv b2wgZm9yY2U7Cittb2R1bGVfcGFyYW0oZm9yY2UsIGJvb2wsIDApOworTU9EVUxFX1BBUk1fREVT Qyhmb3JjZSwgIkZvcmNlIGxvYWRpbmcgd2l0aG91dCBjaGVja2luZyBmb3Igc3VwcG9ydGVkIG1v ZGVscyIpOworCitzdGF0aWMgYm9vbCBpZ25vcmVfZG1pOworbW9kdWxlX3BhcmFtKGlnbm9yZV9k bWksIGJvb2wsIDApOworTU9EVUxFX1BBUk1fREVTQyhpZ25vcmVfZG1pLCAiQ29udGludWUgcHJv YmluZyBoYXJkd2FyZSBldmVuIGlmIERNSSBkYXRhIGRvZXMgbm90IG1hdGNoIik7CisKK3N0YXRp YyBib29sIHJlc3RyaWN0ZWQ7Cittb2R1bGVfcGFyYW0ocmVzdHJpY3RlZCwgYm9vbCwgMCk7CitN T0RVTEVfUEFSTV9ERVNDKHJlc3RyaWN0ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURN SU4gY2FwYWJpbGl0eSBzZXQiKTsKKworc3RhdGljIGJvb2wgcG93ZXJfc3RhdHVzOworbW9kdWxl X3BhcmFtKHBvd2VyX3N0YXR1cywgYm9vbCwgMDYwMCk7CitNT0RVTEVfUEFSTV9ERVNDKHBvd2Vy X3N0YXR1cywgIlJlcG9ydCBwb3dlciBzdGF0dXMgaW4gL3Byb2MvaThrIik7CisKK3N0YXRpYyB1 aW50IGZhbl9tdWx0OworbW9kdWxlX3BhcmFtKGZhbl9tdWx0LCB1aW50LCAwKTsKK01PRFVMRV9Q QVJNX0RFU0MoZmFuX211bHQsICJGYWN0b3IgdG8gbXVsdGlwbHkgZmFuIHNwZWVkIHdpdGggKGRl ZmF1bHQ6IGF1dG9kZXRlY3QpIik7CisKK3N0YXRpYyB1aW50IGZhbl9tYXg7Cittb2R1bGVfcGFy YW0oZmFuX21heCwgdWludCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKGZhbl9tYXgsICJNYXhpbXVt IGNvbmZpZ3VyYWJsZSBmYW4gc3BlZWQgKGRlZmF1bHQ6IGF1dG9kZXRlY3QpIik7CisKK3N0YXRp YyBpbnQgaThrX29wZW5fZnMoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUp Oworc3RhdGljIGxvbmcgaThrX2lvY3RsKHN0cnVjdCBmaWxlICosIHVuc2lnbmVkIGludCwgdW5z aWduZWQgbG9uZyk7CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGk4a19m b3BzID0geworCS5vd25lcgkJPSBUSElTX01PRFVMRSwKKwkub3BlbgkJPSBpOGtfb3Blbl9mcywK KwkucmVhZAkJPSBzZXFfcmVhZCwKKwkubGxzZWVrCQk9IHNlcV9sc2VlaywKKwkucmVsZWFzZQk9 IHNpbmdsZV9yZWxlYXNlLAorCS51bmxvY2tlZF9pb2N0bAk9IGk4a19pb2N0bCwKK307CisKK3N0 cnVjdCBzbW1fcmVncyB7CisJdW5zaWduZWQgaW50IGVheDsKKwl1bnNpZ25lZCBpbnQgZWJ4IF9f cGFja2VkOworCXVuc2lnbmVkIGludCBlY3ggX19wYWNrZWQ7CisJdW5zaWduZWQgaW50IGVkeCBf X3BhY2tlZDsKKwl1bnNpZ25lZCBpbnQgZXNpIF9fcGFja2VkOworCXVuc2lnbmVkIGludCBlZGkg X19wYWNrZWQ7Cit9OworCitzdGF0aWMgaW5saW5lIGNvbnN0IGNoYXIgKmk4a19nZXRfZG1pX2Rh dGEoaW50IGZpZWxkKQoreworCWNvbnN0IGNoYXIgKmRtaV9kYXRhID0gZG1pX2dldF9zeXN0ZW1f aW5mbyhmaWVsZCk7CisKKwlyZXR1cm4gZG1pX2RhdGEgJiYgKmRtaV9kYXRhID8gZG1pX2RhdGEg OiAiPyI7Cit9CisKKy8qCisgKiBDYWxsIHRoZSBTeXN0ZW0gTWFuYWdlbWVudCBNb2RlIEJJT1Mu IENvZGUgcHJvdmlkZWQgYnkgSm9uYXRoYW4gQnV6emFyZC4KKyAqLworc3RhdGljIGludCBpOGtf c21tKHN0cnVjdCBzbW1fcmVncyAqcmVncykKK3sKKwlpbnQgcmM7CisJaW50IGVheCA9IHJlZ3Mt PmVheDsKKwljcHVtYXNrX3Zhcl90IG9sZF9tYXNrOworCisJLyogU01NIHJlcXVpcmVzIENQVSAw ICovCisJaWYgKCFhbGxvY19jcHVtYXNrX3Zhcigmb2xkX21hc2ssIEdGUF9LRVJORUwpKQorCQly ZXR1cm4gLUVOT01FTTsKKwljcHVtYXNrX2NvcHkob2xkX21hc2ssICZjdXJyZW50LT5jcHVzX2Fs bG93ZWQpOworCXJjID0gc2V0X2NwdXNfYWxsb3dlZF9wdHIoY3VycmVudCwgY3B1bWFza19vZigw KSk7CisJaWYgKHJjKQorCQlnb3RvIG91dDsKKwlpZiAoc21wX3Byb2Nlc3Nvcl9pZCgpICE9IDAp IHsKKwkJcmMgPSAtRUJVU1k7CisJCWdvdG8gb3V0OworCX0KKworI2lmIGRlZmluZWQoQ09ORklH X1g4Nl82NCkKKwlhc20gdm9sYXRpbGUoInB1c2hxICUlcmF4XG5cdCIKKwkJIm1vdmwgMCglJXJh eCksJSVlZHhcblx0IgorCQkicHVzaHEgJSVyZHhcblx0IgorCQkibW92bCA0KCUlcmF4KSwlJWVi eFxuXHQiCisJCSJtb3ZsIDgoJSVyYXgpLCUlZWN4XG5cdCIKKwkJIm1vdmwgMTIoJSVyYXgpLCUl ZWR4XG5cdCIKKwkJIm1vdmwgMTYoJSVyYXgpLCUlZXNpXG5cdCIKKwkJIm1vdmwgMjAoJSVyYXgp LCUlZWRpXG5cdCIKKwkJInBvcHEgJSVyYXhcblx0IgorCQkib3V0ICUlYWwsJDB4YjJcblx0Igor CQkib3V0ICUlYWwsJDB4ODRcblx0IgorCQkieGNoZ3EgJSVyYXgsKCUlcnNwKVxuXHQiCisJCSJt b3ZsICUlZWJ4LDQoJSVyYXgpXG5cdCIKKwkJIm1vdmwgJSVlY3gsOCglJXJheClcblx0IgorCQki bW92bCAlJWVkeCwxMiglJXJheClcblx0IgorCQkibW92bCAlJWVzaSwxNiglJXJheClcblx0Igor CQkibW92bCAlJWVkaSwyMCglJXJheClcblx0IgorCQkicG9wcSAlJXJkeFxuXHQiCisJCSJtb3Zs ICUlZWR4LDAoJSVyYXgpXG5cdCIKKwkJInB1c2hmcVxuXHQiCisJCSJwb3BxICUlcmF4XG5cdCIK KwkJImFuZGwgJDEsJSVlYXhcbiIKKwkJOiAiPWEiKHJjKQorCQk6ICAgICJhIihyZWdzKQorCQk6 ICAgICIlZWJ4IiwgIiVlY3giLCAiJWVkeCIsICIlZXNpIiwgIiVlZGkiLCAibWVtb3J5Iik7Cisj ZWxzZQorCWFzbSB2b2xhdGlsZSgicHVzaGwgJSVlYXhcblx0IgorCSAgICAibW92bCAwKCUlZWF4 KSwlJWVkeFxuXHQiCisJICAgICJwdXNoICUlZWR4XG5cdCIKKwkgICAgIm1vdmwgNCglJWVheCks JSVlYnhcblx0IgorCSAgICAibW92bCA4KCUlZWF4KSwlJWVjeFxuXHQiCisJICAgICJtb3ZsIDEy KCUlZWF4KSwlJWVkeFxuXHQiCisJICAgICJtb3ZsIDE2KCUlZWF4KSwlJWVzaVxuXHQiCisJICAg ICJtb3ZsIDIwKCUlZWF4KSwlJWVkaVxuXHQiCisJICAgICJwb3BsICUlZWF4XG5cdCIKKwkgICAg Im91dCAlJWFsLCQweGIyXG5cdCIKKwkgICAgIm91dCAlJWFsLCQweDg0XG5cdCIKKwkgICAgInhj aGdsICUlZWF4LCglJWVzcClcblx0IgorCSAgICAibW92bCAlJWVieCw0KCUlZWF4KVxuXHQiCisJ ICAgICJtb3ZsICUlZWN4LDgoJSVlYXgpXG5cdCIKKwkgICAgIm1vdmwgJSVlZHgsMTIoJSVlYXgp XG5cdCIKKwkgICAgIm1vdmwgJSVlc2ksMTYoJSVlYXgpXG5cdCIKKwkgICAgIm1vdmwgJSVlZGks MjAoJSVlYXgpXG5cdCIKKwkgICAgInBvcGwgJSVlZHhcblx0IgorCSAgICAibW92bCAlJWVkeCww KCUlZWF4KVxuXHQiCisJICAgICJsYWhmXG5cdCIKKwkgICAgInNocmwgJDgsJSVlYXhcblx0Igor CSAgICAiYW5kbCAkMSwlJWVheFxuIgorCSAgICA6ICI9YSIocmMpCisJICAgIDogICAgImEiKHJl Z3MpCisJICAgIDogICAgIiVlYngiLCAiJWVjeCIsICIlZWR4IiwgIiVlc2kiLCAiJWVkaSIsICJt ZW1vcnkiKTsKKyNlbmRpZgorCWlmIChyYyAhPSAwIHx8IChyZWdzLT5lYXggJiAweGZmZmYpID09 IDB4ZmZmZiB8fCByZWdzLT5lYXggPT0gZWF4KQorCQlyYyA9IC1FSU5WQUw7CisKK291dDoKKwlz ZXRfY3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBvbGRfbWFzayk7CisJZnJlZV9jcHVtYXNrX3Zh cihvbGRfbWFzayk7CisJcmV0dXJuIHJjOworfQorCisvKgorICogUmVhZCB0aGUgRm4ga2V5IHN0 YXR1cy4KKyAqLworc3RhdGljIGludCBpOGtfZ2V0X2ZuX3N0YXR1cyh2b2lkKQoreworCXN0cnVj dCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9GTl9TVEFUVVMsIH07CisJaW50IHJj OworCisJcmMgPSBpOGtfc21tKCZyZWdzKTsKKwlpZiAocmMgPCAwKQorCQlyZXR1cm4gcmM7CisK Kwlzd2l0Y2ggKChyZWdzLmVheCA+PiBJOEtfRk5fU0hJRlQpICYgSThLX0ZOX01BU0spIHsKKwlj YXNlIEk4S19GTl9VUDoKKwkJcmV0dXJuIEk4S19WT0xfVVA7CisJY2FzZSBJOEtfRk5fRE9XTjoK KwkJcmV0dXJuIEk4S19WT0xfRE9XTjsKKwljYXNlIEk4S19GTl9NVVRFOgorCQlyZXR1cm4gSThL X1ZPTF9NVVRFOworCWRlZmF1bHQ6CisJCXJldHVybiAwOworCX0KK30KKworLyoKKyAqIFJlYWQg dGhlIHBvd2VyIHN0YXR1cy4KKyAqLworc3RhdGljIGludCBpOGtfZ2V0X3Bvd2VyX3N0YXR1cyh2 b2lkKQoreworCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9QT1dFUl9T VEFUVVMsIH07CisJaW50IHJjOworCisJcmMgPSBpOGtfc21tKCZyZWdzKTsKKwlpZiAocmMgPCAw KQorCQlyZXR1cm4gcmM7CisKKwlyZXR1cm4gKHJlZ3MuZWF4ICYgMHhmZikgPT0gSThLX1BPV0VS X0FDID8gSThLX0FDIDogSThLX0JBVFRFUlk7Cit9CisKKy8qCisgKiBSZWFkIHRoZSBmYW4gc3Rh dHVzLgorICovCitzdGF0aWMgaW50IGk4a19nZXRfZmFuX3N0YXR1cyhpbnQgZmFuKQoreworCXN0 cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfRkFOLCB9OworCisJcmVn cy5lYnggPSBmYW4gJiAweGZmOworCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXgg JiAweGZmOworfQorCisvKgorICogUmVhZCB0aGUgZmFuIHNwZWVkIGluIFJQTS4KKyAqLworc3Rh dGljIGludCBpOGtfZ2V0X2Zhbl9zcGVlZChpbnQgZmFuKQoreworCXN0cnVjdCBzbW1fcmVncyBy ZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfU1BFRUQsIH07CisKKwlyZWdzLmVieCA9IGZhbiAm IDB4ZmY7CisJcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiAocmVncy5lYXggJiAweGZmZmYpICog aThrX2Zhbl9tdWx0OworfQorCisvKgorICogUmVhZCB0aGUgZmFuIHR5cGUuCisgKi8KK3N0YXRp YyBpbnQgaThrX2dldF9mYW5fdHlwZShpbnQgZmFuKQoreworCXN0cnVjdCBzbW1fcmVncyByZWdz ID0geyAuZWF4ID0gSThLX1NNTV9HRVRfRkFOX1RZUEUsIH07CisKKwlyZWdzLmVieCA9IGZhbiAm IDB4ZmY7CisJcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiByZWdzLmVheCAmIDB4ZmY7Cit9CisK Ky8qCisgKiBSZWFkIHRoZSBmYW4gbm9taW5hbCBycG0gZm9yIHNwZWNpZmljIGZhbiBzcGVlZC4K KyAqLworc3RhdGljIGludCBpOGtfZ2V0X2Zhbl9ub21pbmFsX3NwZWVkKGludCBmYW4sIGludCBz cGVlZCkKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fR0VUX05P TV9TUEVFRCwgfTsKKworCXJlZ3MuZWJ4ID0gKGZhbiAmIDB4ZmYpIHwgKHNwZWVkIDw8IDgpOwor CXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogKHJlZ3MuZWF4ICYgMHhmZmZmKSAqIGk4a19mYW5f bXVsdDsKK30KKworLyoKKyAqIFNldCB0aGUgZmFuIHNwZWVkIChvZmYsIGxvdywgaGlnaCkuIFJl dHVybnMgdGhlIG5ldyBmYW4gc3RhdHVzLgorICovCitzdGF0aWMgaW50IGk4a19zZXRfZmFuKGlu dCBmYW4sIGludCBzcGVlZCkKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4 S19TTU1fU0VUX0ZBTiwgfTsKKworCXNwZWVkID0gKHNwZWVkIDwgMCkgPyAwIDogKChzcGVlZCA+ IGk4a19mYW5fbWF4KSA/IGk4a19mYW5fbWF4IDogc3BlZWQpOworCXJlZ3MuZWJ4ID0gKGZhbiAm IDB4ZmYpIHwgKHNwZWVkIDw8IDgpOworCisJcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiBpOGtf Z2V0X2Zhbl9zdGF0dXMoZmFuKTsKK30KKworc3RhdGljIGludCBpOGtfZ2V0X3RlbXBfdHlwZShp bnQgc2Vuc29yKQoreworCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9H RVRfVEVNUF9UWVBFLCB9OworCisJcmVncy5lYnggPSBzZW5zb3IgJiAweGZmOworCXJldHVybiBp OGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAweGZmOworfQorCisvKgorICogUmVhZCB0aGUg Y3B1IHRlbXBlcmF0dXJlLgorICovCitzdGF0aWMgaW50IF9pOGtfZ2V0X3RlbXAoaW50IHNlbnNv cikKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsKKwkJLmVheCA9IEk4S19TTU1fR0VUX1RF TVAsCisJCS5lYnggPSBzZW5zb3IgJiAweGZmLAorCX07CisKKwlyZXR1cm4gaThrX3NtbSgmcmVn cykgPyA6IHJlZ3MuZWF4ICYgMHhmZjsKK30KKworc3RhdGljIGludCBpOGtfZ2V0X3RlbXAoaW50 IHNlbnNvcikKK3sKKwlpbnQgdGVtcCA9IF9pOGtfZ2V0X3RlbXAoc2Vuc29yKTsKKworCS8qCisJ ICogU29tZXRpbWVzIHRoZSB0ZW1wZXJhdHVyZSBzZW5zb3IgcmV0dXJucyAweDk5LCB3aGljaCBp cyBvdXQgb2YgcmFuZ2UuCisJICogSW4gdGhpcyBjYXNlIHdlIHJldHJ5IChvbmNlKSBiZWZvcmUg cmV0dXJuaW5nIGFuIGVycm9yLgorCSAjIDEwMDM2NTUxMzcgMDAwMDAwNTggMDAwMDVhNGIKKwkg IyAxMDAzNjU1MTM4IDAwMDAwMDk5IDAwMDAzYTgwIDwtLS0gMHg5OSA9IDE1MyBkZWdyZWVzCisJ ICMgMTAwMzY1NTEzOSAwMDAwMDA1NCAwMDAwNWM1MgorCSAqLworCWlmICh0ZW1wID09IDB4OTkp IHsKKwkJbXNsZWVwKDEwMCk7CisJCXRlbXAgPSBfaThrX2dldF90ZW1wKHNlbnNvcik7CisJfQor CS8qCisJICogUmV0dXJuIC1FTk9EQVRBIGZvciBhbGwgaW52YWxpZCB0ZW1wZXJhdHVyZXMuCisJ ICoKKwkgKiBLbm93biBpbnN0YW5jZXMgYXJlIHRoZSAweDk5IHZhbHVlIGFzIHNlZW4gYWJvdmUg YXMgd2VsbCBhcworCSAqIDB4YzEgKDE5MyksIHdoaWNoIG1heSBiZSByZXR1cm5lZCB3aGVuIHRy eWluZyB0byByZWFkIHRoZSBHUFUKKwkgKiB0ZW1wZXJhdHVyZSBpZiB0aGUgc3lzdGVtIHN1cHBv cnRzIGEgR1BVIGFuZCBpdCBpcyBjdXJyZW50bHkKKwkgKiB0dXJuZWQgb2ZmLgorCSAqLworCWlm ICh0ZW1wID4gSThLX01BWF9URU1QKQorCQlyZXR1cm4gLUVOT0RBVEE7CisKKwlyZXR1cm4gdGVt cDsKK30KKworc3RhdGljIGludCBpOGtfZ2V0X2RlbGxfc2lnbmF0dXJlKGludCByZXFfZm4pCit7 CisJc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSByZXFfZm4sIH07CisJaW50IHJjOwor CisJcmMgPSBpOGtfc21tKCZyZWdzKTsKKwlpZiAocmMgPCAwKQorCQlyZXR1cm4gcmM7CisKKwly ZXR1cm4gcmVncy5lYXggPT0gMTE0NTY1MTUyNyAmJiByZWdzLmVkeCA9PSAxMTQ1MzkyMjA0ID8g MCA6IC0xOworfQorCitzdGF0aWMgaW50CitpOGtfaW9jdGxfdW5sb2NrZWQoc3RydWN0IGZpbGUg KmZwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlpbnQgdmFsID0g MDsKKwlpbnQgc3BlZWQ7CisJdW5zaWduZWQgY2hhciBidWZmWzE2XTsKKwlpbnQgX191c2VyICph cmdwID0gKGludCBfX3VzZXIgKilhcmc7CisKKwlpZiAoIWFyZ3ApCisJCXJldHVybiAtRUlOVkFM OworCisJc3dpdGNoIChjbWQpIHsKKwljYXNlIEk4S19CSU9TX1ZFUlNJT046CisJCXZhbCA9IChi aW9zX3ZlcnNpb25bMF0gPDwgMTYpIHwKKwkJCQkoYmlvc192ZXJzaW9uWzFdIDw8IDgpIHwgYmlv c192ZXJzaW9uWzJdOworCQlicmVhazsKKworCWNhc2UgSThLX01BQ0hJTkVfSUQ6CisJCW1lbXNl dChidWZmLCAwLCAxNik7CisJCXN0cmxjcHkoYnVmZiwgaThrX2dldF9kbWlfZGF0YShETUlfUFJP RFVDVF9TRVJJQUwpLAorCQkJc2l6ZW9mKGJ1ZmYpKTsKKwkJYnJlYWs7CisKKwljYXNlIEk4S19G Tl9TVEFUVVM6CisJCXZhbCA9IGk4a19nZXRfZm5fc3RhdHVzKCk7CisJCWJyZWFrOworCisJY2Fz ZSBJOEtfUE9XRVJfU1RBVFVTOgorCQl2YWwgPSBpOGtfZ2V0X3Bvd2VyX3N0YXR1cygpOworCQli cmVhazsKKworCWNhc2UgSThLX0dFVF9URU1QOgorCQl2YWwgPSBpOGtfZ2V0X3RlbXAoMCk7CisJ CWJyZWFrOworCisJY2FzZSBJOEtfR0VUX1NQRUVEOgorCQlpZiAoY29weV9mcm9tX3VzZXIoJnZh bCwgYXJncCwgc2l6ZW9mKGludCkpKQorCQkJcmV0dXJuIC1FRkFVTFQ7CisKKwkJdmFsID0gaThr X2dldF9mYW5fc3BlZWQodmFsKTsKKwkJYnJlYWs7CisKKwljYXNlIEk4S19HRVRfRkFOOgorCQlp ZiAoY29weV9mcm9tX3VzZXIoJnZhbCwgYXJncCwgc2l6ZW9mKGludCkpKQorCQkJcmV0dXJuIC1F RkFVTFQ7CisKKwkJdmFsID0gaThrX2dldF9mYW5fc3RhdHVzKHZhbCk7CisJCWJyZWFrOworCisJ Y2FzZSBJOEtfU0VUX0ZBTjoKKwkJaWYgKHJlc3RyaWN0ZWQgJiYgIWNhcGFibGUoQ0FQX1NZU19B RE1JTikpCisJCQlyZXR1cm4gLUVQRVJNOworCisJCWlmIChjb3B5X2Zyb21fdXNlcigmdmFsLCBh cmdwLCBzaXplb2YoaW50KSkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKworCQlpZiAoY29weV9mcm9t X3VzZXIoJnNwZWVkLCBhcmdwICsgMSwgc2l6ZW9mKGludCkpKQorCQkJcmV0dXJuIC1FRkFVTFQ7 CisKKwkJdmFsID0gaThrX3NldF9mYW4odmFsLCBzcGVlZCk7CisJCWJyZWFrOworCisJZGVmYXVs dDoKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYgKHZhbCA8IDApCisJCXJldHVybiB2YWw7 CisKKwlzd2l0Y2ggKGNtZCkgeworCWNhc2UgSThLX0JJT1NfVkVSU0lPTjoKKwkJaWYgKGNvcHlf dG9fdXNlcihhcmdwLCAmdmFsLCA0KSkKKwkJCXJldHVybiAtRUZBVUxUOworCisJCWJyZWFrOwor CWNhc2UgSThLX01BQ0hJTkVfSUQ6CisJCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgYnVmZiwgMTYp KQorCQkJcmV0dXJuIC1FRkFVTFQ7CisKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJaWYgKGNvcHlf dG9fdXNlcihhcmdwLCAmdmFsLCBzaXplb2YoaW50KSkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKwor CQlicmVhazsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGxvbmcgaThrX2lvY3RsKHN0 cnVjdCBmaWxlICpmcCwgdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJ bG9uZyByZXQ7CisKKwltdXRleF9sb2NrKCZpOGtfbXV0ZXgpOworCXJldCA9IGk4a19pb2N0bF91 bmxvY2tlZChmcCwgY21kLCBhcmcpOworCW11dGV4X3VubG9jaygmaThrX211dGV4KTsKKworCXJl dHVybiByZXQ7Cit9CisKKy8qCisgKiBQcmludCB0aGUgaW5mb3JtYXRpb24gZm9yIC9wcm9jL2k4 ay4KKyAqLworc3RhdGljIGludCBpOGtfcHJvY19zaG93KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2 b2lkICpvZmZzZXQpCit7CisJaW50IGZuX2tleSwgY3B1X3RlbXAsIGFjX3Bvd2VyOworCWludCBs ZWZ0X2ZhbiwgcmlnaHRfZmFuLCBsZWZ0X3NwZWVkLCByaWdodF9zcGVlZDsKKworCWNwdV90ZW1w CT0gaThrX2dldF90ZW1wKDApOwkJCS8qIDExMTAwIMK1cyAqLworCWxlZnRfZmFuCT0gaThrX2dl dF9mYW5fc3RhdHVzKEk4S19GQU5fTEVGVCk7CS8qICAgNTgwIMK1cyAqLworCXJpZ2h0X2Zhbgk9 IGk4a19nZXRfZmFuX3N0YXR1cyhJOEtfRkFOX1JJR0hUKTsJLyogICA1ODAgwrVzICovCisJbGVm dF9zcGVlZAk9IGk4a19nZXRfZmFuX3NwZWVkKEk4S19GQU5fTEVGVCk7CS8qICAgNTgwIMK1cyAq LworCXJpZ2h0X3NwZWVkCT0gaThrX2dldF9mYW5fc3BlZWQoSThLX0ZBTl9SSUdIVCk7CS8qICAg NTgwIMK1cyAqLworCWZuX2tleQkJPSBpOGtfZ2V0X2ZuX3N0YXR1cygpOwkJCS8qICAgNzUwIMK1 cyAqLworCWlmIChwb3dlcl9zdGF0dXMpCisJCWFjX3Bvd2VyID0gaThrX2dldF9wb3dlcl9zdGF0 dXMoKTsJCS8qIDE0NzAwIMK1cyAqLworCWVsc2UKKwkJYWNfcG93ZXIgPSAtMTsKKworCS8qCisJ ICogSW5mbzoKKwkgKgorCSAqIDEpICBGb3JtYXQgdmVyc2lvbiAodGhpcyB3aWxsIGNoYW5nZSBp ZiBmb3JtYXQgY2hhbmdlcykKKwkgKiAyKSAgQklPUyB2ZXJzaW9uCisJICogMykgIEJJT1MgbWFj aGluZSBJRAorCSAqIDQpICBDcHUgdGVtcGVyYXR1cmUKKwkgKiA1KSAgTGVmdCBmYW4gc3RhdHVz CisJICogNikgIFJpZ2h0IGZhbiBzdGF0dXMKKwkgKiA3KSAgTGVmdCBmYW4gc3BlZWQKKwkgKiA4 KSAgUmlnaHQgZmFuIHNwZWVkCisJICogOSkgIEFDIHBvd2VyCisJICogMTApIEZuIEtleSBzdGF0 dXMKKwkgKi8KKwlyZXR1cm4gc2VxX3ByaW50ZihzZXEsICIlcyAlcyAlcyAlZCAlZCAlZCAlZCAl ZCAlZCAlZFxuIiwKKwkJCSAgSThLX1BST0NfRk1ULAorCQkJICBiaW9zX3ZlcnNpb24sCisJCQkg IGk4a19nZXRfZG1pX2RhdGEoRE1JX1BST0RVQ1RfU0VSSUFMKSwKKwkJCSAgY3B1X3RlbXAsCisJ CQkgIGxlZnRfZmFuLCByaWdodF9mYW4sIGxlZnRfc3BlZWQsIHJpZ2h0X3NwZWVkLAorCQkJICBh Y19wb3dlciwgZm5fa2V5KTsKK30KKworc3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5v ZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gc2luZ2xlX29wZW4oZmls ZSwgaThrX3Byb2Nfc2hvdywgTlVMTCk7Cit9CisKKworLyoKKyAqIEh3bW9uIGludGVyZmFjZQor ICovCisKK3N0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwoc3RydWN0IGRl dmljZSAqZGV2LAorCQkJCQkgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCisJCQkJ CSBjaGFyICpidWYpCit7CisJc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBsYWJlbHNbXSA9IHsK KwkJIkNQVSIsCisJCSJHUFUiLAorCQkiU09ESU1NIiwKKwkJIk90aGVyIiwKKwkJIkFtYmllbnQi LAorCQkiT3RoZXIiLAorCX07CisJaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0 dHIpLT5pbmRleDsKKwlpbnQgdHlwZTsKKworCXR5cGUgPSBpOGtfZ2V0X3RlbXBfdHlwZShpbmRl eCk7CisJaWYgKHR5cGUgPCAwKQorCQlyZXR1cm4gdHlwZTsKKwlpZiAodHlwZSA+PSBBUlJBWV9T SVpFKGxhYmVscykpCisJCXR5cGUgPSBBUlJBWV9TSVpFKGxhYmVscykgLSAxOworCXJldHVybiBz cHJpbnRmKGJ1ZiwgIiVzXG4iLCBsYWJlbHNbdHlwZV0pOworfQorCitzdGF0aWMgc3NpemVfdCBp OGtfaHdtb25fc2hvd190ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkgICBzdHJ1Y3QgZGV2 aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKKwkJCQkgICBjaGFyICpidWYpCit7CisJaW50IGluZGV4 ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKKwlpbnQgdGVtcDsKKworCXRl bXAgPSBpOGtfZ2V0X3RlbXAoaW5kZXgpOworCWlmICh0ZW1wIDwgMCkKKwkJcmV0dXJuIHRlbXA7 CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIHRlbXAgKiAxMDAwKTsKK30KKworc3RhdGlj IHNzaXplX3QgaThrX2h3bW9uX3Nob3dfZmFuX2xhYmVsKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJ CQkJc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCisJCQkJCWNoYXIgKmJ1ZikKK3sK KwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGxhYmVsc1tdID0geworCQkiUHJvY2Vzc29yIEZh biIsCisJCSJNb3RoZXJib2FyZCBGYW4iLAorCQkiVmlkZW8gRmFuIiwKKwkJIlBvd2VyIFN1cHBs eSBGYW4iLAorCQkiQ2hpcHNldCBGYW4iLAorCQkiT3RoZXIgRmFuIiwKKwl9OworCWludCBpbmRl eCA9IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+aW5kZXg7CisJYm9vbCBkb2NrID0gZmFs c2U7CisJaW50IHR5cGU7CisKKwl0eXBlID0gaThrX2dldF9mYW5fdHlwZShpbmRleCk7CisJaWYg KHR5cGUgPCAwKQorCQlyZXR1cm4gdHlwZTsKKworCWlmICh0eXBlICYgMHgxMCkgeworCQlkb2Nr ID0gdHJ1ZTsKKwkJdHlwZSAmPSAweDBGOworCX0KKworCWlmICh0eXBlID49IEFSUkFZX1NJWkUo bGFiZWxzKSkKKwkJdHlwZSA9IChBUlJBWV9TSVpFKGxhYmVscykgLSAxKTsKKworCXJldHVybiBz cHJpbnRmKGJ1ZiwgIiVzJXNcbiIsIChkb2NrID8gIkRvY2tpbmcgIiA6ICIiKSwgbGFiZWxzW3R5 cGVdKTsKK30KKworc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3dfZmFuKHN0cnVjdCBkZXZp Y2UgKmRldiwKKwkJCQkgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLAorCQkJCSAg Y2hhciAqYnVmKQoreworCWludCBpbmRleCA9IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+ aW5kZXg7CisJaW50IGZhbl9zcGVlZDsKKworCWZhbl9zcGVlZCA9IGk4a19nZXRfZmFuX3NwZWVk KGluZGV4KTsKKwlpZiAoZmFuX3NwZWVkIDwgMCkKKwkJcmV0dXJuIGZhbl9zcGVlZDsKKwlyZXR1 cm4gc3ByaW50ZihidWYsICIlZFxuIiwgZmFuX3NwZWVkKTsKK30KKworc3RhdGljIHNzaXplX3Qg aThrX2h3bW9uX3Nob3dfcHdtKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkgIHN0cnVjdCBkZXZp Y2VfYXR0cmlidXRlICpkZXZhdHRyLAorCQkJCSAgY2hhciAqYnVmKQoreworCWludCBpbmRleCA9 IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+aW5kZXg7CisJaW50IHN0YXR1czsKKworCXN0 YXR1cyA9IGk4a19nZXRfZmFuX3N0YXR1cyhpbmRleCk7CisJaWYgKHN0YXR1cyA8IDApCisJCXJl dHVybiAtRUlPOworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBjbGFtcF92YWwoc3RhdHVz ICogaThrX3B3bV9tdWx0LCAwLCAyNTUpKTsKK30KKworc3RhdGljIHNzaXplX3QgaThrX2h3bW9u X3NldF9wd20oc3RydWN0IGRldmljZSAqZGV2LAorCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0 ZSAqYXR0ciwKKwkJCQkgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJaW50IGlu ZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpLT5pbmRleDsKKwl1bnNpZ25lZCBsb25nIHZh bDsKKwlpbnQgZXJyOworCisJZXJyID0ga3N0cnRvdWwoYnVmLCAxMCwgJnZhbCk7CisJaWYgKGVy cikKKwkJcmV0dXJuIGVycjsKKwl2YWwgPSBjbGFtcF92YWwoRElWX1JPVU5EX0NMT1NFU1QodmFs LCBpOGtfcHdtX211bHQpLCAwLCBpOGtfZmFuX21heCk7CisKKwltdXRleF9sb2NrKCZpOGtfbXV0 ZXgpOworCWVyciA9IGk4a19zZXRfZmFuKGluZGV4LCB2YWwpOworCW11dGV4X3VubG9jaygmaThr X211dGV4KTsKKworCXJldHVybiBlcnIgPCAwID8gLUVJTyA6IGNvdW50OworfQorCitzdGF0aWMg U0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190 ZW1wLCBOVUxMLCAwKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbGFiZWwsIFNf SVJVR08sIGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwsIE5VTEwsCisJCQkgIDApOworc3RhdGlj IFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMl9pbnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3df dGVtcCwgTlVMTCwgMSk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAyX2xhYmVsLCBT X0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wX2xhYmVsLCBOVUxMLAorCQkJICAxKTsKK3N0YXRp YyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDNfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93 X3RlbXAsIE5VTEwsIDIpOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wM19sYWJlbCwg U19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbCwgTlVMTCwKKwkJCSAgMik7CitzdGF0 aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXA0X2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hv d190ZW1wLCBOVUxMLCAzKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDRfbGFiZWws IFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwsIE5VTEwsCisJCQkgIDMpOworc3Rh dGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4xX2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hv d19mYW4sIE5VTEwsIDApOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4xX2xhYmVsLCBT X0lSVUdPLCBpOGtfaHdtb25fc2hvd19mYW5fbGFiZWwsIE5VTEwsCisJCQkgIDApOworc3RhdGlj IFNFTlNPUl9ERVZJQ0VfQVRUUihwd20xLCBTX0lSVUdPIHwgU19JV1VTUiwgaThrX2h3bW9uX3No b3dfcHdtLAorCQkJICBpOGtfaHdtb25fc2V0X3B3bSwgMCk7CitzdGF0aWMgU0VOU09SX0RFVklD RV9BVFRSKGZhbjJfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X2ZhbiwgTlVMTCwKKwkJ CSAgMSk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGZhbjJfbGFiZWwsIFNfSVJVR08sIGk4 a19od21vbl9zaG93X2Zhbl9sYWJlbCwgTlVMTCwKKwkJCSAgMSk7CitzdGF0aWMgU0VOU09SX0RF VklDRV9BVFRSKHB3bTIsIFNfSVJVR08gfCBTX0lXVVNSLCBpOGtfaHdtb25fc2hvd19wd20sCisJ CQkgIGk4a19od21vbl9zZXRfcHdtLCAxKTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmk4 a19hdHRyc1tdID0geworCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIuYXR0 ciwJLyogMCAqLworCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfbGFiZWwuZGV2X2F0dHIuYXR0ciwJ LyogMSAqLworCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDJfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyog MiAqLworCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDJfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogMyAq LworCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDNfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogNCAqLwor CSZzZW5zb3JfZGV2X2F0dHJfdGVtcDNfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogNSAqLworCSZz ZW5zb3JfZGV2X2F0dHJfdGVtcDRfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogNiAqLworCSZzZW5z b3JfZGV2X2F0dHJfdGVtcDRfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogNyAqLworCSZzZW5zb3Jf ZGV2X2F0dHJfZmFuMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiA4ICovCisJJnNlbnNvcl9kZXZf YXR0cl9mYW4xX2xhYmVsLmRldl9hdHRyLmF0dHIsCS8qIDkgKi8KKwkmc2Vuc29yX2Rldl9hdHRy X3B3bTEuZGV2X2F0dHIuYXR0ciwJCS8qIDEwICovCisJJnNlbnNvcl9kZXZfYXR0cl9mYW4yX2lu cHV0LmRldl9hdHRyLmF0dHIsCS8qIDExICovCisJJnNlbnNvcl9kZXZfYXR0cl9mYW4yX2xhYmVs LmRldl9hdHRyLmF0dHIsCS8qIDEyICovCisJJnNlbnNvcl9kZXZfYXR0cl9wd20yLmRldl9hdHRy LmF0dHIsCQkvKiAxMyAqLworCU5VTEwKK307CisKK3N0YXRpYyB1bW9kZV90IGk4a19pc192aXNp YmxlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3QgYXR0cmlidXRlICphdHRyLAorCQkJICAg ICAgaW50IGluZGV4KQoreworCWlmIChpbmRleCA+PSAwICYmIGluZGV4IDw9IDEgJiYKKwkgICAg IShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9URU1QMSkpCisJCXJldHVybiAwOwor CWlmIChpbmRleCA+PSAyICYmIGluZGV4IDw9IDMgJiYKKwkgICAgIShpOGtfaHdtb25fZmxhZ3Mg JiBJOEtfSFdNT05fSEFWRV9URU1QMikpCisJCXJldHVybiAwOworCWlmIChpbmRleCA+PSA0ICYm IGluZGV4IDw9IDUgJiYKKwkgICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9U RU1QMykpCisJCXJldHVybiAwOworCWlmIChpbmRleCA+PSA2ICYmIGluZGV4IDw9IDcgJiYKKwkg ICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9URU1QNCkpCisJCXJldHVybiAw OworCWlmIChpbmRleCA+PSA4ICYmIGluZGV4IDw9IDEwICYmCisJICAgICEoaThrX2h3bW9uX2Zs YWdzICYgSThLX0hXTU9OX0hBVkVfRkFOMSkpCisJCXJldHVybiAwOworCWlmIChpbmRleCA+PSAx MSAmJiBpbmRleCA8PSAxMyAmJgorCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9I QVZFX0ZBTjIpKQorCQlyZXR1cm4gMDsKKworCXJldHVybiBhdHRyLT5tb2RlOworfQorCitzdGF0 aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBpOGtfZ3JvdXAgPSB7CisJLmF0dHJzID0g aThrX2F0dHJzLAorCS5pc192aXNpYmxlID0gaThrX2lzX3Zpc2libGUsCit9OworX19BVFRSSUJV VEVfR1JPVVBTKGk4ayk7CisKK3N0YXRpYyBpbnQgX19pbml0IGk4a19pbml0X2h3bW9uKHZvaWQp Cit7CisJaW50IGVycjsKKworCWk4a19od21vbl9mbGFncyA9IDA7CisKKwkvKiBDUFUgdGVtcGVy YXR1cmUgYXR0cmlidXRlcywgaWYgdGVtcGVyYXR1cmUgdHlwZSBpcyBPSyAqLworCWVyciA9IGk4 a19nZXRfdGVtcF90eXBlKDApOworCWlmIChlcnIgPj0gMCkKKwkJaThrX2h3bW9uX2ZsYWdzIHw9 IEk4S19IV01PTl9IQVZFX1RFTVAxOworCS8qIGNoZWNrIGZvciBhZGRpdGlvbmFsIHRlbXBlcmF0 dXJlIHNlbnNvcnMgKi8KKwllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgxKTsKKwlpZiAoZXJyID49 IDApCisJCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9URU1QMjsKKwllcnIgPSBp OGtfZ2V0X3RlbXBfdHlwZSgyKTsKKwlpZiAoZXJyID49IDApCisJCWk4a19od21vbl9mbGFncyB8 PSBJOEtfSFdNT05fSEFWRV9URU1QMzsKKwllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgzKTsKKwlp ZiAoZXJyID49IDApCisJCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9URU1QNDsK KworCS8qIEZpcnN0IGZhbiBhdHRyaWJ1dGVzLCBpZiBmYW4gdHlwZSBpcyBPSyAqLworCWVyciA9 IGk4a19nZXRfZmFuX3R5cGUoMCk7CisJaWYgKGVyciA+PSAwKQorCQlpOGtfaHdtb25fZmxhZ3Mg fD0gSThLX0hXTU9OX0hBVkVfRkFOMTsKKworCS8qIFNlY29uZCBmYW4gYXR0cmlidXRlcywgaWYg ZmFuIHR5cGUgaXMgT0sgKi8KKwllcnIgPSBpOGtfZ2V0X2Zhbl90eXBlKDEpOworCWlmIChlcnIg Pj0gMCkKKwkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX0ZBTjI7CisKKwlpOGtf aHdtb25fZGV2ID0gaHdtb25fZGV2aWNlX3JlZ2lzdGVyX3dpdGhfZ3JvdXBzKE5VTEwsICJpOGsi LCBOVUxMLAorCQkJCQkJCSAgaThrX2dyb3Vwcyk7CisJaWYgKElTX0VSUihpOGtfaHdtb25fZGV2 KSkgeworCQllcnIgPSBQVFJfRVJSKGk4a19od21vbl9kZXYpOworCQlpOGtfaHdtb25fZGV2ID0g TlVMTDsKKwkJcHJfZXJyKCJod21vbiByZWdpc3RyYXRpb24gZmFpbGVkICglZClcbiIsIGVycik7 CisJCXJldHVybiBlcnI7CisJfQorCXJldHVybiAwOworfQorCitzdHJ1Y3QgaThrX2NvbmZpZ19k YXRhIHsKKwl1aW50IGZhbl9tdWx0OworCXVpbnQgZmFuX21heDsKK307CisKK2VudW0gaThrX2Nv bmZpZ3MgeworCURFTExfTEFUSVRVREVfRDUyMCwKKwlERUxMX1BSRUNJU0lPTl80OTAsCisJREVM TF9TVFVESU8sCisJREVMTF9YUFMsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGk4a19jb25m aWdfZGF0YSBpOGtfY29uZmlnX2RhdGFbXSA9IHsKKwlbREVMTF9MQVRJVFVERV9ENTIwXSA9IHsK KwkJLmZhbl9tdWx0ID0gMSwKKwkJLmZhbl9tYXggPSBJOEtfRkFOX1RVUkJPLAorCX0sCisJW0RF TExfUFJFQ0lTSU9OXzQ5MF0gPSB7CisJCS5mYW5fbXVsdCA9IDEsCisJCS5mYW5fbWF4ID0gSThL X0ZBTl9UVVJCTywKKwl9LAorCVtERUxMX1NUVURJT10gPSB7CisJCS5mYW5fbXVsdCA9IDEsCisJ CS5mYW5fbWF4ID0gSThLX0ZBTl9ISUdILAorCX0sCisJW0RFTExfWFBTXSA9IHsKKwkJLmZhbl9t dWx0ID0gMSwKKwkJLmZhbl9tYXggPSBJOEtfRkFOX0hJR0gsCisJfSwKK307CisKK3N0YXRpYyBz dHJ1Y3QgZG1pX3N5c3RlbV9pZCBpOGtfZG1pX3RhYmxlW10gX19pbml0ZGF0YSA9IHsKKwl7CisJ CS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0go RE1JX1NZU19WRU5ET1IsICJEZWxsIENvbXB1dGVyIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RV Q1RfTkFNRSwgIkluc3Bpcm9uIiksCisJCX0sCisJfSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIExh dGl0dWRlIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJE ZWxsIENvbXB1dGVyIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkxhdGl0dWRl IiksCisJCX0sCisJfSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIDIiLAorCQkubWF0 Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJ RE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJJbnNwaXJvbiIpLAorCQl9LAorCX0sCisJewor CQkuaWRlbnQgPSAiRGVsbCBMYXRpdHVkZSBENTIwIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlf TUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKKwkJCURNSV9NQVRDSChETUlfUFJP RFVDVF9OQU1FLCAiTGF0aXR1ZGUgRDUyMCIpLAorCQl9LAorCQkuZHJpdmVyX2RhdGEgPSAodm9p ZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9MQVRJVFVERV9ENTIwXSwKKwl9LAorCXsKKwkJLmlk ZW50ID0gIkRlbGwgTGF0aXR1ZGUgMiIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERN SV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFN RSwgIkxhdGl0dWRlIiksCisJCX0sCisJfSwKKwl7CS8qIFVLIEluc3Bpcm9uIDY0MDAgICovCisJ CS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIDMiLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRD SChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNU X05BTUUsICJNTTA2MSIpLAorCQl9LAorCX0sCisJeworCQkuaWRlbnQgPSAiRGVsbCBJbnNwaXJv biAzIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxs IEluYy4iKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTVAwNjEiKSwKKwkJfSwK Kwl9LAorCXsKKwkJLmlkZW50ID0gIkRlbGwgUHJlY2lzaW9uIDQ5MCIsCisJCS5tYXRjaGVzID0g eworCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFU Q0goRE1JX1BST0RVQ1RfTkFNRSwKKwkJCQkgICJQcmVjaXNpb24gV29ya1N0YXRpb24gNDkwIiks CisJCX0sCisJCS5kcml2ZXJfZGF0YSA9ICh2b2lkICopJmk4a19jb25maWdfZGF0YVtERUxMX1BS RUNJU0lPTl80OTBdLAorCX0sCisJeworCQkuaWRlbnQgPSAiRGVsbCBQcmVjaXNpb24iLAorCQku bWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAor CQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJQcmVjaXNpb24iKSwKKwkJfSwKKwl9LAor CXsKKwkJLmlkZW50ID0gIkRlbGwgVm9zdHJvIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFU Q0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVD VF9OQU1FLCAiVm9zdHJvIiksCisJCX0sCisJfSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIFhQUzQy MSIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJ bmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlhQUyBMNDIxWCIpLAorCQl9 LAorCX0sCisJeworCQkuaWRlbnQgPSAiRGVsbCBTdHVkaW8iLAorCQkubWF0Y2hlcyA9IHsKKwkJ CURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJRE1JX01BVENIKERN SV9QUk9EVUNUX05BTUUsICJTdHVkaW8iKSwKKwkJfSwKKwkJLmRyaXZlcl9kYXRhID0gKHZvaWQg KikmaThrX2NvbmZpZ19kYXRhW0RFTExfU1RVRElPXSwKKwl9LAorCXsKKwkJLmlkZW50ID0gIkRl bGwgWFBTIDEzIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1Is ICJEZWxsIEluYy4iKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiWFBTMTMiKSwK KwkJfSwKKwkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfWFBT XSwKKwl9LAorCXsKKwkJLmlkZW50ID0gIkRlbGwgWFBTIE0xNDAiLAorCQkubWF0Y2hlcyA9IHsK KwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJRE1JX01BVENI KERNSV9QUk9EVUNUX05BTUUsICJNWEMwNTEiKSwKKwkJfSwKKwkJLmRyaXZlcl9kYXRhID0gKHZv aWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfWFBTXSwKKwl9LAorCXsgfQorfTsKKworTU9EVUxF X0RFVklDRV9UQUJMRShkbWksIGk4a19kbWlfdGFibGUpOworCisvKgorICogUHJvYmUgZm9yIHRo ZSBwcmVzZW5jZSBvZiBhIHN1cHBvcnRlZCBsYXB0b3AuCisgKi8KK3N0YXRpYyBpbnQgX19pbml0 IGk4a19wcm9iZSh2b2lkKQoreworCWNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkICppZDsKKwlp bnQgZmFuLCByZXQ7CisKKwkvKgorCSAqIEdldCBETUkgaW5mb3JtYXRpb24KKwkgKi8KKwlpZiAo IWRtaV9jaGVja19zeXN0ZW0oaThrX2RtaV90YWJsZSkpIHsKKwkJaWYgKCFpZ25vcmVfZG1pICYm ICFmb3JjZSkKKwkJCXJldHVybiAtRU5PREVWOworCisJCXByX2luZm8oIm5vdCBydW5uaW5nIG9u IGEgc3VwcG9ydGVkIERlbGwgc3lzdGVtLlxuIik7CisJCXByX2luZm8oInZlbmRvcj0lcywgbW9k ZWw9JXMsIHZlcnNpb249JXNcbiIsCisJCQlpOGtfZ2V0X2RtaV9kYXRhKERNSV9TWVNfVkVORE9S KSwKKwkJCWk4a19nZXRfZG1pX2RhdGEoRE1JX1BST0RVQ1RfTkFNRSksCisJCQlpOGtfZ2V0X2Rt aV9kYXRhKERNSV9CSU9TX1ZFUlNJT04pKTsKKwl9CisKKwlzdHJsY3B5KGJpb3NfdmVyc2lvbiwg aThrX2dldF9kbWlfZGF0YShETUlfQklPU19WRVJTSU9OKSwKKwkJc2l6ZW9mKGJpb3NfdmVyc2lv bikpOworCisJLyoKKwkgKiBHZXQgU01NIERlbGwgc2lnbmF0dXJlCisJICovCisJaWYgKGk4a19n ZXRfZGVsbF9zaWduYXR1cmUoSThLX1NNTV9HRVRfREVMTF9TSUcxKSAmJgorCSAgICBpOGtfZ2V0 X2RlbGxfc2lnbmF0dXJlKEk4S19TTU1fR0VUX0RFTExfU0lHMikpIHsKKwkJcHJfZXJyKCJ1bmFi bGUgdG8gZ2V0IFNNTSBEZWxsIHNpZ25hdHVyZVxuIik7CisJCWlmICghZm9yY2UpCisJCQlyZXR1 cm4gLUVOT0RFVjsKKwl9CisKKwkvKgorCSAqIFNldCBmYW4gbXVsdGlwbGllciBhbmQgbWF4aW1h bCBmYW4gc3BlZWQgZnJvbSBkbWkgY29uZmlnCisJICogVmFsdWVzIHNwZWNpZmllZCBpbiBtb2R1 bGUgcGFyYW1ldGVycyBvdmVycmlkZSB2YWx1ZXMgZnJvbSBkbWkKKwkgKi8KKwlpZCA9IGRtaV9m aXJzdF9tYXRjaChpOGtfZG1pX3RhYmxlKTsKKwlpZiAoaWQgJiYgaWQtPmRyaXZlcl9kYXRhKSB7 CisJCWNvbnN0IHN0cnVjdCBpOGtfY29uZmlnX2RhdGEgKmNvbmYgPSBpZC0+ZHJpdmVyX2RhdGE7 CisJCWlmICghZmFuX211bHQgJiYgY29uZi0+ZmFuX211bHQpCisJCQlmYW5fbXVsdCA9IGNvbmYt PmZhbl9tdWx0OworCQlpZiAoIWZhbl9tYXggJiYgY29uZi0+ZmFuX21heCkKKwkJCWZhbl9tYXgg PSBjb25mLT5mYW5fbWF4OworCX0KKworCWk4a19mYW5fbWF4ID0gZmFuX21heCA/IDogSThLX0ZB Tl9ISUdIOwkvKiBNdXN0IG5vdCBiZSAwICovCisJaThrX3B3bV9tdWx0ID0gRElWX1JPVU5EX1VQ KDI1NSwgaThrX2Zhbl9tYXgpOworCisJaWYgKCFmYW5fbXVsdCkgeworCQkvKgorCQkgKiBBdXRv ZGV0ZWN0IGZhbiBtdWx0aXBsaWVyIGJhc2VkIG9uIG5vbWluYWwgcnBtCisJCSAqIElmIGZhbiBy ZXBvcnRzIHJwbSB2YWx1ZSB0b28gaGlnaCB0aGVuIHNldCBtdWx0aXBsaWVyIHRvIDEKKwkJICov CisJCWZvciAoZmFuID0gMDsgZmFuIDwgMjsgKytmYW4pIHsKKwkJCXJldCA9IGk4a19nZXRfZmFu X25vbWluYWxfc3BlZWQoZmFuLCBpOGtfZmFuX21heCk7CisJCQlpZiAocmV0IDwgMCkKKwkJCQlj b250aW51ZTsKKwkJCWlmIChyZXQgPiBJOEtfRkFOX01BWF9SUE0pCisJCQkJaThrX2Zhbl9tdWx0 ID0gMTsKKwkJCWJyZWFrOworCQl9CisJfSBlbHNlIHsKKwkJLyogRmFuIG11bHRpcGxpZXIgd2Fz IHNwZWNpZmllZCBpbiBtb2R1bGUgcGFyYW0gb3IgaW4gZG1pICovCisJCWk4a19mYW5fbXVsdCA9 IGZhbl9tdWx0OworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IF9faW5pdCBpOGtf aW5pdCh2b2lkKQoreworCXN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqcHJvY19pOGs7CisJaW50IGVy cjsKKworCS8qIEFyZSB3ZSBydW5uaW5nIG9uIGFuIHN1cHBvcnRlZCBsYXB0b3A/ICovCisJaWYg KGk4a19wcm9iZSgpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCS8qIFJlZ2lzdGVyIHRoZSBwcm9j IGVudHJ5ICovCisJcHJvY19pOGsgPSBwcm9jX2NyZWF0ZSgiaThrIiwgMCwgTlVMTCwgJmk4a19m b3BzKTsKKwlpZiAoIXByb2NfaThrKQorCQlyZXR1cm4gLUVOT0VOVDsKKworCWVyciA9IGk4a19p bml0X2h3bW9uKCk7CisJaWYgKGVycikKKwkJZ290byBleGl0X3JlbW92ZV9wcm9jOworCisJcmV0 dXJuIDA7CisKKyBleGl0X3JlbW92ZV9wcm9jOgorCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBO VUxMKTsKKwlyZXR1cm4gZXJyOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgaThrX2V4aXQodm9p ZCkKK3sKKwlod21vbl9kZXZpY2VfdW5yZWdpc3RlcihpOGtfaHdtb25fZGV2KTsKKwlyZW1vdmVf cHJvY19lbnRyeSgiaThrIiwgTlVMTCk7Cit9CisKK21vZHVsZV9pbml0KGk4a19pbml0KTsKK21v ZHVsZV9leGl0KGk4a19leGl0KTsKLS0gCjEuNy45LjUKCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5z b3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree @ 2015-03-28 10:24 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 10:24 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This commit moves i8k driver to hwmon tree under name dell-smm-hwmon which is better name then abbreviation i8k. For backward compatibility is added macro MODULE_ALIAS("i8k") so modprobe will load driver also old name i8k. CONFIG_I8K compile option was not changed. This commit also adds me as maintainer of this new dell-smm-hwmon driver. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- MAINTAINERS | 3 +- drivers/char/Makefile | 1 - drivers/char/i8k.c | 1005 --------------------------------------- drivers/hwmon/Makefile | 1 + drivers/hwmon/dell-smm-hwmon.c | 1007 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 1010 insertions(+), 1007 deletions(-) delete mode 100644 drivers/char/i8k.c create mode 100644 drivers/hwmon/dell-smm-hwmon.c diff --git a/MAINTAINERS b/MAINTAINERS index 88c09ca..bf5bb05 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3064,8 +3064,9 @@ F: drivers/platform/x86/dell-laptop.c DELL LAPTOP SMM DRIVER M: Guenter Roeck <linux@roeck-us.net> +M: Pali Rohár <pali.rohar@gmail.com> S: Maintained -F: drivers/char/i8k.c +F: drivers/hwmon/dell-smm-hwmon.c F: include/uapi/linux/i8k.h DELL SYSTEMS MANAGEMENT BASE DRIVER (dcdbas) diff --git a/drivers/char/Makefile b/drivers/char/Makefile index d06cde26..1d9cf00 100644 --- a/drivers/char/Makefile +++ b/drivers/char/Makefile @@ -36,7 +36,6 @@ else obj-$(CONFIG_NVRAM) += nvram.o endif obj-$(CONFIG_TOSHIBA) += toshiba.o -obj-$(CONFIG_I8K) += i8k.o obj-$(CONFIG_DS1620) += ds1620.o obj-$(CONFIG_HW_RANDOM) += hw_random/ obj-$(CONFIG_PPDEV) += ppdev.o diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c deleted file mode 100644 index 24cc4ed..0000000 --- a/drivers/char/i8k.c +++ /dev/null @@ -1,1005 +0,0 @@ -/* - * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops. - * - * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> - * - * Hwmon integration: - * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> - * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> - * Copyright (C) 2014 Pali Rohár <pali.rohar@gmail.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, 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. - */ - -#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt - -#include <linux/delay.h> -#include <linux/module.h> -#include <linux/types.h> -#include <linux/init.h> -#include <linux/proc_fs.h> -#include <linux/seq_file.h> -#include <linux/dmi.h> -#include <linux/capability.h> -#include <linux/mutex.h> -#include <linux/hwmon.h> -#include <linux/hwmon-sysfs.h> -#include <linux/uaccess.h> -#include <linux/io.h> -#include <linux/sched.h> - -#include <linux/i8k.h> - -#define I8K_SMM_FN_STATUS 0x0025 -#define I8K_SMM_POWER_STATUS 0x0069 -#define I8K_SMM_SET_FAN 0x01a3 -#define I8K_SMM_GET_FAN 0x00a3 -#define I8K_SMM_GET_SPEED 0x02a3 -#define I8K_SMM_GET_FAN_TYPE 0x03a3 -#define I8K_SMM_GET_NOM_SPEED 0x04a3 -#define I8K_SMM_GET_TEMP 0x10a3 -#define I8K_SMM_GET_TEMP_TYPE 0x11a3 -#define I8K_SMM_GET_DELL_SIG1 0xfea3 -#define I8K_SMM_GET_DELL_SIG2 0xffa3 - -#define I8K_FAN_MULT 30 -#define I8K_FAN_MAX_RPM 30000 -#define I8K_MAX_TEMP 127 - -#define I8K_FN_NONE 0x00 -#define I8K_FN_UP 0x01 -#define I8K_FN_DOWN 0x02 -#define I8K_FN_MUTE 0x04 -#define I8K_FN_MASK 0x07 -#define I8K_FN_SHIFT 8 - -#define I8K_POWER_AC 0x05 -#define I8K_POWER_BATTERY 0x01 - -static DEFINE_MUTEX(i8k_mutex); -static char bios_version[4]; -static struct device *i8k_hwmon_dev; -static u32 i8k_hwmon_flags; -static uint i8k_fan_mult = I8K_FAN_MULT; -static uint i8k_pwm_mult; -static uint i8k_fan_max = I8K_FAN_HIGH; - -#define I8K_HWMON_HAVE_TEMP1 (1 << 0) -#define I8K_HWMON_HAVE_TEMP2 (1 << 1) -#define I8K_HWMON_HAVE_TEMP3 (1 << 2) -#define I8K_HWMON_HAVE_TEMP4 (1 << 3) -#define I8K_HWMON_HAVE_FAN1 (1 << 4) -#define I8K_HWMON_HAVE_FAN2 (1 << 5) - -MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); -MODULE_LICENSE("GPL"); - -static bool force; -module_param(force, bool, 0); -MODULE_PARM_DESC(force, "Force loading without checking for supported models"); - -static bool ignore_dmi; -module_param(ignore_dmi, bool, 0); -MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); - -static bool restricted; -module_param(restricted, bool, 0); -MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); - -static bool power_status; -module_param(power_status, bool, 0600); -MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); - -static uint fan_mult; -module_param(fan_mult, uint, 0); -MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); - -static uint fan_max; -module_param(fan_max, uint, 0); -MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); - -static int i8k_open_fs(struct inode *inode, struct file *file); -static long i8k_ioctl(struct file *, unsigned int, unsigned long); - -static const struct file_operations i8k_fops = { - .owner = THIS_MODULE, - .open = i8k_open_fs, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, - .unlocked_ioctl = i8k_ioctl, -}; - -struct smm_regs { - unsigned int eax; - unsigned int ebx __packed; - unsigned int ecx __packed; - unsigned int edx __packed; - unsigned int esi __packed; - unsigned int edi __packed; -}; - -static inline const char *i8k_get_dmi_data(int field) -{ - const char *dmi_data = dmi_get_system_info(field); - - return dmi_data && *dmi_data ? dmi_data : "?"; -} - -/* - * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. - */ -static int i8k_smm(struct smm_regs *regs) -{ - int rc; - int eax = regs->eax; - cpumask_var_t old_mask; - - /* SMM requires CPU 0 */ - if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) - return -ENOMEM; - cpumask_copy(old_mask, ¤t->cpus_allowed); - rc = set_cpus_allowed_ptr(current, cpumask_of(0)); - if (rc) - goto out; - if (smp_processor_id() != 0) { - rc = -EBUSY; - goto out; - } - -#if defined(CONFIG_X86_64) - asm volatile("pushq %%rax\n\t" - "movl 0(%%rax),%%edx\n\t" - "pushq %%rdx\n\t" - "movl 4(%%rax),%%ebx\n\t" - "movl 8(%%rax),%%ecx\n\t" - "movl 12(%%rax),%%edx\n\t" - "movl 16(%%rax),%%esi\n\t" - "movl 20(%%rax),%%edi\n\t" - "popq %%rax\n\t" - "out %%al,$0xb2\n\t" - "out %%al,$0x84\n\t" - "xchgq %%rax,(%%rsp)\n\t" - "movl %%ebx,4(%%rax)\n\t" - "movl %%ecx,8(%%rax)\n\t" - "movl %%edx,12(%%rax)\n\t" - "movl %%esi,16(%%rax)\n\t" - "movl %%edi,20(%%rax)\n\t" - "popq %%rdx\n\t" - "movl %%edx,0(%%rax)\n\t" - "pushfq\n\t" - "popq %%rax\n\t" - "andl $1,%%eax\n" - : "=a"(rc) - : "a"(regs) - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); -#else - asm volatile("pushl %%eax\n\t" - "movl 0(%%eax),%%edx\n\t" - "push %%edx\n\t" - "movl 4(%%eax),%%ebx\n\t" - "movl 8(%%eax),%%ecx\n\t" - "movl 12(%%eax),%%edx\n\t" - "movl 16(%%eax),%%esi\n\t" - "movl 20(%%eax),%%edi\n\t" - "popl %%eax\n\t" - "out %%al,$0xb2\n\t" - "out %%al,$0x84\n\t" - "xchgl %%eax,(%%esp)\n\t" - "movl %%ebx,4(%%eax)\n\t" - "movl %%ecx,8(%%eax)\n\t" - "movl %%edx,12(%%eax)\n\t" - "movl %%esi,16(%%eax)\n\t" - "movl %%edi,20(%%eax)\n\t" - "popl %%edx\n\t" - "movl %%edx,0(%%eax)\n\t" - "lahf\n\t" - "shrl $8,%%eax\n\t" - "andl $1,%%eax\n" - : "=a"(rc) - : "a"(regs) - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); -#endif - if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) - rc = -EINVAL; - -out: - set_cpus_allowed_ptr(current, old_mask); - free_cpumask_var(old_mask); - return rc; -} - -/* - * Read the Fn key status. - */ -static int i8k_get_fn_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { - case I8K_FN_UP: - return I8K_VOL_UP; - case I8K_FN_DOWN: - return I8K_VOL_DOWN; - case I8K_FN_MUTE: - return I8K_VOL_MUTE; - default: - return 0; - } -} - -/* - * Read the power status. - */ -static int i8k_get_power_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; -} - -/* - * Read the fan status. - */ -static int i8k_get_fan_status(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the fan speed in RPM. - */ -static int i8k_get_fan_speed(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; -} - -/* - * Read the fan type. - */ -static int i8k_get_fan_type(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the fan nominal rpm for specific fan speed. - */ -static int i8k_get_fan_nominal_speed(int fan, int speed) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; - - regs.ebx = (fan & 0xff) | (speed << 8); - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; -} - -/* - * Set the fan speed (off, low, high). Returns the new fan status. - */ -static int i8k_set_fan(int fan, int speed) -{ - struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; - - speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); - regs.ebx = (fan & 0xff) | (speed << 8); - - return i8k_smm(®s) ? : i8k_get_fan_status(fan); -} - -static int i8k_get_temp_type(int sensor) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; - - regs.ebx = sensor & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the cpu temperature. - */ -static int _i8k_get_temp(int sensor) -{ - struct smm_regs regs = { - .eax = I8K_SMM_GET_TEMP, - .ebx = sensor & 0xff, - }; - - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -static int i8k_get_temp(int sensor) -{ - int temp = _i8k_get_temp(sensor); - - /* - * Sometimes the temperature sensor returns 0x99, which is out of range. - * In this case we retry (once) before returning an error. - # 1003655137 00000058 00005a4b - # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees - # 1003655139 00000054 00005c52 - */ - if (temp == 0x99) { - msleep(100); - temp = _i8k_get_temp(sensor); - } - /* - * Return -ENODATA for all invalid temperatures. - * - * Known instances are the 0x99 value as seen above as well as - * 0xc1 (193), which may be returned when trying to read the GPU - * temperature if the system supports a GPU and it is currently - * turned off. - */ - if (temp > I8K_MAX_TEMP) - return -ENODATA; - - return temp; -} - -static int i8k_get_dell_signature(int req_fn) -{ - struct smm_regs regs = { .eax = req_fn, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; -} - -static int -i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) -{ - int val = 0; - int speed; - unsigned char buff[16]; - int __user *argp = (int __user *)arg; - - if (!argp) - return -EINVAL; - - switch (cmd) { - case I8K_BIOS_VERSION: - val = (bios_version[0] << 16) | - (bios_version[1] << 8) | bios_version[2]; - break; - - case I8K_MACHINE_ID: - memset(buff, 0, 16); - strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), - sizeof(buff)); - break; - - case I8K_FN_STATUS: - val = i8k_get_fn_status(); - break; - - case I8K_POWER_STATUS: - val = i8k_get_power_status(); - break; - - case I8K_GET_TEMP: - val = i8k_get_temp(0); - break; - - case I8K_GET_SPEED: - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - val = i8k_get_fan_speed(val); - break; - - case I8K_GET_FAN: - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - val = i8k_get_fan_status(val); - break; - - case I8K_SET_FAN: - if (restricted && !capable(CAP_SYS_ADMIN)) - return -EPERM; - - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - if (copy_from_user(&speed, argp + 1, sizeof(int))) - return -EFAULT; - - val = i8k_set_fan(val, speed); - break; - - default: - return -EINVAL; - } - - if (val < 0) - return val; - - switch (cmd) { - case I8K_BIOS_VERSION: - if (copy_to_user(argp, &val, 4)) - return -EFAULT; - - break; - case I8K_MACHINE_ID: - if (copy_to_user(argp, buff, 16)) - return -EFAULT; - - break; - default: - if (copy_to_user(argp, &val, sizeof(int))) - return -EFAULT; - - break; - } - - return 0; -} - -static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) -{ - long ret; - - mutex_lock(&i8k_mutex); - ret = i8k_ioctl_unlocked(fp, cmd, arg); - mutex_unlock(&i8k_mutex); - - return ret; -} - -/* - * Print the information for /proc/i8k. - */ -static int i8k_proc_show(struct seq_file *seq, void *offset) -{ - int fn_key, cpu_temp, ac_power; - int left_fan, right_fan, left_speed, right_speed; - - cpu_temp = i8k_get_temp(0); /* 11100 µs */ - left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ - right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ - left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ - right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ - fn_key = i8k_get_fn_status(); /* 750 µs */ - if (power_status) - ac_power = i8k_get_power_status(); /* 14700 µs */ - else - ac_power = -1; - - /* - * Info: - * - * 1) Format version (this will change if format changes) - * 2) BIOS version - * 3) BIOS machine ID - * 4) Cpu temperature - * 5) Left fan status - * 6) Right fan status - * 7) Left fan speed - * 8) Right fan speed - * 9) AC power - * 10) Fn Key status - */ - return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", - I8K_PROC_FMT, - bios_version, - i8k_get_dmi_data(DMI_PRODUCT_SERIAL), - cpu_temp, - left_fan, right_fan, left_speed, right_speed, - ac_power, fn_key); -} - -static int i8k_open_fs(struct inode *inode, struct file *file) -{ - return single_open(file, i8k_proc_show, NULL); -} - - -/* - * Hwmon interface - */ - -static ssize_t i8k_hwmon_show_temp_label(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - static const char * const labels[] = { - "CPU", - "GPU", - "SODIMM", - "Other", - "Ambient", - "Other", - }; - int index = to_sensor_dev_attr(devattr)->index; - int type; - - type = i8k_get_temp_type(index); - if (type < 0) - return type; - if (type >= ARRAY_SIZE(labels)) - type = ARRAY_SIZE(labels) - 1; - return sprintf(buf, "%s\n", labels[type]); -} - -static ssize_t i8k_hwmon_show_temp(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int temp; - - temp = i8k_get_temp(index); - if (temp < 0) - return temp; - return sprintf(buf, "%d\n", temp * 1000); -} - -static ssize_t i8k_hwmon_show_fan_label(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - static const char * const labels[] = { - "Processor Fan", - "Motherboard Fan", - "Video Fan", - "Power Supply Fan", - "Chipset Fan", - "Other Fan", - }; - int index = to_sensor_dev_attr(devattr)->index; - bool dock = false; - int type; - - type = i8k_get_fan_type(index); - if (type < 0) - return type; - - if (type & 0x10) { - dock = true; - type &= 0x0F; - } - - if (type >= ARRAY_SIZE(labels)) - type = (ARRAY_SIZE(labels) - 1); - - return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); -} - -static ssize_t i8k_hwmon_show_fan(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int fan_speed; - - fan_speed = i8k_get_fan_speed(index); - if (fan_speed < 0) - return fan_speed; - return sprintf(buf, "%d\n", fan_speed); -} - -static ssize_t i8k_hwmon_show_pwm(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int status; - - status = i8k_get_fan_status(index); - if (status < 0) - return -EIO; - return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); -} - -static ssize_t i8k_hwmon_set_pwm(struct device *dev, - struct device_attribute *attr, - const char *buf, size_t count) -{ - int index = to_sensor_dev_attr(attr)->index; - unsigned long val; - int err; - - err = kstrtoul(buf, 10, &val); - if (err) - return err; - val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); - - mutex_lock(&i8k_mutex); - err = i8k_set_fan(index, val); - mutex_unlock(&i8k_mutex); - - return err < 0 ? -EIO : count; -} - -static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); -static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 0); -static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); -static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 1); -static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); -static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 2); -static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); -static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 3); -static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); -static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, - 0); -static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, - i8k_hwmon_set_pwm, 0); -static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, - 1); -static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, - 1); -static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, - i8k_hwmon_set_pwm, 1); - -static struct attribute *i8k_attrs[] = { - &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ - &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ - &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ - &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ - &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ - &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ - &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ - &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ - &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ - &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ - &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ - &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ - &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ - &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ - NULL -}; - -static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, - int index) -{ - if (index >= 0 && index <= 1 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) - return 0; - if (index >= 2 && index <= 3 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) - return 0; - if (index >= 4 && index <= 5 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) - return 0; - if (index >= 6 && index <= 7 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) - return 0; - if (index >= 8 && index <= 10 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) - return 0; - if (index >= 11 && index <= 13 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) - return 0; - - return attr->mode; -} - -static const struct attribute_group i8k_group = { - .attrs = i8k_attrs, - .is_visible = i8k_is_visible, -}; -__ATTRIBUTE_GROUPS(i8k); - -static int __init i8k_init_hwmon(void) -{ - int err; - - i8k_hwmon_flags = 0; - - /* CPU temperature attributes, if temperature type is OK */ - err = i8k_get_temp_type(0); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; - /* check for additional temperature sensors */ - err = i8k_get_temp_type(1); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; - err = i8k_get_temp_type(2); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; - err = i8k_get_temp_type(3); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; - - /* First fan attributes, if fan type is OK */ - err = i8k_get_fan_type(0); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; - - /* Second fan attributes, if fan type is OK */ - err = i8k_get_fan_type(1); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; - - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, - i8k_groups); - if (IS_ERR(i8k_hwmon_dev)) { - err = PTR_ERR(i8k_hwmon_dev); - i8k_hwmon_dev = NULL; - pr_err("hwmon registration failed (%d)\n", err); - return err; - } - return 0; -} - -struct i8k_config_data { - uint fan_mult; - uint fan_max; -}; - -enum i8k_configs { - DELL_LATITUDE_D520, - DELL_PRECISION_490, - DELL_STUDIO, - DELL_XPS, -}; - -static const struct i8k_config_data i8k_config_data[] = { - [DELL_LATITUDE_D520] = { - .fan_mult = 1, - .fan_max = I8K_FAN_TURBO, - }, - [DELL_PRECISION_490] = { - .fan_mult = 1, - .fan_max = I8K_FAN_TURBO, - }, - [DELL_STUDIO] = { - .fan_mult = 1, - .fan_max = I8K_FAN_HIGH, - }, - [DELL_XPS] = { - .fan_mult = 1, - .fan_max = I8K_FAN_HIGH, - }, -}; - -static struct dmi_system_id i8k_dmi_table[] __initdata = { - { - .ident = "Dell Inspiron", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), - }, - }, - { - .ident = "Dell Latitude", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), - }, - }, - { - .ident = "Dell Inspiron 2", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), - }, - }, - { - .ident = "Dell Latitude D520", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), - }, - .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], - }, - { - .ident = "Dell Latitude 2", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), - }, - }, - { /* UK Inspiron 6400 */ - .ident = "Dell Inspiron 3", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), - }, - }, - { - .ident = "Dell Inspiron 3", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), - }, - }, - { - .ident = "Dell Precision 490", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, - "Precision WorkStation 490"), - }, - .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], - }, - { - .ident = "Dell Precision", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), - }, - }, - { - .ident = "Dell Vostro", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), - }, - }, - { - .ident = "Dell XPS421", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), - }, - }, - { - .ident = "Dell Studio", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), - }, - .driver_data = (void *)&i8k_config_data[DELL_STUDIO], - }, - { - .ident = "Dell XPS 13", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), - }, - .driver_data = (void *)&i8k_config_data[DELL_XPS], - }, - { - .ident = "Dell XPS M140", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), - }, - .driver_data = (void *)&i8k_config_data[DELL_XPS], - }, - { } -}; - -MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); - -/* - * Probe for the presence of a supported laptop. - */ -static int __init i8k_probe(void) -{ - const struct dmi_system_id *id; - int fan, ret; - - /* - * Get DMI information - */ - if (!dmi_check_system(i8k_dmi_table)) { - if (!ignore_dmi && !force) - return -ENODEV; - - pr_info("not running on a supported Dell system.\n"); - pr_info("vendor=%s, model=%s, version=%s\n", - i8k_get_dmi_data(DMI_SYS_VENDOR), - i8k_get_dmi_data(DMI_PRODUCT_NAME), - i8k_get_dmi_data(DMI_BIOS_VERSION)); - } - - strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), - sizeof(bios_version)); - - /* - * Get SMM Dell signature - */ - if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && - i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { - pr_err("unable to get SMM Dell signature\n"); - if (!force) - return -ENODEV; - } - - /* - * Set fan multiplier and maximal fan speed from dmi config - * Values specified in module parameters override values from dmi - */ - id = dmi_first_match(i8k_dmi_table); - if (id && id->driver_data) { - const struct i8k_config_data *conf = id->driver_data; - if (!fan_mult && conf->fan_mult) - fan_mult = conf->fan_mult; - if (!fan_max && conf->fan_max) - fan_max = conf->fan_max; - } - - i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ - i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); - - if (!fan_mult) { - /* - * Autodetect fan multiplier based on nominal rpm - * If fan reports rpm value too high then set multiplier to 1 - */ - for (fan = 0; fan < 2; ++fan) { - ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); - if (ret < 0) - continue; - if (ret > I8K_FAN_MAX_RPM) - i8k_fan_mult = 1; - break; - } - } else { - /* Fan multiplier was specified in module param or in dmi */ - i8k_fan_mult = fan_mult; - } - - return 0; -} - -static int __init i8k_init(void) -{ - struct proc_dir_entry *proc_i8k; - int err; - - /* Are we running on an supported laptop? */ - if (i8k_probe()) - return -ENODEV; - - /* Register the proc entry */ - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); - if (!proc_i8k) - return -ENOENT; - - err = i8k_init_hwmon(); - if (err) - goto exit_remove_proc; - - return 0; - - exit_remove_proc: - remove_proc_entry("i8k", NULL); - return err; -} - -static void __exit i8k_exit(void) -{ - hwmon_device_unregister(i8k_hwmon_dev); - remove_proc_entry("i8k", NULL); -} - -module_init(i8k_init); -module_exit(i8k_exit); diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 6c94147..1c3e458 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -155,6 +155,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o +obj-$(CONFIG_I8K) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c new file mode 100644 index 0000000..2b04e4f --- /dev/null +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -0,0 +1,1007 @@ +/* + * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops. + * + * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> + * + * Hwmon integration: + * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> + * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> + * Copyright (C) 2014, 2015 Pali Rohár <pali.rohar@gmail.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, 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. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/delay.h> +#include <linux/module.h> +#include <linux/types.h> +#include <linux/init.h> +#include <linux/proc_fs.h> +#include <linux/seq_file.h> +#include <linux/dmi.h> +#include <linux/capability.h> +#include <linux/mutex.h> +#include <linux/hwmon.h> +#include <linux/hwmon-sysfs.h> +#include <linux/uaccess.h> +#include <linux/io.h> +#include <linux/sched.h> + +#include <linux/i8k.h> + +#define I8K_SMM_FN_STATUS 0x0025 +#define I8K_SMM_POWER_STATUS 0x0069 +#define I8K_SMM_SET_FAN 0x01a3 +#define I8K_SMM_GET_FAN 0x00a3 +#define I8K_SMM_GET_SPEED 0x02a3 +#define I8K_SMM_GET_FAN_TYPE 0x03a3 +#define I8K_SMM_GET_NOM_SPEED 0x04a3 +#define I8K_SMM_GET_TEMP 0x10a3 +#define I8K_SMM_GET_TEMP_TYPE 0x11a3 +#define I8K_SMM_GET_DELL_SIG1 0xfea3 +#define I8K_SMM_GET_DELL_SIG2 0xffa3 + +#define I8K_FAN_MULT 30 +#define I8K_FAN_MAX_RPM 30000 +#define I8K_MAX_TEMP 127 + +#define I8K_FN_NONE 0x00 +#define I8K_FN_UP 0x01 +#define I8K_FN_DOWN 0x02 +#define I8K_FN_MUTE 0x04 +#define I8K_FN_MASK 0x07 +#define I8K_FN_SHIFT 8 + +#define I8K_POWER_AC 0x05 +#define I8K_POWER_BATTERY 0x01 + +static DEFINE_MUTEX(i8k_mutex); +static char bios_version[4]; +static struct device *i8k_hwmon_dev; +static u32 i8k_hwmon_flags; +static uint i8k_fan_mult = I8K_FAN_MULT; +static uint i8k_pwm_mult; +static uint i8k_fan_max = I8K_FAN_HIGH; + +#define I8K_HWMON_HAVE_TEMP1 (1 << 0) +#define I8K_HWMON_HAVE_TEMP2 (1 << 1) +#define I8K_HWMON_HAVE_TEMP3 (1 << 2) +#define I8K_HWMON_HAVE_TEMP4 (1 << 3) +#define I8K_HWMON_HAVE_FAN1 (1 << 4) +#define I8K_HWMON_HAVE_FAN2 (1 << 5) + +MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); +MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); +MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("i8k"); + +static bool force; +module_param(force, bool, 0); +MODULE_PARM_DESC(force, "Force loading without checking for supported models"); + +static bool ignore_dmi; +module_param(ignore_dmi, bool, 0); +MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); + +static bool restricted; +module_param(restricted, bool, 0); +MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); + +static bool power_status; +module_param(power_status, bool, 0600); +MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); + +static uint fan_mult; +module_param(fan_mult, uint, 0); +MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); + +static uint fan_max; +module_param(fan_max, uint, 0); +MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); + +static int i8k_open_fs(struct inode *inode, struct file *file); +static long i8k_ioctl(struct file *, unsigned int, unsigned long); + +static const struct file_operations i8k_fops = { + .owner = THIS_MODULE, + .open = i8k_open_fs, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .unlocked_ioctl = i8k_ioctl, +}; + +struct smm_regs { + unsigned int eax; + unsigned int ebx __packed; + unsigned int ecx __packed; + unsigned int edx __packed; + unsigned int esi __packed; + unsigned int edi __packed; +}; + +static inline const char *i8k_get_dmi_data(int field) +{ + const char *dmi_data = dmi_get_system_info(field); + + return dmi_data && *dmi_data ? dmi_data : "?"; +} + +/* + * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. + */ +static int i8k_smm(struct smm_regs *regs) +{ + int rc; + int eax = regs->eax; + cpumask_var_t old_mask; + + /* SMM requires CPU 0 */ + if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) + return -ENOMEM; + cpumask_copy(old_mask, ¤t->cpus_allowed); + rc = set_cpus_allowed_ptr(current, cpumask_of(0)); + if (rc) + goto out; + if (smp_processor_id() != 0) { + rc = -EBUSY; + goto out; + } + +#if defined(CONFIG_X86_64) + asm volatile("pushq %%rax\n\t" + "movl 0(%%rax),%%edx\n\t" + "pushq %%rdx\n\t" + "movl 4(%%rax),%%ebx\n\t" + "movl 8(%%rax),%%ecx\n\t" + "movl 12(%%rax),%%edx\n\t" + "movl 16(%%rax),%%esi\n\t" + "movl 20(%%rax),%%edi\n\t" + "popq %%rax\n\t" + "out %%al,$0xb2\n\t" + "out %%al,$0x84\n\t" + "xchgq %%rax,(%%rsp)\n\t" + "movl %%ebx,4(%%rax)\n\t" + "movl %%ecx,8(%%rax)\n\t" + "movl %%edx,12(%%rax)\n\t" + "movl %%esi,16(%%rax)\n\t" + "movl %%edi,20(%%rax)\n\t" + "popq %%rdx\n\t" + "movl %%edx,0(%%rax)\n\t" + "pushfq\n\t" + "popq %%rax\n\t" + "andl $1,%%eax\n" + : "=a"(rc) + : "a"(regs) + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); +#else + asm volatile("pushl %%eax\n\t" + "movl 0(%%eax),%%edx\n\t" + "push %%edx\n\t" + "movl 4(%%eax),%%ebx\n\t" + "movl 8(%%eax),%%ecx\n\t" + "movl 12(%%eax),%%edx\n\t" + "movl 16(%%eax),%%esi\n\t" + "movl 20(%%eax),%%edi\n\t" + "popl %%eax\n\t" + "out %%al,$0xb2\n\t" + "out %%al,$0x84\n\t" + "xchgl %%eax,(%%esp)\n\t" + "movl %%ebx,4(%%eax)\n\t" + "movl %%ecx,8(%%eax)\n\t" + "movl %%edx,12(%%eax)\n\t" + "movl %%esi,16(%%eax)\n\t" + "movl %%edi,20(%%eax)\n\t" + "popl %%edx\n\t" + "movl %%edx,0(%%eax)\n\t" + "lahf\n\t" + "shrl $8,%%eax\n\t" + "andl $1,%%eax\n" + : "=a"(rc) + : "a"(regs) + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); +#endif + if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) + rc = -EINVAL; + +out: + set_cpus_allowed_ptr(current, old_mask); + free_cpumask_var(old_mask); + return rc; +} + +/* + * Read the Fn key status. + */ +static int i8k_get_fn_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { + case I8K_FN_UP: + return I8K_VOL_UP; + case I8K_FN_DOWN: + return I8K_VOL_DOWN; + case I8K_FN_MUTE: + return I8K_VOL_MUTE; + default: + return 0; + } +} + +/* + * Read the power status. + */ +static int i8k_get_power_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; +} + +/* + * Read the fan status. + */ +static int i8k_get_fan_status(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the fan speed in RPM. + */ +static int i8k_get_fan_speed(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; +} + +/* + * Read the fan type. + */ +static int i8k_get_fan_type(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the fan nominal rpm for specific fan speed. + */ +static int i8k_get_fan_nominal_speed(int fan, int speed) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; + + regs.ebx = (fan & 0xff) | (speed << 8); + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; +} + +/* + * Set the fan speed (off, low, high). Returns the new fan status. + */ +static int i8k_set_fan(int fan, int speed) +{ + struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; + + speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); + regs.ebx = (fan & 0xff) | (speed << 8); + + return i8k_smm(®s) ? : i8k_get_fan_status(fan); +} + +static int i8k_get_temp_type(int sensor) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; + + regs.ebx = sensor & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the cpu temperature. + */ +static int _i8k_get_temp(int sensor) +{ + struct smm_regs regs = { + .eax = I8K_SMM_GET_TEMP, + .ebx = sensor & 0xff, + }; + + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +static int i8k_get_temp(int sensor) +{ + int temp = _i8k_get_temp(sensor); + + /* + * Sometimes the temperature sensor returns 0x99, which is out of range. + * In this case we retry (once) before returning an error. + # 1003655137 00000058 00005a4b + # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees + # 1003655139 00000054 00005c52 + */ + if (temp == 0x99) { + msleep(100); + temp = _i8k_get_temp(sensor); + } + /* + * Return -ENODATA for all invalid temperatures. + * + * Known instances are the 0x99 value as seen above as well as + * 0xc1 (193), which may be returned when trying to read the GPU + * temperature if the system supports a GPU and it is currently + * turned off. + */ + if (temp > I8K_MAX_TEMP) + return -ENODATA; + + return temp; +} + +static int i8k_get_dell_signature(int req_fn) +{ + struct smm_regs regs = { .eax = req_fn, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; +} + +static int +i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) +{ + int val = 0; + int speed; + unsigned char buff[16]; + int __user *argp = (int __user *)arg; + + if (!argp) + return -EINVAL; + + switch (cmd) { + case I8K_BIOS_VERSION: + val = (bios_version[0] << 16) | + (bios_version[1] << 8) | bios_version[2]; + break; + + case I8K_MACHINE_ID: + memset(buff, 0, 16); + strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + sizeof(buff)); + break; + + case I8K_FN_STATUS: + val = i8k_get_fn_status(); + break; + + case I8K_POWER_STATUS: + val = i8k_get_power_status(); + break; + + case I8K_GET_TEMP: + val = i8k_get_temp(0); + break; + + case I8K_GET_SPEED: + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + val = i8k_get_fan_speed(val); + break; + + case I8K_GET_FAN: + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + val = i8k_get_fan_status(val); + break; + + case I8K_SET_FAN: + if (restricted && !capable(CAP_SYS_ADMIN)) + return -EPERM; + + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + if (copy_from_user(&speed, argp + 1, sizeof(int))) + return -EFAULT; + + val = i8k_set_fan(val, speed); + break; + + default: + return -EINVAL; + } + + if (val < 0) + return val; + + switch (cmd) { + case I8K_BIOS_VERSION: + if (copy_to_user(argp, &val, 4)) + return -EFAULT; + + break; + case I8K_MACHINE_ID: + if (copy_to_user(argp, buff, 16)) + return -EFAULT; + + break; + default: + if (copy_to_user(argp, &val, sizeof(int))) + return -EFAULT; + + break; + } + + return 0; +} + +static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) +{ + long ret; + + mutex_lock(&i8k_mutex); + ret = i8k_ioctl_unlocked(fp, cmd, arg); + mutex_unlock(&i8k_mutex); + + return ret; +} + +/* + * Print the information for /proc/i8k. + */ +static int i8k_proc_show(struct seq_file *seq, void *offset) +{ + int fn_key, cpu_temp, ac_power; + int left_fan, right_fan, left_speed, right_speed; + + cpu_temp = i8k_get_temp(0); /* 11100 µs */ + left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ + right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ + left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ + right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ + fn_key = i8k_get_fn_status(); /* 750 µs */ + if (power_status) + ac_power = i8k_get_power_status(); /* 14700 µs */ + else + ac_power = -1; + + /* + * Info: + * + * 1) Format version (this will change if format changes) + * 2) BIOS version + * 3) BIOS machine ID + * 4) Cpu temperature + * 5) Left fan status + * 6) Right fan status + * 7) Left fan speed + * 8) Right fan speed + * 9) AC power + * 10) Fn Key status + */ + return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", + I8K_PROC_FMT, + bios_version, + i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + cpu_temp, + left_fan, right_fan, left_speed, right_speed, + ac_power, fn_key); +} + +static int i8k_open_fs(struct inode *inode, struct file *file) +{ + return single_open(file, i8k_proc_show, NULL); +} + + +/* + * Hwmon interface + */ + +static ssize_t i8k_hwmon_show_temp_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + static const char * const labels[] = { + "CPU", + "GPU", + "SODIMM", + "Other", + "Ambient", + "Other", + }; + int index = to_sensor_dev_attr(devattr)->index; + int type; + + type = i8k_get_temp_type(index); + if (type < 0) + return type; + if (type >= ARRAY_SIZE(labels)) + type = ARRAY_SIZE(labels) - 1; + return sprintf(buf, "%s\n", labels[type]); +} + +static ssize_t i8k_hwmon_show_temp(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int temp; + + temp = i8k_get_temp(index); + if (temp < 0) + return temp; + return sprintf(buf, "%d\n", temp * 1000); +} + +static ssize_t i8k_hwmon_show_fan_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + static const char * const labels[] = { + "Processor Fan", + "Motherboard Fan", + "Video Fan", + "Power Supply Fan", + "Chipset Fan", + "Other Fan", + }; + int index = to_sensor_dev_attr(devattr)->index; + bool dock = false; + int type; + + type = i8k_get_fan_type(index); + if (type < 0) + return type; + + if (type & 0x10) { + dock = true; + type &= 0x0F; + } + + if (type >= ARRAY_SIZE(labels)) + type = (ARRAY_SIZE(labels) - 1); + + return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); +} + +static ssize_t i8k_hwmon_show_fan(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int fan_speed; + + fan_speed = i8k_get_fan_speed(index); + if (fan_speed < 0) + return fan_speed; + return sprintf(buf, "%d\n", fan_speed); +} + +static ssize_t i8k_hwmon_show_pwm(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int status; + + status = i8k_get_fan_status(index); + if (status < 0) + return -EIO; + return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); +} + +static ssize_t i8k_hwmon_set_pwm(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int index = to_sensor_dev_attr(attr)->index; + unsigned long val; + int err; + + err = kstrtoul(buf, 10, &val); + if (err) + return err; + val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); + + mutex_lock(&i8k_mutex); + err = i8k_set_fan(index, val); + mutex_unlock(&i8k_mutex); + + return err < 0 ? -EIO : count; +} + +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 0); +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); +static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 1); +static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); +static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 2); +static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); +static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 3); +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); +static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, + 0); +static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, + i8k_hwmon_set_pwm, 0); +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, + 1); +static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, + 1); +static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, + i8k_hwmon_set_pwm, 1); + +static struct attribute *i8k_attrs[] = { + &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ + &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ + &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ + &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ + &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ + &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ + &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ + &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ + &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ + &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ + &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ + &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ + &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ + &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ + NULL +}; + +static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, + int index) +{ + if (index >= 0 && index <= 1 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) + return 0; + if (index >= 2 && index <= 3 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) + return 0; + if (index >= 4 && index <= 5 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) + return 0; + if (index >= 6 && index <= 7 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) + return 0; + if (index >= 8 && index <= 10 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) + return 0; + if (index >= 11 && index <= 13 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) + return 0; + + return attr->mode; +} + +static const struct attribute_group i8k_group = { + .attrs = i8k_attrs, + .is_visible = i8k_is_visible, +}; +__ATTRIBUTE_GROUPS(i8k); + +static int __init i8k_init_hwmon(void) +{ + int err; + + i8k_hwmon_flags = 0; + + /* CPU temperature attributes, if temperature type is OK */ + err = i8k_get_temp_type(0); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; + /* check for additional temperature sensors */ + err = i8k_get_temp_type(1); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; + err = i8k_get_temp_type(2); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; + err = i8k_get_temp_type(3); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; + + /* First fan attributes, if fan type is OK */ + err = i8k_get_fan_type(0); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; + + /* Second fan attributes, if fan type is OK */ + err = i8k_get_fan_type(1); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; + + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, + i8k_groups); + if (IS_ERR(i8k_hwmon_dev)) { + err = PTR_ERR(i8k_hwmon_dev); + i8k_hwmon_dev = NULL; + pr_err("hwmon registration failed (%d)\n", err); + return err; + } + return 0; +} + +struct i8k_config_data { + uint fan_mult; + uint fan_max; +}; + +enum i8k_configs { + DELL_LATITUDE_D520, + DELL_PRECISION_490, + DELL_STUDIO, + DELL_XPS, +}; + +static const struct i8k_config_data i8k_config_data[] = { + [DELL_LATITUDE_D520] = { + .fan_mult = 1, + .fan_max = I8K_FAN_TURBO, + }, + [DELL_PRECISION_490] = { + .fan_mult = 1, + .fan_max = I8K_FAN_TURBO, + }, + [DELL_STUDIO] = { + .fan_mult = 1, + .fan_max = I8K_FAN_HIGH, + }, + [DELL_XPS] = { + .fan_mult = 1, + .fan_max = I8K_FAN_HIGH, + }, +}; + +static struct dmi_system_id i8k_dmi_table[] __initdata = { + { + .ident = "Dell Inspiron", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), + }, + }, + { + .ident = "Dell Latitude", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), + }, + }, + { + .ident = "Dell Inspiron 2", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), + }, + }, + { + .ident = "Dell Latitude D520", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), + }, + .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], + }, + { + .ident = "Dell Latitude 2", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), + }, + }, + { /* UK Inspiron 6400 */ + .ident = "Dell Inspiron 3", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), + }, + }, + { + .ident = "Dell Inspiron 3", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), + }, + }, + { + .ident = "Dell Precision 490", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, + "Precision WorkStation 490"), + }, + .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], + }, + { + .ident = "Dell Precision", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), + }, + }, + { + .ident = "Dell Vostro", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), + }, + }, + { + .ident = "Dell XPS421", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), + }, + }, + { + .ident = "Dell Studio", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), + }, + .driver_data = (void *)&i8k_config_data[DELL_STUDIO], + }, + { + .ident = "Dell XPS 13", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), + }, + .driver_data = (void *)&i8k_config_data[DELL_XPS], + }, + { + .ident = "Dell XPS M140", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), + }, + .driver_data = (void *)&i8k_config_data[DELL_XPS], + }, + { } +}; + +MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); + +/* + * Probe for the presence of a supported laptop. + */ +static int __init i8k_probe(void) +{ + const struct dmi_system_id *id; + int fan, ret; + + /* + * Get DMI information + */ + if (!dmi_check_system(i8k_dmi_table)) { + if (!ignore_dmi && !force) + return -ENODEV; + + pr_info("not running on a supported Dell system.\n"); + pr_info("vendor=%s, model=%s, version=%s\n", + i8k_get_dmi_data(DMI_SYS_VENDOR), + i8k_get_dmi_data(DMI_PRODUCT_NAME), + i8k_get_dmi_data(DMI_BIOS_VERSION)); + } + + strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), + sizeof(bios_version)); + + /* + * Get SMM Dell signature + */ + if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && + i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { + pr_err("unable to get SMM Dell signature\n"); + if (!force) + return -ENODEV; + } + + /* + * Set fan multiplier and maximal fan speed from dmi config + * Values specified in module parameters override values from dmi + */ + id = dmi_first_match(i8k_dmi_table); + if (id && id->driver_data) { + const struct i8k_config_data *conf = id->driver_data; + if (!fan_mult && conf->fan_mult) + fan_mult = conf->fan_mult; + if (!fan_max && conf->fan_max) + fan_max = conf->fan_max; + } + + i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ + i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); + + if (!fan_mult) { + /* + * Autodetect fan multiplier based on nominal rpm + * If fan reports rpm value too high then set multiplier to 1 + */ + for (fan = 0; fan < 2; ++fan) { + ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); + if (ret < 0) + continue; + if (ret > I8K_FAN_MAX_RPM) + i8k_fan_mult = 1; + break; + } + } else { + /* Fan multiplier was specified in module param or in dmi */ + i8k_fan_mult = fan_mult; + } + + return 0; +} + +static int __init i8k_init(void) +{ + struct proc_dir_entry *proc_i8k; + int err; + + /* Are we running on an supported laptop? */ + if (i8k_probe()) + return -ENODEV; + + /* Register the proc entry */ + proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); + if (!proc_i8k) + return -ENOENT; + + err = i8k_init_hwmon(); + if (err) + goto exit_remove_proc; + + return 0; + + exit_remove_proc: + remove_proc_entry("i8k", NULL); + return err; +} + +static void __exit i8k_exit(void) +{ + hwmon_device_unregister(i8k_hwmon_dev); + remove_proc_entry("i8k", NULL); +} + +module_init(i8k_init); +module_exit(i8k_exit); -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree 2015-03-28 10:24 ` Pali Rohár @ 2015-03-28 14:31 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 14:31 UTC (permalink / raw) To: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMDMvMjgvMjAxNSAwMzoyNCBBTSwgUGFsaSBSb2jDoXIgd3JvdGU6Cj4gVGhpcyBjb21taXQg bW92ZXMgaThrIGRyaXZlciB0byBod21vbiB0cmVlIHVuZGVyIG5hbWUgZGVsbC1zbW0taHdtb24g d2hpY2ggaXMKPiBiZXR0ZXIgbmFtZSB0aGVuIGFiYnJldmlhdGlvbiBpOGsuIEZvciBiYWNrd2Fy ZCBjb21wYXRpYmlsaXR5IGlzIGFkZGVkIG1hY3JvCj4gTU9EVUxFX0FMSUFTKCJpOGsiKSBzbyBt b2Rwcm9iZSB3aWxsIGxvYWQgZHJpdmVyIGFsc28gb2xkIG5hbWUgaThrLiBDT05GSUdfSThLCj4g Y29tcGlsZSBvcHRpb24gd2FzIG5vdCBjaGFuZ2VkLgo+Cj4gVGhpcyBjb21taXQgYWxzbyBhZGRz IG1lIGFzIG1haW50YWluZXIgb2YgdGhpcyBuZXcgZGVsbC1zbW0taHdtb24gZHJpdmVyLgo+Cj4g U2lnbmVkLW9mZi1ieTogUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPgoKTG9va3Mg b2sgdG8gbWUsIHNvIEknbGwgYmUgaGFwcHkgdG8gdGFrZSBpdCBmb3IgNC4xIGlmIEdyZWcgYWdy ZWVzLgoKSSB0aG91Z2h0IGFib3V0IG1vdmluZyB0aGUgSThLIGNvbmZpZ3VyYXRpb24gb3B0aW9u IGFzIHdlbGwuIE5vdCByZWFsbHkgc3VyZQp3aGF0IHRvIGRvIHRoZXJlLiBHcmVnLCBhbnkgb3Bp bmlvbiA/Ckl0IHdvdWxkIGhhdmUgdG8gcmVzaWRlIG91dHNpZGUgdGhlIEhXTU9OIGJsb2NrIG9m IGRyaXZlcnMvaHdtb24vS2NvbmZpZyBpZgp3ZSBtb3ZlIGl0LgoKV2UgYWxzbyBjYW4gZHJvcCBt ZSBhcyBleHBsaWNpdCBtYWludGFpbmVyIC0gSSBhbSBvbiB0aGUgaG9vayBmcm9tIHRoZSBod21v biBzaWRlCmFueXdheSwgYW5kIHdlIGRvbid0IG5lZWQgdG8gc3RlcCBvbiBlYWNoIG90aGVyJ3Mg Zm9vdCBmb3IgdGhpcyBkcml2ZXIuCgpUaGFua3MsCkd1ZW50ZXIKCj4gLS0tCj4gICBNQUlOVEFJ TkVSUyAgICAgICAgICAgICAgICAgICAgfCAgICAzICstCj4gICBkcml2ZXJzL2NoYXIvTWFrZWZp bGUgICAgICAgICAgfCAgICAxIC0KPiAgIGRyaXZlcnMvY2hhci9pOGsuYyAgICAgICAgICAgICB8 IDEwMDUgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gICBkcml2ZXJz L2h3bW9uL01ha2VmaWxlICAgICAgICAgfCAgICAxICsKPiAgIGRyaXZlcnMvaHdtb24vZGVsbC1z bW0taHdtb24uYyB8IDEwMDcgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Kwo+ICAgNSBmaWxlcyBjaGFuZ2VkLCAxMDEwIGluc2VydGlvbnMoKyksIDEwMDcgZGVsZXRpb25z KC0pCj4gICBkZWxldGUgbW9kZSAxMDA2NDQgZHJpdmVycy9jaGFyL2k4ay5jCj4gICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jCj4KPiBkaWZmIC0tZ2l0 IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwo+IGluZGV4IDg4YzA5Y2EuLmJmNWJiMDUgMTAw NjQ0Cj4gLS0tIGEvTUFJTlRBSU5FUlMKPiArKysgYi9NQUlOVEFJTkVSUwo+IEBAIC0zMDY0LDgg KzMwNjQsOSBAQCBGOglkcml2ZXJzL3BsYXRmb3JtL3g4Ni9kZWxsLWxhcHRvcC5jCj4KPiAgIERF TEwgTEFQVE9QIFNNTSBEUklWRVIKPiAgIE06CUd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVz Lm5ldD4KPiArTToJUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPgo+ICAgUzoJTWFp bnRhaW5lZAo+IC1GOglkcml2ZXJzL2NoYXIvaThrLmMKPiArRjoJZHJpdmVycy9od21vbi9kZWxs LXNtbS1od21vbi5jCj4gICBGOglpbmNsdWRlL3VhcGkvbGludXgvaThrLmgKPgo+ICAgREVMTCBT WVNURU1TIE1BTkFHRU1FTlQgQkFTRSBEUklWRVIgKGRjZGJhcykKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9jaGFyL01ha2VmaWxlIGIvZHJpdmVycy9jaGFyL01ha2VmaWxlCj4gaW5kZXggZDA2Y2Rl MjYuLjFkOWNmMDAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9jaGFyL01ha2VmaWxlCj4gKysrIGIv ZHJpdmVycy9jaGFyL01ha2VmaWxlCj4gQEAgLTM2LDcgKzM2LDYgQEAgZWxzZQo+ICAgICBvYmot JChDT05GSUdfTlZSQU0pCSs9IG52cmFtLm8KPiAgIGVuZGlmCj4gICBvYmotJChDT05GSUdfVE9T SElCQSkJCSs9IHRvc2hpYmEubwo+IC1vYmotJChDT05GSUdfSThLKQkJKz0gaThrLm8KPiAgIG9i ai0kKENPTkZJR19EUzE2MjApCQkrPSBkczE2MjAubwo+ICAgb2JqLSQoQ09ORklHX0hXX1JBTkRP TSkJCSs9IGh3X3JhbmRvbS8KPiAgIG9iai0kKENPTkZJR19QUERFVikJCSs9IHBwZGV2Lm8KPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2k4ay5jIGIvZHJpdmVycy9jaGFyL2k4ay5jCj4gZGVs ZXRlZCBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMjRjYzRlZC4uMDAwMDAwMAo+IC0tLSBhL2Ry aXZlcnMvY2hhci9pOGsuYwo+ICsrKyAvZGV2L251bGwKPiBAQCAtMSwxMDA1ICswLDAgQEAKPiAt LyoKPiAtICogaThrLmMgLS0gTGludXggZHJpdmVyIGZvciBhY2Nlc3NpbmcgdGhlIFNNTSBCSU9T IG9uIERlbGwgbGFwdG9wcy4KPiAtICoKPiAtICogQ29weXJpZ2h0IChDKSAyMDAxICBNYXNzaW1v IERhbCBab3R0byA8ZHpAZGViaWFuLm9yZz4KPiAtICoKPiAtICogSHdtb24gaW50ZWdyYXRpb246 Cj4gLSAqIENvcHlyaWdodCAoQykgMjAxMSAgSmVhbiBEZWx2YXJlIDxqZGVsdmFyZUBzdXNlLmRl Pgo+IC0gKiBDb3B5cmlnaHQgKEMpIDIwMTMsIDIwMTQgIEd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJv ZWNrLXVzLm5ldD4KPiAtICogQ29weXJpZ2h0IChDKSAyMDE0ICBQYWxpIFJvaMOhciA8cGFsaS5y b2hhckBnbWFpbC5jb20+Cj4gLSAqCj4gLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0Cj4gLSAqIHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZQo+IC0gKiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55Cj4gLSAqIGxhdGVyIHZlcnNpb24uCj4gLSAqCj4gLSAqIFRo aXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLCBidXQKPiAtICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgo+IC0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQo+IC0gKiBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCj4gLSAqLwo+IC0KPiAtI2RlZmluZSBwcl9mbXQoZm10KSBL QlVJTERfTU9ETkFNRSAiOiAiIGZtdAo+IC0KPiAtI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Cj4g LSNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiAtI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+Cj4g LSNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Cj4gLSNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+Cj4g LSNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgo+IC0jaW5jbHVkZSA8bGludXgvZG1pLmg+Cj4g LSNpbmNsdWRlIDxsaW51eC9jYXBhYmlsaXR5Lmg+Cj4gLSNpbmNsdWRlIDxsaW51eC9tdXRleC5o Pgo+IC0jaW5jbHVkZSA8bGludXgvaHdtb24uaD4KPiAtI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5 c2ZzLmg+Cj4gLSNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+Cj4gLSNpbmNsdWRlIDxsaW51eC9p by5oPgo+IC0jaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KPiAtCj4gLSNpbmNsdWRlIDxsaW51eC9p OGsuaD4KPiAtCj4gLSNkZWZpbmUgSThLX1NNTV9GTl9TVEFUVVMJMHgwMDI1Cj4gLSNkZWZpbmUg SThLX1NNTV9QT1dFUl9TVEFUVVMJMHgwMDY5Cj4gLSNkZWZpbmUgSThLX1NNTV9TRVRfRkFOCQkw eDAxYTMKPiAtI2RlZmluZSBJOEtfU01NX0dFVF9GQU4JCTB4MDBhMwo+IC0jZGVmaW5lIEk4S19T TU1fR0VUX1NQRUVECTB4MDJhMwo+IC0jZGVmaW5lIEk4S19TTU1fR0VUX0ZBTl9UWVBFCTB4MDNh Mwo+IC0jZGVmaW5lIEk4S19TTU1fR0VUX05PTV9TUEVFRAkweDA0YTMKPiAtI2RlZmluZSBJOEtf U01NX0dFVF9URU1QCTB4MTBhMwo+IC0jZGVmaW5lIEk4S19TTU1fR0VUX1RFTVBfVFlQRQkweDEx YTMKPiAtI2RlZmluZSBJOEtfU01NX0dFVF9ERUxMX1NJRzEJMHhmZWEzCj4gLSNkZWZpbmUgSThL X1NNTV9HRVRfREVMTF9TSUcyCTB4ZmZhMwo+IC0KPiAtI2RlZmluZSBJOEtfRkFOX01VTFQJCTMw Cj4gLSNkZWZpbmUgSThLX0ZBTl9NQVhfUlBNCQkzMDAwMAo+IC0jZGVmaW5lIEk4S19NQVhfVEVN UAkJMTI3Cj4gLQo+IC0jZGVmaW5lIEk4S19GTl9OT05FCQkweDAwCj4gLSNkZWZpbmUgSThLX0ZO X1VQCQkweDAxCj4gLSNkZWZpbmUgSThLX0ZOX0RPV04JCTB4MDIKPiAtI2RlZmluZSBJOEtfRk5f TVVURQkJMHgwNAo+IC0jZGVmaW5lIEk4S19GTl9NQVNLCQkweDA3Cj4gLSNkZWZpbmUgSThLX0ZO X1NISUZUCQk4Cj4gLQo+IC0jZGVmaW5lIEk4S19QT1dFUl9BQwkJMHgwNQo+IC0jZGVmaW5lIEk4 S19QT1dFUl9CQVRURVJZCTB4MDEKPiAtCj4gLXN0YXRpYyBERUZJTkVfTVVURVgoaThrX211dGV4 KTsKPiAtc3RhdGljIGNoYXIgYmlvc192ZXJzaW9uWzRdOwo+IC1zdGF0aWMgc3RydWN0IGRldmlj ZSAqaThrX2h3bW9uX2RldjsKPiAtc3RhdGljIHUzMiBpOGtfaHdtb25fZmxhZ3M7Cj4gLXN0YXRp YyB1aW50IGk4a19mYW5fbXVsdCA9IEk4S19GQU5fTVVMVDsKPiAtc3RhdGljIHVpbnQgaThrX3B3 bV9tdWx0Owo+IC1zdGF0aWMgdWludCBpOGtfZmFuX21heCA9IEk4S19GQU5fSElHSDsKPiAtCj4g LSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDEJKDEgPDwgMCkKPiAtI2RlZmluZSBJOEtfSFdN T05fSEFWRV9URU1QMgkoMSA8PCAxKQo+IC0jZGVmaW5lIEk4S19IV01PTl9IQVZFX1RFTVAzCSgx IDw8IDIpCj4gLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDQJKDEgPDwgMykKPiAtI2RlZmlu ZSBJOEtfSFdNT05fSEFWRV9GQU4xCSgxIDw8IDQpCj4gLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVf RkFOMgkoMSA8PCA1KQo+IC0KPiAtTU9EVUxFX0FVVEhPUigiTWFzc2ltbyBEYWwgWm90dG8gKGR6 QGRlYmlhbi5vcmcpIik7Cj4gLU1PRFVMRV9ERVNDUklQVElPTigiRHJpdmVyIGZvciBhY2Nlc3Np bmcgU01NIEJJT1Mgb24gRGVsbCBsYXB0b3BzIik7Cj4gLU1PRFVMRV9MSUNFTlNFKCJHUEwiKTsK PiAtCj4gLXN0YXRpYyBib29sIGZvcmNlOwo+IC1tb2R1bGVfcGFyYW0oZm9yY2UsIGJvb2wsIDAp Owo+IC1NT0RVTEVfUEFSTV9ERVNDKGZvcmNlLCAiRm9yY2UgbG9hZGluZyB3aXRob3V0IGNoZWNr aW5nIGZvciBzdXBwb3J0ZWQgbW9kZWxzIik7Cj4gLQo+IC1zdGF0aWMgYm9vbCBpZ25vcmVfZG1p Owo+IC1tb2R1bGVfcGFyYW0oaWdub3JlX2RtaSwgYm9vbCwgMCk7Cj4gLU1PRFVMRV9QQVJNX0RF U0MoaWdub3JlX2RtaSwgIkNvbnRpbnVlIHByb2JpbmcgaGFyZHdhcmUgZXZlbiBpZiBETUkgZGF0 YSBkb2VzIG5vdCBtYXRjaCIpOwo+IC0KPiAtc3RhdGljIGJvb2wgcmVzdHJpY3RlZDsKPiAtbW9k dWxlX3BhcmFtKHJlc3RyaWN0ZWQsIGJvb2wsIDApOwo+IC1NT0RVTEVfUEFSTV9ERVNDKHJlc3Ry aWN0ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJpbGl0eSBzZXQiKTsK PiAtCj4gLXN0YXRpYyBib29sIHBvd2VyX3N0YXR1czsKPiAtbW9kdWxlX3BhcmFtKHBvd2VyX3N0 YXR1cywgYm9vbCwgMDYwMCk7Cj4gLU1PRFVMRV9QQVJNX0RFU0MocG93ZXJfc3RhdHVzLCAiUmVw b3J0IHBvd2VyIHN0YXR1cyBpbiAvcHJvYy9pOGsiKTsKPiAtCj4gLXN0YXRpYyB1aW50IGZhbl9t dWx0Owo+IC1tb2R1bGVfcGFyYW0oZmFuX211bHQsIHVpbnQsIDApOwo+IC1NT0RVTEVfUEFSTV9E RVNDKGZhbl9tdWx0LCAiRmFjdG9yIHRvIG11bHRpcGx5IGZhbiBzcGVlZCB3aXRoIChkZWZhdWx0 OiBhdXRvZGV0ZWN0KSIpOwo+IC0KPiAtc3RhdGljIHVpbnQgZmFuX21heDsKPiAtbW9kdWxlX3Bh cmFtKGZhbl9tYXgsIHVpbnQsIDApOwo+IC1NT0RVTEVfUEFSTV9ERVNDKGZhbl9tYXgsICJNYXhp bXVtIGNvbmZpZ3VyYWJsZSBmYW4gc3BlZWQgKGRlZmF1bHQ6IGF1dG9kZXRlY3QpIik7Cj4gLQo+ IC1zdGF0aWMgaW50IGk4a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxl ICpmaWxlKTsKPiAtc3RhdGljIGxvbmcgaThrX2lvY3RsKHN0cnVjdCBmaWxlICosIHVuc2lnbmVk IGludCwgdW5zaWduZWQgbG9uZyk7Cj4gLQo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3Bl cmF0aW9ucyBpOGtfZm9wcyA9IHsKPiAtCS5vd25lcgkJPSBUSElTX01PRFVMRSwKPiAtCS5vcGVu CQk9IGk4a19vcGVuX2ZzLAo+IC0JLnJlYWQJCT0gc2VxX3JlYWQsCj4gLQkubGxzZWVrCQk9IHNl cV9sc2VlaywKPiAtCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVhc2UsCj4gLQkudW5sb2NrZWRfaW9j dGwJPSBpOGtfaW9jdGwsCj4gLX07Cj4gLQo+IC1zdHJ1Y3Qgc21tX3JlZ3Mgewo+IC0JdW5zaWdu ZWQgaW50IGVheDsKPiAtCXVuc2lnbmVkIGludCBlYnggX19wYWNrZWQ7Cj4gLQl1bnNpZ25lZCBp bnQgZWN4IF9fcGFja2VkOwo+IC0JdW5zaWduZWQgaW50IGVkeCBfX3BhY2tlZDsKPiAtCXVuc2ln bmVkIGludCBlc2kgX19wYWNrZWQ7Cj4gLQl1bnNpZ25lZCBpbnQgZWRpIF9fcGFja2VkOwo+IC19 Owo+IC0KPiAtc3RhdGljIGlubGluZSBjb25zdCBjaGFyICppOGtfZ2V0X2RtaV9kYXRhKGludCBm aWVsZCkKPiAtewo+IC0JY29uc3QgY2hhciAqZG1pX2RhdGEgPSBkbWlfZ2V0X3N5c3RlbV9pbmZv KGZpZWxkKTsKPiAtCj4gLQlyZXR1cm4gZG1pX2RhdGEgJiYgKmRtaV9kYXRhID8gZG1pX2RhdGEg OiAiPyI7Cj4gLX0KPiAtCj4gLS8qCj4gLSAqIENhbGwgdGhlIFN5c3RlbSBNYW5hZ2VtZW50IE1v ZGUgQklPUy4gQ29kZSBwcm92aWRlZCBieSBKb25hdGhhbiBCdXp6YXJkLgo+IC0gKi8KPiAtc3Rh dGljIGludCBpOGtfc21tKHN0cnVjdCBzbW1fcmVncyAqcmVncykKPiAtewo+IC0JaW50IHJjOwo+ IC0JaW50IGVheCA9IHJlZ3MtPmVheDsKPiAtCWNwdW1hc2tfdmFyX3Qgb2xkX21hc2s7Cj4gLQo+ IC0JLyogU01NIHJlcXVpcmVzIENQVSAwICovCj4gLQlpZiAoIWFsbG9jX2NwdW1hc2tfdmFyKCZv bGRfbWFzaywgR0ZQX0tFUk5FTCkpCj4gLQkJcmV0dXJuIC1FTk9NRU07Cj4gLQljcHVtYXNrX2Nv cHkob2xkX21hc2ssICZjdXJyZW50LT5jcHVzX2FsbG93ZWQpOwo+IC0JcmMgPSBzZXRfY3B1c19h bGxvd2VkX3B0cihjdXJyZW50LCBjcHVtYXNrX29mKDApKTsKPiAtCWlmIChyYykKPiAtCQlnb3Rv IG91dDsKPiAtCWlmIChzbXBfcHJvY2Vzc29yX2lkKCkgIT0gMCkgewo+IC0JCXJjID0gLUVCVVNZ Owo+IC0JCWdvdG8gb3V0Owo+IC0JfQo+IC0KPiAtI2lmIGRlZmluZWQoQ09ORklHX1g4Nl82NCkK PiAtCWFzbSB2b2xhdGlsZSgicHVzaHEgJSVyYXhcblx0Igo+IC0JCSJtb3ZsIDAoJSVyYXgpLCUl ZWR4XG5cdCIKPiAtCQkicHVzaHEgJSVyZHhcblx0Igo+IC0JCSJtb3ZsIDQoJSVyYXgpLCUlZWJ4 XG5cdCIKPiAtCQkibW92bCA4KCUlcmF4KSwlJWVjeFxuXHQiCj4gLQkJIm1vdmwgMTIoJSVyYXgp LCUlZWR4XG5cdCIKPiAtCQkibW92bCAxNiglJXJheCksJSVlc2lcblx0Igo+IC0JCSJtb3ZsIDIw KCUlcmF4KSwlJWVkaVxuXHQiCj4gLQkJInBvcHEgJSVyYXhcblx0Igo+IC0JCSJvdXQgJSVhbCwk MHhiMlxuXHQiCj4gLQkJIm91dCAlJWFsLCQweDg0XG5cdCIKPiAtCQkieGNoZ3EgJSVyYXgsKCUl cnNwKVxuXHQiCj4gLQkJIm1vdmwgJSVlYngsNCglJXJheClcblx0Igo+IC0JCSJtb3ZsICUlZWN4 LDgoJSVyYXgpXG5cdCIKPiAtCQkibW92bCAlJWVkeCwxMiglJXJheClcblx0Igo+IC0JCSJtb3Zs ICUlZXNpLDE2KCUlcmF4KVxuXHQiCj4gLQkJIm1vdmwgJSVlZGksMjAoJSVyYXgpXG5cdCIKPiAt CQkicG9wcSAlJXJkeFxuXHQiCj4gLQkJIm1vdmwgJSVlZHgsMCglJXJheClcblx0Igo+IC0JCSJw dXNoZnFcblx0Igo+IC0JCSJwb3BxICUlcmF4XG5cdCIKPiAtCQkiYW5kbCAkMSwlJWVheFxuIgo+ IC0JCTogIj1hIihyYykKPiAtCQk6ICAgICJhIihyZWdzKQo+IC0JCTogICAgIiVlYngiLCAiJWVj eCIsICIlZWR4IiwgIiVlc2kiLCAiJWVkaSIsICJtZW1vcnkiKTsKPiAtI2Vsc2UKPiAtCWFzbSB2 b2xhdGlsZSgicHVzaGwgJSVlYXhcblx0Igo+IC0JICAgICJtb3ZsIDAoJSVlYXgpLCUlZWR4XG5c dCIKPiAtCSAgICAicHVzaCAlJWVkeFxuXHQiCj4gLQkgICAgIm1vdmwgNCglJWVheCksJSVlYnhc blx0Igo+IC0JICAgICJtb3ZsIDgoJSVlYXgpLCUlZWN4XG5cdCIKPiAtCSAgICAibW92bCAxMigl JWVheCksJSVlZHhcblx0Igo+IC0JICAgICJtb3ZsIDE2KCUlZWF4KSwlJWVzaVxuXHQiCj4gLQkg ICAgIm1vdmwgMjAoJSVlYXgpLCUlZWRpXG5cdCIKPiAtCSAgICAicG9wbCAlJWVheFxuXHQiCj4g LQkgICAgIm91dCAlJWFsLCQweGIyXG5cdCIKPiAtCSAgICAib3V0ICUlYWwsJDB4ODRcblx0Igo+ IC0JICAgICJ4Y2hnbCAlJWVheCwoJSVlc3ApXG5cdCIKPiAtCSAgICAibW92bCAlJWVieCw0KCUl ZWF4KVxuXHQiCj4gLQkgICAgIm1vdmwgJSVlY3gsOCglJWVheClcblx0Igo+IC0JICAgICJtb3Zs ICUlZWR4LDEyKCUlZWF4KVxuXHQiCj4gLQkgICAgIm1vdmwgJSVlc2ksMTYoJSVlYXgpXG5cdCIK PiAtCSAgICAibW92bCAlJWVkaSwyMCglJWVheClcblx0Igo+IC0JICAgICJwb3BsICUlZWR4XG5c dCIKPiAtCSAgICAibW92bCAlJWVkeCwwKCUlZWF4KVxuXHQiCj4gLQkgICAgImxhaGZcblx0Igo+ IC0JICAgICJzaHJsICQ4LCUlZWF4XG5cdCIKPiAtCSAgICAiYW5kbCAkMSwlJWVheFxuIgo+IC0J ICAgIDogIj1hIihyYykKPiAtCSAgICA6ICAgICJhIihyZWdzKQo+IC0JICAgIDogICAgIiVlYngi LCAiJWVjeCIsICIlZWR4IiwgIiVlc2kiLCAiJWVkaSIsICJtZW1vcnkiKTsKPiAtI2VuZGlmCj4g LQlpZiAocmMgIT0gMCB8fCAocmVncy0+ZWF4ICYgMHhmZmZmKSA9PSAweGZmZmYgfHwgcmVncy0+ ZWF4ID09IGVheCkKPiAtCQlyYyA9IC1FSU5WQUw7Cj4gLQo+IC1vdXQ6Cj4gLQlzZXRfY3B1c19h bGxvd2VkX3B0cihjdXJyZW50LCBvbGRfbWFzayk7Cj4gLQlmcmVlX2NwdW1hc2tfdmFyKG9sZF9t YXNrKTsKPiAtCXJldHVybiByYzsKPiAtfQo+IC0KPiAtLyoKPiAtICogUmVhZCB0aGUgRm4ga2V5 IHN0YXR1cy4KPiAtICovCj4gLXN0YXRpYyBpbnQgaThrX2dldF9mbl9zdGF0dXModm9pZCkKPiAt ewo+IC0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0ZOX1NUQVRVUywg fTsKPiAtCWludCByYzsKPiAtCj4gLQlyYyA9IGk4a19zbW0oJnJlZ3MpOwo+IC0JaWYgKHJjIDwg MCkKPiAtCQlyZXR1cm4gcmM7Cj4gLQo+IC0Jc3dpdGNoICgocmVncy5lYXggPj4gSThLX0ZOX1NI SUZUKSAmIEk4S19GTl9NQVNLKSB7Cj4gLQljYXNlIEk4S19GTl9VUDoKPiAtCQlyZXR1cm4gSThL X1ZPTF9VUDsKPiAtCWNhc2UgSThLX0ZOX0RPV046Cj4gLQkJcmV0dXJuIEk4S19WT0xfRE9XTjsK PiAtCWNhc2UgSThLX0ZOX01VVEU6Cj4gLQkJcmV0dXJuIEk4S19WT0xfTVVURTsKPiAtCWRlZmF1 bHQ6Cj4gLQkJcmV0dXJuIDA7Cj4gLQl9Cj4gLX0KPiAtCj4gLS8qCj4gLSAqIFJlYWQgdGhlIHBv d2VyIHN0YXR1cy4KPiAtICovCj4gLXN0YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9p ZCkKPiAtewo+IC0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX1BPV0VS X1NUQVRVUywgfTsKPiAtCWludCByYzsKPiAtCj4gLQlyYyA9IGk4a19zbW0oJnJlZ3MpOwo+IC0J aWYgKHJjIDwgMCkKPiAtCQlyZXR1cm4gcmM7Cj4gLQo+IC0JcmV0dXJuIChyZWdzLmVheCAmIDB4 ZmYpID09IEk4S19QT1dFUl9BQyA/IEk4S19BQyA6IEk4S19CQVRURVJZOwo+IC19Cj4gLQo+IC0v Kgo+IC0gKiBSZWFkIHRoZSBmYW4gc3RhdHVzLgo+IC0gKi8KPiAtc3RhdGljIGludCBpOGtfZ2V0 X2Zhbl9zdGF0dXMoaW50IGZhbikKPiAtewo+IC0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5l YXggPSBJOEtfU01NX0dFVF9GQU4sIH07Cj4gLQo+IC0JcmVncy5lYnggPSBmYW4gJiAweGZmOwo+ IC0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiByZWdzLmVheCAmIDB4ZmY7Cj4gLX0KPiAtCj4g LS8qCj4gLSAqIFJlYWQgdGhlIGZhbiBzcGVlZCBpbiBSUE0uCj4gLSAqLwo+IC1zdGF0aWMgaW50 IGk4a19nZXRfZmFuX3NwZWVkKGludCBmYW4pCj4gLXsKPiAtCXN0cnVjdCBzbW1fcmVncyByZWdz ID0geyAuZWF4ID0gSThLX1NNTV9HRVRfU1BFRUQsIH07Cj4gLQo+IC0JcmVncy5lYnggPSBmYW4g JiAweGZmOwo+IC0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiAocmVncy5lYXggJiAweGZmZmYp ICogaThrX2Zhbl9tdWx0Owo+IC19Cj4gLQo+IC0vKgo+IC0gKiBSZWFkIHRoZSBmYW4gdHlwZS4K PiAtICovCj4gLXN0YXRpYyBpbnQgaThrX2dldF9mYW5fdHlwZShpbnQgZmFuKQo+IC17Cj4gLQlz dHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fR0VUX0ZBTl9UWVBFLCB9Owo+ IC0KPiAtCXJlZ3MuZWJ4ID0gZmFuICYgMHhmZjsKPiAtCXJldHVybiBpOGtfc21tKCZyZWdzKSA/ IDogcmVncy5lYXggJiAweGZmOwo+IC19Cj4gLQo+IC0vKgo+IC0gKiBSZWFkIHRoZSBmYW4gbm9t aW5hbCBycG0gZm9yIHNwZWNpZmljIGZhbiBzcGVlZC4KPiAtICovCj4gLXN0YXRpYyBpbnQgaThr X2dldF9mYW5fbm9taW5hbF9zcGVlZChpbnQgZmFuLCBpbnQgc3BlZWQpCj4gLXsKPiAtCXN0cnVj dCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfTk9NX1NQRUVELCB9Owo+IC0K PiAtCXJlZ3MuZWJ4ID0gKGZhbiAmIDB4ZmYpIHwgKHNwZWVkIDw8IDgpOwo+IC0JcmV0dXJuIGk4 a19zbW0oJnJlZ3MpID8gOiAocmVncy5lYXggJiAweGZmZmYpICogaThrX2Zhbl9tdWx0Owo+IC19 Cj4gLQo+IC0vKgo+IC0gKiBTZXQgdGhlIGZhbiBzcGVlZCAob2ZmLCBsb3csIGhpZ2gpLiBSZXR1 cm5zIHRoZSBuZXcgZmFuIHN0YXR1cy4KPiAtICovCj4gLXN0YXRpYyBpbnQgaThrX3NldF9mYW4o aW50IGZhbiwgaW50IHNwZWVkKQo+IC17Cj4gLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVh eCA9IEk4S19TTU1fU0VUX0ZBTiwgfTsKPiAtCj4gLQlzcGVlZCA9IChzcGVlZCA8IDApID8gMCA6 ICgoc3BlZWQgPiBpOGtfZmFuX21heCkgPyBpOGtfZmFuX21heCA6IHNwZWVkKTsKPiAtCXJlZ3Mu ZWJ4ID0gKGZhbiAmIDB4ZmYpIHwgKHNwZWVkIDw8IDgpOwo+IC0KPiAtCXJldHVybiBpOGtfc21t KCZyZWdzKSA/IDogaThrX2dldF9mYW5fc3RhdHVzKGZhbik7Cj4gLX0KPiAtCj4gLXN0YXRpYyBp bnQgaThrX2dldF90ZW1wX3R5cGUoaW50IHNlbnNvcikKPiAtewo+IC0Jc3RydWN0IHNtbV9yZWdz IHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0dFVF9URU1QX1RZUEUsIH07Cj4gLQo+IC0JcmVncy5l YnggPSBzZW5zb3IgJiAweGZmOwo+IC0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiByZWdzLmVh eCAmIDB4ZmY7Cj4gLX0KPiAtCj4gLS8qCj4gLSAqIFJlYWQgdGhlIGNwdSB0ZW1wZXJhdHVyZS4K PiAtICovCj4gLXN0YXRpYyBpbnQgX2k4a19nZXRfdGVtcChpbnQgc2Vuc29yKQo+IC17Cj4gLQlz dHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsKPiAtCQkuZWF4ID0gSThLX1NNTV9HRVRfVEVNUCwKPiAt CQkuZWJ4ID0gc2Vuc29yICYgMHhmZiwKPiAtCX07Cj4gLQo+IC0JcmV0dXJuIGk4a19zbW0oJnJl Z3MpID8gOiByZWdzLmVheCAmIDB4ZmY7Cj4gLX0KPiAtCj4gLXN0YXRpYyBpbnQgaThrX2dldF90 ZW1wKGludCBzZW5zb3IpCj4gLXsKPiAtCWludCB0ZW1wID0gX2k4a19nZXRfdGVtcChzZW5zb3Ip Owo+IC0KPiAtCS8qCj4gLQkgKiBTb21ldGltZXMgdGhlIHRlbXBlcmF0dXJlIHNlbnNvciByZXR1 cm5zIDB4OTksIHdoaWNoIGlzIG91dCBvZiByYW5nZS4KPiAtCSAqIEluIHRoaXMgY2FzZSB3ZSBy ZXRyeSAob25jZSkgYmVmb3JlIHJldHVybmluZyBhbiBlcnJvci4KPiAtCSAjIDEwMDM2NTUxMzcg MDAwMDAwNTggMDAwMDVhNGIKPiAtCSAjIDEwMDM2NTUxMzggMDAwMDAwOTkgMDAwMDNhODAgPC0t LSAweDk5ID0gMTUzIGRlZ3JlZXMKPiAtCSAjIDEwMDM2NTUxMzkgMDAwMDAwNTQgMDAwMDVjNTIK PiAtCSAqLwo+IC0JaWYgKHRlbXAgPT0gMHg5OSkgewo+IC0JCW1zbGVlcCgxMDApOwo+IC0JCXRl bXAgPSBfaThrX2dldF90ZW1wKHNlbnNvcik7Cj4gLQl9Cj4gLQkvKgo+IC0JICogUmV0dXJuIC1F Tk9EQVRBIGZvciBhbGwgaW52YWxpZCB0ZW1wZXJhdHVyZXMuCj4gLQkgKgo+IC0JICogS25vd24g aW5zdGFuY2VzIGFyZSB0aGUgMHg5OSB2YWx1ZSBhcyBzZWVuIGFib3ZlIGFzIHdlbGwgYXMKPiAt CSAqIDB4YzEgKDE5MyksIHdoaWNoIG1heSBiZSByZXR1cm5lZCB3aGVuIHRyeWluZyB0byByZWFk IHRoZSBHUFUKPiAtCSAqIHRlbXBlcmF0dXJlIGlmIHRoZSBzeXN0ZW0gc3VwcG9ydHMgYSBHUFUg YW5kIGl0IGlzIGN1cnJlbnRseQo+IC0JICogdHVybmVkIG9mZi4KPiAtCSAqLwo+IC0JaWYgKHRl bXAgPiBJOEtfTUFYX1RFTVApCj4gLQkJcmV0dXJuIC1FTk9EQVRBOwo+IC0KPiAtCXJldHVybiB0 ZW1wOwo+IC19Cj4gLQo+IC1zdGF0aWMgaW50IGk4a19nZXRfZGVsbF9zaWduYXR1cmUoaW50IHJl cV9mbikKPiAtewo+IC0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSByZXFfZm4sIH07 Cj4gLQlpbnQgcmM7Cj4gLQo+IC0JcmMgPSBpOGtfc21tKCZyZWdzKTsKPiAtCWlmIChyYyA8IDAp Cj4gLQkJcmV0dXJuIHJjOwo+IC0KPiAtCXJldHVybiByZWdzLmVheCA9PSAxMTQ1NjUxNTI3ICYm IHJlZ3MuZWR4ID09IDExNDUzOTIyMDQgPyAwIDogLTE7Cj4gLX0KPiAtCj4gLXN0YXRpYyBpbnQK PiAtaThrX2lvY3RsX3VubG9ja2VkKHN0cnVjdCBmaWxlICpmcCwgdW5zaWduZWQgaW50IGNtZCwg dW5zaWduZWQgbG9uZyBhcmcpCj4gLXsKPiAtCWludCB2YWwgPSAwOwo+IC0JaW50IHNwZWVkOwo+ IC0JdW5zaWduZWQgY2hhciBidWZmWzE2XTsKPiAtCWludCBfX3VzZXIgKmFyZ3AgPSAoaW50IF9f dXNlciAqKWFyZzsKPiAtCj4gLQlpZiAoIWFyZ3ApCj4gLQkJcmV0dXJuIC1FSU5WQUw7Cj4gLQo+ IC0Jc3dpdGNoIChjbWQpIHsKPiAtCWNhc2UgSThLX0JJT1NfVkVSU0lPTjoKPiAtCQl2YWwgPSAo Ymlvc192ZXJzaW9uWzBdIDw8IDE2KSB8Cj4gLQkJCQkoYmlvc192ZXJzaW9uWzFdIDw8IDgpIHwg Ymlvc192ZXJzaW9uWzJdOwo+IC0JCWJyZWFrOwo+IC0KPiAtCWNhc2UgSThLX01BQ0hJTkVfSUQ6 Cj4gLQkJbWVtc2V0KGJ1ZmYsIDAsIDE2KTsKPiAtCQlzdHJsY3B5KGJ1ZmYsIGk4a19nZXRfZG1p X2RhdGEoRE1JX1BST0RVQ1RfU0VSSUFMKSwKPiAtCQkJc2l6ZW9mKGJ1ZmYpKTsKPiAtCQlicmVh azsKPiAtCj4gLQljYXNlIEk4S19GTl9TVEFUVVM6Cj4gLQkJdmFsID0gaThrX2dldF9mbl9zdGF0 dXMoKTsKPiAtCQlicmVhazsKPiAtCj4gLQljYXNlIEk4S19QT1dFUl9TVEFUVVM6Cj4gLQkJdmFs ID0gaThrX2dldF9wb3dlcl9zdGF0dXMoKTsKPiAtCQlicmVhazsKPiAtCj4gLQljYXNlIEk4S19H RVRfVEVNUDoKPiAtCQl2YWwgPSBpOGtfZ2V0X3RlbXAoMCk7Cj4gLQkJYnJlYWs7Cj4gLQo+IC0J Y2FzZSBJOEtfR0VUX1NQRUVEOgo+IC0JCWlmIChjb3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBz aXplb2YoaW50KSkpCj4gLQkJCXJldHVybiAtRUZBVUxUOwo+IC0KPiAtCQl2YWwgPSBpOGtfZ2V0 X2Zhbl9zcGVlZCh2YWwpOwo+IC0JCWJyZWFrOwo+IC0KPiAtCWNhc2UgSThLX0dFVF9GQU46Cj4g LQkJaWYgKGNvcHlfZnJvbV91c2VyKCZ2YWwsIGFyZ3AsIHNpemVvZihpbnQpKSkKPiAtCQkJcmV0 dXJuIC1FRkFVTFQ7Cj4gLQo+IC0JCXZhbCA9IGk4a19nZXRfZmFuX3N0YXR1cyh2YWwpOwo+IC0J CWJyZWFrOwo+IC0KPiAtCWNhc2UgSThLX1NFVF9GQU46Cj4gLQkJaWYgKHJlc3RyaWN0ZWQgJiYg IWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCj4gLQkJCXJldHVybiAtRVBFUk07Cj4gLQo+IC0JCWlm IChjb3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBzaXplb2YoaW50KSkpCj4gLQkJCXJldHVybiAt RUZBVUxUOwo+IC0KPiAtCQlpZiAoY29weV9mcm9tX3VzZXIoJnNwZWVkLCBhcmdwICsgMSwgc2l6 ZW9mKGludCkpKQo+IC0JCQlyZXR1cm4gLUVGQVVMVDsKPiAtCj4gLQkJdmFsID0gaThrX3NldF9m YW4odmFsLCBzcGVlZCk7Cj4gLQkJYnJlYWs7Cj4gLQo+IC0JZGVmYXVsdDoKPiAtCQlyZXR1cm4g LUVJTlZBTDsKPiAtCX0KPiAtCj4gLQlpZiAodmFsIDwgMCkKPiAtCQlyZXR1cm4gdmFsOwo+IC0K PiAtCXN3aXRjaCAoY21kKSB7Cj4gLQljYXNlIEk4S19CSU9TX1ZFUlNJT046Cj4gLQkJaWYgKGNv cHlfdG9fdXNlcihhcmdwLCAmdmFsLCA0KSkKPiAtCQkJcmV0dXJuIC1FRkFVTFQ7Cj4gLQo+IC0J CWJyZWFrOwo+IC0JY2FzZSBJOEtfTUFDSElORV9JRDoKPiAtCQlpZiAoY29weV90b191c2VyKGFy Z3AsIGJ1ZmYsIDE2KSkKPiAtCQkJcmV0dXJuIC1FRkFVTFQ7Cj4gLQo+IC0JCWJyZWFrOwo+IC0J ZGVmYXVsdDoKPiAtCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZ2YWwsIHNpemVvZihpbnQpKSkK PiAtCQkJcmV0dXJuIC1FRkFVTFQ7Cj4gLQo+IC0JCWJyZWFrOwo+IC0JfQo+IC0KPiAtCXJldHVy biAwOwo+IC19Cj4gLQo+IC1zdGF0aWMgbG9uZyBpOGtfaW9jdGwoc3RydWN0IGZpbGUgKmZwLCB1 bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKPiAtewo+IC0JbG9uZyByZXQ7Cj4g LQo+IC0JbXV0ZXhfbG9jaygmaThrX211dGV4KTsKPiAtCXJldCA9IGk4a19pb2N0bF91bmxvY2tl ZChmcCwgY21kLCBhcmcpOwo+IC0JbXV0ZXhfdW5sb2NrKCZpOGtfbXV0ZXgpOwo+IC0KPiAtCXJl dHVybiByZXQ7Cj4gLX0KPiAtCj4gLS8qCj4gLSAqIFByaW50IHRoZSBpbmZvcm1hdGlvbiBmb3Ig L3Byb2MvaThrLgo+IC0gKi8KPiAtc3RhdGljIGludCBpOGtfcHJvY19zaG93KHN0cnVjdCBzZXFf ZmlsZSAqc2VxLCB2b2lkICpvZmZzZXQpCj4gLXsKPiAtCWludCBmbl9rZXksIGNwdV90ZW1wLCBh Y19wb3dlcjsKPiAtCWludCBsZWZ0X2ZhbiwgcmlnaHRfZmFuLCBsZWZ0X3NwZWVkLCByaWdodF9z cGVlZDsKPiAtCj4gLQljcHVfdGVtcAk9IGk4a19nZXRfdGVtcCgwKTsJCQkvKiAxMTEwMCDCtXMg Ki8KPiAtCWxlZnRfZmFuCT0gaThrX2dldF9mYW5fc3RhdHVzKEk4S19GQU5fTEVGVCk7CS8qICAg NTgwIMK1cyAqLwo+IC0JcmlnaHRfZmFuCT0gaThrX2dldF9mYW5fc3RhdHVzKEk4S19GQU5fUklH SFQpOwkvKiAgIDU4MCDCtXMgKi8KPiAtCWxlZnRfc3BlZWQJPSBpOGtfZ2V0X2Zhbl9zcGVlZChJ OEtfRkFOX0xFRlQpOwkvKiAgIDU4MCDCtXMgKi8KPiAtCXJpZ2h0X3NwZWVkCT0gaThrX2dldF9m YW5fc3BlZWQoSThLX0ZBTl9SSUdIVCk7CS8qICAgNTgwIMK1cyAqLwo+IC0JZm5fa2V5CQk9IGk4 a19nZXRfZm5fc3RhdHVzKCk7CQkJLyogICA3NTAgwrVzICovCj4gLQlpZiAocG93ZXJfc3RhdHVz KQo+IC0JCWFjX3Bvd2VyID0gaThrX2dldF9wb3dlcl9zdGF0dXMoKTsJCS8qIDE0NzAwIMK1cyAq Lwo+IC0JZWxzZQo+IC0JCWFjX3Bvd2VyID0gLTE7Cj4gLQo+IC0JLyoKPiAtCSAqIEluZm86Cj4g LQkgKgo+IC0JICogMSkgIEZvcm1hdCB2ZXJzaW9uICh0aGlzIHdpbGwgY2hhbmdlIGlmIGZvcm1h dCBjaGFuZ2VzKQo+IC0JICogMikgIEJJT1MgdmVyc2lvbgo+IC0JICogMykgIEJJT1MgbWFjaGlu ZSBJRAo+IC0JICogNCkgIENwdSB0ZW1wZXJhdHVyZQo+IC0JICogNSkgIExlZnQgZmFuIHN0YXR1 cwo+IC0JICogNikgIFJpZ2h0IGZhbiBzdGF0dXMKPiAtCSAqIDcpICBMZWZ0IGZhbiBzcGVlZAo+ IC0JICogOCkgIFJpZ2h0IGZhbiBzcGVlZAo+IC0JICogOSkgIEFDIHBvd2VyCj4gLQkgKiAxMCkg Rm4gS2V5IHN0YXR1cwo+IC0JICovCj4gLQlyZXR1cm4gc2VxX3ByaW50ZihzZXEsICIlcyAlcyAl cyAlZCAlZCAlZCAlZCAlZCAlZCAlZFxuIiwKPiAtCQkJICBJOEtfUFJPQ19GTVQsCj4gLQkJCSAg Ymlvc192ZXJzaW9uLAo+IC0JCQkgIGk4a19nZXRfZG1pX2RhdGEoRE1JX1BST0RVQ1RfU0VSSUFM KSwKPiAtCQkJICBjcHVfdGVtcCwKPiAtCQkJICBsZWZ0X2ZhbiwgcmlnaHRfZmFuLCBsZWZ0X3Nw ZWVkLCByaWdodF9zcGVlZCwKPiAtCQkJICBhY19wb3dlciwgZm5fa2V5KTsKPiAtfQo+IC0KPiAt c3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAq ZmlsZSkKPiAtewo+IC0JcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIGk4a19wcm9jX3Nob3csIE5V TEwpOwo+IC19Cj4gLQo+IC0KPiAtLyoKPiAtICogSHdtb24gaW50ZXJmYWNlCj4gLSAqLwo+IC0K PiAtc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbChzdHJ1Y3QgZGV2aWNl ICpkZXYsCj4gLQkJCQkJIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLAo+IC0JCQkJ CSBjaGFyICpidWYpCj4gLXsKPiAtCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbGFiZWxzW10g PSB7Cj4gLQkJIkNQVSIsCj4gLQkJIkdQVSIsCj4gLQkJIlNPRElNTSIsCj4gLQkJIk90aGVyIiwK PiAtCQkiQW1iaWVudCIsCj4gLQkJIk90aGVyIiwKPiAtCX07Cj4gLQlpbnQgaW5kZXggPSB0b19z ZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4Owo+IC0JaW50IHR5cGU7Cj4gLQo+IC0JdHlw ZSA9IGk4a19nZXRfdGVtcF90eXBlKGluZGV4KTsKPiAtCWlmICh0eXBlIDwgMCkKPiAtCQlyZXR1 cm4gdHlwZTsKPiAtCWlmICh0eXBlID49IEFSUkFZX1NJWkUobGFiZWxzKSkKPiAtCQl0eXBlID0g QVJSQVlfU0laRShsYWJlbHMpIC0gMTsKPiAtCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCBs YWJlbHNbdHlwZV0pOwo+IC19Cj4gLQo+IC1zdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2hvd190 ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwKPiAtCQkJCSAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRl ICpkZXZhdHRyLAo+IC0JCQkJICAgY2hhciAqYnVmKQo+IC17Cj4gLQlpbnQgaW5kZXggPSB0b19z ZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4Owo+IC0JaW50IHRlbXA7Cj4gLQo+IC0JdGVt cCA9IGk4a19nZXRfdGVtcChpbmRleCk7Cj4gLQlpZiAodGVtcCA8IDApCj4gLQkJcmV0dXJuIHRl bXA7Cj4gLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgdGVtcCAqIDEwMDApOwo+IC19Cj4g LQo+IC1zdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2hvd19mYW5fbGFiZWwoc3RydWN0IGRldmlj ZSAqZGV2LAo+IC0JCQkJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLAo+IC0JCQkJ CWNoYXIgKmJ1ZikKPiAtewo+IC0Jc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBsYWJlbHNbXSA9 IHsKPiAtCQkiUHJvY2Vzc29yIEZhbiIsCj4gLQkJIk1vdGhlcmJvYXJkIEZhbiIsCj4gLQkJIlZp ZGVvIEZhbiIsCj4gLQkJIlBvd2VyIFN1cHBseSBGYW4iLAo+IC0JCSJDaGlwc2V0IEZhbiIsCj4g LQkJIk90aGVyIEZhbiIsCj4gLQl9Owo+IC0JaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRy KGRldmF0dHIpLT5pbmRleDsKPiAtCWJvb2wgZG9jayA9IGZhbHNlOwo+IC0JaW50IHR5cGU7Cj4g LQo+IC0JdHlwZSA9IGk4a19nZXRfZmFuX3R5cGUoaW5kZXgpOwo+IC0JaWYgKHR5cGUgPCAwKQo+ IC0JCXJldHVybiB0eXBlOwo+IC0KPiAtCWlmICh0eXBlICYgMHgxMCkgewo+IC0JCWRvY2sgPSB0 cnVlOwo+IC0JCXR5cGUgJj0gMHgwRjsKPiAtCX0KPiAtCj4gLQlpZiAodHlwZSA+PSBBUlJBWV9T SVpFKGxhYmVscykpCj4gLQkJdHlwZSA9IChBUlJBWV9TSVpFKGxhYmVscykgLSAxKTsKPiAtCj4g LQlyZXR1cm4gc3ByaW50ZihidWYsICIlcyVzXG4iLCAoZG9jayA/ICJEb2NraW5nICIgOiAiIiks IGxhYmVsc1t0eXBlXSk7Cj4gLX0KPiAtCj4gLXN0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zaG93 X2ZhbihzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gLQkJCQkgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRl ICpkZXZhdHRyLAo+IC0JCQkJICBjaGFyICpidWYpCj4gLXsKPiAtCWludCBpbmRleCA9IHRvX3Nl bnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+aW5kZXg7Cj4gLQlpbnQgZmFuX3NwZWVkOwo+IC0KPiAt CWZhbl9zcGVlZCA9IGk4a19nZXRfZmFuX3NwZWVkKGluZGV4KTsKPiAtCWlmIChmYW5fc3BlZWQg PCAwKQo+IC0JCXJldHVybiBmYW5fc3BlZWQ7Cj4gLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxu IiwgZmFuX3NwZWVkKTsKPiAtfQo+IC0KPiAtc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3df cHdtKHN0cnVjdCBkZXZpY2UgKmRldiwKPiAtCQkJCSAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUg KmRldmF0dHIsCj4gLQkJCQkgIGNoYXIgKmJ1ZikKPiAtewo+IC0JaW50IGluZGV4ID0gdG9fc2Vu c29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKPiAtCWludCBzdGF0dXM7Cj4gLQo+IC0Jc3Rh dHVzID0gaThrX2dldF9mYW5fc3RhdHVzKGluZGV4KTsKPiAtCWlmIChzdGF0dXMgPCAwKQo+IC0J CXJldHVybiAtRUlPOwo+IC0JcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIGNsYW1wX3ZhbChz dGF0dXMgKiBpOGtfcHdtX211bHQsIDAsIDI1NSkpOwo+IC19Cj4gLQo+IC1zdGF0aWMgc3NpemVf dCBpOGtfaHdtb25fc2V0X3B3bShzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gLQkJCQkgc3RydWN0IGRl dmljZV9hdHRyaWJ1dGUgKmF0dHIsCj4gLQkJCQkgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291 bnQpCj4gLXsKPiAtCWludCBpbmRleCA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRyKS0+aW5kZXg7 Cj4gLQl1bnNpZ25lZCBsb25nIHZhbDsKPiAtCWludCBlcnI7Cj4gLQo+IC0JZXJyID0ga3N0cnRv dWwoYnVmLCAxMCwgJnZhbCk7Cj4gLQlpZiAoZXJyKQo+IC0JCXJldHVybiBlcnI7Cj4gLQl2YWwg PSBjbGFtcF92YWwoRElWX1JPVU5EX0NMT1NFU1QodmFsLCBpOGtfcHdtX211bHQpLCAwLCBpOGtf ZmFuX21heCk7Cj4gLQo+IC0JbXV0ZXhfbG9jaygmaThrX211dGV4KTsKPiAtCWVyciA9IGk4a19z ZXRfZmFuKGluZGV4LCB2YWwpOwo+IC0JbXV0ZXhfdW5sb2NrKCZpOGtfbXV0ZXgpOwo+IC0KPiAt CXJldHVybiBlcnIgPCAwID8gLUVJTyA6IGNvdW50Owo+IC19Cj4gLQo+IC1zdGF0aWMgU0VOU09S X0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wLCBO VUxMLCAwKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9sYWJlbCwgU19JUlVH TywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbCwgTlVMTCwKPiAtCQkJICAwKTsKPiAtc3RhdGlj IFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMl9pbnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3df dGVtcCwgTlVMTCwgMSk7Cj4gLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDJfbGFiZWws IFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwsIE5VTEwsCj4gLQkJCSAgMSk7Cj4g LXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDNfaW5wdXQsIFNfSVJVR08sIGk4a19od21v bl9zaG93X3RlbXAsIE5VTEwsIDIpOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAz X2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wX2xhYmVsLCBOVUxMLAo+IC0JCQkg IDIpOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXA0X2lucHV0LCBTX0lSVUdPLCBp OGtfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAzKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRU Uih0ZW1wNF9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbCwgTlVMTCwK PiAtCQkJICAzKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4xX2lucHV0LCBTX0lS VUdPLCBpOGtfaHdtb25fc2hvd19mYW4sIE5VTEwsIDApOwo+IC1zdGF0aWMgU0VOU09SX0RFVklD RV9BVFRSKGZhbjFfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9zaG93X2Zhbl9sYWJlbCwgTlVM TCwKPiAtCQkJICAwKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihwd20xLCBTX0lSVUdP IHwgU19JV1VTUiwgaThrX2h3bW9uX3Nob3dfcHdtLAo+IC0JCQkgIGk4a19od21vbl9zZXRfcHdt LCAwKTsKPiAtc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4yX2lucHV0LCBTX0lSVUdPLCBp OGtfaHdtb25fc2hvd19mYW4sIE5VTEwsCj4gLQkJCSAgMSk7Cj4gLXN0YXRpYyBTRU5TT1JfREVW SUNFX0FUVFIoZmFuMl9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuX2xhYmVsLCBO VUxMLAo+IC0JCQkgIDEpOwo+IC1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHB3bTIsIFNfSVJV R08gfCBTX0lXVVNSLCBpOGtfaHdtb25fc2hvd19wd20sCj4gLQkJCSAgaThrX2h3bW9uX3NldF9w d20sIDEpOwo+IC0KPiAtc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmk4a19hdHRyc1tdID0gewo+ IC0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiAwICovCj4g LQkmc2Vuc29yX2Rldl9hdHRyX3RlbXAxX2xhYmVsLmRldl9hdHRyLmF0dHIsCS8qIDEgKi8KPiAt CSZzZW5zb3JfZGV2X2F0dHJfdGVtcDJfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogMiAqLwo+IC0J JnNlbnNvcl9kZXZfYXR0cl90ZW1wMl9sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiAzICovCj4gLQkm c2Vuc29yX2Rldl9hdHRyX3RlbXAzX2lucHV0LmRldl9hdHRyLmF0dHIsCS8qIDQgKi8KPiAtCSZz ZW5zb3JfZGV2X2F0dHJfdGVtcDNfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogNSAqLwo+IC0JJnNl bnNvcl9kZXZfYXR0cl90ZW1wNF9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiA2ICovCj4gLQkmc2Vu c29yX2Rldl9hdHRyX3RlbXA0X2xhYmVsLmRldl9hdHRyLmF0dHIsCS8qIDcgKi8KPiAtCSZzZW5z b3JfZGV2X2F0dHJfZmFuMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiA4ICovCj4gLQkmc2Vuc29y X2Rldl9hdHRyX2ZhbjFfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogOSAqLwo+IC0JJnNlbnNvcl9k ZXZfYXR0cl9wd20xLmRldl9hdHRyLmF0dHIsCQkvKiAxMCAqLwo+IC0JJnNlbnNvcl9kZXZfYXR0 cl9mYW4yX2lucHV0LmRldl9hdHRyLmF0dHIsCS8qIDExICovCj4gLQkmc2Vuc29yX2Rldl9hdHRy X2ZhbjJfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogMTIgKi8KPiAtCSZzZW5zb3JfZGV2X2F0dHJf cHdtMi5kZXZfYXR0ci5hdHRyLAkJLyogMTMgKi8KPiAtCU5VTEwKPiAtfTsKPiAtCj4gLXN0YXRp YyB1bW9kZV90IGk4a19pc192aXNpYmxlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3QgYXR0 cmlidXRlICphdHRyLAo+IC0JCQkgICAgICBpbnQgaW5kZXgpCj4gLXsKPiAtCWlmIChpbmRleCA+ PSAwICYmIGluZGV4IDw9IDEgJiYKPiAtCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01P Tl9IQVZFX1RFTVAxKSkKPiAtCQlyZXR1cm4gMDsKPiAtCWlmIChpbmRleCA+PSAyICYmIGluZGV4 IDw9IDMgJiYKPiAtCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVAy KSkKPiAtCQlyZXR1cm4gMDsKPiAtCWlmIChpbmRleCA+PSA0ICYmIGluZGV4IDw9IDUgJiYKPiAt CSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVAzKSkKPiAtCQlyZXR1 cm4gMDsKPiAtCWlmIChpbmRleCA+PSA2ICYmIGluZGV4IDw9IDcgJiYKPiAtCSAgICAhKGk4a19o d21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVA0KSkKPiAtCQlyZXR1cm4gMDsKPiAtCWlm IChpbmRleCA+PSA4ICYmIGluZGV4IDw9IDEwICYmCj4gLQkgICAgIShpOGtfaHdtb25fZmxhZ3Mg JiBJOEtfSFdNT05fSEFWRV9GQU4xKSkKPiAtCQlyZXR1cm4gMDsKPiAtCWlmIChpbmRleCA+PSAx MSAmJiBpbmRleCA8PSAxMyAmJgo+IC0JICAgICEoaThrX2h3bW9uX2ZsYWdzICYgSThLX0hXTU9O X0hBVkVfRkFOMikpCj4gLQkJcmV0dXJuIDA7Cj4gLQo+IC0JcmV0dXJuIGF0dHItPm1vZGU7Cj4g LX0KPiAtCj4gLXN0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGk4a19ncm91cCA9 IHsKPiAtCS5hdHRycyA9IGk4a19hdHRycywKPiAtCS5pc192aXNpYmxlID0gaThrX2lzX3Zpc2li bGUsCj4gLX07Cj4gLV9fQVRUUklCVVRFX0dST1VQUyhpOGspOwo+IC0KPiAtc3RhdGljIGludCBf X2luaXQgaThrX2luaXRfaHdtb24odm9pZCkKPiAtewo+IC0JaW50IGVycjsKPiAtCj4gLQlpOGtf aHdtb25fZmxhZ3MgPSAwOwo+IC0KPiAtCS8qIENQVSB0ZW1wZXJhdHVyZSBhdHRyaWJ1dGVzLCBp ZiB0ZW1wZXJhdHVyZSB0eXBlIGlzIE9LICovCj4gLQllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgw KTsKPiAtCWlmIChlcnIgPj0gMCkKPiAtCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hB VkVfVEVNUDE7Cj4gLQkvKiBjaGVjayBmb3IgYWRkaXRpb25hbCB0ZW1wZXJhdHVyZSBzZW5zb3Jz ICovCj4gLQllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgxKTsKPiAtCWlmIChlcnIgPj0gMCkKPiAt CQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVfVEVNUDI7Cj4gLQllcnIgPSBpOGtf Z2V0X3RlbXBfdHlwZSgyKTsKPiAtCWlmIChlcnIgPj0gMCkKPiAtCQlpOGtfaHdtb25fZmxhZ3Mg fD0gSThLX0hXTU9OX0hBVkVfVEVNUDM7Cj4gLQllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgzKTsK PiAtCWlmIChlcnIgPj0gMCkKPiAtCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVf VEVNUDQ7Cj4gLQo+IC0JLyogRmlyc3QgZmFuIGF0dHJpYnV0ZXMsIGlmIGZhbiB0eXBlIGlzIE9L ICovCj4gLQllcnIgPSBpOGtfZ2V0X2Zhbl90eXBlKDApOwo+IC0JaWYgKGVyciA+PSAwKQo+IC0J CWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9GQU4xOwo+IC0KPiAtCS8qIFNlY29u ZCBmYW4gYXR0cmlidXRlcywgaWYgZmFuIHR5cGUgaXMgT0sgKi8KPiAtCWVyciA9IGk4a19nZXRf ZmFuX3R5cGUoMSk7Cj4gLQlpZiAoZXJyID49IDApCj4gLQkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4 S19IV01PTl9IQVZFX0ZBTjI7Cj4gLQo+IC0JaThrX2h3bW9uX2RldiA9IGh3bW9uX2RldmljZV9y ZWdpc3Rlcl93aXRoX2dyb3VwcyhOVUxMLCAiaThrIiwgTlVMTCwKPiAtCQkJCQkJCSAgaThrX2dy b3Vwcyk7Cj4gLQlpZiAoSVNfRVJSKGk4a19od21vbl9kZXYpKSB7Cj4gLQkJZXJyID0gUFRSX0VS UihpOGtfaHdtb25fZGV2KTsKPiAtCQlpOGtfaHdtb25fZGV2ID0gTlVMTDsKPiAtCQlwcl9lcnIo Imh3bW9uIHJlZ2lzdHJhdGlvbiBmYWlsZWQgKCVkKVxuIiwgZXJyKTsKPiAtCQlyZXR1cm4gZXJy Owo+IC0JfQo+IC0JcmV0dXJuIDA7Cj4gLX0KPiAtCj4gLXN0cnVjdCBpOGtfY29uZmlnX2RhdGEg ewo+IC0JdWludCBmYW5fbXVsdDsKPiAtCXVpbnQgZmFuX21heDsKPiAtfTsKPiAtCj4gLWVudW0g aThrX2NvbmZpZ3Mgewo+IC0JREVMTF9MQVRJVFVERV9ENTIwLAo+IC0JREVMTF9QUkVDSVNJT05f NDkwLAo+IC0JREVMTF9TVFVESU8sCj4gLQlERUxMX1hQUywKPiAtfTsKPiAtCj4gLXN0YXRpYyBj b25zdCBzdHJ1Y3QgaThrX2NvbmZpZ19kYXRhIGk4a19jb25maWdfZGF0YVtdID0gewo+IC0JW0RF TExfTEFUSVRVREVfRDUyMF0gPSB7Cj4gLQkJLmZhbl9tdWx0ID0gMSwKPiAtCQkuZmFuX21heCA9 IEk4S19GQU5fVFVSQk8sCj4gLQl9LAo+IC0JW0RFTExfUFJFQ0lTSU9OXzQ5MF0gPSB7Cj4gLQkJ LmZhbl9tdWx0ID0gMSwKPiAtCQkuZmFuX21heCA9IEk4S19GQU5fVFVSQk8sCj4gLQl9LAo+IC0J W0RFTExfU1RVRElPXSA9IHsKPiAtCQkuZmFuX211bHQgPSAxLAo+IC0JCS5mYW5fbWF4ID0gSThL X0ZBTl9ISUdILAo+IC0JfSwKPiAtCVtERUxMX1hQU10gPSB7Cj4gLQkJLmZhbl9tdWx0ID0gMSwK PiAtCQkuZmFuX21heCA9IEk4S19GQU5fSElHSCwKPiAtCX0sCj4gLX07Cj4gLQo+IC1zdGF0aWMg c3RydWN0IGRtaV9zeXN0ZW1faWQgaThrX2RtaV90YWJsZVtdIF9faW5pdGRhdGEgPSB7Cj4gLQl7 Cj4gLQkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24iLAo+IC0JCS5tYXRjaGVzID0gewo+IC0JCQlE TUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIENvbXB1dGVyIiksCj4gLQkJCURNSV9NQVRD SChETUlfUFJPRFVDVF9OQU1FLCAiSW5zcGlyb24iKSwKPiAtCQl9LAo+IC0JfSwKPiAtCXsKPiAt CQkuaWRlbnQgPSAiRGVsbCBMYXRpdHVkZSIsCj4gLQkJLm1hdGNoZXMgPSB7Cj4gLQkJCURNSV9N QVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgQ29tcHV0ZXIiKSwKPiAtCQkJRE1JX01BVENIKERN SV9QUk9EVUNUX05BTUUsICJMYXRpdHVkZSIpLAo+IC0JCX0sCj4gLQl9LAo+IC0Jewo+IC0JCS5p ZGVudCA9ICJEZWxsIEluc3Bpcm9uIDIiLAo+IC0JCS5tYXRjaGVzID0gewo+IC0JCQlETUlfTUFU Q0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKPiAtCQkJRE1JX01BVENIKERNSV9QUk9E VUNUX05BTUUsICJJbnNwaXJvbiIpLAo+IC0JCX0sCj4gLQl9LAo+IC0Jewo+IC0JCS5pZGVudCA9 ICJEZWxsIExhdGl0dWRlIEQ1MjAiLAo+IC0JCS5tYXRjaGVzID0gewo+IC0JCQlETUlfTUFUQ0go RE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKPiAtCQkJRE1JX01BVENIKERNSV9QUk9EVUNU X05BTUUsICJMYXRpdHVkZSBENTIwIiksCj4gLQkJfSwKPiAtCQkuZHJpdmVyX2RhdGEgPSAodm9p ZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9MQVRJVFVERV9ENTIwXSwKPiAtCX0sCj4gLQl7Cj4g LQkJLmlkZW50ID0gIkRlbGwgTGF0aXR1ZGUgMiIsCj4gLQkJLm1hdGNoZXMgPSB7Cj4gLQkJCURN SV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAo+IC0JCQlETUlfTUFUQ0goRE1J X1BST0RVQ1RfTkFNRSwgIkxhdGl0dWRlIiksCj4gLQkJfSwKPiAtCX0sCj4gLQl7CS8qIFVLIElu c3Bpcm9uIDY0MDAgICovCj4gLQkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24gMyIsCj4gLQkJLm1h dGNoZXMgPSB7Cj4gLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAo+ IC0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIk1NMDYxIiksCj4gLQkJfSwKPiAtCX0s Cj4gLQl7Cj4gLQkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24gMyIsCj4gLQkJLm1hdGNoZXMgPSB7 Cj4gLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAo+IC0JCQlETUlf TUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIk1QMDYxIiksCj4gLQkJfSwKPiAtCX0sCj4gLQl7Cj4g LQkJLmlkZW50ID0gIkRlbGwgUHJlY2lzaW9uIDQ5MCIsCj4gLQkJLm1hdGNoZXMgPSB7Cj4gLQkJ CURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAo+IC0JCQlETUlfTUFUQ0go RE1JX1BST0RVQ1RfTkFNRSwKPiAtCQkJCSAgIlByZWNpc2lvbiBXb3JrU3RhdGlvbiA0OTAiKSwK PiAtCQl9LAo+IC0JCS5kcml2ZXJfZGF0YSA9ICh2b2lkICopJmk4a19jb25maWdfZGF0YVtERUxM X1BSRUNJU0lPTl80OTBdLAo+IC0JfSwKPiAtCXsKPiAtCQkuaWRlbnQgPSAiRGVsbCBQcmVjaXNp b24iLAo+IC0JCS5tYXRjaGVzID0gewo+IC0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJE ZWxsIEluYy4iKSwKPiAtCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJQcmVjaXNpb24i KSwKPiAtCQl9LAo+IC0JfSwKPiAtCXsKPiAtCQkuaWRlbnQgPSAiRGVsbCBWb3N0cm8iLAo+IC0J CS5tYXRjaGVzID0gewo+IC0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4i KSwKPiAtCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJWb3N0cm8iKSwKPiAtCQl9LAo+ IC0JfSwKPiAtCXsKPiAtCQkuaWRlbnQgPSAiRGVsbCBYUFM0MjEiLAo+IC0JCS5tYXRjaGVzID0g ewo+IC0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKPiAtCQkJRE1J X01BVENIKERNSV9QUk9EVUNUX05BTUUsICJYUFMgTDQyMVgiKSwKPiAtCQl9LAo+IC0JfSwKPiAt CXsKPiAtCQkuaWRlbnQgPSAiRGVsbCBTdHVkaW8iLAo+IC0JCS5tYXRjaGVzID0gewo+IC0JCQlE TUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKPiAtCQkJRE1JX01BVENIKERN SV9QUk9EVUNUX05BTUUsICJTdHVkaW8iKSwKPiAtCQl9LAo+IC0JCS5kcml2ZXJfZGF0YSA9ICh2 b2lkICopJmk4a19jb25maWdfZGF0YVtERUxMX1NUVURJT10sCj4gLQl9LAo+IC0Jewo+IC0JCS5p ZGVudCA9ICJEZWxsIFhQUyAxMyIsCj4gLQkJLm1hdGNoZXMgPSB7Cj4gLQkJCURNSV9NQVRDSChE TUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAo+IC0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1Rf TkFNRSwgIlhQUzEzIiksCj4gLQkJfSwKPiAtCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtf Y29uZmlnX2RhdGFbREVMTF9YUFNdLAo+IC0JfSwKPiAtCXsKPiAtCQkuaWRlbnQgPSAiRGVsbCBY UFMgTTE0MCIsCj4gLQkJLm1hdGNoZXMgPSB7Cj4gLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRP UiwgIkRlbGwgSW5jLiIpLAo+IC0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIk1YQzA1 MSIpLAo+IC0JCX0sCj4gLQkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRh W0RFTExfWFBTXSwKPiAtCX0sCj4gLQl7IH0KPiAtfTsKPiAtCj4gLU1PRFVMRV9ERVZJQ0VfVEFC TEUoZG1pLCBpOGtfZG1pX3RhYmxlKTsKPiAtCj4gLS8qCj4gLSAqIFByb2JlIGZvciB0aGUgcHJl c2VuY2Ugb2YgYSBzdXBwb3J0ZWQgbGFwdG9wLgo+IC0gKi8KPiAtc3RhdGljIGludCBfX2luaXQg aThrX3Byb2JlKHZvaWQpCj4gLXsKPiAtCWNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkICppZDsK PiAtCWludCBmYW4sIHJldDsKPiAtCj4gLQkvKgo+IC0JICogR2V0IERNSSBpbmZvcm1hdGlvbgo+ IC0JICovCj4gLQlpZiAoIWRtaV9jaGVja19zeXN0ZW0oaThrX2RtaV90YWJsZSkpIHsKPiAtCQlp ZiAoIWlnbm9yZV9kbWkgJiYgIWZvcmNlKQo+IC0JCQlyZXR1cm4gLUVOT0RFVjsKPiAtCj4gLQkJ cHJfaW5mbygibm90IHJ1bm5pbmcgb24gYSBzdXBwb3J0ZWQgRGVsbCBzeXN0ZW0uXG4iKTsKPiAt CQlwcl9pbmZvKCJ2ZW5kb3I9JXMsIG1vZGVsPSVzLCB2ZXJzaW9uPSVzXG4iLAo+IC0JCQlpOGtf Z2V0X2RtaV9kYXRhKERNSV9TWVNfVkVORE9SKSwKPiAtCQkJaThrX2dldF9kbWlfZGF0YShETUlf UFJPRFVDVF9OQU1FKSwKPiAtCQkJaThrX2dldF9kbWlfZGF0YShETUlfQklPU19WRVJTSU9OKSk7 Cj4gLQl9Cj4gLQo+IC0Jc3RybGNweShiaW9zX3ZlcnNpb24sIGk4a19nZXRfZG1pX2RhdGEoRE1J X0JJT1NfVkVSU0lPTiksCj4gLQkJc2l6ZW9mKGJpb3NfdmVyc2lvbikpOwo+IC0KPiAtCS8qCj4g LQkgKiBHZXQgU01NIERlbGwgc2lnbmF0dXJlCj4gLQkgKi8KPiAtCWlmIChpOGtfZ2V0X2RlbGxf c2lnbmF0dXJlKEk4S19TTU1fR0VUX0RFTExfU0lHMSkgJiYKPiAtCSAgICBpOGtfZ2V0X2RlbGxf c2lnbmF0dXJlKEk4S19TTU1fR0VUX0RFTExfU0lHMikpIHsKPiAtCQlwcl9lcnIoInVuYWJsZSB0 byBnZXQgU01NIERlbGwgc2lnbmF0dXJlXG4iKTsKPiAtCQlpZiAoIWZvcmNlKQo+IC0JCQlyZXR1 cm4gLUVOT0RFVjsKPiAtCX0KPiAtCj4gLQkvKgo+IC0JICogU2V0IGZhbiBtdWx0aXBsaWVyIGFu ZCBtYXhpbWFsIGZhbiBzcGVlZCBmcm9tIGRtaSBjb25maWcKPiAtCSAqIFZhbHVlcyBzcGVjaWZp ZWQgaW4gbW9kdWxlIHBhcmFtZXRlcnMgb3ZlcnJpZGUgdmFsdWVzIGZyb20gZG1pCj4gLQkgKi8K PiAtCWlkID0gZG1pX2ZpcnN0X21hdGNoKGk4a19kbWlfdGFibGUpOwo+IC0JaWYgKGlkICYmIGlk LT5kcml2ZXJfZGF0YSkgewo+IC0JCWNvbnN0IHN0cnVjdCBpOGtfY29uZmlnX2RhdGEgKmNvbmYg PSBpZC0+ZHJpdmVyX2RhdGE7Cj4gLQkJaWYgKCFmYW5fbXVsdCAmJiBjb25mLT5mYW5fbXVsdCkK PiAtCQkJZmFuX211bHQgPSBjb25mLT5mYW5fbXVsdDsKPiAtCQlpZiAoIWZhbl9tYXggJiYgY29u Zi0+ZmFuX21heCkKPiAtCQkJZmFuX21heCA9IGNvbmYtPmZhbl9tYXg7Cj4gLQl9Cj4gLQo+IC0J aThrX2Zhbl9tYXggPSBmYW5fbWF4ID8gOiBJOEtfRkFOX0hJR0g7CS8qIE11c3Qgbm90IGJlIDAg Ki8KPiAtCWk4a19wd21fbXVsdCA9IERJVl9ST1VORF9VUCgyNTUsIGk4a19mYW5fbWF4KTsKPiAt Cj4gLQlpZiAoIWZhbl9tdWx0KSB7Cj4gLQkJLyoKPiAtCQkgKiBBdXRvZGV0ZWN0IGZhbiBtdWx0 aXBsaWVyIGJhc2VkIG9uIG5vbWluYWwgcnBtCj4gLQkJICogSWYgZmFuIHJlcG9ydHMgcnBtIHZh bHVlIHRvbyBoaWdoIHRoZW4gc2V0IG11bHRpcGxpZXIgdG8gMQo+IC0JCSAqLwo+IC0JCWZvciAo ZmFuID0gMDsgZmFuIDwgMjsgKytmYW4pIHsKPiAtCQkJcmV0ID0gaThrX2dldF9mYW5fbm9taW5h bF9zcGVlZChmYW4sIGk4a19mYW5fbWF4KTsKPiAtCQkJaWYgKHJldCA8IDApCj4gLQkJCQljb250 aW51ZTsKPiAtCQkJaWYgKHJldCA+IEk4S19GQU5fTUFYX1JQTSkKPiAtCQkJCWk4a19mYW5fbXVs dCA9IDE7Cj4gLQkJCWJyZWFrOwo+IC0JCX0KPiAtCX0gZWxzZSB7Cj4gLQkJLyogRmFuIG11bHRp cGxpZXIgd2FzIHNwZWNpZmllZCBpbiBtb2R1bGUgcGFyYW0gb3IgaW4gZG1pICovCj4gLQkJaThr X2Zhbl9tdWx0ID0gZmFuX211bHQ7Cj4gLQl9Cj4gLQo+IC0JcmV0dXJuIDA7Cj4gLX0KPiAtCj4g LXN0YXRpYyBpbnQgX19pbml0IGk4a19pbml0KHZvaWQpCj4gLXsKPiAtCXN0cnVjdCBwcm9jX2Rp cl9lbnRyeSAqcHJvY19pOGs7Cj4gLQlpbnQgZXJyOwo+IC0KPiAtCS8qIEFyZSB3ZSBydW5uaW5n IG9uIGFuIHN1cHBvcnRlZCBsYXB0b3A/ICovCj4gLQlpZiAoaThrX3Byb2JlKCkpCj4gLQkJcmV0 dXJuIC1FTk9ERVY7Cj4gLQo+IC0JLyogUmVnaXN0ZXIgdGhlIHByb2MgZW50cnkgKi8KPiAtCXBy b2NfaThrID0gcHJvY19jcmVhdGUoImk4ayIsIDAsIE5VTEwsICZpOGtfZm9wcyk7Cj4gLQlpZiAo IXByb2NfaThrKQo+IC0JCXJldHVybiAtRU5PRU5UOwo+IC0KPiAtCWVyciA9IGk4a19pbml0X2h3 bW9uKCk7Cj4gLQlpZiAoZXJyKQo+IC0JCWdvdG8gZXhpdF9yZW1vdmVfcHJvYzsKPiAtCj4gLQly ZXR1cm4gMDsKPiAtCj4gLSBleGl0X3JlbW92ZV9wcm9jOgo+IC0JcmVtb3ZlX3Byb2NfZW50cnko Imk4ayIsIE5VTEwpOwo+IC0JcmV0dXJuIGVycjsKPiAtfQo+IC0KPiAtc3RhdGljIHZvaWQgX19l eGl0IGk4a19leGl0KHZvaWQpCj4gLXsKPiAtCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGk4a19o d21vbl9kZXYpOwo+IC0JcmVtb3ZlX3Byb2NfZW50cnkoImk4ayIsIE5VTEwpOwo+IC19Cj4gLQo+ IC1tb2R1bGVfaW5pdChpOGtfaW5pdCk7Cj4gLW1vZHVsZV9leGl0KGk4a19leGl0KTsKPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9od21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUK PiBpbmRleCA2Yzk0MTQ3Li4xYzNlNDU4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaHdtb24vTWFr ZWZpbGUKPiArKysgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4gQEAgLTE1NSw2ICsxNTUsNyBA QCBvYmotJChDT05GSUdfU0VOU09SU19XODNMNzg1VFMpCSs9IHc4M2w3ODV0cy5vCj4gICBvYmot JChDT05GSUdfU0VOU09SU19XODNMNzg2TkcpCSs9IHc4M2w3ODZuZy5vCj4gICBvYmotJChDT05G SUdfU0VOU09SU19XTTgzMVgpCSs9IHdtODMxeC1od21vbi5vCj4gICBvYmotJChDT05GSUdfU0VO U09SU19XTTgzNTApCSs9IHdtODM1MC1od21vbi5vCj4gK29iai0kKENPTkZJR19JOEspCQkrPSBk ZWxsLXNtbS1od21vbi5vCj4KPiAgIG9iai0kKENPTkZJR19QTUJVUykJCSs9IHBtYnVzLwo+Cj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYyBiL2RyaXZlcnMvaHdt b24vZGVsbC1zbW0taHdtb24uYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAw MC4uMmIwNGU0Zgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2h3bW9uL2RlbGwtc21t LWh3bW9uLmMKPiBAQCAtMCwwICsxLDEwMDcgQEAKPiArLyoKPiArICogZGVsbC1zbW0taHdtb24u YyAtLSBMaW51eCBkcml2ZXIgZm9yIGFjY2Vzc2luZyB0aGUgU01NIEJJT1Mgb24gRGVsbCBsYXB0 b3BzLgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMDEgIE1hc3NpbW8gRGFsIFpvdHRvIDxk ekBkZWJpYW4ub3JnPgo+ICsgKgo+ICsgKiBId21vbiBpbnRlZ3JhdGlvbjoKPiArICogQ29weXJp Z2h0IChDKSAyMDExICBKZWFuIERlbHZhcmUgPGpkZWx2YXJlQHN1c2UuZGU+Cj4gKyAqIENvcHly aWdodCAoQykgMjAxMywgMjAxNCAgR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0Pgo+ ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTQsIDIwMTUgIFBhbGkgUm9ow6FyIDxwYWxpLnJvaGFyQGdt YWlsLmNvbT4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKPiArICogdW5kZXIgdGhlIHRlcm1z IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlCj4g KyAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlv dXIgb3B0aW9uKSBhbnkKPiArICogbGF0ZXIgdmVyc2lvbi4KPiArICoKPiArICogVGhpcyBwcm9n cmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1 dAo+ICsgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCj4gKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCj4gKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KPiArICovCj4gKwo+ICsjZGVmaW5lIHByX2ZtdChmbXQpIEtCVUlMRF9N T0ROQU1FICI6ICIgZm10Cj4gKwo+ICsjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L2luaXQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L3NlcV9maWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9kbWkuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KPiArI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9od21vbi5oPgo+ICsjaW5jbHVkZSA8bGludXgvaHdtb24tc3lzZnMuaD4K PiArI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2lvLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2k4ay5oPgo+ ICsKPiArI2RlZmluZSBJOEtfU01NX0ZOX1NUQVRVUwkweDAwMjUKPiArI2RlZmluZSBJOEtfU01N X1BPV0VSX1NUQVRVUwkweDAwNjkKPiArI2RlZmluZSBJOEtfU01NX1NFVF9GQU4JCTB4MDFhMwo+ ICsjZGVmaW5lIEk4S19TTU1fR0VUX0ZBTgkJMHgwMGEzCj4gKyNkZWZpbmUgSThLX1NNTV9HRVRf U1BFRUQJMHgwMmEzCj4gKyNkZWZpbmUgSThLX1NNTV9HRVRfRkFOX1RZUEUJMHgwM2EzCj4gKyNk ZWZpbmUgSThLX1NNTV9HRVRfTk9NX1NQRUVECTB4MDRhMwo+ICsjZGVmaW5lIEk4S19TTU1fR0VU X1RFTVAJMHgxMGEzCj4gKyNkZWZpbmUgSThLX1NNTV9HRVRfVEVNUF9UWVBFCTB4MTFhMwo+ICsj ZGVmaW5lIEk4S19TTU1fR0VUX0RFTExfU0lHMQkweGZlYTMKPiArI2RlZmluZSBJOEtfU01NX0dF VF9ERUxMX1NJRzIJMHhmZmEzCj4gKwo+ICsjZGVmaW5lIEk4S19GQU5fTVVMVAkJMzAKPiArI2Rl ZmluZSBJOEtfRkFOX01BWF9SUE0JCTMwMDAwCj4gKyNkZWZpbmUgSThLX01BWF9URU1QCQkxMjcK PiArCj4gKyNkZWZpbmUgSThLX0ZOX05PTkUJCTB4MDAKPiArI2RlZmluZSBJOEtfRk5fVVAJCTB4 MDEKPiArI2RlZmluZSBJOEtfRk5fRE9XTgkJMHgwMgo+ICsjZGVmaW5lIEk4S19GTl9NVVRFCQkw eDA0Cj4gKyNkZWZpbmUgSThLX0ZOX01BU0sJCTB4MDcKPiArI2RlZmluZSBJOEtfRk5fU0hJRlQJ CTgKPiArCj4gKyNkZWZpbmUgSThLX1BPV0VSX0FDCQkweDA1Cj4gKyNkZWZpbmUgSThLX1BPV0VS X0JBVFRFUlkJMHgwMQo+ICsKPiArc3RhdGljIERFRklORV9NVVRFWChpOGtfbXV0ZXgpOwo+ICtz dGF0aWMgY2hhciBiaW9zX3ZlcnNpb25bNF07Cj4gK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlICppOGtf aHdtb25fZGV2Owo+ICtzdGF0aWMgdTMyIGk4a19od21vbl9mbGFnczsKPiArc3RhdGljIHVpbnQg aThrX2Zhbl9tdWx0ID0gSThLX0ZBTl9NVUxUOwo+ICtzdGF0aWMgdWludCBpOGtfcHdtX211bHQ7 Cj4gK3N0YXRpYyB1aW50IGk4a19mYW5fbWF4ID0gSThLX0ZBTl9ISUdIOwo+ICsKPiArI2RlZmlu ZSBJOEtfSFdNT05fSEFWRV9URU1QMQkoMSA8PCAwKQo+ICsjZGVmaW5lIEk4S19IV01PTl9IQVZF X1RFTVAyCSgxIDw8IDEpCj4gKyNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDMJKDEgPDwgMikK PiArI2RlZmluZSBJOEtfSFdNT05fSEFWRV9URU1QNAkoMSA8PCAzKQo+ICsjZGVmaW5lIEk4S19I V01PTl9IQVZFX0ZBTjEJKDEgPDwgNCkKPiArI2RlZmluZSBJOEtfSFdNT05fSEFWRV9GQU4yCSgx IDw8IDUpCj4gKwo+ICtNT0RVTEVfQVVUSE9SKCJNYXNzaW1vIERhbCBab3R0byAoZHpAZGViaWFu Lm9yZykiKTsKPiArTU9EVUxFX0FVVEhPUigiUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwu Y29tPiIpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIkRyaXZlciBmb3IgYWNjZXNzaW5nIFNNTSBC SU9TIG9uIERlbGwgbGFwdG9wcyIpOwo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIik7Cj4gK01PRFVM RV9BTElBUygiaThrIik7Cj4gKwo+ICtzdGF0aWMgYm9vbCBmb3JjZTsKPiArbW9kdWxlX3BhcmFt KGZvcmNlLCBib29sLCAwKTsKPiArTU9EVUxFX1BBUk1fREVTQyhmb3JjZSwgIkZvcmNlIGxvYWRp bmcgd2l0aG91dCBjaGVja2luZyBmb3Igc3VwcG9ydGVkIG1vZGVscyIpOwo+ICsKPiArc3RhdGlj IGJvb2wgaWdub3JlX2RtaTsKPiArbW9kdWxlX3BhcmFtKGlnbm9yZV9kbWksIGJvb2wsIDApOwo+ ICtNT0RVTEVfUEFSTV9ERVNDKGlnbm9yZV9kbWksICJDb250aW51ZSBwcm9iaW5nIGhhcmR3YXJl IGV2ZW4gaWYgRE1JIGRhdGEgZG9lcyBub3QgbWF0Y2giKTsKPiArCj4gK3N0YXRpYyBib29sIHJl c3RyaWN0ZWQ7Cj4gK21vZHVsZV9wYXJhbShyZXN0cmljdGVkLCBib29sLCAwKTsKPiArTU9EVUxF X1BBUk1fREVTQyhyZXN0cmljdGVkLCAiQWxsb3cgZmFuIGNvbnRyb2wgaWYgU1lTX0FETUlOIGNh cGFiaWxpdHkgc2V0Iik7Cj4gKwo+ICtzdGF0aWMgYm9vbCBwb3dlcl9zdGF0dXM7Cj4gK21vZHVs ZV9wYXJhbShwb3dlcl9zdGF0dXMsIGJvb2wsIDA2MDApOwo+ICtNT0RVTEVfUEFSTV9ERVNDKHBv d2VyX3N0YXR1cywgIlJlcG9ydCBwb3dlciBzdGF0dXMgaW4gL3Byb2MvaThrIik7Cj4gKwo+ICtz dGF0aWMgdWludCBmYW5fbXVsdDsKPiArbW9kdWxlX3BhcmFtKGZhbl9tdWx0LCB1aW50LCAwKTsK PiArTU9EVUxFX1BBUk1fREVTQyhmYW5fbXVsdCwgIkZhY3RvciB0byBtdWx0aXBseSBmYW4gc3Bl ZWQgd2l0aCAoZGVmYXVsdDogYXV0b2RldGVjdCkiKTsKPiArCj4gK3N0YXRpYyB1aW50IGZhbl9t YXg7Cj4gK21vZHVsZV9wYXJhbShmYW5fbWF4LCB1aW50LCAwKTsKPiArTU9EVUxFX1BBUk1fREVT QyhmYW5fbWF4LCAiTWF4aW11bSBjb25maWd1cmFibGUgZmFuIHNwZWVkIChkZWZhdWx0OiBhdXRv ZGV0ZWN0KSIpOwo+ICsKPiArc3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5vZGUgKmlu b2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSk7Cj4gK3N0YXRpYyBsb25nIGk4a19pb2N0bChzdHJ1Y3Qg ZmlsZSAqLCB1bnNpZ25lZCBpbnQsIHVuc2lnbmVkIGxvbmcpOwo+ICsKPiArc3RhdGljIGNvbnN0 IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7Cj4gKwkub3duZXIJCT0gVEhJU19N T0RVTEUsCj4gKwkub3BlbgkJPSBpOGtfb3Blbl9mcywKPiArCS5yZWFkCQk9IHNlcV9yZWFkLAo+ ICsJLmxsc2VlawkJPSBzZXFfbHNlZWssCj4gKwkucmVsZWFzZQk9IHNpbmdsZV9yZWxlYXNlLAo+ ICsJLnVubG9ja2VkX2lvY3RsCT0gaThrX2lvY3RsLAo+ICt9Owo+ICsKPiArc3RydWN0IHNtbV9y ZWdzIHsKPiArCXVuc2lnbmVkIGludCBlYXg7Cj4gKwl1bnNpZ25lZCBpbnQgZWJ4IF9fcGFja2Vk Owo+ICsJdW5zaWduZWQgaW50IGVjeCBfX3BhY2tlZDsKPiArCXVuc2lnbmVkIGludCBlZHggX19w YWNrZWQ7Cj4gKwl1bnNpZ25lZCBpbnQgZXNpIF9fcGFja2VkOwo+ICsJdW5zaWduZWQgaW50IGVk aSBfX3BhY2tlZDsKPiArfTsKPiArCj4gK3N0YXRpYyBpbmxpbmUgY29uc3QgY2hhciAqaThrX2dl dF9kbWlfZGF0YShpbnQgZmllbGQpCj4gK3sKPiArCWNvbnN0IGNoYXIgKmRtaV9kYXRhID0gZG1p X2dldF9zeXN0ZW1faW5mbyhmaWVsZCk7Cj4gKwo+ICsJcmV0dXJuIGRtaV9kYXRhICYmICpkbWlf ZGF0YSA/IGRtaV9kYXRhIDogIj8iOwo+ICt9Cj4gKwo+ICsvKgo+ICsgKiBDYWxsIHRoZSBTeXN0 ZW0gTWFuYWdlbWVudCBNb2RlIEJJT1MuIENvZGUgcHJvdmlkZWQgYnkgSm9uYXRoYW4gQnV6emFy ZC4KPiArICovCj4gK3N0YXRpYyBpbnQgaThrX3NtbShzdHJ1Y3Qgc21tX3JlZ3MgKnJlZ3MpCj4g K3sKPiArCWludCByYzsKPiArCWludCBlYXggPSByZWdzLT5lYXg7Cj4gKwljcHVtYXNrX3Zhcl90 IG9sZF9tYXNrOwo+ICsKPiArCS8qIFNNTSByZXF1aXJlcyBDUFUgMCAqLwo+ICsJaWYgKCFhbGxv Y19jcHVtYXNrX3Zhcigmb2xkX21hc2ssIEdGUF9LRVJORUwpKQo+ICsJCXJldHVybiAtRU5PTUVN Owo+ICsJY3B1bWFza19jb3B5KG9sZF9tYXNrLCAmY3VycmVudC0+Y3B1c19hbGxvd2VkKTsKPiAr CXJjID0gc2V0X2NwdXNfYWxsb3dlZF9wdHIoY3VycmVudCwgY3B1bWFza19vZigwKSk7Cj4gKwlp ZiAocmMpCj4gKwkJZ290byBvdXQ7Cj4gKwlpZiAoc21wX3Byb2Nlc3Nvcl9pZCgpICE9IDApIHsK PiArCQlyYyA9IC1FQlVTWTsKPiArCQlnb3RvIG91dDsKPiArCX0KPiArCj4gKyNpZiBkZWZpbmVk KENPTkZJR19YODZfNjQpCj4gKwlhc20gdm9sYXRpbGUoInB1c2hxICUlcmF4XG5cdCIKPiArCQki bW92bCAwKCUlcmF4KSwlJWVkeFxuXHQiCj4gKwkJInB1c2hxICUlcmR4XG5cdCIKPiArCQkibW92 bCA0KCUlcmF4KSwlJWVieFxuXHQiCj4gKwkJIm1vdmwgOCglJXJheCksJSVlY3hcblx0Igo+ICsJ CSJtb3ZsIDEyKCUlcmF4KSwlJWVkeFxuXHQiCj4gKwkJIm1vdmwgMTYoJSVyYXgpLCUlZXNpXG5c dCIKPiArCQkibW92bCAyMCglJXJheCksJSVlZGlcblx0Igo+ICsJCSJwb3BxICUlcmF4XG5cdCIK PiArCQkib3V0ICUlYWwsJDB4YjJcblx0Igo+ICsJCSJvdXQgJSVhbCwkMHg4NFxuXHQiCj4gKwkJ InhjaGdxICUlcmF4LCglJXJzcClcblx0Igo+ICsJCSJtb3ZsICUlZWJ4LDQoJSVyYXgpXG5cdCIK PiArCQkibW92bCAlJWVjeCw4KCUlcmF4KVxuXHQiCj4gKwkJIm1vdmwgJSVlZHgsMTIoJSVyYXgp XG5cdCIKPiArCQkibW92bCAlJWVzaSwxNiglJXJheClcblx0Igo+ICsJCSJtb3ZsICUlZWRpLDIw KCUlcmF4KVxuXHQiCj4gKwkJInBvcHEgJSVyZHhcblx0Igo+ICsJCSJtb3ZsICUlZWR4LDAoJSVy YXgpXG5cdCIKPiArCQkicHVzaGZxXG5cdCIKPiArCQkicG9wcSAlJXJheFxuXHQiCj4gKwkJImFu ZGwgJDEsJSVlYXhcbiIKPiArCQk6ICI9YSIocmMpCj4gKwkJOiAgICAiYSIocmVncykKPiArCQk6 ICAgICIlZWJ4IiwgIiVlY3giLCAiJWVkeCIsICIlZXNpIiwgIiVlZGkiLCAibWVtb3J5Iik7Cj4g KyNlbHNlCj4gKwlhc20gdm9sYXRpbGUoInB1c2hsICUlZWF4XG5cdCIKPiArCSAgICAibW92bCAw KCUlZWF4KSwlJWVkeFxuXHQiCj4gKwkgICAgInB1c2ggJSVlZHhcblx0Igo+ICsJICAgICJtb3Zs IDQoJSVlYXgpLCUlZWJ4XG5cdCIKPiArCSAgICAibW92bCA4KCUlZWF4KSwlJWVjeFxuXHQiCj4g KwkgICAgIm1vdmwgMTIoJSVlYXgpLCUlZWR4XG5cdCIKPiArCSAgICAibW92bCAxNiglJWVheCks JSVlc2lcblx0Igo+ICsJICAgICJtb3ZsIDIwKCUlZWF4KSwlJWVkaVxuXHQiCj4gKwkgICAgInBv cGwgJSVlYXhcblx0Igo+ICsJICAgICJvdXQgJSVhbCwkMHhiMlxuXHQiCj4gKwkgICAgIm91dCAl JWFsLCQweDg0XG5cdCIKPiArCSAgICAieGNoZ2wgJSVlYXgsKCUlZXNwKVxuXHQiCj4gKwkgICAg Im1vdmwgJSVlYngsNCglJWVheClcblx0Igo+ICsJICAgICJtb3ZsICUlZWN4LDgoJSVlYXgpXG5c dCIKPiArCSAgICAibW92bCAlJWVkeCwxMiglJWVheClcblx0Igo+ICsJICAgICJtb3ZsICUlZXNp LDE2KCUlZWF4KVxuXHQiCj4gKwkgICAgIm1vdmwgJSVlZGksMjAoJSVlYXgpXG5cdCIKPiArCSAg ICAicG9wbCAlJWVkeFxuXHQiCj4gKwkgICAgIm1vdmwgJSVlZHgsMCglJWVheClcblx0Igo+ICsJ ICAgICJsYWhmXG5cdCIKPiArCSAgICAic2hybCAkOCwlJWVheFxuXHQiCj4gKwkgICAgImFuZGwg JDEsJSVlYXhcbiIKPiArCSAgICA6ICI9YSIocmMpCj4gKwkgICAgOiAgICAiYSIocmVncykKPiAr CSAgICA6ICAgICIlZWJ4IiwgIiVlY3giLCAiJWVkeCIsICIlZXNpIiwgIiVlZGkiLCAibWVtb3J5 Iik7Cj4gKyNlbmRpZgo+ICsJaWYgKHJjICE9IDAgfHwgKHJlZ3MtPmVheCAmIDB4ZmZmZikgPT0g MHhmZmZmIHx8IHJlZ3MtPmVheCA9PSBlYXgpCj4gKwkJcmMgPSAtRUlOVkFMOwo+ICsKPiArb3V0 Ogo+ICsJc2V0X2NwdXNfYWxsb3dlZF9wdHIoY3VycmVudCwgb2xkX21hc2spOwo+ICsJZnJlZV9j cHVtYXNrX3ZhcihvbGRfbWFzayk7Cj4gKwlyZXR1cm4gcmM7Cj4gK30KPiArCj4gKy8qCj4gKyAq IFJlYWQgdGhlIEZuIGtleSBzdGF0dXMuCj4gKyAqLwo+ICtzdGF0aWMgaW50IGk4a19nZXRfZm5f c3RhdHVzKHZvaWQpCj4gK3sKPiArCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThL X1NNTV9GTl9TVEFUVVMsIH07Cj4gKwlpbnQgcmM7Cj4gKwo+ICsJcmMgPSBpOGtfc21tKCZyZWdz KTsKPiArCWlmIChyYyA8IDApCj4gKwkJcmV0dXJuIHJjOwo+ICsKPiArCXN3aXRjaCAoKHJlZ3Mu ZWF4ID4+IEk4S19GTl9TSElGVCkgJiBJOEtfRk5fTUFTSykgewo+ICsJY2FzZSBJOEtfRk5fVVA6 Cj4gKwkJcmV0dXJuIEk4S19WT0xfVVA7Cj4gKwljYXNlIEk4S19GTl9ET1dOOgo+ICsJCXJldHVy biBJOEtfVk9MX0RPV047Cj4gKwljYXNlIEk4S19GTl9NVVRFOgo+ICsJCXJldHVybiBJOEtfVk9M X01VVEU7Cj4gKwlkZWZhdWx0Ogo+ICsJCXJldHVybiAwOwo+ICsJfQo+ICt9Cj4gKwo+ICsvKgo+ ICsgKiBSZWFkIHRoZSBwb3dlciBzdGF0dXMuCj4gKyAqLwo+ICtzdGF0aWMgaW50IGk4a19nZXRf cG93ZXJfc3RhdHVzKHZvaWQpCj4gK3sKPiArCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4 ID0gSThLX1NNTV9QT1dFUl9TVEFUVVMsIH07Cj4gKwlpbnQgcmM7Cj4gKwo+ICsJcmMgPSBpOGtf c21tKCZyZWdzKTsKPiArCWlmIChyYyA8IDApCj4gKwkJcmV0dXJuIHJjOwo+ICsKPiArCXJldHVy biAocmVncy5lYXggJiAweGZmKSA9PSBJOEtfUE9XRVJfQUMgPyBJOEtfQUMgOiBJOEtfQkFUVEVS WTsKPiArfQo+ICsKPiArLyoKPiArICogUmVhZCB0aGUgZmFuIHN0YXR1cy4KPiArICovCj4gK3N0 YXRpYyBpbnQgaThrX2dldF9mYW5fc3RhdHVzKGludCBmYW4pCj4gK3sKPiArCXN0cnVjdCBzbW1f cmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfRkFOLCB9Owo+ICsKPiArCXJlZ3MuZWJ4 ID0gZmFuICYgMHhmZjsKPiArCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAw eGZmOwo+ICt9Cj4gKwo+ICsvKgo+ICsgKiBSZWFkIHRoZSBmYW4gc3BlZWQgaW4gUlBNLgo+ICsg Ki8KPiArc3RhdGljIGludCBpOGtfZ2V0X2Zhbl9zcGVlZChpbnQgZmFuKQo+ICt7Cj4gKwlzdHJ1 Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fR0VUX1NQRUVELCB9Owo+ICsKPiAr CXJlZ3MuZWJ4ID0gZmFuICYgMHhmZjsKPiArCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogKHJl Z3MuZWF4ICYgMHhmZmZmKSAqIGk4a19mYW5fbXVsdDsKPiArfQo+ICsKPiArLyoKPiArICogUmVh ZCB0aGUgZmFuIHR5cGUuCj4gKyAqLwo+ICtzdGF0aWMgaW50IGk4a19nZXRfZmFuX3R5cGUoaW50 IGZhbikKPiArewo+ICsJc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0dF VF9GQU5fVFlQRSwgfTsKPiArCj4gKwlyZWdzLmVieCA9IGZhbiAmIDB4ZmY7Cj4gKwlyZXR1cm4g aThrX3NtbSgmcmVncykgPyA6IHJlZ3MuZWF4ICYgMHhmZjsKPiArfQo+ICsKPiArLyoKPiArICog UmVhZCB0aGUgZmFuIG5vbWluYWwgcnBtIGZvciBzcGVjaWZpYyBmYW4gc3BlZWQuCj4gKyAqLwo+ ICtzdGF0aWMgaW50IGk4a19nZXRfZmFuX25vbWluYWxfc3BlZWQoaW50IGZhbiwgaW50IHNwZWVk KQo+ICt7Cj4gKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fR0VUX05P TV9TUEVFRCwgfTsKPiArCj4gKwlyZWdzLmVieCA9IChmYW4gJiAweGZmKSB8IChzcGVlZCA8PCA4 KTsKPiArCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogKHJlZ3MuZWF4ICYgMHhmZmZmKSAqIGk4 a19mYW5fbXVsdDsKPiArfQo+ICsKPiArLyoKPiArICogU2V0IHRoZSBmYW4gc3BlZWQgKG9mZiwg bG93LCBoaWdoKS4gUmV0dXJucyB0aGUgbmV3IGZhbiBzdGF0dXMuCj4gKyAqLwo+ICtzdGF0aWMg aW50IGk4a19zZXRfZmFuKGludCBmYW4sIGludCBzcGVlZCkKPiArewo+ICsJc3RydWN0IHNtbV9y ZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX1NFVF9GQU4sIH07Cj4gKwo+ICsJc3BlZWQgPSAo c3BlZWQgPCAwKSA/IDAgOiAoKHNwZWVkID4gaThrX2Zhbl9tYXgpID8gaThrX2Zhbl9tYXggOiBz cGVlZCk7Cj4gKwlyZWdzLmVieCA9IChmYW4gJiAweGZmKSB8IChzcGVlZCA8PCA4KTsKPiArCj4g KwlyZXR1cm4gaThrX3NtbSgmcmVncykgPyA6IGk4a19nZXRfZmFuX3N0YXR1cyhmYW4pOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgaW50IGk4a19nZXRfdGVtcF90eXBlKGludCBzZW5zb3IpCj4gK3sKPiAr CXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfVEVNUF9UWVBFLCB9 Owo+ICsKPiArCXJlZ3MuZWJ4ID0gc2Vuc29yICYgMHhmZjsKPiArCXJldHVybiBpOGtfc21tKCZy ZWdzKSA/IDogcmVncy5lYXggJiAweGZmOwo+ICt9Cj4gKwo+ICsvKgo+ICsgKiBSZWFkIHRoZSBj cHUgdGVtcGVyYXR1cmUuCj4gKyAqLwo+ICtzdGF0aWMgaW50IF9pOGtfZ2V0X3RlbXAoaW50IHNl bnNvcikKPiArewo+ICsJc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7Cj4gKwkJLmVheCA9IEk4S19T TU1fR0VUX1RFTVAsCj4gKwkJLmVieCA9IHNlbnNvciAmIDB4ZmYsCj4gKwl9Owo+ICsKPiArCXJl dHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAweGZmOwo+ICt9Cj4gKwo+ICtzdGF0 aWMgaW50IGk4a19nZXRfdGVtcChpbnQgc2Vuc29yKQo+ICt7Cj4gKwlpbnQgdGVtcCA9IF9pOGtf Z2V0X3RlbXAoc2Vuc29yKTsKPiArCj4gKwkvKgo+ICsJICogU29tZXRpbWVzIHRoZSB0ZW1wZXJh dHVyZSBzZW5zb3IgcmV0dXJucyAweDk5LCB3aGljaCBpcyBvdXQgb2YgcmFuZ2UuCj4gKwkgKiBJ biB0aGlzIGNhc2Ugd2UgcmV0cnkgKG9uY2UpIGJlZm9yZSByZXR1cm5pbmcgYW4gZXJyb3IuCj4g KwkgIyAxMDAzNjU1MTM3IDAwMDAwMDU4IDAwMDA1YTRiCj4gKwkgIyAxMDAzNjU1MTM4IDAwMDAw MDk5IDAwMDAzYTgwIDwtLS0gMHg5OSA9IDE1MyBkZWdyZWVzCj4gKwkgIyAxMDAzNjU1MTM5IDAw MDAwMDU0IDAwMDA1YzUyCj4gKwkgKi8KPiArCWlmICh0ZW1wID09IDB4OTkpIHsKPiArCQltc2xl ZXAoMTAwKTsKPiArCQl0ZW1wID0gX2k4a19nZXRfdGVtcChzZW5zb3IpOwo+ICsJfQo+ICsJLyoK PiArCSAqIFJldHVybiAtRU5PREFUQSBmb3IgYWxsIGludmFsaWQgdGVtcGVyYXR1cmVzLgo+ICsJ ICoKPiArCSAqIEtub3duIGluc3RhbmNlcyBhcmUgdGhlIDB4OTkgdmFsdWUgYXMgc2VlbiBhYm92 ZSBhcyB3ZWxsIGFzCj4gKwkgKiAweGMxICgxOTMpLCB3aGljaCBtYXkgYmUgcmV0dXJuZWQgd2hl biB0cnlpbmcgdG8gcmVhZCB0aGUgR1BVCj4gKwkgKiB0ZW1wZXJhdHVyZSBpZiB0aGUgc3lzdGVt IHN1cHBvcnRzIGEgR1BVIGFuZCBpdCBpcyBjdXJyZW50bHkKPiArCSAqIHR1cm5lZCBvZmYuCj4g KwkgKi8KPiArCWlmICh0ZW1wID4gSThLX01BWF9URU1QKQo+ICsJCXJldHVybiAtRU5PREFUQTsK PiArCj4gKwlyZXR1cm4gdGVtcDsKPiArfQo+ICsKPiArc3RhdGljIGludCBpOGtfZ2V0X2RlbGxf c2lnbmF0dXJlKGludCByZXFfZm4pCj4gK3sKPiArCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAu ZWF4ID0gcmVxX2ZuLCB9Owo+ICsJaW50IHJjOwo+ICsKPiArCXJjID0gaThrX3NtbSgmcmVncyk7 Cj4gKwlpZiAocmMgPCAwKQo+ICsJCXJldHVybiByYzsKPiArCj4gKwlyZXR1cm4gcmVncy5lYXgg PT0gMTE0NTY1MTUyNyAmJiByZWdzLmVkeCA9PSAxMTQ1MzkyMjA0ID8gMCA6IC0xOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgaW50Cj4gK2k4a19pb2N0bF91bmxvY2tlZChzdHJ1Y3QgZmlsZSAqZnAsIHVu c2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQo+ICt7Cj4gKwlpbnQgdmFsID0gMDsK PiArCWludCBzcGVlZDsKPiArCXVuc2lnbmVkIGNoYXIgYnVmZlsxNl07Cj4gKwlpbnQgX191c2Vy ICphcmdwID0gKGludCBfX3VzZXIgKilhcmc7Cj4gKwo+ICsJaWYgKCFhcmdwKQo+ICsJCXJldHVy biAtRUlOVkFMOwo+ICsKPiArCXN3aXRjaCAoY21kKSB7Cj4gKwljYXNlIEk4S19CSU9TX1ZFUlNJ T046Cj4gKwkJdmFsID0gKGJpb3NfdmVyc2lvblswXSA8PCAxNikgfAo+ICsJCQkJKGJpb3NfdmVy c2lvblsxXSA8PCA4KSB8IGJpb3NfdmVyc2lvblsyXTsKPiArCQlicmVhazsKPiArCj4gKwljYXNl IEk4S19NQUNISU5FX0lEOgo+ICsJCW1lbXNldChidWZmLCAwLCAxNik7Cj4gKwkJc3RybGNweShi dWZmLCBpOGtfZ2V0X2RtaV9kYXRhKERNSV9QUk9EVUNUX1NFUklBTCksCj4gKwkJCXNpemVvZihi dWZmKSk7Cj4gKwkJYnJlYWs7Cj4gKwo+ICsJY2FzZSBJOEtfRk5fU1RBVFVTOgo+ICsJCXZhbCA9 IGk4a19nZXRfZm5fc3RhdHVzKCk7Cj4gKwkJYnJlYWs7Cj4gKwo+ICsJY2FzZSBJOEtfUE9XRVJf U1RBVFVTOgo+ICsJCXZhbCA9IGk4a19nZXRfcG93ZXJfc3RhdHVzKCk7Cj4gKwkJYnJlYWs7Cj4g Kwo+ICsJY2FzZSBJOEtfR0VUX1RFTVA6Cj4gKwkJdmFsID0gaThrX2dldF90ZW1wKDApOwo+ICsJ CWJyZWFrOwo+ICsKPiArCWNhc2UgSThLX0dFVF9TUEVFRDoKPiArCQlpZiAoY29weV9mcm9tX3Vz ZXIoJnZhbCwgYXJncCwgc2l6ZW9mKGludCkpKQo+ICsJCQlyZXR1cm4gLUVGQVVMVDsKPiArCj4g KwkJdmFsID0gaThrX2dldF9mYW5fc3BlZWQodmFsKTsKPiArCQlicmVhazsKPiArCj4gKwljYXNl IEk4S19HRVRfRkFOOgo+ICsJCWlmIChjb3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBzaXplb2Yo aW50KSkpCj4gKwkJCXJldHVybiAtRUZBVUxUOwo+ICsKPiArCQl2YWwgPSBpOGtfZ2V0X2Zhbl9z dGF0dXModmFsKTsKPiArCQlicmVhazsKPiArCj4gKwljYXNlIEk4S19TRVRfRkFOOgo+ICsJCWlm IChyZXN0cmljdGVkICYmICFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQo+ICsJCQlyZXR1cm4gLUVQ RVJNOwo+ICsKPiArCQlpZiAoY29weV9mcm9tX3VzZXIoJnZhbCwgYXJncCwgc2l6ZW9mKGludCkp KQo+ICsJCQlyZXR1cm4gLUVGQVVMVDsKPiArCj4gKwkJaWYgKGNvcHlfZnJvbV91c2VyKCZzcGVl ZCwgYXJncCArIDEsIHNpemVvZihpbnQpKSkKPiArCQkJcmV0dXJuIC1FRkFVTFQ7Cj4gKwo+ICsJ CXZhbCA9IGk4a19zZXRfZmFuKHZhbCwgc3BlZWQpOwo+ICsJCWJyZWFrOwo+ICsKPiArCWRlZmF1 bHQ6Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJaWYgKHZhbCA8IDApCj4gKwkJ cmV0dXJuIHZhbDsKPiArCj4gKwlzd2l0Y2ggKGNtZCkgewo+ICsJY2FzZSBJOEtfQklPU19WRVJT SU9OOgo+ICsJCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgJnZhbCwgNCkpCj4gKwkJCXJldHVybiAt RUZBVUxUOwo+ICsKPiArCQlicmVhazsKPiArCWNhc2UgSThLX01BQ0hJTkVfSUQ6Cj4gKwkJaWYg KGNvcHlfdG9fdXNlcihhcmdwLCBidWZmLCAxNikpCj4gKwkJCXJldHVybiAtRUZBVUxUOwo+ICsK PiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJaWYgKGNvcHlfdG9fdXNlcihhcmdwLCAmdmFs LCBzaXplb2YoaW50KSkpCj4gKwkJCXJldHVybiAtRUZBVUxUOwo+ICsKPiArCQlicmVhazsKPiAr CX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGxvbmcgaThrX2lvY3RsKHN0 cnVjdCBmaWxlICpmcCwgdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCj4gK3sK PiArCWxvbmcgcmV0Owo+ICsKPiArCW11dGV4X2xvY2soJmk4a19tdXRleCk7Cj4gKwlyZXQgPSBp OGtfaW9jdGxfdW5sb2NrZWQoZnAsIGNtZCwgYXJnKTsKPiArCW11dGV4X3VubG9jaygmaThrX211 dGV4KTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICsvKgo+ICsgKiBQcmludCB0aGUg aW5mb3JtYXRpb24gZm9yIC9wcm9jL2k4ay4KPiArICovCj4gK3N0YXRpYyBpbnQgaThrX3Byb2Nf c2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqb2Zmc2V0KQo+ICt7Cj4gKwlpbnQgZm5f a2V5LCBjcHVfdGVtcCwgYWNfcG93ZXI7Cj4gKwlpbnQgbGVmdF9mYW4sIHJpZ2h0X2ZhbiwgbGVm dF9zcGVlZCwgcmlnaHRfc3BlZWQ7Cj4gKwo+ICsJY3B1X3RlbXAJPSBpOGtfZ2V0X3RlbXAoMCk7 CQkJLyogMTExMDAgwrVzICovCj4gKwlsZWZ0X2Zhbgk9IGk4a19nZXRfZmFuX3N0YXR1cyhJOEtf RkFOX0xFRlQpOwkvKiAgIDU4MCDCtXMgKi8KPiArCXJpZ2h0X2Zhbgk9IGk4a19nZXRfZmFuX3N0 YXR1cyhJOEtfRkFOX1JJR0hUKTsJLyogICA1ODAgwrVzICovCj4gKwlsZWZ0X3NwZWVkCT0gaThr X2dldF9mYW5fc3BlZWQoSThLX0ZBTl9MRUZUKTsJLyogICA1ODAgwrVzICovCj4gKwlyaWdodF9z cGVlZAk9IGk4a19nZXRfZmFuX3NwZWVkKEk4S19GQU5fUklHSFQpOwkvKiAgIDU4MCDCtXMgKi8K PiArCWZuX2tleQkJPSBpOGtfZ2V0X2ZuX3N0YXR1cygpOwkJCS8qICAgNzUwIMK1cyAqLwo+ICsJ aWYgKHBvd2VyX3N0YXR1cykKPiArCQlhY19wb3dlciA9IGk4a19nZXRfcG93ZXJfc3RhdHVzKCk7 CQkvKiAxNDcwMCDCtXMgKi8KPiArCWVsc2UKPiArCQlhY19wb3dlciA9IC0xOwo+ICsKPiArCS8q Cj4gKwkgKiBJbmZvOgo+ICsJICoKPiArCSAqIDEpICBGb3JtYXQgdmVyc2lvbiAodGhpcyB3aWxs IGNoYW5nZSBpZiBmb3JtYXQgY2hhbmdlcykKPiArCSAqIDIpICBCSU9TIHZlcnNpb24KPiArCSAq IDMpICBCSU9TIG1hY2hpbmUgSUQKPiArCSAqIDQpICBDcHUgdGVtcGVyYXR1cmUKPiArCSAqIDUp ICBMZWZ0IGZhbiBzdGF0dXMKPiArCSAqIDYpICBSaWdodCBmYW4gc3RhdHVzCj4gKwkgKiA3KSAg TGVmdCBmYW4gc3BlZWQKPiArCSAqIDgpICBSaWdodCBmYW4gc3BlZWQKPiArCSAqIDkpICBBQyBw b3dlcgo+ICsJICogMTApIEZuIEtleSBzdGF0dXMKPiArCSAqLwo+ICsJcmV0dXJuIHNlcV9wcmlu dGYoc2VxLCAiJXMgJXMgJXMgJWQgJWQgJWQgJWQgJWQgJWQgJWRcbiIsCj4gKwkJCSAgSThLX1BS T0NfRk1ULAo+ICsJCQkgIGJpb3NfdmVyc2lvbiwKPiArCQkJICBpOGtfZ2V0X2RtaV9kYXRhKERN SV9QUk9EVUNUX1NFUklBTCksCj4gKwkJCSAgY3B1X3RlbXAsCj4gKwkJCSAgbGVmdF9mYW4sIHJp Z2h0X2ZhbiwgbGVmdF9zcGVlZCwgcmlnaHRfc3BlZWQsCj4gKwkJCSAgYWNfcG93ZXIsIGZuX2tl eSk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgaThrX29wZW5fZnMoc3RydWN0IGlub2RlICppbm9k ZSwgc3RydWN0IGZpbGUgKmZpbGUpCj4gK3sKPiArCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBp OGtfcHJvY19zaG93LCBOVUxMKTsKPiArfQo+ICsKPiArCj4gKy8qCj4gKyAqIEh3bW9uIGludGVy ZmFjZQo+ICsgKi8KPiArCj4gK3N0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zaG93X3RlbXBfbGFi ZWwoc3RydWN0IGRldmljZSAqZGV2LAo+ICsJCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq ZGV2YXR0ciwKPiArCQkJCQkgY2hhciAqYnVmKQo+ICt7Cj4gKwlzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IGxhYmVsc1tdID0gewo+ICsJCSJDUFUiLAo+ICsJCSJHUFUiLAo+ICsJCSJTT0RJTU0i LAo+ICsJCSJPdGhlciIsCj4gKwkJIkFtYmllbnQiLAo+ICsJCSJPdGhlciIsCj4gKwl9Owo+ICsJ aW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKPiArCWludCB0 eXBlOwo+ICsKPiArCXR5cGUgPSBpOGtfZ2V0X3RlbXBfdHlwZShpbmRleCk7Cj4gKwlpZiAodHlw ZSA8IDApCj4gKwkJcmV0dXJuIHR5cGU7Cj4gKwlpZiAodHlwZSA+PSBBUlJBWV9TSVpFKGxhYmVs cykpCj4gKwkJdHlwZSA9IEFSUkFZX1NJWkUobGFiZWxzKSAtIDE7Cj4gKwlyZXR1cm4gc3ByaW50 ZihidWYsICIlc1xuIiwgbGFiZWxzW3R5cGVdKTsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3Qg aThrX2h3bW9uX3Nob3dfdGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQkgICBzdHJ1Y3Qg ZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKPiArCQkJCSAgIGNoYXIgKmJ1ZikKPiArewo+ICsJ aW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKPiArCWludCB0 ZW1wOwo+ICsKPiArCXRlbXAgPSBpOGtfZ2V0X3RlbXAoaW5kZXgpOwo+ICsJaWYgKHRlbXAgPCAw KQo+ICsJCXJldHVybiB0ZW1wOwo+ICsJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIHRlbXAg KiAxMDAwKTsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3dfZmFuX2xh YmVsKHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq ZGV2YXR0ciwKPiArCQkJCQljaGFyICpidWYpCj4gK3sKPiArCXN0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgbGFiZWxzW10gPSB7Cj4gKwkJIlByb2Nlc3NvciBGYW4iLAo+ICsJCSJNb3RoZXJib2Fy ZCBGYW4iLAo+ICsJCSJWaWRlbyBGYW4iLAo+ICsJCSJQb3dlciBTdXBwbHkgRmFuIiwKPiArCQki Q2hpcHNldCBGYW4iLAo+ICsJCSJPdGhlciBGYW4iLAo+ICsJfTsKPiArCWludCBpbmRleCA9IHRv X3NlbnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+aW5kZXg7Cj4gKwlib29sIGRvY2sgPSBmYWxzZTsK PiArCWludCB0eXBlOwo+ICsKPiArCXR5cGUgPSBpOGtfZ2V0X2Zhbl90eXBlKGluZGV4KTsKPiAr CWlmICh0eXBlIDwgMCkKPiArCQlyZXR1cm4gdHlwZTsKPiArCj4gKwlpZiAodHlwZSAmIDB4MTAp IHsKPiArCQlkb2NrID0gdHJ1ZTsKPiArCQl0eXBlICY9IDB4MEY7Cj4gKwl9Cj4gKwo+ICsJaWYg KHR5cGUgPj0gQVJSQVlfU0laRShsYWJlbHMpKQo+ICsJCXR5cGUgPSAoQVJSQVlfU0laRShsYWJl bHMpIC0gMSk7Cj4gKwo+ICsJcmV0dXJuIHNwcmludGYoYnVmLCAiJXMlc1xuIiwgKGRvY2sgPyAi RG9ja2luZyAiIDogIiIpLCBsYWJlbHNbdHlwZV0pOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVf dCBpOGtfaHdtb25fc2hvd19mYW4oc3RydWN0IGRldmljZSAqZGV2LAo+ICsJCQkJICBzdHJ1Y3Qg ZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKPiArCQkJCSAgY2hhciAqYnVmKQo+ICt7Cj4gKwlp bnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4Owo+ICsJaW50IGZh bl9zcGVlZDsKPiArCj4gKwlmYW5fc3BlZWQgPSBpOGtfZ2V0X2Zhbl9zcGVlZChpbmRleCk7Cj4g KwlpZiAoZmFuX3NwZWVkIDwgMCkKPiArCQlyZXR1cm4gZmFuX3NwZWVkOwo+ICsJcmV0dXJuIHNw cmludGYoYnVmLCAiJWRcbiIsIGZhbl9zcGVlZCk7Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90 IGk4a19od21vbl9zaG93X3B3bShzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQkgIHN0cnVjdCBk ZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLAo+ICsJCQkJICBjaGFyICpidWYpCj4gK3sKPiArCWlu dCBpbmRleCA9IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+aW5kZXg7Cj4gKwlpbnQgc3Rh dHVzOwo+ICsKPiArCXN0YXR1cyA9IGk4a19nZXRfZmFuX3N0YXR1cyhpbmRleCk7Cj4gKwlpZiAo c3RhdHVzIDwgMCkKPiArCQlyZXR1cm4gLUVJTzsKPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVk XG4iLCBjbGFtcF92YWwoc3RhdHVzICogaThrX3B3bV9tdWx0LCAwLCAyNTUpKTsKPiArfQo+ICsK PiArc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3NldF9wd20oc3RydWN0IGRldmljZSAqZGV2LAo+ ICsJCQkJIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+ICsJCQkJIGNvbnN0IGNoYXIg KmJ1Ziwgc2l6ZV90IGNvdW50KQo+ICt7Cj4gKwlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0 dHIoYXR0ciktPmluZGV4Owo+ICsJdW5zaWduZWQgbG9uZyB2YWw7Cj4gKwlpbnQgZXJyOwo+ICsK PiArCWVyciA9IGtzdHJ0b3VsKGJ1ZiwgMTAsICZ2YWwpOwo+ICsJaWYgKGVycikKPiArCQlyZXR1 cm4gZXJyOwo+ICsJdmFsID0gY2xhbXBfdmFsKERJVl9ST1VORF9DTE9TRVNUKHZhbCwgaThrX3B3 bV9tdWx0KSwgMCwgaThrX2Zhbl9tYXgpOwo+ICsKPiArCW11dGV4X2xvY2soJmk4a19tdXRleCk7 Cj4gKwllcnIgPSBpOGtfc2V0X2ZhbihpbmRleCwgdmFsKTsKPiArCW11dGV4X3VubG9jaygmaThr X211dGV4KTsKPiArCj4gKwlyZXR1cm4gZXJyIDwgMCA/IC1FSU8gOiBjb3VudDsKPiArfQo+ICsK PiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywgaThrX2h3 bW9uX3Nob3dfdGVtcCwgTlVMTCwgMCk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVt cDFfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwsIE5VTEwsCj4gKwkJ CSAgMCk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDJfaW5wdXQsIFNfSVJVR08s IGk4a19od21vbl9zaG93X3RlbXAsIE5VTEwsIDEpOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9B VFRSKHRlbXAyX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wX2xhYmVsLCBOVUxM LAo+ICsJCQkgIDEpOwo+ICtzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAzX2lucHV0LCBT X0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAyKTsKPiArc3RhdGljIFNFTlNPUl9E RVZJQ0VfQVRUUih0ZW1wM19sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJl bCwgTlVMTCwKPiArCQkJICAyKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wNF9p bnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcCwgTlVMTCwgMyk7Cj4gK3N0YXRpYyBT RU5TT1JfREVWSUNFX0FUVFIodGVtcDRfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3Rl bXBfbGFiZWwsIE5VTEwsCj4gKwkJCSAgMyk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIo ZmFuMV9pbnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuLCBOVUxMLCAwKTsKPiArc3Rh dGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4xX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25fc2hv d19mYW5fbGFiZWwsIE5VTEwsCj4gKwkJCSAgMCk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FU VFIocHdtMSwgU19JUlVHTyB8IFNfSVdVU1IsIGk4a19od21vbl9zaG93X3B3bSwKPiArCQkJICBp OGtfaHdtb25fc2V0X3B3bSwgMCk7Cj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFuMl9p bnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuLCBOVUxMLAo+ICsJCQkgIDEpOwo+ICtz dGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGZhbjJfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9z aG93X2Zhbl9sYWJlbCwgTlVMTCwKPiArCQkJICAxKTsKPiArc3RhdGljIFNFTlNPUl9ERVZJQ0Vf QVRUUihwd20yLCBTX0lSVUdPIHwgU19JV1VTUiwgaThrX2h3bW9uX3Nob3dfcHdtLAo+ICsJCQkg IGk4a19od21vbl9zZXRfcHdtLCAxKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpp OGtfYXR0cnNbXSA9IHsKPiArCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfaW5wdXQuZGV2X2F0dHIu YXR0ciwJLyogMCAqLwo+ICsJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9sYWJlbC5kZXZfYXR0ci5h dHRyLAkvKiAxICovCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAyX2lucHV0LmRldl9hdHRyLmF0 dHIsCS8qIDIgKi8KPiArCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDJfbGFiZWwuZGV2X2F0dHIuYXR0 ciwJLyogMyAqLwo+ICsJJnNlbnNvcl9kZXZfYXR0cl90ZW1wM19pbnB1dC5kZXZfYXR0ci5hdHRy LAkvKiA0ICovCj4gKwkmc2Vuc29yX2Rldl9hdHRyX3RlbXAzX2xhYmVsLmRldl9hdHRyLmF0dHIs CS8qIDUgKi8KPiArCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDRfaW5wdXQuZGV2X2F0dHIuYXR0ciwJ LyogNiAqLwo+ICsJJnNlbnNvcl9kZXZfYXR0cl90ZW1wNF9sYWJlbC5kZXZfYXR0ci5hdHRyLAkv KiA3ICovCj4gKwkmc2Vuc29yX2Rldl9hdHRyX2ZhbjFfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyog OCAqLwo+ICsJJnNlbnNvcl9kZXZfYXR0cl9mYW4xX2xhYmVsLmRldl9hdHRyLmF0dHIsCS8qIDkg Ki8KPiArCSZzZW5zb3JfZGV2X2F0dHJfcHdtMS5kZXZfYXR0ci5hdHRyLAkJLyogMTAgKi8KPiAr CSZzZW5zb3JfZGV2X2F0dHJfZmFuMl9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiAxMSAqLwo+ICsJ JnNlbnNvcl9kZXZfYXR0cl9mYW4yX2xhYmVsLmRldl9hdHRyLmF0dHIsCS8qIDEyICovCj4gKwkm c2Vuc29yX2Rldl9hdHRyX3B3bTIuZGV2X2F0dHIuYXR0ciwJCS8qIDEzICovCj4gKwlOVUxMCj4g K307Cj4gKwo+ICtzdGF0aWMgdW1vZGVfdCBpOGtfaXNfdmlzaWJsZShzdHJ1Y3Qga29iamVjdCAq a29iaiwgc3RydWN0IGF0dHJpYnV0ZSAqYXR0ciwKPiArCQkJICAgICAgaW50IGluZGV4KQo+ICt7 Cj4gKwlpZiAoaW5kZXggPj0gMCAmJiBpbmRleCA8PSAxICYmCj4gKwkgICAgIShpOGtfaHdtb25f ZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9URU1QMSkpCj4gKwkJcmV0dXJuIDA7Cj4gKwlpZiAoaW5k ZXggPj0gMiAmJiBpbmRleCA8PSAzICYmCj4gKwkgICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtf SFdNT05fSEFWRV9URU1QMikpCj4gKwkJcmV0dXJuIDA7Cj4gKwlpZiAoaW5kZXggPj0gNCAmJiBp bmRleCA8PSA1ICYmCj4gKwkgICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9U RU1QMykpCj4gKwkJcmV0dXJuIDA7Cj4gKwlpZiAoaW5kZXggPj0gNiAmJiBpbmRleCA8PSA3ICYm Cj4gKwkgICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9URU1QNCkpCj4gKwkJ cmV0dXJuIDA7Cj4gKwlpZiAoaW5kZXggPj0gOCAmJiBpbmRleCA8PSAxMCAmJgo+ICsJICAgICEo aThrX2h3bW9uX2ZsYWdzICYgSThLX0hXTU9OX0hBVkVfRkFOMSkpCj4gKwkJcmV0dXJuIDA7Cj4g KwlpZiAoaW5kZXggPj0gMTEgJiYgaW5kZXggPD0gMTMgJiYKPiArCSAgICAhKGk4a19od21vbl9m bGFncyAmIEk4S19IV01PTl9IQVZFX0ZBTjIpKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCXJldHVy biBhdHRyLT5tb2RlOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9n cm91cCBpOGtfZ3JvdXAgPSB7Cj4gKwkuYXR0cnMgPSBpOGtfYXR0cnMsCj4gKwkuaXNfdmlzaWJs ZSA9IGk4a19pc192aXNpYmxlLAo+ICt9Owo+ICtfX0FUVFJJQlVURV9HUk9VUFMoaThrKTsKPiAr Cj4gK3N0YXRpYyBpbnQgX19pbml0IGk4a19pbml0X2h3bW9uKHZvaWQpCj4gK3sKPiArCWludCBl cnI7Cj4gKwo+ICsJaThrX2h3bW9uX2ZsYWdzID0gMDsKPiArCj4gKwkvKiBDUFUgdGVtcGVyYXR1 cmUgYXR0cmlidXRlcywgaWYgdGVtcGVyYXR1cmUgdHlwZSBpcyBPSyAqLwo+ICsJZXJyID0gaThr X2dldF90ZW1wX3R5cGUoMCk7Cj4gKwlpZiAoZXJyID49IDApCj4gKwkJaThrX2h3bW9uX2ZsYWdz IHw9IEk4S19IV01PTl9IQVZFX1RFTVAxOwo+ICsJLyogY2hlY2sgZm9yIGFkZGl0aW9uYWwgdGVt cGVyYXR1cmUgc2Vuc29ycyAqLwo+ICsJZXJyID0gaThrX2dldF90ZW1wX3R5cGUoMSk7Cj4gKwlp ZiAoZXJyID49IDApCj4gKwkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RFTVAy Owo+ICsJZXJyID0gaThrX2dldF90ZW1wX3R5cGUoMik7Cj4gKwlpZiAoZXJyID49IDApCj4gKwkJ aThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RFTVAzOwo+ICsJZXJyID0gaThrX2dl dF90ZW1wX3R5cGUoMyk7Cj4gKwlpZiAoZXJyID49IDApCj4gKwkJaThrX2h3bW9uX2ZsYWdzIHw9 IEk4S19IV01PTl9IQVZFX1RFTVA0Owo+ICsKPiArCS8qIEZpcnN0IGZhbiBhdHRyaWJ1dGVzLCBp ZiBmYW4gdHlwZSBpcyBPSyAqLwo+ICsJZXJyID0gaThrX2dldF9mYW5fdHlwZSgwKTsKPiArCWlm IChlcnIgPj0gMCkKPiArCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVfRkFOMTsK PiArCj4gKwkvKiBTZWNvbmQgZmFuIGF0dHJpYnV0ZXMsIGlmIGZhbiB0eXBlIGlzIE9LICovCj4g KwllcnIgPSBpOGtfZ2V0X2Zhbl90eXBlKDEpOwo+ICsJaWYgKGVyciA+PSAwKQo+ICsJCWk4a19o d21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9GQU4yOwo+ICsKPiArCWk4a19od21vbl9kZXYg PSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoTlVMTCwgImk4ayIsIE5VTEwsCj4g KwkJCQkJCQkgIGk4a19ncm91cHMpOwo+ICsJaWYgKElTX0VSUihpOGtfaHdtb25fZGV2KSkgewo+ ICsJCWVyciA9IFBUUl9FUlIoaThrX2h3bW9uX2Rldik7Cj4gKwkJaThrX2h3bW9uX2RldiA9IE5V TEw7Cj4gKwkJcHJfZXJyKCJod21vbiByZWdpc3RyYXRpb24gZmFpbGVkICglZClcbiIsIGVycik7 Cj4gKwkJcmV0dXJuIGVycjsKPiArCX0KPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdHJ1Y3Qg aThrX2NvbmZpZ19kYXRhIHsKPiArCXVpbnQgZmFuX211bHQ7Cj4gKwl1aW50IGZhbl9tYXg7Cj4g K307Cj4gKwo+ICtlbnVtIGk4a19jb25maWdzIHsKPiArCURFTExfTEFUSVRVREVfRDUyMCwKPiAr CURFTExfUFJFQ0lTSU9OXzQ5MCwKPiArCURFTExfU1RVRElPLAo+ICsJREVMTF9YUFMsCj4gK307 Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGk4a19jb25maWdfZGF0YSBpOGtfY29uZmlnX2Rh dGFbXSA9IHsKPiArCVtERUxMX0xBVElUVURFX0Q1MjBdID0gewo+ICsJCS5mYW5fbXVsdCA9IDEs Cj4gKwkJLmZhbl9tYXggPSBJOEtfRkFOX1RVUkJPLAo+ICsJfSwKPiArCVtERUxMX1BSRUNJU0lP Tl80OTBdID0gewo+ICsJCS5mYW5fbXVsdCA9IDEsCj4gKwkJLmZhbl9tYXggPSBJOEtfRkFOX1RV UkJPLAo+ICsJfSwKPiArCVtERUxMX1NUVURJT10gPSB7Cj4gKwkJLmZhbl9tdWx0ID0gMSwKPiAr CQkuZmFuX21heCA9IEk4S19GQU5fSElHSCwKPiArCX0sCj4gKwlbREVMTF9YUFNdID0gewo+ICsJ CS5mYW5fbXVsdCA9IDEsCj4gKwkJLmZhbl9tYXggPSBJOEtfRkFOX0hJR0gsCj4gKwl9LAo+ICt9 Owo+ICsKPiArc3RhdGljIHN0cnVjdCBkbWlfc3lzdGVtX2lkIGk4a19kbWlfdGFibGVbXSBfX2lu aXRkYXRhID0gewo+ICsJewo+ICsJCS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIiwKPiArCQkubWF0 Y2hlcyA9IHsKPiArCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBDb21wdXRlciIp LAo+ICsJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkluc3Bpcm9uIiksCj4gKwkJfSwK PiArCX0sCj4gKwl7Cj4gKwkJLmlkZW50ID0gIkRlbGwgTGF0aXR1ZGUiLAo+ICsJCS5tYXRjaGVz ID0gewo+ICsJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIENvbXB1dGVyIiksCj4g KwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTGF0aXR1ZGUiKSwKPiArCQl9LAo+ICsJ fSwKPiArCXsKPiArCQkuaWRlbnQgPSAiRGVsbCBJbnNwaXJvbiAyIiwKPiArCQkubWF0Y2hlcyA9 IHsKPiArCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCj4gKwkJCURN SV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiSW5zcGlyb24iKSwKPiArCQl9LAo+ICsJfSwKPiAr CXsKPiArCQkuaWRlbnQgPSAiRGVsbCBMYXRpdHVkZSBENTIwIiwKPiArCQkubWF0Y2hlcyA9IHsK PiArCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCj4gKwkJCURNSV9N QVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTGF0aXR1ZGUgRDUyMCIpLAo+ICsJCX0sCj4gKwkJLmRy aXZlcl9kYXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfTEFUSVRVREVfRDUyMF0s Cj4gKwl9LAo+ICsJewo+ICsJCS5pZGVudCA9ICJEZWxsIExhdGl0dWRlIDIiLAo+ICsJCS5tYXRj aGVzID0gewo+ICsJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKPiAr CQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJMYXRpdHVkZSIpLAo+ICsJCX0sCj4gKwl9 LAo+ICsJewkvKiBVSyBJbnNwaXJvbiA2NDAwICAqLwo+ICsJCS5pZGVudCA9ICJEZWxsIEluc3Bp cm9uIDMiLAo+ICsJCS5tYXRjaGVzID0gewo+ICsJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1Is ICJEZWxsIEluYy4iKSwKPiArCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJNTTA2MSIp LAo+ICsJCX0sCj4gKwl9LAo+ICsJewo+ICsJCS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIDMiLAo+ ICsJCS5tYXRjaGVzID0gewo+ICsJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIElu Yy4iKSwKPiArCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJNUDA2MSIpLAo+ICsJCX0s Cj4gKwl9LAo+ICsJewo+ICsJCS5pZGVudCA9ICJEZWxsIFByZWNpc2lvbiA0OTAiLAo+ICsJCS5t YXRjaGVzID0gewo+ICsJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwK PiArCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsCj4gKwkJCQkgICJQcmVjaXNpb24gV29y a1N0YXRpb24gNDkwIiksCj4gKwkJfSwKPiArCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtf Y29uZmlnX2RhdGFbREVMTF9QUkVDSVNJT05fNDkwXSwKPiArCX0sCj4gKwl7Cj4gKwkJLmlkZW50 ID0gIkRlbGwgUHJlY2lzaW9uIiwKPiArCQkubWF0Y2hlcyA9IHsKPiArCQkJRE1JX01BVENIKERN SV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCj4gKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9O QU1FLCAiUHJlY2lzaW9uIiksCj4gKwkJfSwKPiArCX0sCj4gKwl7Cj4gKwkJLmlkZW50ID0gIkRl bGwgVm9zdHJvIiwKPiArCQkubWF0Y2hlcyA9IHsKPiArCQkJRE1JX01BVENIKERNSV9TWVNfVkVO RE9SLCAiRGVsbCBJbmMuIiksCj4gKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiVm9z dHJvIiksCj4gKwkJfSwKPiArCX0sCj4gKwl7Cj4gKwkJLmlkZW50ID0gIkRlbGwgWFBTNDIxIiwK PiArCQkubWF0Y2hlcyA9IHsKPiArCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJ bmMuIiksCj4gKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiWFBTIEw0MjFYIiksCj4g KwkJfSwKPiArCX0sCj4gKwl7Cj4gKwkJLmlkZW50ID0gIkRlbGwgU3R1ZGlvIiwKPiArCQkubWF0 Y2hlcyA9IHsKPiArCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCj4g KwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiU3R1ZGlvIiksCj4gKwkJfSwKPiArCQku ZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9TVFVESU9dLAo+ICsJ fSwKPiArCXsKPiArCQkuaWRlbnQgPSAiRGVsbCBYUFMgMTMiLAo+ICsJCS5tYXRjaGVzID0gewo+ ICsJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKPiArCQkJRE1JX01B VENIKERNSV9QUk9EVUNUX05BTUUsICJYUFMxMyIpLAo+ICsJCX0sCj4gKwkJLmRyaXZlcl9kYXRh ID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfWFBTXSwKPiArCX0sCj4gKwl7Cj4gKwkJ LmlkZW50ID0gIkRlbGwgWFBTIE0xNDAiLAo+ICsJCS5tYXRjaGVzID0gewo+ICsJCQlETUlfTUFU Q0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKPiArCQkJRE1JX01BVENIKERNSV9QUk9E VUNUX05BTUUsICJNWEMwNTEiKSwKPiArCQl9LAo+ICsJCS5kcml2ZXJfZGF0YSA9ICh2b2lkICop Jmk4a19jb25maWdfZGF0YVtERUxMX1hQU10sCj4gKwl9LAo+ICsJeyB9Cj4gK307Cj4gKwo+ICtN T0RVTEVfREVWSUNFX1RBQkxFKGRtaSwgaThrX2RtaV90YWJsZSk7Cj4gKwo+ICsvKgo+ICsgKiBQ cm9iZSBmb3IgdGhlIHByZXNlbmNlIG9mIGEgc3VwcG9ydGVkIGxhcHRvcC4KPiArICovCj4gK3N0 YXRpYyBpbnQgX19pbml0IGk4a19wcm9iZSh2b2lkKQo+ICt7Cj4gKwljb25zdCBzdHJ1Y3QgZG1p X3N5c3RlbV9pZCAqaWQ7Cj4gKwlpbnQgZmFuLCByZXQ7Cj4gKwo+ICsJLyoKPiArCSAqIEdldCBE TUkgaW5mb3JtYXRpb24KPiArCSAqLwo+ICsJaWYgKCFkbWlfY2hlY2tfc3lzdGVtKGk4a19kbWlf dGFibGUpKSB7Cj4gKwkJaWYgKCFpZ25vcmVfZG1pICYmICFmb3JjZSkKPiArCQkJcmV0dXJuIC1F Tk9ERVY7Cj4gKwo+ICsJCXByX2luZm8oIm5vdCBydW5uaW5nIG9uIGEgc3VwcG9ydGVkIERlbGwg c3lzdGVtLlxuIik7Cj4gKwkJcHJfaW5mbygidmVuZG9yPSVzLCBtb2RlbD0lcywgdmVyc2lvbj0l c1xuIiwKPiArCQkJaThrX2dldF9kbWlfZGF0YShETUlfU1lTX1ZFTkRPUiksCj4gKwkJCWk4a19n ZXRfZG1pX2RhdGEoRE1JX1BST0RVQ1RfTkFNRSksCj4gKwkJCWk4a19nZXRfZG1pX2RhdGEoRE1J X0JJT1NfVkVSU0lPTikpOwo+ICsJfQo+ICsKPiArCXN0cmxjcHkoYmlvc192ZXJzaW9uLCBpOGtf Z2V0X2RtaV9kYXRhKERNSV9CSU9TX1ZFUlNJT04pLAo+ICsJCXNpemVvZihiaW9zX3ZlcnNpb24p KTsKPiArCj4gKwkvKgo+ICsJICogR2V0IFNNTSBEZWxsIHNpZ25hdHVyZQo+ICsJICovCj4gKwlp ZiAoaThrX2dldF9kZWxsX3NpZ25hdHVyZShJOEtfU01NX0dFVF9ERUxMX1NJRzEpICYmCj4gKwkg ICAgaThrX2dldF9kZWxsX3NpZ25hdHVyZShJOEtfU01NX0dFVF9ERUxMX1NJRzIpKSB7Cj4gKwkJ cHJfZXJyKCJ1bmFibGUgdG8gZ2V0IFNNTSBEZWxsIHNpZ25hdHVyZVxuIik7Cj4gKwkJaWYgKCFm b3JjZSkKPiArCQkJcmV0dXJuIC1FTk9ERVY7Cj4gKwl9Cj4gKwo+ICsJLyoKPiArCSAqIFNldCBm YW4gbXVsdGlwbGllciBhbmQgbWF4aW1hbCBmYW4gc3BlZWQgZnJvbSBkbWkgY29uZmlnCj4gKwkg KiBWYWx1ZXMgc3BlY2lmaWVkIGluIG1vZHVsZSBwYXJhbWV0ZXJzIG92ZXJyaWRlIHZhbHVlcyBm cm9tIGRtaQo+ICsJICovCj4gKwlpZCA9IGRtaV9maXJzdF9tYXRjaChpOGtfZG1pX3RhYmxlKTsK PiArCWlmIChpZCAmJiBpZC0+ZHJpdmVyX2RhdGEpIHsKPiArCQljb25zdCBzdHJ1Y3QgaThrX2Nv bmZpZ19kYXRhICpjb25mID0gaWQtPmRyaXZlcl9kYXRhOwo+ICsJCWlmICghZmFuX211bHQgJiYg Y29uZi0+ZmFuX211bHQpCj4gKwkJCWZhbl9tdWx0ID0gY29uZi0+ZmFuX211bHQ7Cj4gKwkJaWYg KCFmYW5fbWF4ICYmIGNvbmYtPmZhbl9tYXgpCj4gKwkJCWZhbl9tYXggPSBjb25mLT5mYW5fbWF4 Owo+ICsJfQo+ICsKPiArCWk4a19mYW5fbWF4ID0gZmFuX21heCA/IDogSThLX0ZBTl9ISUdIOwkv KiBNdXN0IG5vdCBiZSAwICovCj4gKwlpOGtfcHdtX211bHQgPSBESVZfUk9VTkRfVVAoMjU1LCBp OGtfZmFuX21heCk7Cj4gKwo+ICsJaWYgKCFmYW5fbXVsdCkgewo+ICsJCS8qCj4gKwkJICogQXV0 b2RldGVjdCBmYW4gbXVsdGlwbGllciBiYXNlZCBvbiBub21pbmFsIHJwbQo+ICsJCSAqIElmIGZh biByZXBvcnRzIHJwbSB2YWx1ZSB0b28gaGlnaCB0aGVuIHNldCBtdWx0aXBsaWVyIHRvIDEKPiAr CQkgKi8KPiArCQlmb3IgKGZhbiA9IDA7IGZhbiA8IDI7ICsrZmFuKSB7Cj4gKwkJCXJldCA9IGk4 a19nZXRfZmFuX25vbWluYWxfc3BlZWQoZmFuLCBpOGtfZmFuX21heCk7Cj4gKwkJCWlmIChyZXQg PCAwKQo+ICsJCQkJY29udGludWU7Cj4gKwkJCWlmIChyZXQgPiBJOEtfRkFOX01BWF9SUE0pCj4g KwkJCQlpOGtfZmFuX211bHQgPSAxOwo+ICsJCQlicmVhazsKPiArCQl9Cj4gKwl9IGVsc2Ugewo+ ICsJCS8qIEZhbiBtdWx0aXBsaWVyIHdhcyBzcGVjaWZpZWQgaW4gbW9kdWxlIHBhcmFtIG9yIGlu IGRtaSAqLwo+ICsJCWk4a19mYW5fbXVsdCA9IGZhbl9tdWx0Owo+ICsJfQo+ICsKPiArCXJldHVy biAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IF9faW5pdCBpOGtfaW5pdCh2b2lkKQo+ICt7Cj4g KwlzdHJ1Y3QgcHJvY19kaXJfZW50cnkgKnByb2NfaThrOwo+ICsJaW50IGVycjsKPiArCj4gKwkv KiBBcmUgd2UgcnVubmluZyBvbiBhbiBzdXBwb3J0ZWQgbGFwdG9wPyAqLwo+ICsJaWYgKGk4a19w cm9iZSgpKQo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsKPiArCS8qIFJlZ2lzdGVyIHRoZSBwcm9j IGVudHJ5ICovCj4gKwlwcm9jX2k4ayA9IHByb2NfY3JlYXRlKCJpOGsiLCAwLCBOVUxMLCAmaThr X2ZvcHMpOwo+ICsJaWYgKCFwcm9jX2k4aykKPiArCQlyZXR1cm4gLUVOT0VOVDsKPiArCj4gKwll cnIgPSBpOGtfaW5pdF9od21vbigpOwo+ICsJaWYgKGVycikKPiArCQlnb3RvIGV4aXRfcmVtb3Zl X3Byb2M7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICsgZXhpdF9yZW1vdmVfcHJvYzoKPiArCXJl bW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBOVUxMKTsKPiArCXJldHVybiBlcnI7Cj4gK30KPiArCj4g K3N0YXRpYyB2b2lkIF9fZXhpdCBpOGtfZXhpdCh2b2lkKQo+ICt7Cj4gKwlod21vbl9kZXZpY2Vf dW5yZWdpc3RlcihpOGtfaHdtb25fZGV2KTsKPiArCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBO VUxMKTsKPiArfQo+ICsKPiArbW9kdWxlX2luaXQoaThrX2luaXQpOwo+ICttb2R1bGVfZXhpdChp OGtfZXhpdCk7Cj4KCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0 dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree @ 2015-03-28 14:31 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 14:31 UTC (permalink / raw) To: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 03/28/2015 03:24 AM, Pali Rohár wrote: > This commit moves i8k driver to hwmon tree under name dell-smm-hwmon which is > better name then abbreviation i8k. For backward compatibility is added macro > MODULE_ALIAS("i8k") so modprobe will load driver also old name i8k. CONFIG_I8K > compile option was not changed. > > This commit also adds me as maintainer of this new dell-smm-hwmon driver. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> Looks ok to me, so I'll be happy to take it for 4.1 if Greg agrees. I thought about moving the I8K configuration option as well. Not really sure what to do there. Greg, any opinion ? It would have to reside outside the HWMON block of drivers/hwmon/Kconfig if we move it. We also can drop me as explicit maintainer - I am on the hook from the hwmon side anyway, and we don't need to step on each other's foot for this driver. Thanks, Guenter > --- > MAINTAINERS | 3 +- > drivers/char/Makefile | 1 - > drivers/char/i8k.c | 1005 --------------------------------------- > drivers/hwmon/Makefile | 1 + > drivers/hwmon/dell-smm-hwmon.c | 1007 ++++++++++++++++++++++++++++++++++++++++ > 5 files changed, 1010 insertions(+), 1007 deletions(-) > delete mode 100644 drivers/char/i8k.c > create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > diff --git a/MAINTAINERS b/MAINTAINERS > index 88c09ca..bf5bb05 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -3064,8 +3064,9 @@ F: drivers/platform/x86/dell-laptop.c > > DELL LAPTOP SMM DRIVER > M: Guenter Roeck <linux@roeck-us.net> > +M: Pali Rohár <pali.rohar@gmail.com> > S: Maintained > -F: drivers/char/i8k.c > +F: drivers/hwmon/dell-smm-hwmon.c > F: include/uapi/linux/i8k.h > > DELL SYSTEMS MANAGEMENT BASE DRIVER (dcdbas) > diff --git a/drivers/char/Makefile b/drivers/char/Makefile > index d06cde26..1d9cf00 100644 > --- a/drivers/char/Makefile > +++ b/drivers/char/Makefile > @@ -36,7 +36,6 @@ else > obj-$(CONFIG_NVRAM) += nvram.o > endif > obj-$(CONFIG_TOSHIBA) += toshiba.o > -obj-$(CONFIG_I8K) += i8k.o > obj-$(CONFIG_DS1620) += ds1620.o > obj-$(CONFIG_HW_RANDOM) += hw_random/ > obj-$(CONFIG_PPDEV) += ppdev.o > diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c > deleted file mode 100644 > index 24cc4ed..0000000 > --- a/drivers/char/i8k.c > +++ /dev/null > @@ -1,1005 +0,0 @@ > -/* > - * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops. > - * > - * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> > - * > - * Hwmon integration: > - * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> > - * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> > - * Copyright (C) 2014 Pali Rohár <pali.rohar@gmail.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, 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. > - */ > - > -#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > - > -#include <linux/delay.h> > -#include <linux/module.h> > -#include <linux/types.h> > -#include <linux/init.h> > -#include <linux/proc_fs.h> > -#include <linux/seq_file.h> > -#include <linux/dmi.h> > -#include <linux/capability.h> > -#include <linux/mutex.h> > -#include <linux/hwmon.h> > -#include <linux/hwmon-sysfs.h> > -#include <linux/uaccess.h> > -#include <linux/io.h> > -#include <linux/sched.h> > - > -#include <linux/i8k.h> > - > -#define I8K_SMM_FN_STATUS 0x0025 > -#define I8K_SMM_POWER_STATUS 0x0069 > -#define I8K_SMM_SET_FAN 0x01a3 > -#define I8K_SMM_GET_FAN 0x00a3 > -#define I8K_SMM_GET_SPEED 0x02a3 > -#define I8K_SMM_GET_FAN_TYPE 0x03a3 > -#define I8K_SMM_GET_NOM_SPEED 0x04a3 > -#define I8K_SMM_GET_TEMP 0x10a3 > -#define I8K_SMM_GET_TEMP_TYPE 0x11a3 > -#define I8K_SMM_GET_DELL_SIG1 0xfea3 > -#define I8K_SMM_GET_DELL_SIG2 0xffa3 > - > -#define I8K_FAN_MULT 30 > -#define I8K_FAN_MAX_RPM 30000 > -#define I8K_MAX_TEMP 127 > - > -#define I8K_FN_NONE 0x00 > -#define I8K_FN_UP 0x01 > -#define I8K_FN_DOWN 0x02 > -#define I8K_FN_MUTE 0x04 > -#define I8K_FN_MASK 0x07 > -#define I8K_FN_SHIFT 8 > - > -#define I8K_POWER_AC 0x05 > -#define I8K_POWER_BATTERY 0x01 > - > -static DEFINE_MUTEX(i8k_mutex); > -static char bios_version[4]; > -static struct device *i8k_hwmon_dev; > -static u32 i8k_hwmon_flags; > -static uint i8k_fan_mult = I8K_FAN_MULT; > -static uint i8k_pwm_mult; > -static uint i8k_fan_max = I8K_FAN_HIGH; > - > -#define I8K_HWMON_HAVE_TEMP1 (1 << 0) > -#define I8K_HWMON_HAVE_TEMP2 (1 << 1) > -#define I8K_HWMON_HAVE_TEMP3 (1 << 2) > -#define I8K_HWMON_HAVE_TEMP4 (1 << 3) > -#define I8K_HWMON_HAVE_FAN1 (1 << 4) > -#define I8K_HWMON_HAVE_FAN2 (1 << 5) > - > -MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); > -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); > -MODULE_LICENSE("GPL"); > - > -static bool force; > -module_param(force, bool, 0); > -MODULE_PARM_DESC(force, "Force loading without checking for supported models"); > - > -static bool ignore_dmi; > -module_param(ignore_dmi, bool, 0); > -MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); > - > -static bool restricted; > -module_param(restricted, bool, 0); > -MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > - > -static bool power_status; > -module_param(power_status, bool, 0600); > -MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); > - > -static uint fan_mult; > -module_param(fan_mult, uint, 0); > -MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); > - > -static uint fan_max; > -module_param(fan_max, uint, 0); > -MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); > - > -static int i8k_open_fs(struct inode *inode, struct file *file); > -static long i8k_ioctl(struct file *, unsigned int, unsigned long); > - > -static const struct file_operations i8k_fops = { > - .owner = THIS_MODULE, > - .open = i8k_open_fs, > - .read = seq_read, > - .llseek = seq_lseek, > - .release = single_release, > - .unlocked_ioctl = i8k_ioctl, > -}; > - > -struct smm_regs { > - unsigned int eax; > - unsigned int ebx __packed; > - unsigned int ecx __packed; > - unsigned int edx __packed; > - unsigned int esi __packed; > - unsigned int edi __packed; > -}; > - > -static inline const char *i8k_get_dmi_data(int field) > -{ > - const char *dmi_data = dmi_get_system_info(field); > - > - return dmi_data && *dmi_data ? dmi_data : "?"; > -} > - > -/* > - * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. > - */ > -static int i8k_smm(struct smm_regs *regs) > -{ > - int rc; > - int eax = regs->eax; > - cpumask_var_t old_mask; > - > - /* SMM requires CPU 0 */ > - if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) > - return -ENOMEM; > - cpumask_copy(old_mask, ¤t->cpus_allowed); > - rc = set_cpus_allowed_ptr(current, cpumask_of(0)); > - if (rc) > - goto out; > - if (smp_processor_id() != 0) { > - rc = -EBUSY; > - goto out; > - } > - > -#if defined(CONFIG_X86_64) > - asm volatile("pushq %%rax\n\t" > - "movl 0(%%rax),%%edx\n\t" > - "pushq %%rdx\n\t" > - "movl 4(%%rax),%%ebx\n\t" > - "movl 8(%%rax),%%ecx\n\t" > - "movl 12(%%rax),%%edx\n\t" > - "movl 16(%%rax),%%esi\n\t" > - "movl 20(%%rax),%%edi\n\t" > - "popq %%rax\n\t" > - "out %%al,$0xb2\n\t" > - "out %%al,$0x84\n\t" > - "xchgq %%rax,(%%rsp)\n\t" > - "movl %%ebx,4(%%rax)\n\t" > - "movl %%ecx,8(%%rax)\n\t" > - "movl %%edx,12(%%rax)\n\t" > - "movl %%esi,16(%%rax)\n\t" > - "movl %%edi,20(%%rax)\n\t" > - "popq %%rdx\n\t" > - "movl %%edx,0(%%rax)\n\t" > - "pushfq\n\t" > - "popq %%rax\n\t" > - "andl $1,%%eax\n" > - : "=a"(rc) > - : "a"(regs) > - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); > -#else > - asm volatile("pushl %%eax\n\t" > - "movl 0(%%eax),%%edx\n\t" > - "push %%edx\n\t" > - "movl 4(%%eax),%%ebx\n\t" > - "movl 8(%%eax),%%ecx\n\t" > - "movl 12(%%eax),%%edx\n\t" > - "movl 16(%%eax),%%esi\n\t" > - "movl 20(%%eax),%%edi\n\t" > - "popl %%eax\n\t" > - "out %%al,$0xb2\n\t" > - "out %%al,$0x84\n\t" > - "xchgl %%eax,(%%esp)\n\t" > - "movl %%ebx,4(%%eax)\n\t" > - "movl %%ecx,8(%%eax)\n\t" > - "movl %%edx,12(%%eax)\n\t" > - "movl %%esi,16(%%eax)\n\t" > - "movl %%edi,20(%%eax)\n\t" > - "popl %%edx\n\t" > - "movl %%edx,0(%%eax)\n\t" > - "lahf\n\t" > - "shrl $8,%%eax\n\t" > - "andl $1,%%eax\n" > - : "=a"(rc) > - : "a"(regs) > - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); > -#endif > - if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) > - rc = -EINVAL; > - > -out: > - set_cpus_allowed_ptr(current, old_mask); > - free_cpumask_var(old_mask); > - return rc; > -} > - > -/* > - * Read the Fn key status. > - */ > -static int i8k_get_fn_status(void) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; > - int rc; > - > - rc = i8k_smm(®s); > - if (rc < 0) > - return rc; > - > - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { > - case I8K_FN_UP: > - return I8K_VOL_UP; > - case I8K_FN_DOWN: > - return I8K_VOL_DOWN; > - case I8K_FN_MUTE: > - return I8K_VOL_MUTE; > - default: > - return 0; > - } > -} > - > -/* > - * Read the power status. > - */ > -static int i8k_get_power_status(void) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; > - int rc; > - > - rc = i8k_smm(®s); > - if (rc < 0) > - return rc; > - > - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; > -} > - > -/* > - * Read the fan status. > - */ > -static int i8k_get_fan_status(int fan) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; > - > - regs.ebx = fan & 0xff; > - return i8k_smm(®s) ? : regs.eax & 0xff; > -} > - > -/* > - * Read the fan speed in RPM. > - */ > -static int i8k_get_fan_speed(int fan) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; > - > - regs.ebx = fan & 0xff; > - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; > -} > - > -/* > - * Read the fan type. > - */ > -static int i8k_get_fan_type(int fan) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; > - > - regs.ebx = fan & 0xff; > - return i8k_smm(®s) ? : regs.eax & 0xff; > -} > - > -/* > - * Read the fan nominal rpm for specific fan speed. > - */ > -static int i8k_get_fan_nominal_speed(int fan, int speed) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; > - > - regs.ebx = (fan & 0xff) | (speed << 8); > - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; > -} > - > -/* > - * Set the fan speed (off, low, high). Returns the new fan status. > - */ > -static int i8k_set_fan(int fan, int speed) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; > - > - speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); > - regs.ebx = (fan & 0xff) | (speed << 8); > - > - return i8k_smm(®s) ? : i8k_get_fan_status(fan); > -} > - > -static int i8k_get_temp_type(int sensor) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; > - > - regs.ebx = sensor & 0xff; > - return i8k_smm(®s) ? : regs.eax & 0xff; > -} > - > -/* > - * Read the cpu temperature. > - */ > -static int _i8k_get_temp(int sensor) > -{ > - struct smm_regs regs = { > - .eax = I8K_SMM_GET_TEMP, > - .ebx = sensor & 0xff, > - }; > - > - return i8k_smm(®s) ? : regs.eax & 0xff; > -} > - > -static int i8k_get_temp(int sensor) > -{ > - int temp = _i8k_get_temp(sensor); > - > - /* > - * Sometimes the temperature sensor returns 0x99, which is out of range. > - * In this case we retry (once) before returning an error. > - # 1003655137 00000058 00005a4b > - # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees > - # 1003655139 00000054 00005c52 > - */ > - if (temp == 0x99) { > - msleep(100); > - temp = _i8k_get_temp(sensor); > - } > - /* > - * Return -ENODATA for all invalid temperatures. > - * > - * Known instances are the 0x99 value as seen above as well as > - * 0xc1 (193), which may be returned when trying to read the GPU > - * temperature if the system supports a GPU and it is currently > - * turned off. > - */ > - if (temp > I8K_MAX_TEMP) > - return -ENODATA; > - > - return temp; > -} > - > -static int i8k_get_dell_signature(int req_fn) > -{ > - struct smm_regs regs = { .eax = req_fn, }; > - int rc; > - > - rc = i8k_smm(®s); > - if (rc < 0) > - return rc; > - > - return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; > -} > - > -static int > -i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) > -{ > - int val = 0; > - int speed; > - unsigned char buff[16]; > - int __user *argp = (int __user *)arg; > - > - if (!argp) > - return -EINVAL; > - > - switch (cmd) { > - case I8K_BIOS_VERSION: > - val = (bios_version[0] << 16) | > - (bios_version[1] << 8) | bios_version[2]; > - break; > - > - case I8K_MACHINE_ID: > - memset(buff, 0, 16); > - strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), > - sizeof(buff)); > - break; > - > - case I8K_FN_STATUS: > - val = i8k_get_fn_status(); > - break; > - > - case I8K_POWER_STATUS: > - val = i8k_get_power_status(); > - break; > - > - case I8K_GET_TEMP: > - val = i8k_get_temp(0); > - break; > - > - case I8K_GET_SPEED: > - if (copy_from_user(&val, argp, sizeof(int))) > - return -EFAULT; > - > - val = i8k_get_fan_speed(val); > - break; > - > - case I8K_GET_FAN: > - if (copy_from_user(&val, argp, sizeof(int))) > - return -EFAULT; > - > - val = i8k_get_fan_status(val); > - break; > - > - case I8K_SET_FAN: > - if (restricted && !capable(CAP_SYS_ADMIN)) > - return -EPERM; > - > - if (copy_from_user(&val, argp, sizeof(int))) > - return -EFAULT; > - > - if (copy_from_user(&speed, argp + 1, sizeof(int))) > - return -EFAULT; > - > - val = i8k_set_fan(val, speed); > - break; > - > - default: > - return -EINVAL; > - } > - > - if (val < 0) > - return val; > - > - switch (cmd) { > - case I8K_BIOS_VERSION: > - if (copy_to_user(argp, &val, 4)) > - return -EFAULT; > - > - break; > - case I8K_MACHINE_ID: > - if (copy_to_user(argp, buff, 16)) > - return -EFAULT; > - > - break; > - default: > - if (copy_to_user(argp, &val, sizeof(int))) > - return -EFAULT; > - > - break; > - } > - > - return 0; > -} > - > -static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) > -{ > - long ret; > - > - mutex_lock(&i8k_mutex); > - ret = i8k_ioctl_unlocked(fp, cmd, arg); > - mutex_unlock(&i8k_mutex); > - > - return ret; > -} > - > -/* > - * Print the information for /proc/i8k. > - */ > -static int i8k_proc_show(struct seq_file *seq, void *offset) > -{ > - int fn_key, cpu_temp, ac_power; > - int left_fan, right_fan, left_speed, right_speed; > - > - cpu_temp = i8k_get_temp(0); /* 11100 µs */ > - left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ > - right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ > - left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ > - right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ > - fn_key = i8k_get_fn_status(); /* 750 µs */ > - if (power_status) > - ac_power = i8k_get_power_status(); /* 14700 µs */ > - else > - ac_power = -1; > - > - /* > - * Info: > - * > - * 1) Format version (this will change if format changes) > - * 2) BIOS version > - * 3) BIOS machine ID > - * 4) Cpu temperature > - * 5) Left fan status > - * 6) Right fan status > - * 7) Left fan speed > - * 8) Right fan speed > - * 9) AC power > - * 10) Fn Key status > - */ > - return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", > - I8K_PROC_FMT, > - bios_version, > - i8k_get_dmi_data(DMI_PRODUCT_SERIAL), > - cpu_temp, > - left_fan, right_fan, left_speed, right_speed, > - ac_power, fn_key); > -} > - > -static int i8k_open_fs(struct inode *inode, struct file *file) > -{ > - return single_open(file, i8k_proc_show, NULL); > -} > - > - > -/* > - * Hwmon interface > - */ > - > -static ssize_t i8k_hwmon_show_temp_label(struct device *dev, > - struct device_attribute *devattr, > - char *buf) > -{ > - static const char * const labels[] = { > - "CPU", > - "GPU", > - "SODIMM", > - "Other", > - "Ambient", > - "Other", > - }; > - int index = to_sensor_dev_attr(devattr)->index; > - int type; > - > - type = i8k_get_temp_type(index); > - if (type < 0) > - return type; > - if (type >= ARRAY_SIZE(labels)) > - type = ARRAY_SIZE(labels) - 1; > - return sprintf(buf, "%s\n", labels[type]); > -} > - > -static ssize_t i8k_hwmon_show_temp(struct device *dev, > - struct device_attribute *devattr, > - char *buf) > -{ > - int index = to_sensor_dev_attr(devattr)->index; > - int temp; > - > - temp = i8k_get_temp(index); > - if (temp < 0) > - return temp; > - return sprintf(buf, "%d\n", temp * 1000); > -} > - > -static ssize_t i8k_hwmon_show_fan_label(struct device *dev, > - struct device_attribute *devattr, > - char *buf) > -{ > - static const char * const labels[] = { > - "Processor Fan", > - "Motherboard Fan", > - "Video Fan", > - "Power Supply Fan", > - "Chipset Fan", > - "Other Fan", > - }; > - int index = to_sensor_dev_attr(devattr)->index; > - bool dock = false; > - int type; > - > - type = i8k_get_fan_type(index); > - if (type < 0) > - return type; > - > - if (type & 0x10) { > - dock = true; > - type &= 0x0F; > - } > - > - if (type >= ARRAY_SIZE(labels)) > - type = (ARRAY_SIZE(labels) - 1); > - > - return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); > -} > - > -static ssize_t i8k_hwmon_show_fan(struct device *dev, > - struct device_attribute *devattr, > - char *buf) > -{ > - int index = to_sensor_dev_attr(devattr)->index; > - int fan_speed; > - > - fan_speed = i8k_get_fan_speed(index); > - if (fan_speed < 0) > - return fan_speed; > - return sprintf(buf, "%d\n", fan_speed); > -} > - > -static ssize_t i8k_hwmon_show_pwm(struct device *dev, > - struct device_attribute *devattr, > - char *buf) > -{ > - int index = to_sensor_dev_attr(devattr)->index; > - int status; > - > - status = i8k_get_fan_status(index); > - if (status < 0) > - return -EIO; > - return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); > -} > - > -static ssize_t i8k_hwmon_set_pwm(struct device *dev, > - struct device_attribute *attr, > - const char *buf, size_t count) > -{ > - int index = to_sensor_dev_attr(attr)->index; > - unsigned long val; > - int err; > - > - err = kstrtoul(buf, 10, &val); > - if (err) > - return err; > - val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); > - > - mutex_lock(&i8k_mutex); > - err = i8k_set_fan(index, val); > - mutex_unlock(&i8k_mutex); > - > - return err < 0 ? -EIO : count; > -} > - > -static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); > -static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > - 0); > -static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); > -static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > - 1); > -static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); > -static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > - 2); > -static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); > -static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > - 3); > -static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); > -static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, > - 0); > -static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, > - i8k_hwmon_set_pwm, 0); > -static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, > - 1); > -static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, > - 1); > -static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, > - i8k_hwmon_set_pwm, 1); > - > -static struct attribute *i8k_attrs[] = { > - &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ > - &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ > - &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ > - &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ > - &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ > - &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ > - &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ > - &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ > - &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ > - &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ > - &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ > - &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ > - &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ > - &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ > - NULL > -}; > - > -static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, > - int index) > -{ > - if (index >= 0 && index <= 1 && > - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) > - return 0; > - if (index >= 2 && index <= 3 && > - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) > - return 0; > - if (index >= 4 && index <= 5 && > - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) > - return 0; > - if (index >= 6 && index <= 7 && > - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) > - return 0; > - if (index >= 8 && index <= 10 && > - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) > - return 0; > - if (index >= 11 && index <= 13 && > - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) > - return 0; > - > - return attr->mode; > -} > - > -static const struct attribute_group i8k_group = { > - .attrs = i8k_attrs, > - .is_visible = i8k_is_visible, > -}; > -__ATTRIBUTE_GROUPS(i8k); > - > -static int __init i8k_init_hwmon(void) > -{ > - int err; > - > - i8k_hwmon_flags = 0; > - > - /* CPU temperature attributes, if temperature type is OK */ > - err = i8k_get_temp_type(0); > - if (err >= 0) > - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; > - /* check for additional temperature sensors */ > - err = i8k_get_temp_type(1); > - if (err >= 0) > - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; > - err = i8k_get_temp_type(2); > - if (err >= 0) > - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; > - err = i8k_get_temp_type(3); > - if (err >= 0) > - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; > - > - /* First fan attributes, if fan type is OK */ > - err = i8k_get_fan_type(0); > - if (err >= 0) > - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; > - > - /* Second fan attributes, if fan type is OK */ > - err = i8k_get_fan_type(1); > - if (err >= 0) > - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > - > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, > - i8k_groups); > - if (IS_ERR(i8k_hwmon_dev)) { > - err = PTR_ERR(i8k_hwmon_dev); > - i8k_hwmon_dev = NULL; > - pr_err("hwmon registration failed (%d)\n", err); > - return err; > - } > - return 0; > -} > - > -struct i8k_config_data { > - uint fan_mult; > - uint fan_max; > -}; > - > -enum i8k_configs { > - DELL_LATITUDE_D520, > - DELL_PRECISION_490, > - DELL_STUDIO, > - DELL_XPS, > -}; > - > -static const struct i8k_config_data i8k_config_data[] = { > - [DELL_LATITUDE_D520] = { > - .fan_mult = 1, > - .fan_max = I8K_FAN_TURBO, > - }, > - [DELL_PRECISION_490] = { > - .fan_mult = 1, > - .fan_max = I8K_FAN_TURBO, > - }, > - [DELL_STUDIO] = { > - .fan_mult = 1, > - .fan_max = I8K_FAN_HIGH, > - }, > - [DELL_XPS] = { > - .fan_mult = 1, > - .fan_max = I8K_FAN_HIGH, > - }, > -}; > - > -static struct dmi_system_id i8k_dmi_table[] __initdata = { > - { > - .ident = "Dell Inspiron", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), > - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), > - }, > - }, > - { > - .ident = "Dell Latitude", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), > - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), > - }, > - }, > - { > - .ident = "Dell Inspiron 2", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), > - }, > - }, > - { > - .ident = "Dell Latitude D520", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), > - }, > - .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], > - }, > - { > - .ident = "Dell Latitude 2", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), > - }, > - }, > - { /* UK Inspiron 6400 */ > - .ident = "Dell Inspiron 3", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), > - }, > - }, > - { > - .ident = "Dell Inspiron 3", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), > - }, > - }, > - { > - .ident = "Dell Precision 490", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, > - "Precision WorkStation 490"), > - }, > - .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], > - }, > - { > - .ident = "Dell Precision", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), > - }, > - }, > - { > - .ident = "Dell Vostro", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), > - }, > - }, > - { > - .ident = "Dell XPS421", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), > - }, > - }, > - { > - .ident = "Dell Studio", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), > - }, > - .driver_data = (void *)&i8k_config_data[DELL_STUDIO], > - }, > - { > - .ident = "Dell XPS 13", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), > - }, > - .driver_data = (void *)&i8k_config_data[DELL_XPS], > - }, > - { > - .ident = "Dell XPS M140", > - .matches = { > - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > - DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), > - }, > - .driver_data = (void *)&i8k_config_data[DELL_XPS], > - }, > - { } > -}; > - > -MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); > - > -/* > - * Probe for the presence of a supported laptop. > - */ > -static int __init i8k_probe(void) > -{ > - const struct dmi_system_id *id; > - int fan, ret; > - > - /* > - * Get DMI information > - */ > - if (!dmi_check_system(i8k_dmi_table)) { > - if (!ignore_dmi && !force) > - return -ENODEV; > - > - pr_info("not running on a supported Dell system.\n"); > - pr_info("vendor=%s, model=%s, version=%s\n", > - i8k_get_dmi_data(DMI_SYS_VENDOR), > - i8k_get_dmi_data(DMI_PRODUCT_NAME), > - i8k_get_dmi_data(DMI_BIOS_VERSION)); > - } > - > - strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), > - sizeof(bios_version)); > - > - /* > - * Get SMM Dell signature > - */ > - if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && > - i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { > - pr_err("unable to get SMM Dell signature\n"); > - if (!force) > - return -ENODEV; > - } > - > - /* > - * Set fan multiplier and maximal fan speed from dmi config > - * Values specified in module parameters override values from dmi > - */ > - id = dmi_first_match(i8k_dmi_table); > - if (id && id->driver_data) { > - const struct i8k_config_data *conf = id->driver_data; > - if (!fan_mult && conf->fan_mult) > - fan_mult = conf->fan_mult; > - if (!fan_max && conf->fan_max) > - fan_max = conf->fan_max; > - } > - > - i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ > - i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); > - > - if (!fan_mult) { > - /* > - * Autodetect fan multiplier based on nominal rpm > - * If fan reports rpm value too high then set multiplier to 1 > - */ > - for (fan = 0; fan < 2; ++fan) { > - ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); > - if (ret < 0) > - continue; > - if (ret > I8K_FAN_MAX_RPM) > - i8k_fan_mult = 1; > - break; > - } > - } else { > - /* Fan multiplier was specified in module param or in dmi */ > - i8k_fan_mult = fan_mult; > - } > - > - return 0; > -} > - > -static int __init i8k_init(void) > -{ > - struct proc_dir_entry *proc_i8k; > - int err; > - > - /* Are we running on an supported laptop? */ > - if (i8k_probe()) > - return -ENODEV; > - > - /* Register the proc entry */ > - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); > - if (!proc_i8k) > - return -ENOENT; > - > - err = i8k_init_hwmon(); > - if (err) > - goto exit_remove_proc; > - > - return 0; > - > - exit_remove_proc: > - remove_proc_entry("i8k", NULL); > - return err; > -} > - > -static void __exit i8k_exit(void) > -{ > - hwmon_device_unregister(i8k_hwmon_dev); > - remove_proc_entry("i8k", NULL); > -} > - > -module_init(i8k_init); > -module_exit(i8k_exit); > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > index 6c94147..1c3e458 100644 > --- a/drivers/hwmon/Makefile > +++ b/drivers/hwmon/Makefile > @@ -155,6 +155,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o > obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o > obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o > obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o > +obj-$(CONFIG_I8K) += dell-smm-hwmon.o > > obj-$(CONFIG_PMBUS) += pmbus/ > > diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c > new file mode 100644 > index 0000000..2b04e4f > --- /dev/null > +++ b/drivers/hwmon/dell-smm-hwmon.c > @@ -0,0 +1,1007 @@ > +/* > + * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops. > + * > + * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> > + * > + * Hwmon integration: > + * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> > + * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> > + * Copyright (C) 2014, 2015 Pali Rohár <pali.rohar@gmail.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, 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. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/delay.h> > +#include <linux/module.h> > +#include <linux/types.h> > +#include <linux/init.h> > +#include <linux/proc_fs.h> > +#include <linux/seq_file.h> > +#include <linux/dmi.h> > +#include <linux/capability.h> > +#include <linux/mutex.h> > +#include <linux/hwmon.h> > +#include <linux/hwmon-sysfs.h> > +#include <linux/uaccess.h> > +#include <linux/io.h> > +#include <linux/sched.h> > + > +#include <linux/i8k.h> > + > +#define I8K_SMM_FN_STATUS 0x0025 > +#define I8K_SMM_POWER_STATUS 0x0069 > +#define I8K_SMM_SET_FAN 0x01a3 > +#define I8K_SMM_GET_FAN 0x00a3 > +#define I8K_SMM_GET_SPEED 0x02a3 > +#define I8K_SMM_GET_FAN_TYPE 0x03a3 > +#define I8K_SMM_GET_NOM_SPEED 0x04a3 > +#define I8K_SMM_GET_TEMP 0x10a3 > +#define I8K_SMM_GET_TEMP_TYPE 0x11a3 > +#define I8K_SMM_GET_DELL_SIG1 0xfea3 > +#define I8K_SMM_GET_DELL_SIG2 0xffa3 > + > +#define I8K_FAN_MULT 30 > +#define I8K_FAN_MAX_RPM 30000 > +#define I8K_MAX_TEMP 127 > + > +#define I8K_FN_NONE 0x00 > +#define I8K_FN_UP 0x01 > +#define I8K_FN_DOWN 0x02 > +#define I8K_FN_MUTE 0x04 > +#define I8K_FN_MASK 0x07 > +#define I8K_FN_SHIFT 8 > + > +#define I8K_POWER_AC 0x05 > +#define I8K_POWER_BATTERY 0x01 > + > +static DEFINE_MUTEX(i8k_mutex); > +static char bios_version[4]; > +static struct device *i8k_hwmon_dev; > +static u32 i8k_hwmon_flags; > +static uint i8k_fan_mult = I8K_FAN_MULT; > +static uint i8k_pwm_mult; > +static uint i8k_fan_max = I8K_FAN_HIGH; > + > +#define I8K_HWMON_HAVE_TEMP1 (1 << 0) > +#define I8K_HWMON_HAVE_TEMP2 (1 << 1) > +#define I8K_HWMON_HAVE_TEMP3 (1 << 2) > +#define I8K_HWMON_HAVE_TEMP4 (1 << 3) > +#define I8K_HWMON_HAVE_FAN1 (1 << 4) > +#define I8K_HWMON_HAVE_FAN2 (1 << 5) > + > +MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); > +MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); > +MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); > +MODULE_LICENSE("GPL"); > +MODULE_ALIAS("i8k"); > + > +static bool force; > +module_param(force, bool, 0); > +MODULE_PARM_DESC(force, "Force loading without checking for supported models"); > + > +static bool ignore_dmi; > +module_param(ignore_dmi, bool, 0); > +MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); > + > +static bool restricted; > +module_param(restricted, bool, 0); > +MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > + > +static bool power_status; > +module_param(power_status, bool, 0600); > +MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); > + > +static uint fan_mult; > +module_param(fan_mult, uint, 0); > +MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); > + > +static uint fan_max; > +module_param(fan_max, uint, 0); > +MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); > + > +static int i8k_open_fs(struct inode *inode, struct file *file); > +static long i8k_ioctl(struct file *, unsigned int, unsigned long); > + > +static const struct file_operations i8k_fops = { > + .owner = THIS_MODULE, > + .open = i8k_open_fs, > + .read = seq_read, > + .llseek = seq_lseek, > + .release = single_release, > + .unlocked_ioctl = i8k_ioctl, > +}; > + > +struct smm_regs { > + unsigned int eax; > + unsigned int ebx __packed; > + unsigned int ecx __packed; > + unsigned int edx __packed; > + unsigned int esi __packed; > + unsigned int edi __packed; > +}; > + > +static inline const char *i8k_get_dmi_data(int field) > +{ > + const char *dmi_data = dmi_get_system_info(field); > + > + return dmi_data && *dmi_data ? dmi_data : "?"; > +} > + > +/* > + * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. > + */ > +static int i8k_smm(struct smm_regs *regs) > +{ > + int rc; > + int eax = regs->eax; > + cpumask_var_t old_mask; > + > + /* SMM requires CPU 0 */ > + if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) > + return -ENOMEM; > + cpumask_copy(old_mask, ¤t->cpus_allowed); > + rc = set_cpus_allowed_ptr(current, cpumask_of(0)); > + if (rc) > + goto out; > + if (smp_processor_id() != 0) { > + rc = -EBUSY; > + goto out; > + } > + > +#if defined(CONFIG_X86_64) > + asm volatile("pushq %%rax\n\t" > + "movl 0(%%rax),%%edx\n\t" > + "pushq %%rdx\n\t" > + "movl 4(%%rax),%%ebx\n\t" > + "movl 8(%%rax),%%ecx\n\t" > + "movl 12(%%rax),%%edx\n\t" > + "movl 16(%%rax),%%esi\n\t" > + "movl 20(%%rax),%%edi\n\t" > + "popq %%rax\n\t" > + "out %%al,$0xb2\n\t" > + "out %%al,$0x84\n\t" > + "xchgq %%rax,(%%rsp)\n\t" > + "movl %%ebx,4(%%rax)\n\t" > + "movl %%ecx,8(%%rax)\n\t" > + "movl %%edx,12(%%rax)\n\t" > + "movl %%esi,16(%%rax)\n\t" > + "movl %%edi,20(%%rax)\n\t" > + "popq %%rdx\n\t" > + "movl %%edx,0(%%rax)\n\t" > + "pushfq\n\t" > + "popq %%rax\n\t" > + "andl $1,%%eax\n" > + : "=a"(rc) > + : "a"(regs) > + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); > +#else > + asm volatile("pushl %%eax\n\t" > + "movl 0(%%eax),%%edx\n\t" > + "push %%edx\n\t" > + "movl 4(%%eax),%%ebx\n\t" > + "movl 8(%%eax),%%ecx\n\t" > + "movl 12(%%eax),%%edx\n\t" > + "movl 16(%%eax),%%esi\n\t" > + "movl 20(%%eax),%%edi\n\t" > + "popl %%eax\n\t" > + "out %%al,$0xb2\n\t" > + "out %%al,$0x84\n\t" > + "xchgl %%eax,(%%esp)\n\t" > + "movl %%ebx,4(%%eax)\n\t" > + "movl %%ecx,8(%%eax)\n\t" > + "movl %%edx,12(%%eax)\n\t" > + "movl %%esi,16(%%eax)\n\t" > + "movl %%edi,20(%%eax)\n\t" > + "popl %%edx\n\t" > + "movl %%edx,0(%%eax)\n\t" > + "lahf\n\t" > + "shrl $8,%%eax\n\t" > + "andl $1,%%eax\n" > + : "=a"(rc) > + : "a"(regs) > + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); > +#endif > + if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) > + rc = -EINVAL; > + > +out: > + set_cpus_allowed_ptr(current, old_mask); > + free_cpumask_var(old_mask); > + return rc; > +} > + > +/* > + * Read the Fn key status. > + */ > +static int i8k_get_fn_status(void) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; > + int rc; > + > + rc = i8k_smm(®s); > + if (rc < 0) > + return rc; > + > + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { > + case I8K_FN_UP: > + return I8K_VOL_UP; > + case I8K_FN_DOWN: > + return I8K_VOL_DOWN; > + case I8K_FN_MUTE: > + return I8K_VOL_MUTE; > + default: > + return 0; > + } > +} > + > +/* > + * Read the power status. > + */ > +static int i8k_get_power_status(void) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; > + int rc; > + > + rc = i8k_smm(®s); > + if (rc < 0) > + return rc; > + > + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; > +} > + > +/* > + * Read the fan status. > + */ > +static int i8k_get_fan_status(int fan) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; > + > + regs.ebx = fan & 0xff; > + return i8k_smm(®s) ? : regs.eax & 0xff; > +} > + > +/* > + * Read the fan speed in RPM. > + */ > +static int i8k_get_fan_speed(int fan) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; > + > + regs.ebx = fan & 0xff; > + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; > +} > + > +/* > + * Read the fan type. > + */ > +static int i8k_get_fan_type(int fan) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; > + > + regs.ebx = fan & 0xff; > + return i8k_smm(®s) ? : regs.eax & 0xff; > +} > + > +/* > + * Read the fan nominal rpm for specific fan speed. > + */ > +static int i8k_get_fan_nominal_speed(int fan, int speed) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; > + > + regs.ebx = (fan & 0xff) | (speed << 8); > + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; > +} > + > +/* > + * Set the fan speed (off, low, high). Returns the new fan status. > + */ > +static int i8k_set_fan(int fan, int speed) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; > + > + speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); > + regs.ebx = (fan & 0xff) | (speed << 8); > + > + return i8k_smm(®s) ? : i8k_get_fan_status(fan); > +} > + > +static int i8k_get_temp_type(int sensor) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; > + > + regs.ebx = sensor & 0xff; > + return i8k_smm(®s) ? : regs.eax & 0xff; > +} > + > +/* > + * Read the cpu temperature. > + */ > +static int _i8k_get_temp(int sensor) > +{ > + struct smm_regs regs = { > + .eax = I8K_SMM_GET_TEMP, > + .ebx = sensor & 0xff, > + }; > + > + return i8k_smm(®s) ? : regs.eax & 0xff; > +} > + > +static int i8k_get_temp(int sensor) > +{ > + int temp = _i8k_get_temp(sensor); > + > + /* > + * Sometimes the temperature sensor returns 0x99, which is out of range. > + * In this case we retry (once) before returning an error. > + # 1003655137 00000058 00005a4b > + # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees > + # 1003655139 00000054 00005c52 > + */ > + if (temp == 0x99) { > + msleep(100); > + temp = _i8k_get_temp(sensor); > + } > + /* > + * Return -ENODATA for all invalid temperatures. > + * > + * Known instances are the 0x99 value as seen above as well as > + * 0xc1 (193), which may be returned when trying to read the GPU > + * temperature if the system supports a GPU and it is currently > + * turned off. > + */ > + if (temp > I8K_MAX_TEMP) > + return -ENODATA; > + > + return temp; > +} > + > +static int i8k_get_dell_signature(int req_fn) > +{ > + struct smm_regs regs = { .eax = req_fn, }; > + int rc; > + > + rc = i8k_smm(®s); > + if (rc < 0) > + return rc; > + > + return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; > +} > + > +static int > +i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) > +{ > + int val = 0; > + int speed; > + unsigned char buff[16]; > + int __user *argp = (int __user *)arg; > + > + if (!argp) > + return -EINVAL; > + > + switch (cmd) { > + case I8K_BIOS_VERSION: > + val = (bios_version[0] << 16) | > + (bios_version[1] << 8) | bios_version[2]; > + break; > + > + case I8K_MACHINE_ID: > + memset(buff, 0, 16); > + strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), > + sizeof(buff)); > + break; > + > + case I8K_FN_STATUS: > + val = i8k_get_fn_status(); > + break; > + > + case I8K_POWER_STATUS: > + val = i8k_get_power_status(); > + break; > + > + case I8K_GET_TEMP: > + val = i8k_get_temp(0); > + break; > + > + case I8K_GET_SPEED: > + if (copy_from_user(&val, argp, sizeof(int))) > + return -EFAULT; > + > + val = i8k_get_fan_speed(val); > + break; > + > + case I8K_GET_FAN: > + if (copy_from_user(&val, argp, sizeof(int))) > + return -EFAULT; > + > + val = i8k_get_fan_status(val); > + break; > + > + case I8K_SET_FAN: > + if (restricted && !capable(CAP_SYS_ADMIN)) > + return -EPERM; > + > + if (copy_from_user(&val, argp, sizeof(int))) > + return -EFAULT; > + > + if (copy_from_user(&speed, argp + 1, sizeof(int))) > + return -EFAULT; > + > + val = i8k_set_fan(val, speed); > + break; > + > + default: > + return -EINVAL; > + } > + > + if (val < 0) > + return val; > + > + switch (cmd) { > + case I8K_BIOS_VERSION: > + if (copy_to_user(argp, &val, 4)) > + return -EFAULT; > + > + break; > + case I8K_MACHINE_ID: > + if (copy_to_user(argp, buff, 16)) > + return -EFAULT; > + > + break; > + default: > + if (copy_to_user(argp, &val, sizeof(int))) > + return -EFAULT; > + > + break; > + } > + > + return 0; > +} > + > +static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) > +{ > + long ret; > + > + mutex_lock(&i8k_mutex); > + ret = i8k_ioctl_unlocked(fp, cmd, arg); > + mutex_unlock(&i8k_mutex); > + > + return ret; > +} > + > +/* > + * Print the information for /proc/i8k. > + */ > +static int i8k_proc_show(struct seq_file *seq, void *offset) > +{ > + int fn_key, cpu_temp, ac_power; > + int left_fan, right_fan, left_speed, right_speed; > + > + cpu_temp = i8k_get_temp(0); /* 11100 µs */ > + left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ > + right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ > + left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ > + right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ > + fn_key = i8k_get_fn_status(); /* 750 µs */ > + if (power_status) > + ac_power = i8k_get_power_status(); /* 14700 µs */ > + else > + ac_power = -1; > + > + /* > + * Info: > + * > + * 1) Format version (this will change if format changes) > + * 2) BIOS version > + * 3) BIOS machine ID > + * 4) Cpu temperature > + * 5) Left fan status > + * 6) Right fan status > + * 7) Left fan speed > + * 8) Right fan speed > + * 9) AC power > + * 10) Fn Key status > + */ > + return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", > + I8K_PROC_FMT, > + bios_version, > + i8k_get_dmi_data(DMI_PRODUCT_SERIAL), > + cpu_temp, > + left_fan, right_fan, left_speed, right_speed, > + ac_power, fn_key); > +} > + > +static int i8k_open_fs(struct inode *inode, struct file *file) > +{ > + return single_open(file, i8k_proc_show, NULL); > +} > + > + > +/* > + * Hwmon interface > + */ > + > +static ssize_t i8k_hwmon_show_temp_label(struct device *dev, > + struct device_attribute *devattr, > + char *buf) > +{ > + static const char * const labels[] = { > + "CPU", > + "GPU", > + "SODIMM", > + "Other", > + "Ambient", > + "Other", > + }; > + int index = to_sensor_dev_attr(devattr)->index; > + int type; > + > + type = i8k_get_temp_type(index); > + if (type < 0) > + return type; > + if (type >= ARRAY_SIZE(labels)) > + type = ARRAY_SIZE(labels) - 1; > + return sprintf(buf, "%s\n", labels[type]); > +} > + > +static ssize_t i8k_hwmon_show_temp(struct device *dev, > + struct device_attribute *devattr, > + char *buf) > +{ > + int index = to_sensor_dev_attr(devattr)->index; > + int temp; > + > + temp = i8k_get_temp(index); > + if (temp < 0) > + return temp; > + return sprintf(buf, "%d\n", temp * 1000); > +} > + > +static ssize_t i8k_hwmon_show_fan_label(struct device *dev, > + struct device_attribute *devattr, > + char *buf) > +{ > + static const char * const labels[] = { > + "Processor Fan", > + "Motherboard Fan", > + "Video Fan", > + "Power Supply Fan", > + "Chipset Fan", > + "Other Fan", > + }; > + int index = to_sensor_dev_attr(devattr)->index; > + bool dock = false; > + int type; > + > + type = i8k_get_fan_type(index); > + if (type < 0) > + return type; > + > + if (type & 0x10) { > + dock = true; > + type &= 0x0F; > + } > + > + if (type >= ARRAY_SIZE(labels)) > + type = (ARRAY_SIZE(labels) - 1); > + > + return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); > +} > + > +static ssize_t i8k_hwmon_show_fan(struct device *dev, > + struct device_attribute *devattr, > + char *buf) > +{ > + int index = to_sensor_dev_attr(devattr)->index; > + int fan_speed; > + > + fan_speed = i8k_get_fan_speed(index); > + if (fan_speed < 0) > + return fan_speed; > + return sprintf(buf, "%d\n", fan_speed); > +} > + > +static ssize_t i8k_hwmon_show_pwm(struct device *dev, > + struct device_attribute *devattr, > + char *buf) > +{ > + int index = to_sensor_dev_attr(devattr)->index; > + int status; > + > + status = i8k_get_fan_status(index); > + if (status < 0) > + return -EIO; > + return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); > +} > + > +static ssize_t i8k_hwmon_set_pwm(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t count) > +{ > + int index = to_sensor_dev_attr(attr)->index; > + unsigned long val; > + int err; > + > + err = kstrtoul(buf, 10, &val); > + if (err) > + return err; > + val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); > + > + mutex_lock(&i8k_mutex); > + err = i8k_set_fan(index, val); > + mutex_unlock(&i8k_mutex); > + > + return err < 0 ? -EIO : count; > +} > + > +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); > +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > + 0); > +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); > +static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > + 1); > +static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); > +static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > + 2); > +static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); > +static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, > + 3); > +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); > +static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, > + 0); > +static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, > + i8k_hwmon_set_pwm, 0); > +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, > + 1); > +static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, > + 1); > +static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, > + i8k_hwmon_set_pwm, 1); > + > +static struct attribute *i8k_attrs[] = { > + &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ > + &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ > + &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ > + &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ > + &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ > + &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ > + &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ > + &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ > + &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ > + &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ > + &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ > + &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ > + &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ > + &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ > + NULL > +}; > + > +static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, > + int index) > +{ > + if (index >= 0 && index <= 1 && > + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) > + return 0; > + if (index >= 2 && index <= 3 && > + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) > + return 0; > + if (index >= 4 && index <= 5 && > + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) > + return 0; > + if (index >= 6 && index <= 7 && > + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) > + return 0; > + if (index >= 8 && index <= 10 && > + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) > + return 0; > + if (index >= 11 && index <= 13 && > + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) > + return 0; > + > + return attr->mode; > +} > + > +static const struct attribute_group i8k_group = { > + .attrs = i8k_attrs, > + .is_visible = i8k_is_visible, > +}; > +__ATTRIBUTE_GROUPS(i8k); > + > +static int __init i8k_init_hwmon(void) > +{ > + int err; > + > + i8k_hwmon_flags = 0; > + > + /* CPU temperature attributes, if temperature type is OK */ > + err = i8k_get_temp_type(0); > + if (err >= 0) > + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; > + /* check for additional temperature sensors */ > + err = i8k_get_temp_type(1); > + if (err >= 0) > + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; > + err = i8k_get_temp_type(2); > + if (err >= 0) > + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; > + err = i8k_get_temp_type(3); > + if (err >= 0) > + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; > + > + /* First fan attributes, if fan type is OK */ > + err = i8k_get_fan_type(0); > + if (err >= 0) > + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; > + > + /* Second fan attributes, if fan type is OK */ > + err = i8k_get_fan_type(1); > + if (err >= 0) > + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > + > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, > + i8k_groups); > + if (IS_ERR(i8k_hwmon_dev)) { > + err = PTR_ERR(i8k_hwmon_dev); > + i8k_hwmon_dev = NULL; > + pr_err("hwmon registration failed (%d)\n", err); > + return err; > + } > + return 0; > +} > + > +struct i8k_config_data { > + uint fan_mult; > + uint fan_max; > +}; > + > +enum i8k_configs { > + DELL_LATITUDE_D520, > + DELL_PRECISION_490, > + DELL_STUDIO, > + DELL_XPS, > +}; > + > +static const struct i8k_config_data i8k_config_data[] = { > + [DELL_LATITUDE_D520] = { > + .fan_mult = 1, > + .fan_max = I8K_FAN_TURBO, > + }, > + [DELL_PRECISION_490] = { > + .fan_mult = 1, > + .fan_max = I8K_FAN_TURBO, > + }, > + [DELL_STUDIO] = { > + .fan_mult = 1, > + .fan_max = I8K_FAN_HIGH, > + }, > + [DELL_XPS] = { > + .fan_mult = 1, > + .fan_max = I8K_FAN_HIGH, > + }, > +}; > + > +static struct dmi_system_id i8k_dmi_table[] __initdata = { > + { > + .ident = "Dell Inspiron", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), > + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), > + }, > + }, > + { > + .ident = "Dell Latitude", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), > + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), > + }, > + }, > + { > + .ident = "Dell Inspiron 2", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), > + }, > + }, > + { > + .ident = "Dell Latitude D520", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), > + }, > + .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], > + }, > + { > + .ident = "Dell Latitude 2", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), > + }, > + }, > + { /* UK Inspiron 6400 */ > + .ident = "Dell Inspiron 3", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), > + }, > + }, > + { > + .ident = "Dell Inspiron 3", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), > + }, > + }, > + { > + .ident = "Dell Precision 490", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, > + "Precision WorkStation 490"), > + }, > + .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], > + }, > + { > + .ident = "Dell Precision", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), > + }, > + }, > + { > + .ident = "Dell Vostro", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), > + }, > + }, > + { > + .ident = "Dell XPS421", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), > + }, > + }, > + { > + .ident = "Dell Studio", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), > + }, > + .driver_data = (void *)&i8k_config_data[DELL_STUDIO], > + }, > + { > + .ident = "Dell XPS 13", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), > + }, > + .driver_data = (void *)&i8k_config_data[DELL_XPS], > + }, > + { > + .ident = "Dell XPS M140", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), > + }, > + .driver_data = (void *)&i8k_config_data[DELL_XPS], > + }, > + { } > +}; > + > +MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); > + > +/* > + * Probe for the presence of a supported laptop. > + */ > +static int __init i8k_probe(void) > +{ > + const struct dmi_system_id *id; > + int fan, ret; > + > + /* > + * Get DMI information > + */ > + if (!dmi_check_system(i8k_dmi_table)) { > + if (!ignore_dmi && !force) > + return -ENODEV; > + > + pr_info("not running on a supported Dell system.\n"); > + pr_info("vendor=%s, model=%s, version=%s\n", > + i8k_get_dmi_data(DMI_SYS_VENDOR), > + i8k_get_dmi_data(DMI_PRODUCT_NAME), > + i8k_get_dmi_data(DMI_BIOS_VERSION)); > + } > + > + strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), > + sizeof(bios_version)); > + > + /* > + * Get SMM Dell signature > + */ > + if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && > + i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { > + pr_err("unable to get SMM Dell signature\n"); > + if (!force) > + return -ENODEV; > + } > + > + /* > + * Set fan multiplier and maximal fan speed from dmi config > + * Values specified in module parameters override values from dmi > + */ > + id = dmi_first_match(i8k_dmi_table); > + if (id && id->driver_data) { > + const struct i8k_config_data *conf = id->driver_data; > + if (!fan_mult && conf->fan_mult) > + fan_mult = conf->fan_mult; > + if (!fan_max && conf->fan_max) > + fan_max = conf->fan_max; > + } > + > + i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ > + i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); > + > + if (!fan_mult) { > + /* > + * Autodetect fan multiplier based on nominal rpm > + * If fan reports rpm value too high then set multiplier to 1 > + */ > + for (fan = 0; fan < 2; ++fan) { > + ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); > + if (ret < 0) > + continue; > + if (ret > I8K_FAN_MAX_RPM) > + i8k_fan_mult = 1; > + break; > + } > + } else { > + /* Fan multiplier was specified in module param or in dmi */ > + i8k_fan_mult = fan_mult; > + } > + > + return 0; > +} > + > +static int __init i8k_init(void) > +{ > + struct proc_dir_entry *proc_i8k; > + int err; > + > + /* Are we running on an supported laptop? */ > + if (i8k_probe()) > + return -ENODEV; > + > + /* Register the proc entry */ > + proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); > + if (!proc_i8k) > + return -ENOENT; > + > + err = i8k_init_hwmon(); > + if (err) > + goto exit_remove_proc; > + > + return 0; > + > + exit_remove_proc: > + remove_proc_entry("i8k", NULL); > + return err; > +} > + > +static void __exit i8k_exit(void) > +{ > + hwmon_device_unregister(i8k_hwmon_dev); > + remove_proc_entry("i8k", NULL); > +} > + > +module_init(i8k_init); > +module_exit(i8k_exit); > ^ permalink raw reply [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 10:24 ` Pali Rohár @ 2015-03-28 10:24 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 10:24 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBwYXRjaCBzcGxpdHMgQ09ORklHX0k4SyBjb21waWxlIG9wdGlvbiB0byBTRU5TT1JTX0RF TExfU01NIGFuZCBDT05GSUdfSThLLgpPcHRpb24gU0VOU09SU19ERUxMX1NNTSBpcyBub3cgdXNl ZCB0byBlbmFibGUgY29tcGlsYXRpb24gb2YgZGVsbC1zbW0taHdtb24KZHJpdmVyIGFuZCBvbGQg Q09ORklHX0k4SyBvcHRpb24gdG8gZW5hYmxlIC9wcm9jL2k4ayBpbnRlcmZhY2UgaW4gZHJpdmVy LgoKU28gdGhpcyBjaGFuZ2UgYWxsb3dzIHRvIGNvbXBpbGUgZGVsbC1zbW0taHdtb24gZHJpdmVy IHdpdGhvdXQgbGVnYWN5IC9wcm9jL2k4awppbnRlcmZhY2Ugd2hpY2ggaXMgbmVlZGVkIG9ubHkg Zm9yIG9sZCBEZWxsIEluc3BpcmlvbiBtb2RlbHMgb3IgZm9yIHVzZXJzcGFjZQppOGt1dGlscyBw YWNrYWdlLgoKRm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2hlbiBDT05GSUdfSThLIGlzIGVu YWJsZWQgdGhlbiBhbHNvIFNFTlNPUlNfREVMTF9TTU0KaXMgZW5hYmxlZCBhbmQgc28gZHJpdmVy IGRlbGwtc21tLWh3bW9uICh3aXRoIC9wcm9jL2k4aykgaXMgY29tcGlsZWQuCgpTaWduZWQtb2Zm LWJ5OiBQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Ci0tLQogYXJjaC94ODYvS2Nv bmZpZyAgICAgICAgICAgICAgIHwgICAyNSArKysrKysrKystLS0tLS0tLS0tLS0tLS0tCiBkcml2 ZXJzL2h3bW9uL0tjb25maWcgICAgICAgICAgfCAgIDExICsrKysrKysrKysrCiBkcml2ZXJzL2h3 bW9uL01ha2VmaWxlICAgICAgICAgfCAgICAyICstCiBkcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3 bW9uLmMgfCAgIDIwICsrKysrKysrKysrKysrKystLS0tCiA0IGZpbGVzIGNoYW5nZWQsIDM3IGlu c2VydGlvbnMoKyksIDIxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25m aWcgYi9hcmNoL3g4Ni9LY29uZmlnCmluZGV4IGI3ZDMxY2EuLjhkMDI2NmIgMTAwNjQ0Ci0tLSBh L2FyY2gveDg2L0tjb25maWcKKysrIGIvYXJjaC94ODYvS2NvbmZpZwpAQCAtMTA2MywyNCArMTA2 MywxNyBAQCBjb25maWcgVE9TSElCQQogCSAgU2F5IE4gb3RoZXJ3aXNlLgogCiBjb25maWcgSThL Ci0JdHJpc3RhdGUgIkRlbGwgbGFwdG9wIHN1cHBvcnQiCi0Jc2VsZWN0IEhXTU9OCisJYm9vbCAi RGVsbCBpOGsgbGVnYWN5IGxhcHRvcCBzdXBwb3J0IgorCXNlbGVjdCBTRU5TT1JTX0RFTExfU01N CiAJLS0taGVscC0tLQotCSAgVGhpcyBhZGRzIGEgZHJpdmVyIHRvIHNhZmVseSBhY2Nlc3MgdGhl IFN5c3RlbSBNYW5hZ2VtZW50IE1vZGUKLQkgIG9mIHRoZSBDUFUgb24gdGhlIERlbGwgSW5zcGly b24gODAwMC4gVGhlIFN5c3RlbSBNYW5hZ2VtZW50IE1vZGUKLQkgIGlzIHVzZWQgdG8gcmVhZCBj cHUgdGVtcGVyYXR1cmUgYW5kIGNvb2xpbmcgZmFuIHN0YXR1cyBhbmQgdG8KLQkgIGNvbnRyb2wg dGhlIGZhbnMgb24gdGhlIEk4SyBwb3J0YWJsZXMuCisJICBUaGlzIG9wdGlvbnMgZW5hYmxlcyBs ZWdhY3kgL3Byb2MvaThrIHVzZXJzcGFjZSBpbnRlcmZhY2UgaW4KKwkgIGRlbGwtc21tLWh3bW9u IGRyaXZlci4gQ2hhcmFjdGVyIGZpbGUgL3Byb2MvaThrIHJlcG9ydHMgcG93ZXIgYW5kCisJICBo b3RrZXkgc3RhdHVzIG9uIG9sZCBEZWxsIGxhcHRvcHMgKGxpa2UgRGVsbCBJbnNwaXJvbiA4MDAw KSB2aWEKKwkgIFN5c3RlbSBNYW5hZ2VtZW50IE1vZGUgcHJvdmlkZWQgYnkgRGVsbCBCSU9TLiBU aGlzIC9wcm9jL2k4ayBpbnRlcmZhY2UKKwkgIGlzIGFsc28gdXNlZCBieSB1c2Vyc3BhY2UgcGFj a2FnZSBpOGt1dGlscyB0byBjb250cm9sIGxhcHRvcCBmYW5zLgogCi0JICBUaGlzIGRyaXZlciBo YXMgYmVlbiB0ZXN0ZWQgb25seSBvbiB0aGUgSW5zcGlyb24gODAwMCBidXQgaXQgbWF5Ci0JICBh bHNvIHdvcmsgd2l0aCBvdGhlciBEZWxsIGxhcHRvcHMuIFlvdSBjYW4gZm9yY2UgbG9hZGluZyBv biBvdGhlcgotCSAgbW9kZWxzIGJ5IHBhc3NpbmcgdGhlIHBhcmFtZXRlciBgZm9yY2U9MScgdG8g dGhlIG1vZHVsZS4gVXNlIGF0Ci0JICB5b3VyIG93biByaXNrLgotCi0JICBGb3IgaW5mb3JtYXRp b24gb24gdXRpbGl0aWVzIHRvIG1ha2UgdXNlIG9mIHRoaXMgZHJpdmVyIHNlZSB0aGUKLQkgIEk4 SyBMaW51eCB1dGlsaXRpZXMgd2ViIHNpdGUgYXQ6Ci0JICA8aHR0cDovL3Blb3BsZS5kZWJpYW4u b3JnL35kei9pOGsvPgotCi0JICBTYXkgWSBpZiB5b3UgaW50ZW5kIHRvIHJ1biB0aGlzIGtlcm5l bCBvbiBhIERlbGwgSW5zcGlyb24gODAwMC4KKwkgIFNheSBZIGlmIHlvdSBpbnRlbmQgdG8gcnVu IHRoaXMga2VybmVsIG9uIG9sZCBEZWxsIGxhcHRvcHMgb3Igd2FudCB0bworCSAgdXNlIHVzZXJz cGFjZSBwYWNrYWdlIGk4a3V0aWxzLgogCSAgU2F5IE4gb3RoZXJ3aXNlLgogCiBjb25maWcgWDg2 X1JFQk9PVEZJWFVQUwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVy cy9od21vbi9LY29uZmlnCmluZGV4IDExMGZhZGUuLjg2ZWViN2QgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvaHdtb24vS2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTE3MDMsNiAr MTcwMywxNyBAQCBjb25maWcgU0VOU09SU19VTFRSQTQ1CiAJICBUaGlzIGRyaXZlciBwcm92aWRl cyBzdXBwb3J0IGZvciB0aGUgVWx0cmE0NSB3b3Jrc3RhdGlvbiBlbnZpcm9ubWVudGFsCiAJICBz ZW5zb3JzLgogCitjb25maWcgU0VOU09SU19ERUxMX1NNTQorCXRyaXN0YXRlICJEZWxsIGxhcHRv cCBTTU0gQklPUyBod21vbiBkcml2ZXIiCisJZGVwZW5kcyBPTiBYODYKKwktLS1oZWxwLS0tCisJ ICBUaGlzIGh3bW9uIGRyaXZlciBhZGRzIHN1cHBvcnQgZm9yIHJlcG9ydGluZyB0ZW1wZXJhdHVy ZSBvZiBkaWZmZXJlbnQKKwkgIHNlbnNvcnMgYW5kIGNvbnRyb2xzIHRoZSBmYW5zIG9uIERlbGwg bGFwdG9wcyB2aWEgU3lzdGVtIE1hbmFnZW1lbnQKKwkgIE1vZGUgcHJvdmlkZWQgYnkgRGVsbCBC SU9TLgorCisJICBXaGVuIG9wdGlvbiBJOEsgaXMgYWxzbyBlbmFibGVkIHRoaXMgZHJpdmVyIHBy b3ZpZGVzIGxlZ2FjeSAvcHJvYy9pOGsKKwkgIHVzZXJzcGFjZSBpbnRlcmZhY2UgZm9yIGk4a3V0 aWxzIHBhY2thZ2UuCisKIGlmIEFDUEkKIAogY29tbWVudCAiQUNQSSBkcml2ZXJzIgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9od21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKaW5k ZXggMWMzZTQ1OC4uOWVlYzYxNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQor KysgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCkBAIC0xNTUsNyArMTU1LDcgQEAgb2JqLSQoQ09O RklHX1NFTlNPUlNfVzgzTDc4NVRTKQkrPSB3ODNsNzg1dHMubwogb2JqLSQoQ09ORklHX1NFTlNP UlNfVzgzTDc4Nk5HKQkrPSB3ODNsNzg2bmcubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzFY KQkrPSB3bTgzMXgtaHdtb24ubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzUwKQkrPSB3bTgz NTAtaHdtb24ubwotb2JqLSQoQ09ORklHX0k4SykJCSs9IGRlbGwtc21tLWh3bW9uLm8KK29iai0k KENPTkZJR19TRU5TT1JTX0RFTExfU01NKQkrPSBkZWxsLXNtbS1od21vbi5vCiAKIG9iai0kKENP TkZJR19QTUJVUykJCSs9IHBtYnVzLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2RlbGwt c21tLWh3bW9uLmMgYi9kcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMKaW5kZXggMmIwNGU0 Zi4uZTk2NjFkYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jCisr KyBiL2RyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwpAQCAtODEsNyArODEsNyBAQCBzdGF0 aWMgdWludCBpOGtfZmFuX21heCA9IEk4S19GQU5fSElHSDsKIAogTU9EVUxFX0FVVEhPUigiTWFz c2ltbyBEYWwgWm90dG8gKGR6QGRlYmlhbi5vcmcpIik7CiBNT0RVTEVfQVVUSE9SKCJQYWxpIFJv aMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Iik7Ci1NT0RVTEVfREVTQ1JJUFRJT04oIkRyaXZl ciBmb3IgYWNjZXNzaW5nIFNNTSBCSU9TIG9uIERlbGwgbGFwdG9wcyIpOworTU9EVUxFX0RFU0NS SVBUSU9OKCJEZWxsIGxhcHRvcCBTTU0gQklPUyBod21vbiBkcml2ZXIiKTsKIE1PRFVMRV9MSUNF TlNFKCJHUEwiKTsKIE1PRFVMRV9BTElBUygiaThrIik7CiAKQEAgLTkzLDYgKzkzLDcgQEAgc3Rh dGljIGJvb2wgaWdub3JlX2RtaTsKIG1vZHVsZV9wYXJhbShpZ25vcmVfZG1pLCBib29sLCAwKTsK IE1PRFVMRV9QQVJNX0RFU0MoaWdub3JlX2RtaSwgIkNvbnRpbnVlIHByb2JpbmcgaGFyZHdhcmUg ZXZlbiBpZiBETUkgZGF0YSBkb2VzIG5vdCBtYXRjaCIpOwogCisjaWZkZWYgQ09ORklHX0k4Swog c3RhdGljIGJvb2wgcmVzdHJpY3RlZDsKIG1vZHVsZV9wYXJhbShyZXN0cmljdGVkLCBib29sLCAw KTsKIE1PRFVMRV9QQVJNX0RFU0MocmVzdHJpY3RlZCwgIkFsbG93IGZhbiBjb250cm9sIGlmIFNZ U19BRE1JTiBjYXBhYmlsaXR5IHNldCIpOwpAQCAtMTAwLDYgKzEwMSw3IEBAIE1PRFVMRV9QQVJN X0RFU0MocmVzdHJpY3RlZCwgIkFsbG93IGZhbiBjb250cm9sIGlmIFNZU19BRE1JTiBjYXBhYmls aXR5IHNldCIpOwogc3RhdGljIGJvb2wgcG93ZXJfc3RhdHVzOwogbW9kdWxlX3BhcmFtKHBvd2Vy X3N0YXR1cywgYm9vbCwgMDYwMCk7CiBNT0RVTEVfUEFSTV9ERVNDKHBvd2VyX3N0YXR1cywgIlJl cG9ydCBwb3dlciBzdGF0dXMgaW4gL3Byb2MvaThrIik7CisjZW5kaWYKIAogc3RhdGljIHVpbnQg ZmFuX211bHQ7CiBtb2R1bGVfcGFyYW0oZmFuX211bHQsIHVpbnQsIDApOwpAQCAtMTA5LDYgKzEx MSw3IEBAIHN0YXRpYyB1aW50IGZhbl9tYXg7CiBtb2R1bGVfcGFyYW0oZmFuX21heCwgdWludCwg MCk7CiBNT0RVTEVfUEFSTV9ERVNDKGZhbl9tYXgsICJNYXhpbXVtIGNvbmZpZ3VyYWJsZSBmYW4g c3BlZWQgKGRlZmF1bHQ6IGF1dG9kZXRlY3QpIik7CiAKKyNpZmRlZiBDT05GSUdfSThLCiBzdGF0 aWMgaW50IGk4a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxl KTsKIHN0YXRpYyBsb25nIGk4a19pb2N0bChzdHJ1Y3QgZmlsZSAqLCB1bnNpZ25lZCBpbnQsIHVu c2lnbmVkIGxvbmcpOwogCkBAIC0xMjAsNiArMTIzLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBm aWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7CiAJLnJlbGVhc2UJPSBzaW5nbGVfcmVsZWFzZSwK IAkudW5sb2NrZWRfaW9jdGwJPSBpOGtfaW9jdGwsCiB9OworI2VuZGlmCiAKIHN0cnVjdCBzbW1f cmVncyB7CiAJdW5zaWduZWQgaW50IGVheDsKQEAgLTIyMCw2ICsyMjQsNyBAQCBvdXQ6CiAJcmV0 dXJuIHJjOwogfQogCisjaWZkZWYgQ09ORklHX0k4SwogLyoKICAqIFJlYWQgdGhlIEZuIGtleSBz dGF0dXMuCiAgKi8KQEAgLTI1OCw2ICsyNjMsNyBAQCBzdGF0aWMgaW50IGk4a19nZXRfcG93ZXJf c3RhdHVzKHZvaWQpCiAKIAlyZXR1cm4gKHJlZ3MuZWF4ICYgMHhmZikgPT0gSThLX1BPV0VSX0FD ID8gSThLX0FDIDogSThLX0JBVFRFUlk7CiB9CisjZW5kaWYKIAogLyoKICAqIFJlYWQgdGhlIGZh biBzdGF0dXMuCkBAIC0zNzgsNiArMzg0LDcgQEAgc3RhdGljIGludCBpOGtfZ2V0X2RlbGxfc2ln bmF0dXJlKGludCByZXFfZm4pCiAJcmV0dXJuIHJlZ3MuZWF4ID09IDExNDU2NTE1MjcgJiYgcmVn cy5lZHggPT0gMTE0NTM5MjIwNCA/IDAgOiAtMTsKIH0KIAorI2lmZGVmIENPTkZJR19JOEsKIHN0 YXRpYyBpbnQKIGk4a19pb2N0bF91bmxvY2tlZChzdHJ1Y3QgZmlsZSAqZnAsIHVuc2lnbmVkIGlu dCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQogewpAQCAtNTI1LDYgKzUzMiw3IEBAIHN0YXRpYyBp bnQgaThrX29wZW5fZnMoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCiB7 CiAJcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIGk4a19wcm9jX3Nob3csIE5VTEwpOwogfQorI2Vu ZGlmCiAKIAogLyoKQEAgLTk3NCwxNyArOTgyLDE3IEBAIHN0YXRpYyBpbnQgX19pbml0IGk4a19w cm9iZSh2b2lkKQogCiBzdGF0aWMgaW50IF9faW5pdCBpOGtfaW5pdCh2b2lkKQogewotCXN0cnVj dCBwcm9jX2Rpcl9lbnRyeSAqcHJvY19pOGs7CiAJaW50IGVycjsKIAogCS8qIEFyZSB3ZSBydW5u aW5nIG9uIGFuIHN1cHBvcnRlZCBsYXB0b3A/ICovCiAJaWYgKGk4a19wcm9iZSgpKQogCQlyZXR1 cm4gLUVOT0RFVjsKIAorI2lmZGVmIENPTkZJR19JOEsKIAkvKiBSZWdpc3RlciB0aGUgcHJvYyBl bnRyeSAqLwotCXByb2NfaThrID0gcHJvY19jcmVhdGUoImk4ayIsIDAsIE5VTEwsICZpOGtfZm9w cyk7Ci0JaWYgKCFwcm9jX2k4aykKKwlpZiAoIXByb2NfY3JlYXRlKCJpOGsiLCAwLCBOVUxMLCAm aThrX2ZvcHMpKQogCQlyZXR1cm4gLUVOT0VOVDsKKyNlbmRpZgogCiAJZXJyID0gaThrX2luaXRf aHdtb24oKTsKIAlpZiAoZXJyKQpAQCAtOTkzLDE0ICsxMDAxLDE4IEBAIHN0YXRpYyBpbnQgX19p bml0IGk4a19pbml0KHZvaWQpCiAJcmV0dXJuIDA7CiAKICBleGl0X3JlbW92ZV9wcm9jOgorI2lm ZGVmIENPTkZJR19JOEsKIAlyZW1vdmVfcHJvY19lbnRyeSgiaThrIiwgTlVMTCk7CisjZW5kaWYK IAlyZXR1cm4gZXJyOwogfQogCiBzdGF0aWMgdm9pZCBfX2V4aXQgaThrX2V4aXQodm9pZCkKIHsK IAlod21vbl9kZXZpY2VfdW5yZWdpc3RlcihpOGtfaHdtb25fZGV2KTsKKyNpZmRlZiBDT05GSUdf SThLCiAJcmVtb3ZlX3Byb2NfZW50cnkoImk4ayIsIE5VTEwpOworI2VuZGlmCiB9CiAKIG1vZHVs ZV9pbml0KGk4a19pbml0KTsKLS0gCjEuNy45LjUKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3Jz QGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 10:24 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 10:24 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k interface which is needed only for old Dell Inspirion models or for userspace i8kutils package. For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- arch/x86/Kconfig | 25 +++++++++---------------- drivers/hwmon/Kconfig | 11 +++++++++++ drivers/hwmon/Makefile | 2 +- drivers/hwmon/dell-smm-hwmon.c | 20 ++++++++++++++++---- 4 files changed, 37 insertions(+), 21 deletions(-) diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index b7d31ca..8d0266b 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -1063,24 +1063,17 @@ config TOSHIBA Say N otherwise. config I8K - tristate "Dell laptop support" - select HWMON + bool "Dell i8k legacy laptop support" + select SENSORS_DELL_SMM ---help--- - This adds a driver to safely access the System Management Mode - of the CPU on the Dell Inspiron 8000. The System Management Mode - is used to read cpu temperature and cooling fan status and to - control the fans on the I8K portables. + This options enables legacy /proc/i8k userspace interface in + dell-smm-hwmon driver. Character file /proc/i8k reports power and + hotkey status on old Dell laptops (like Dell Inspiron 8000) via + System Management Mode provided by Dell BIOS. This /proc/i8k interface + is also used by userspace package i8kutils to control laptop fans. - This driver has been tested only on the Inspiron 8000 but it may - also work with other Dell laptops. You can force loading on other - models by passing the parameter `force=1' to the module. Use at - your own risk. - - For information on utilities to make use of this driver see the - I8K Linux utilities web site at: - <http://people.debian.org/~dz/i8k/> - - Say Y if you intend to run this kernel on a Dell Inspiron 8000. + Say Y if you intend to run this kernel on old Dell laptops or want to + use userspace package i8kutils. Say N otherwise. config X86_REBOOTFIXUPS diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 110fade..86eeb7d 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 This driver provides support for the Ultra45 workstation environmental sensors. +config SENSORS_DELL_SMM + tristate "Dell laptop SMM BIOS hwmon driver" + depends ON X86 + ---help--- + This hwmon driver adds support for reporting temperature of different + sensors and controls the fans on Dell laptops via System Management + Mode provided by Dell BIOS. + + When option I8K is also enabled this driver provides legacy /proc/i8k + userspace interface for i8kutils package. + if ACPI comment "ACPI drivers" diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 1c3e458..9eec614 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -155,7 +155,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o -obj-$(CONFIG_I8K) += dell-smm-hwmon.o +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c index 2b04e4f..e9661dc 100644 --- a/drivers/hwmon/dell-smm-hwmon.c +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -81,7 +81,7 @@ static uint i8k_fan_max = I8K_FAN_HIGH; MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); +MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS("i8k"); @@ -93,6 +93,7 @@ static bool ignore_dmi; module_param(ignore_dmi, bool, 0); MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); +#ifdef CONFIG_I8K static bool restricted; module_param(restricted, bool, 0); MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); @@ -100,6 +101,7 @@ MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); static bool power_status; module_param(power_status, bool, 0600); MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); +#endif static uint fan_mult; module_param(fan_mult, uint, 0); @@ -109,6 +111,7 @@ static uint fan_max; module_param(fan_max, uint, 0); MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); +#ifdef CONFIG_I8K static int i8k_open_fs(struct inode *inode, struct file *file); static long i8k_ioctl(struct file *, unsigned int, unsigned long); @@ -120,6 +123,7 @@ static const struct file_operations i8k_fops = { .release = single_release, .unlocked_ioctl = i8k_ioctl, }; +#endif struct smm_regs { unsigned int eax; @@ -220,6 +224,7 @@ out: return rc; } +#ifdef CONFIG_I8K /* * Read the Fn key status. */ @@ -258,6 +263,7 @@ static int i8k_get_power_status(void) return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; } +#endif /* * Read the fan status. @@ -378,6 +384,7 @@ static int i8k_get_dell_signature(int req_fn) return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; } +#ifdef CONFIG_I8K static int i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) { @@ -525,6 +532,7 @@ static int i8k_open_fs(struct inode *inode, struct file *file) { return single_open(file, i8k_proc_show, NULL); } +#endif /* @@ -974,17 +982,17 @@ static int __init i8k_probe(void) static int __init i8k_init(void) { - struct proc_dir_entry *proc_i8k; int err; /* Are we running on an supported laptop? */ if (i8k_probe()) return -ENODEV; +#ifdef CONFIG_I8K /* Register the proc entry */ - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); - if (!proc_i8k) + if (!proc_create("i8k", 0, NULL, &i8k_fops)) return -ENOENT; +#endif err = i8k_init_hwmon(); if (err) @@ -993,14 +1001,18 @@ static int __init i8k_init(void) return 0; exit_remove_proc: +#ifdef CONFIG_I8K remove_proc_entry("i8k", NULL); +#endif return err; } static void __exit i8k_exit(void) { hwmon_device_unregister(i8k_hwmon_dev); +#ifdef CONFIG_I8K remove_proc_entry("i8k", NULL); +#endif } module_init(i8k_init); -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 10:24 ` Pali Rohár @ 2015-03-28 11:04 ` Paul Bolle -1 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-28 11:04 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gU2F0LCAyMDE1LTAzLTI4IGF0IDExOjI0ICswMTAwLCBQYWxpIFJvaMOhciB3cm90ZToKPiAt LS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcKPiArKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcK PiBAQCAtMTcwMyw2ICsxNzAzLDE3IEBAIGNvbmZpZyBTRU5TT1JTX1VMVFJBNDUKPiAgCSAgVGhp cyBkcml2ZXIgcHJvdmlkZXMgc3VwcG9ydCBmb3IgdGhlIFVsdHJhNDUgd29ya3N0YXRpb24gZW52 aXJvbm1lbnRhbAo+ICAJICBzZW5zb3JzLgo+ICAKPiArY29uZmlnIFNFTlNPUlNfREVMTF9TTU0K PiArCXRyaXN0YXRlICJEZWxsIGxhcHRvcCBTTU0gQklPUyBod21vbiBkcml2ZXIiCj4gKwlkZXBl bmRzIE9OIFg4NgoKSG93IGRpZCB0aGlzIHBhc3QgeW91ciB0ZXN0aW5nPwoKPiArCS0tLWhlbHAt LS0KPiArCSAgVGhpcyBod21vbiBkcml2ZXIgYWRkcyBzdXBwb3J0IGZvciByZXBvcnRpbmcgdGVt cGVyYXR1cmUgb2YgZGlmZmVyZW50Cj4gKwkgIHNlbnNvcnMgYW5kIGNvbnRyb2xzIHRoZSBmYW5z IG9uIERlbGwgbGFwdG9wcyB2aWEgU3lzdGVtIE1hbmFnZW1lbnQKPiArCSAgTW9kZSBwcm92aWRl ZCBieSBEZWxsIEJJT1MuCj4gKwo+ICsJICBXaGVuIG9wdGlvbiBJOEsgaXMgYWxzbyBlbmFibGVk IHRoaXMgZHJpdmVyIHByb3ZpZGVzIGxlZ2FjeSAvcHJvYy9pOGsKPiArCSAgdXNlcnNwYWNlIGlu dGVyZmFjZSBmb3IgaThrdXRpbHMgcGFja2FnZS4KPiArIAoKClBhdWwgQm9sbGUKCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxp bmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3Jz Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 11:04 ` Paul Bolle 0 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-28 11:04 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 > This driver provides support for the Ultra45 workstation environmental > sensors. > > +config SENSORS_DELL_SMM > + tristate "Dell laptop SMM BIOS hwmon driver" > + depends ON X86 How did this past your testing? > + ---help--- > + This hwmon driver adds support for reporting temperature of different > + sensors and controls the fans on Dell laptops via System Management > + Mode provided by Dell BIOS. > + > + When option I8K is also enabled this driver provides legacy /proc/i8k > + userspace interface for i8kutils package. > + Paul Bolle ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 11:04 ` Paul Bolle @ 2015-03-28 12:54 ` Steven Honeyman -1 siblings, 0 replies; 86+ messages in thread From: Steven Honeyman @ 2015-03-28 12:54 UTC (permalink / raw) To: Paul Bolle Cc: Pali Rohár, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMjggTWFyY2ggMjAxNSBhdCAxMTowNCwgUGF1bCBCb2xsZSA8cGVib2xsZUB0aXNjYWxpLm5s PiB3cm90ZToKPiBPbiBTYXQsIDIwMTUtMDMtMjggYXQgMTE6MjQgKzAxMDAsIFBhbGkgUm9ow6Fy IHdyb3RlOgo+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcKPj4gKysrIGIvZHJpdmVycy9o d21vbi9LY29uZmlnCj4+IEBAIC0xNzAzLDYgKzE3MDMsMTcgQEAgY29uZmlnIFNFTlNPUlNfVUxU UkE0NQo+PiAgICAgICAgIFRoaXMgZHJpdmVyIHByb3ZpZGVzIHN1cHBvcnQgZm9yIHRoZSBVbHRy YTQ1IHdvcmtzdGF0aW9uIGVudmlyb25tZW50YWwKPj4gICAgICAgICBzZW5zb3JzLgo+Pgo+PiAr Y29uZmlnIFNFTlNPUlNfREVMTF9TTU0KPj4gKyAgICAgdHJpc3RhdGUgIkRlbGwgbGFwdG9wIFNN TSBCSU9TIGh3bW9uIGRyaXZlciIKPj4gKyAgICAgZGVwZW5kcyBPTiBYODYKPgo+IEhvdyBkaWQg dGhpcyBwYXN0IHlvdXIgdGVzdGluZz8KPgo+PiArICAgICAtLS1oZWxwLS0tCj4+ICsgICAgICAg VGhpcyBod21vbiBkcml2ZXIgYWRkcyBzdXBwb3J0IGZvciByZXBvcnRpbmcgdGVtcGVyYXR1cmUg b2YgZGlmZmVyZW50Cj4+ICsgICAgICAgc2Vuc29ycyBhbmQgY29udHJvbHMgdGhlIGZhbnMgb24g RGVsbCBsYXB0b3BzIHZpYSBTeXN0ZW0gTWFuYWdlbWVudAo+PiArICAgICAgIE1vZGUgcHJvdmlk ZWQgYnkgRGVsbCBCSU9TLgo+PiArCj4+ICsgICAgICAgV2hlbiBvcHRpb24gSThLIGlzIGFsc28g ZW5hYmxlZCB0aGlzIGRyaXZlciBwcm92aWRlcyBsZWdhY3kgL3Byb2MvaThrCj4+ICsgICAgICAg dXNlcnNwYWNlIGludGVyZmFjZSBmb3IgaThrdXRpbHMgcGFja2FnZS4KPj4gKwoKSXQncyB3b3Jr aW5nIE9LIGZvciBtZSAoYWZ0ZXIgZml4aW5nIHRoZSBtaXN0YWtlIHBvaW50ZWQgb3V0IGFib3Zl KS4KCltMYXRpdHVkZSBlNjU0MF0KLS0tLS0KY29yZXRlbXAtaXNhLTAwMDAKQWRhcHRlcjogSVNB IGFkYXB0ZXIKUGh5c2ljYWwgaWQgMDogICs1My4wwrBDICAoaGlnaCA9ICs4NC4wwrBDLCBjcml0 ID0gKzEwMC4wwrBDKQpDb3JlIDA6ICAgICAgICAgKzUxLjDCsEMgIChoaWdoID0gKzg0LjDCsEMs IGNyaXQgPSArMTAwLjDCsEMpCkNvcmUgMTogICAgICAgICArNTMuMMKwQyAgKGhpZ2ggPSArODQu MMKwQywgY3JpdCA9ICsxMDAuMMKwQykKCmk4ay12aXJ0dWFsLTAKQWRhcHRlcjogVmlydHVhbCBk ZXZpY2UKUHJvY2Vzc29yIEZhbjogMzE3MSBSUE0KQ1BVOiAgICAgICAgICAgICs1Mi4wwrBDCkFt YmllbnQ6ICAgICAgICArNDYuMMKwQwpTT0RJTU06ICAgICAgICAgKzQwLjDCsEMKLS0tLS0KCkFt YmllbnQgYW5kIFNPRElNTSBsb29rIHN3YXBwZWQgLSBidXQgaXQncyBwcm9iYWJseSBqdXN0IGFu b3RoZXIgRGVsbAplcnJvci4gSSByZWFsbHkgbmVlZCB0byBsb29rIGF0IGdldHRpbmcgY29yZWJv b3Qgb24gdGhpcyB0aGluZy4KCk9uIDI4IE1hcmNoIDIwMTUgYXQgMTA6MjQsIFBhbGkgUm9ow6Fy IDxwYWxpLnJvaGFyQGdtYWlsLmNvbT4gd3JvdGU6Ci4uLgo+ICBjb25maWcgSThLCj4gLSAgICAg ICB0cmlzdGF0ZSAiRGVsbCBsYXB0b3Agc3VwcG9ydCIKPiAtICAgICAgIHNlbGVjdCBIV01PTgo+ ICsgICAgICAgYm9vbCAiRGVsbCBpOGsgbGVnYWN5IGxhcHRvcCBzdXBwb3J0Igo+ICsgICAgICAg c2VsZWN0IFNFTlNPUlNfREVMTF9TTU0KLi4uCj4gK2NvbmZpZyBTRU5TT1JTX0RFTExfU01NCj4g KyAgICAgICB0cmlzdGF0ZSAiRGVsbCBsYXB0b3AgU01NIEJJT1MgaHdtb24gZHJpdmVyIgoKVGhl IG9ubHkgY2hhbmdlIEknZCBzdWdnZXN0IGlzIG5vdCB0byBjaGFuZ2UgdGhlIHRyaXN0YXRlIHRv IGJvb2wgZm9yCkk4Sy4gRm9yY2luZyB0aGF0IHRvIGJvb2wgbWVhbnMgdGhhdCBTRU5TT1JTX0RF TExfU01NIGNhbid0IGJlCmNvbXBpbGVkIGFzIGEgbW9kdWxlIGlmIHRoZSB1c2VyIHdpc2hlcyB0 byBrZWVwIGk4ayBoYW5naW5nIGFyb3VuZAoianVzdCBpbiBjYXNlIi4gSXQnbGwgcHJvYmFibHkg YW5ub3kgZGlzdHJvIGtlcm5lbCBwYWNrYWdlcnMgdG9vLgoKClRoYW5rcywKU3RldmVuCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1h aWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5z b3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 12:54 ` Steven Honeyman 0 siblings, 0 replies; 86+ messages in thread From: Steven Honeyman @ 2015-03-28 12:54 UTC (permalink / raw) To: Paul Bolle Cc: Pali Rohár, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 28 March 2015 at 11:04, Paul Bolle <pebolle@tiscali.nl> wrote: > On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: >> --- a/drivers/hwmon/Kconfig >> +++ b/drivers/hwmon/Kconfig >> @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 >> This driver provides support for the Ultra45 workstation environmental >> sensors. >> >> +config SENSORS_DELL_SMM >> + tristate "Dell laptop SMM BIOS hwmon driver" >> + depends ON X86 > > How did this past your testing? > >> + ---help--- >> + This hwmon driver adds support for reporting temperature of different >> + sensors and controls the fans on Dell laptops via System Management >> + Mode provided by Dell BIOS. >> + >> + When option I8K is also enabled this driver provides legacy /proc/i8k >> + userspace interface for i8kutils package. >> + It's working OK for me (after fixing the mistake pointed out above). [Latitude e6540] ----- coretemp-isa-0000 Adapter: ISA adapter Physical id 0: +53.0°C (high = +84.0°C, crit = +100.0°C) Core 0: +51.0°C (high = +84.0°C, crit = +100.0°C) Core 1: +53.0°C (high = +84.0°C, crit = +100.0°C) i8k-virtual-0 Adapter: Virtual device Processor Fan: 3171 RPM CPU: +52.0°C Ambient: +46.0°C SODIMM: +40.0°C ----- Ambient and SODIMM look swapped - but it's probably just another Dell error. I really need to look at getting coreboot on this thing. On 28 March 2015 at 10:24, Pali Rohár <pali.rohar@gmail.com> wrote: ... > config I8K > - tristate "Dell laptop support" > - select HWMON > + bool "Dell i8k legacy laptop support" > + select SENSORS_DELL_SMM ... > +config SENSORS_DELL_SMM > + tristate "Dell laptop SMM BIOS hwmon driver" The only change I'd suggest is not to change the tristate to bool for I8K. Forcing that to bool means that SENSORS_DELL_SMM can't be compiled as a module if the user wishes to keep i8k hanging around "just in case". It'll probably annoy distro kernel packagers too. Thanks, Steven ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 12:54 ` Steven Honeyman @ 2015-03-28 14:13 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 14:13 UTC (permalink / raw) To: Steven Honeyman, Paul Bolle Cc: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMDMvMjgvMjAxNSAwNTo1NCBBTSwgU3RldmVuIEhvbmV5bWFuIHdyb3RlOgo+IE9uIDI4IE1h cmNoIDIwMTUgYXQgMTE6MDQsIFBhdWwgQm9sbGUgPHBlYm9sbGVAdGlzY2FsaS5ubD4gd3JvdGU6 Cj4+IE9uIFNhdCwgMjAxNS0wMy0yOCBhdCAxMToyNCArMDEwMCwgUGFsaSBSb2jDoXIgd3JvdGU6 Cj4+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcKPj4+ICsrKyBiL2RyaXZlcnMvaHdtb24v S2NvbmZpZwo+Pj4gQEAgLTE3MDMsNiArMTcwMywxNyBAQCBjb25maWcgU0VOU09SU19VTFRSQTQ1 Cj4+PiAgICAgICAgICBUaGlzIGRyaXZlciBwcm92aWRlcyBzdXBwb3J0IGZvciB0aGUgVWx0cmE0 NSB3b3Jrc3RhdGlvbiBlbnZpcm9ubWVudGFsCj4+PiAgICAgICAgICBzZW5zb3JzLgo+Pj4KPj4+ ICtjb25maWcgU0VOU09SU19ERUxMX1NNTQo+Pj4gKyAgICAgdHJpc3RhdGUgIkRlbGwgbGFwdG9w IFNNTSBCSU9TIGh3bW9uIGRyaXZlciIKPj4+ICsgICAgIGRlcGVuZHMgT04gWDg2Cj4+Cj4+IEhv dyBkaWQgdGhpcyBwYXN0IHlvdXIgdGVzdGluZz8KPj4KPj4+ICsgICAgIC0tLWhlbHAtLS0KPj4+ ICsgICAgICAgVGhpcyBod21vbiBkcml2ZXIgYWRkcyBzdXBwb3J0IGZvciByZXBvcnRpbmcgdGVt cGVyYXR1cmUgb2YgZGlmZmVyZW50Cj4+PiArICAgICAgIHNlbnNvcnMgYW5kIGNvbnRyb2xzIHRo ZSBmYW5zIG9uIERlbGwgbGFwdG9wcyB2aWEgU3lzdGVtIE1hbmFnZW1lbnQKPj4+ICsgICAgICAg TW9kZSBwcm92aWRlZCBieSBEZWxsIEJJT1MuCj4+PiArCj4+PiArICAgICAgIFdoZW4gb3B0aW9u IEk4SyBpcyBhbHNvIGVuYWJsZWQgdGhpcyBkcml2ZXIgcHJvdmlkZXMgbGVnYWN5IC9wcm9jL2k4 awo+Pj4gKyAgICAgICB1c2Vyc3BhY2UgaW50ZXJmYWNlIGZvciBpOGt1dGlscyBwYWNrYWdlLgo+ Pj4gKwo+Cj4gSXQncyB3b3JraW5nIE9LIGZvciBtZSAoYWZ0ZXIgZml4aW5nIHRoZSBtaXN0YWtl IHBvaW50ZWQgb3V0IGFib3ZlKS4KPgo+IFtMYXRpdHVkZSBlNjU0MF0KPiAtLS0tLQo+IGNvcmV0 ZW1wLWlzYS0wMDAwCj4gQWRhcHRlcjogSVNBIGFkYXB0ZXIKPiBQaHlzaWNhbCBpZCAwOiAgKzUz LjDCsEMgIChoaWdoID0gKzg0LjDCsEMsIGNyaXQgPSArMTAwLjDCsEMpCj4gQ29yZSAwOiAgICAg ICAgICs1MS4wwrBDICAoaGlnaCA9ICs4NC4wwrBDLCBjcml0ID0gKzEwMC4wwrBDKQo+IENvcmUg MTogICAgICAgICArNTMuMMKwQyAgKGhpZ2ggPSArODQuMMKwQywgY3JpdCA9ICsxMDAuMMKwQykK Pgo+IGk4ay12aXJ0dWFsLTAKPiBBZGFwdGVyOiBWaXJ0dWFsIGRldmljZQo+IFByb2Nlc3NvciBG YW46IDMxNzEgUlBNCj4gQ1BVOiAgICAgICAgICAgICs1Mi4wwrBDCj4gQW1iaWVudDogICAgICAg ICs0Ni4wwrBDCj4gU09ESU1NOiAgICAgICAgICs0MC4wwrBDCj4gLS0tLS0KPgo+IEFtYmllbnQg YW5kIFNPRElNTSBsb29rIHN3YXBwZWQgLSBidXQgaXQncyBwcm9iYWJseSBqdXN0IGFub3RoZXIg RGVsbAo+IGVycm9yLiBJIHJlYWxseSBuZWVkIHRvIGxvb2sgYXQgZ2V0dGluZyBjb3JlYm9vdCBv biB0aGlzIHRoaW5nLgo+Cj4gT24gMjggTWFyY2ggMjAxNSBhdCAxMDoyNCwgUGFsaSBSb2jDoXIg PHBhbGkucm9oYXJAZ21haWwuY29tPiB3cm90ZToKPiAuLi4KPj4gICBjb25maWcgSThLCj4+IC0g ICAgICAgdHJpc3RhdGUgIkRlbGwgbGFwdG9wIHN1cHBvcnQiCj4+IC0gICAgICAgc2VsZWN0IEhX TU9OCj4+ICsgICAgICAgYm9vbCAiRGVsbCBpOGsgbGVnYWN5IGxhcHRvcCBzdXBwb3J0Igo+PiAr ICAgICAgIHNlbGVjdCBTRU5TT1JTX0RFTExfU01NCj4gLi4uCj4+ICtjb25maWcgU0VOU09SU19E RUxMX1NNTQo+PiArICAgICAgIHRyaXN0YXRlICJEZWxsIGxhcHRvcCBTTU0gQklPUyBod21vbiBk cml2ZXIiCj4KPiBUaGUgb25seSBjaGFuZ2UgSSdkIHN1Z2dlc3QgaXMgbm90IHRvIGNoYW5nZSB0 aGUgdHJpc3RhdGUgdG8gYm9vbCBmb3IKPiBJOEsuIEZvcmNpbmcgdGhhdCB0byBib29sIG1lYW5z IHRoYXQgU0VOU09SU19ERUxMX1NNTSBjYW4ndCBiZQo+IGNvbXBpbGVkIGFzIGEgbW9kdWxlIGlm IHRoZSB1c2VyIHdpc2hlcyB0byBrZWVwIGk4ayBoYW5naW5nIGFyb3VuZAo+ICJqdXN0IGluIGNh c2UiLiBJdCdsbCBwcm9iYWJseSBhbm5veSBkaXN0cm8ga2VybmVsIHBhY2thZ2VycyB0b28uCj4K CkFncmVlZC4gSXQgYWxzbyBzdGlsbCBuZWVkcyB0byBzZWxlY3QgSFdNT04gKFNFTlNPUlNfREVM TF9TTU0gaXMKb25seSB2aXNpYmxlIGlmIEhXTU9OIGlzIHNlbGVjdGVkKS4KCkd1ZW50ZXIKCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3Jz IG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1z ZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 14:13 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 14:13 UTC (permalink / raw) To: Steven Honeyman, Paul Bolle Cc: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 03/28/2015 05:54 AM, Steven Honeyman wrote: > On 28 March 2015 at 11:04, Paul Bolle <pebolle@tiscali.nl> wrote: >> On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: >>> --- a/drivers/hwmon/Kconfig >>> +++ b/drivers/hwmon/Kconfig >>> @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 >>> This driver provides support for the Ultra45 workstation environmental >>> sensors. >>> >>> +config SENSORS_DELL_SMM >>> + tristate "Dell laptop SMM BIOS hwmon driver" >>> + depends ON X86 >> >> How did this past your testing? >> >>> + ---help--- >>> + This hwmon driver adds support for reporting temperature of different >>> + sensors and controls the fans on Dell laptops via System Management >>> + Mode provided by Dell BIOS. >>> + >>> + When option I8K is also enabled this driver provides legacy /proc/i8k >>> + userspace interface for i8kutils package. >>> + > > It's working OK for me (after fixing the mistake pointed out above). > > [Latitude e6540] > ----- > coretemp-isa-0000 > Adapter: ISA adapter > Physical id 0: +53.0°C (high = +84.0°C, crit = +100.0°C) > Core 0: +51.0°C (high = +84.0°C, crit = +100.0°C) > Core 1: +53.0°C (high = +84.0°C, crit = +100.0°C) > > i8k-virtual-0 > Adapter: Virtual device > Processor Fan: 3171 RPM > CPU: +52.0°C > Ambient: +46.0°C > SODIMM: +40.0°C > ----- > > Ambient and SODIMM look swapped - but it's probably just another Dell > error. I really need to look at getting coreboot on this thing. > > On 28 March 2015 at 10:24, Pali Rohár <pali.rohar@gmail.com> wrote: > ... >> config I8K >> - tristate "Dell laptop support" >> - select HWMON >> + bool "Dell i8k legacy laptop support" >> + select SENSORS_DELL_SMM > ... >> +config SENSORS_DELL_SMM >> + tristate "Dell laptop SMM BIOS hwmon driver" > > The only change I'd suggest is not to change the tristate to bool for > I8K. Forcing that to bool means that SENSORS_DELL_SMM can't be > compiled as a module if the user wishes to keep i8k hanging around > "just in case". It'll probably annoy distro kernel packagers too. > Agreed. It also still needs to select HWMON (SENSORS_DELL_SMM is only visible if HWMON is selected). Guenter ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 12:54 ` Steven Honeyman @ 2015-03-28 22:00 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 22:00 UTC (permalink / raw) To: Steven Honeyman Cc: Paul Bolle, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1.1: Type: Text/Plain, Size: 3028 bytes --] On Saturday 28 March 2015 13:54:51 Steven Honeyman wrote: > On 28 March 2015 at 11:04, Paul Bolle <pebolle@tiscali.nl> wrote: > > On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: > >> --- a/drivers/hwmon/Kconfig > >> +++ b/drivers/hwmon/Kconfig > >> @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 > >> > >> This driver provides support for the Ultra45 > >> workstation environmental sensors. > >> > >> +config SENSORS_DELL_SMM > >> + tristate "Dell laptop SMM BIOS hwmon driver" > >> + depends ON X86 > > > > How did this past your testing? > > > >> + ---help--- > >> + This hwmon driver adds support for reporting > >> temperature of different + sensors and controls the > >> fans on Dell laptops via System Management + Mode > >> provided by Dell BIOS. > >> + > >> + When option I8K is also enabled this driver > >> provides legacy /proc/i8k + userspace interface for > >> i8kutils package. > >> + > > It's working OK for me (after fixing the mistake pointed out > above). > > [Latitude e6540] > ----- > coretemp-isa-0000 > Adapter: ISA adapter > Physical id 0: +53.0°C (high = +84.0°C, crit = +100.0°C) > Core 0: +51.0°C (high = +84.0°C, crit = +100.0°C) > Core 1: +53.0°C (high = +84.0°C, crit = +100.0°C) > > i8k-virtual-0 > Adapter: Virtual device > Processor Fan: 3171 RPM > CPU: +52.0°C > Ambient: +46.0°C > SODIMM: +40.0°C > ----- > > Ambient and SODIMM look swapped - but it's probably just > another Dell error. I really need to look at getting coreboot > on this thing. > Both patches do not change any code. So there should not be any type swapped with or without my patch. Cpu type is requested via SMM in same way as it is doing old DOS executable. So there can be maybe problem in DELL SMM handler too or maybe just I did not understand correctly assembler dump of DOS executable... > On 28 March 2015 at 10:24, Pali Rohár <pali.rohar@gmail.com> > wrote: ... > > > config I8K > > > > - tristate "Dell laptop support" > > - select HWMON > > + bool "Dell i8k legacy laptop support" > > + select SENSORS_DELL_SMM > > ... > > > +config SENSORS_DELL_SMM > > + tristate "Dell laptop SMM BIOS hwmon driver" > > The only change I'd suggest is not to change the tristate to > bool for I8K. Forcing that to bool means that > SENSORS_DELL_SMM can't be compiled as a module if the user > wishes to keep i8k hanging around "just in case". It'll > probably annoy distro kernel packagers too. > > > Thanks, > Steven My idea was: SENSORS_DELL_SMM enable/disable compilation of kernel driver (ether statically link into kernel image or as external module) CONFIG_I8K just enable /proc/i8k code in SENSORS_DELL_SMM -- no additional driver, just boolean switch which has effect only iff SENSORS_DELL_SMM is Y or M -- Pali Rohár pali.rohar@gmail.com [-- Attachment #1.2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] [-- Attachment #2: Type: text/plain, Size: 153 bytes --] _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 22:00 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 22:00 UTC (permalink / raw) To: Steven Honeyman Cc: Paul Bolle, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1: Type: Text/Plain, Size: 3028 bytes --] On Saturday 28 March 2015 13:54:51 Steven Honeyman wrote: > On 28 March 2015 at 11:04, Paul Bolle <pebolle@tiscali.nl> wrote: > > On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: > >> --- a/drivers/hwmon/Kconfig > >> +++ b/drivers/hwmon/Kconfig > >> @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 > >> > >> This driver provides support for the Ultra45 > >> workstation environmental sensors. > >> > >> +config SENSORS_DELL_SMM > >> + tristate "Dell laptop SMM BIOS hwmon driver" > >> + depends ON X86 > > > > How did this past your testing? > > > >> + ---help--- > >> + This hwmon driver adds support for reporting > >> temperature of different + sensors and controls the > >> fans on Dell laptops via System Management + Mode > >> provided by Dell BIOS. > >> + > >> + When option I8K is also enabled this driver > >> provides legacy /proc/i8k + userspace interface for > >> i8kutils package. > >> + > > It's working OK for me (after fixing the mistake pointed out > above). > > [Latitude e6540] > ----- > coretemp-isa-0000 > Adapter: ISA adapter > Physical id 0: +53.0°C (high = +84.0°C, crit = +100.0°C) > Core 0: +51.0°C (high = +84.0°C, crit = +100.0°C) > Core 1: +53.0°C (high = +84.0°C, crit = +100.0°C) > > i8k-virtual-0 > Adapter: Virtual device > Processor Fan: 3171 RPM > CPU: +52.0°C > Ambient: +46.0°C > SODIMM: +40.0°C > ----- > > Ambient and SODIMM look swapped - but it's probably just > another Dell error. I really need to look at getting coreboot > on this thing. > Both patches do not change any code. So there should not be any type swapped with or without my patch. Cpu type is requested via SMM in same way as it is doing old DOS executable. So there can be maybe problem in DELL SMM handler too or maybe just I did not understand correctly assembler dump of DOS executable... > On 28 March 2015 at 10:24, Pali Rohár <pali.rohar@gmail.com> > wrote: ... > > > config I8K > > > > - tristate "Dell laptop support" > > - select HWMON > > + bool "Dell i8k legacy laptop support" > > + select SENSORS_DELL_SMM > > ... > > > +config SENSORS_DELL_SMM > > + tristate "Dell laptop SMM BIOS hwmon driver" > > The only change I'd suggest is not to change the tristate to > bool for I8K. Forcing that to bool means that > SENSORS_DELL_SMM can't be compiled as a module if the user > wishes to keep i8k hanging around "just in case". It'll > probably annoy distro kernel packagers too. > > > Thanks, > Steven My idea was: SENSORS_DELL_SMM enable/disable compilation of kernel driver (ether statically link into kernel image or as external module) CONFIG_I8K just enable /proc/i8k code in SENSORS_DELL_SMM -- no additional driver, just boolean switch which has effect only iff SENSORS_DELL_SMM is Y or M -- Pali Rohár pali.rohar@gmail.com [-- Attachment #2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 22:00 ` Pali Rohár @ 2015-03-28 22:20 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 22:20 UTC (permalink / raw) To: Pali Rohár, Steven Honeyman Cc: Paul Bolle, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMDMvMjgvMjAxNSAwMzowMCBQTSwgUGFsaSBSb2jDoXIgd3JvdGU6Cj4gT24gU2F0dXJkYXkg MjggTWFyY2ggMjAxNSAxMzo1NDo1MSBTdGV2ZW4gSG9uZXltYW4gd3JvdGU6Cj4+IE9uIDI4IE1h cmNoIDIwMTUgYXQgMTE6MDQsIFBhdWwgQm9sbGUgPHBlYm9sbGVAdGlzY2FsaS5ubD4KPiB3cm90 ZToKPj4+IE9uIFNhdCwgMjAxNS0wMy0yOCBhdCAxMToyNCArMDEwMCwgUGFsaSBSb2jDoXIgd3Jv dGU6Cj4+Pj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4+Pj4gKysrIGIvZHJpdmVycy9o d21vbi9LY29uZmlnCj4+Pj4gQEAgLTE3MDMsNiArMTcwMywxNyBAQCBjb25maWcgU0VOU09SU19V TFRSQTQ1Cj4+Pj4KPj4+PiAgICAgICAgICBUaGlzIGRyaXZlciBwcm92aWRlcyBzdXBwb3J0IGZv ciB0aGUgVWx0cmE0NQo+Pj4+ICAgICAgICAgIHdvcmtzdGF0aW9uIGVudmlyb25tZW50YWwgc2Vu c29ycy4KPj4+Pgo+Pj4+ICtjb25maWcgU0VOU09SU19ERUxMX1NNTQo+Pj4+ICsgICAgIHRyaXN0 YXRlICJEZWxsIGxhcHRvcCBTTU0gQklPUyBod21vbiBkcml2ZXIiCj4+Pj4gKyAgICAgZGVwZW5k cyBPTiBYODYKPj4+Cj4+PiBIb3cgZGlkIHRoaXMgcGFzdCB5b3VyIHRlc3Rpbmc/Cj4+Pgo+Pj4+ ICsgICAgIC0tLWhlbHAtLS0KPj4+PiArICAgICAgIFRoaXMgaHdtb24gZHJpdmVyIGFkZHMgc3Vw cG9ydCBmb3IgcmVwb3J0aW5nCj4+Pj4gdGVtcGVyYXR1cmUgb2YgZGlmZmVyZW50ICsgICAgICAg c2Vuc29ycyBhbmQgY29udHJvbHMgdGhlCj4+Pj4gZmFucyBvbiBEZWxsIGxhcHRvcHMgdmlhIFN5 c3RlbSBNYW5hZ2VtZW50ICsgICAgICAgTW9kZQo+Pj4+IHByb3ZpZGVkIGJ5IERlbGwgQklPUy4K Pj4+PiArCj4+Pj4gKyAgICAgICBXaGVuIG9wdGlvbiBJOEsgaXMgYWxzbyBlbmFibGVkIHRoaXMg ZHJpdmVyCj4+Pj4gcHJvdmlkZXMgbGVnYWN5IC9wcm9jL2k4ayArICAgICAgIHVzZXJzcGFjZSBp bnRlcmZhY2UgZm9yCj4+Pj4gaThrdXRpbHMgcGFja2FnZS4KPj4+PiArCj4+Cj4+IEl0J3Mgd29y a2luZyBPSyBmb3IgbWUgKGFmdGVyIGZpeGluZyB0aGUgbWlzdGFrZSBwb2ludGVkIG91dAo+PiBh Ym92ZSkuCj4+Cj4+IFtMYXRpdHVkZSBlNjU0MF0KPj4gLS0tLS0KPj4gY29yZXRlbXAtaXNhLTAw MDAKPj4gQWRhcHRlcjogSVNBIGFkYXB0ZXIKPj4gUGh5c2ljYWwgaWQgMDogICs1My4wwrBDICAo aGlnaCA9ICs4NC4wwrBDLCBjcml0ID0gKzEwMC4wwrBDKQo+PiBDb3JlIDA6ICAgICAgICAgKzUx LjDCsEMgIChoaWdoID0gKzg0LjDCsEMsIGNyaXQgPSArMTAwLjDCsEMpCj4+IENvcmUgMTogICAg ICAgICArNTMuMMKwQyAgKGhpZ2ggPSArODQuMMKwQywgY3JpdCA9ICsxMDAuMMKwQykKPj4KPj4g aThrLXZpcnR1YWwtMAo+PiBBZGFwdGVyOiBWaXJ0dWFsIGRldmljZQo+PiBQcm9jZXNzb3IgRmFu OiAzMTcxIFJQTQo+PiBDUFU6ICAgICAgICAgICAgKzUyLjDCsEMKPj4gQW1iaWVudDogICAgICAg ICs0Ni4wwrBDCj4+IFNPRElNTTogICAgICAgICArNDAuMMKwQwo+PiAtLS0tLQo+Pgo+PiBBbWJp ZW50IGFuZCBTT0RJTU0gbG9vayBzd2FwcGVkIC0gYnV0IGl0J3MgcHJvYmFibHkganVzdAo+PiBh bm90aGVyIERlbGwgZXJyb3IuIEkgcmVhbGx5IG5lZWQgdG8gbG9vayBhdCBnZXR0aW5nIGNvcmVi b290Cj4+IG9uIHRoaXMgdGhpbmcuCj4+Cj4KPiBCb3RoIHBhdGNoZXMgZG8gbm90IGNoYW5nZSBh bnkgY29kZS4gU28gdGhlcmUgc2hvdWxkIG5vdCBiZSBhbnkKPiB0eXBlIHN3YXBwZWQgd2l0aCBv ciB3aXRob3V0IG15IHBhdGNoLgo+Cj4gQ3B1IHR5cGUgaXMgcmVxdWVzdGVkIHZpYSBTTU0gaW4g c2FtZSB3YXkgYXMgaXQgaXMgZG9pbmcgb2xkIERPUwo+IGV4ZWN1dGFibGUuIFNvIHRoZXJlIGNh biBiZSBtYXliZSBwcm9ibGVtIGluIERFTEwgU01NIGhhbmRsZXIgdG9vCj4gb3IgbWF5YmUganVz dCBJIGRpZCBub3QgdW5kZXJzdGFuZCBjb3JyZWN0bHkgYXNzZW1ibGVyIGR1bXAgb2YKPiBET1Mg ZXhlY3V0YWJsZS4uLgo+Cj4+IE9uIDI4IE1hcmNoIDIwMTUgYXQgMTA6MjQsIFBhbGkgUm9ow6Fy IDxwYWxpLnJvaGFyQGdtYWlsLmNvbT4KPj4gd3JvdGU6IC4uLgo+Pgo+Pj4gICBjb25maWcgSThL Cj4+Pgo+Pj4gLSAgICAgICB0cmlzdGF0ZSAiRGVsbCBsYXB0b3Agc3VwcG9ydCIKPj4+IC0gICAg ICAgc2VsZWN0IEhXTU9OCj4+PiArICAgICAgIGJvb2wgIkRlbGwgaThrIGxlZ2FjeSBsYXB0b3Ag c3VwcG9ydCIKPj4+ICsgICAgICAgc2VsZWN0IFNFTlNPUlNfREVMTF9TTU0KPj4KPj4gLi4uCj4+ Cj4+PiArY29uZmlnIFNFTlNPUlNfREVMTF9TTU0KPj4+ICsgICAgICAgdHJpc3RhdGUgIkRlbGwg bGFwdG9wIFNNTSBCSU9TIGh3bW9uIGRyaXZlciIKPj4KPj4gVGhlIG9ubHkgY2hhbmdlIEknZCBz dWdnZXN0IGlzIG5vdCB0byBjaGFuZ2UgdGhlIHRyaXN0YXRlIHRvCj4+IGJvb2wgZm9yIEk4Sy4g Rm9yY2luZyB0aGF0IHRvIGJvb2wgbWVhbnMgdGhhdAo+PiBTRU5TT1JTX0RFTExfU01NIGNhbid0 IGJlIGNvbXBpbGVkIGFzIGEgbW9kdWxlIGlmIHRoZSB1c2VyCj4+IHdpc2hlcyB0byBrZWVwIGk4 ayBoYW5naW5nIGFyb3VuZCAianVzdCBpbiBjYXNlIi4gSXQnbGwKPj4gcHJvYmFibHkgYW5ub3kg ZGlzdHJvIGtlcm5lbCBwYWNrYWdlcnMgdG9vLgo+Pgo+Pgo+PiBUaGFua3MsCj4+IFN0ZXZlbgo+ Cj4gTXkgaWRlYSB3YXM6Cj4KPiBTRU5TT1JTX0RFTExfU01NIGVuYWJsZS9kaXNhYmxlIGNvbXBp bGF0aW9uIG9mIGtlcm5lbCBkcml2ZXIKPiAoZXRoZXIgc3RhdGljYWxseSBsaW5rIGludG8ga2Vy bmVsIGltYWdlIG9yIGFzIGV4dGVybmFsIG1vZHVsZSkKPgo+IENPTkZJR19JOEsganVzdCBlbmFi bGUgL3Byb2MvaThrIGNvZGUgaW4gU0VOU09SU19ERUxMX1NNTSAtLSBubwo+IGFkZGl0aW9uYWwg ZHJpdmVyLCBqdXN0IGJvb2xlYW4gc3dpdGNoIHdoaWNoIGhhcyBlZmZlY3Qgb25seSBpZmYKPiBT RU5TT1JTX0RFTExfU01NIGlzIFkgb3IgTQo+CgpNYXliZSB0aGF0IGlzIHRoZSBwbGFuLCBidXQg aXQgaXMgbm90IHdoYXQgaXMgaGFwcGVuaW5nLgpJOEsgc2VsZWN0cyBTRU5TT1JTX0RFTExfU01N LCBzbyBhIGJvb2xlYW4gSThLIGZvcmNlcyBTRU5TT1JTX0RFTExfU01NCnRvIGJlIGJ1aWx0IGlu dG8gdGhlIGtlcm5lbC4KCldoYXQgeW91IHN1Z2dlc3Qgd291bGQgd29yayBpZiBJOEsgd291bGQg ZGVwZW5kIG9uIFNFTlNPUlNfREVMTF9TTU0sCmJ1dCB0aGVuIHRoZSBzeW1ib2xzIHdvdWxkIG5v dCBiZSBiYWNrd2FyZC1jb21wYXRpYmxlLgoKR3VlbnRlcgoKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0CmxtLXNl bnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxtYW4v bGlzdGluZm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 22:20 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 22:20 UTC (permalink / raw) To: Pali Rohár, Steven Honeyman Cc: Paul Bolle, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 03/28/2015 03:00 PM, Pali Rohár wrote: > On Saturday 28 March 2015 13:54:51 Steven Honeyman wrote: >> On 28 March 2015 at 11:04, Paul Bolle <pebolle@tiscali.nl> > wrote: >>> On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: >>>> --- a/drivers/hwmon/Kconfig >>>> +++ b/drivers/hwmon/Kconfig >>>> @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 >>>> >>>> This driver provides support for the Ultra45 >>>> workstation environmental sensors. >>>> >>>> +config SENSORS_DELL_SMM >>>> + tristate "Dell laptop SMM BIOS hwmon driver" >>>> + depends ON X86 >>> >>> How did this past your testing? >>> >>>> + ---help--- >>>> + This hwmon driver adds support for reporting >>>> temperature of different + sensors and controls the >>>> fans on Dell laptops via System Management + Mode >>>> provided by Dell BIOS. >>>> + >>>> + When option I8K is also enabled this driver >>>> provides legacy /proc/i8k + userspace interface for >>>> i8kutils package. >>>> + >> >> It's working OK for me (after fixing the mistake pointed out >> above). >> >> [Latitude e6540] >> ----- >> coretemp-isa-0000 >> Adapter: ISA adapter >> Physical id 0: +53.0°C (high = +84.0°C, crit = +100.0°C) >> Core 0: +51.0°C (high = +84.0°C, crit = +100.0°C) >> Core 1: +53.0°C (high = +84.0°C, crit = +100.0°C) >> >> i8k-virtual-0 >> Adapter: Virtual device >> Processor Fan: 3171 RPM >> CPU: +52.0°C >> Ambient: +46.0°C >> SODIMM: +40.0°C >> ----- >> >> Ambient and SODIMM look swapped - but it's probably just >> another Dell error. I really need to look at getting coreboot >> on this thing. >> > > Both patches do not change any code. So there should not be any > type swapped with or without my patch. > > Cpu type is requested via SMM in same way as it is doing old DOS > executable. So there can be maybe problem in DELL SMM handler too > or maybe just I did not understand correctly assembler dump of > DOS executable... > >> On 28 March 2015 at 10:24, Pali Rohár <pali.rohar@gmail.com> >> wrote: ... >> >>> config I8K >>> >>> - tristate "Dell laptop support" >>> - select HWMON >>> + bool "Dell i8k legacy laptop support" >>> + select SENSORS_DELL_SMM >> >> ... >> >>> +config SENSORS_DELL_SMM >>> + tristate "Dell laptop SMM BIOS hwmon driver" >> >> The only change I'd suggest is not to change the tristate to >> bool for I8K. Forcing that to bool means that >> SENSORS_DELL_SMM can't be compiled as a module if the user >> wishes to keep i8k hanging around "just in case". It'll >> probably annoy distro kernel packagers too. >> >> >> Thanks, >> Steven > > My idea was: > > SENSORS_DELL_SMM enable/disable compilation of kernel driver > (ether statically link into kernel image or as external module) > > CONFIG_I8K just enable /proc/i8k code in SENSORS_DELL_SMM -- no > additional driver, just boolean switch which has effect only iff > SENSORS_DELL_SMM is Y or M > Maybe that is the plan, but it is not what is happening. I8K selects SENSORS_DELL_SMM, so a boolean I8K forces SENSORS_DELL_SMM to be built into the kernel. What you suggest would work if I8K would depend on SENSORS_DELL_SMM, but then the symbols would not be backward-compatible. Guenter ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 22:20 ` Guenter Roeck @ 2015-03-28 22:44 ` Paul Bolle -1 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-28 22:44 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Steven Honeyman, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors Guenter Roeck schreef op za 28-03-2015 om 15:20 [-0700]: > Maybe that is the plan, but it is not what is happening. > I8K selects SENSORS_DELL_SMM, so a boolean I8K forces SENSORS_DELL_SMM > to be built into the kernel. > > What you suggest would work if I8K would depend on SENSORS_DELL_SMM, > but then the symbols would not be backward-compatible. I haven't actually looked into this part of the patch, since as far as I'm concerned this patch is broken. Having said that, if using a second Kconfig symbol is worth the effort, perhaps there's also enough reason to break Kconfig backward compatibility. People shouldn't alter Kconfig symbols just because they can, but as far as I'm aware we're on the record to not guarantee backward compatibility for Kconfig symbols. Paul Bolle _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 22:44 ` Paul Bolle 0 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-28 22:44 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Steven Honeyman, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors Guenter Roeck schreef op za 28-03-2015 om 15:20 [-0700]: > Maybe that is the plan, but it is not what is happening. > I8K selects SENSORS_DELL_SMM, so a boolean I8K forces SENSORS_DELL_SMM > to be built into the kernel. > > What you suggest would work if I8K would depend on SENSORS_DELL_SMM, > but then the symbols would not be backward-compatible. I haven't actually looked into this part of the patch, since as far as I'm concerned this patch is broken. Having said that, if using a second Kconfig symbol is worth the effort, perhaps there's also enough reason to break Kconfig backward compatibility. People shouldn't alter Kconfig symbols just because they can, but as far as I'm aware we're on the record to not guarantee backward compatibility for Kconfig symbols. Paul Bolle ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 22:44 ` Paul Bolle @ 2015-03-29 0:55 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-29 0:55 UTC (permalink / raw) To: Paul Bolle Cc: Pali Rohár, Steven Honeyman, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 03/28/2015 03:44 PM, Paul Bolle wrote: > Guenter Roeck schreef op za 28-03-2015 om 15:20 [-0700]: >> Maybe that is the plan, but it is not what is happening. >> I8K selects SENSORS_DELL_SMM, so a boolean I8K forces SENSORS_DELL_SMM >> to be built into the kernel. >> >> What you suggest would work if I8K would depend on SENSORS_DELL_SMM, >> but then the symbols would not be backward-compatible. > > I haven't actually looked into this part of the patch, since as far as > I'm concerned this patch is broken. > You mean beyond the "ON" and the above problem ? Can you elaborate ? Guenter _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-29 0:55 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-29 0:55 UTC (permalink / raw) To: Paul Bolle Cc: Pali Rohár, Steven Honeyman, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 03/28/2015 03:44 PM, Paul Bolle wrote: > Guenter Roeck schreef op za 28-03-2015 om 15:20 [-0700]: >> Maybe that is the plan, but it is not what is happening. >> I8K selects SENSORS_DELL_SMM, so a boolean I8K forces SENSORS_DELL_SMM >> to be built into the kernel. >> >> What you suggest would work if I8K would depend on SENSORS_DELL_SMM, >> but then the symbols would not be backward-compatible. > > I haven't actually looked into this part of the patch, since as far as > I'm concerned this patch is broken. > You mean beyond the "ON" and the above problem ? Can you elaborate ? Guenter ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-29 0:55 ` Guenter Roeck @ 2015-03-30 8:01 ` Paul Bolle -1 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-30 8:01 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Steven Honeyman, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Sat, 2015-03-28 at 17:55 -0700, Guenter Roeck wrote: > On 03/28/2015 03:44 PM, Paul Bolle wrote: > > I haven't actually looked into this part of the patch, since as far as > > I'm concerned this patch is broken. > > You mean beyond the "ON" and the above problem ? Can you elaborate ? No, I was talking about the ON typo. Because a patch that mainly juggles Kconfig symbols but adds a Kconfig syntax error while doing that is a broken patch. Paul Bolle _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-30 8:01 ` Paul Bolle 0 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-30 8:01 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Steven Honeyman, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Sat, 2015-03-28 at 17:55 -0700, Guenter Roeck wrote: > On 03/28/2015 03:44 PM, Paul Bolle wrote: > > I haven't actually looked into this part of the patch, since as far as > > I'm concerned this patch is broken. > > You mean beyond the "ON" and the above problem ? Can you elaborate ? No, I was talking about the ON typo. Because a patch that mainly juggles Kconfig symbols but adds a Kconfig syntax error while doing that is a broken patch. Paul Bolle ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 11:04 ` Paul Bolle @ 2015-03-28 21:55 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 21:55 UTC (permalink / raw) To: Paul Bolle Cc: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1.1: Type: Text/Plain, Size: 663 bytes --] On Saturday 28 March 2015 12:04:20 Paul Bolle wrote: > On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: > > --- a/drivers/hwmon/Kconfig > > +++ b/drivers/hwmon/Kconfig > > @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 > > > > This driver provides support for the Ultra45 workstation > > environmental sensors. > > > > +config SENSORS_DELL_SMM > > + tristate "Dell laptop SMM BIOS hwmon driver" > > + depends ON X86 > > How did this past your testing? > Hello, I have tested compilation only with out of tree make command with manual CONFIG_SENSORS_DELL_SMM and CONFIG_I8K options. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #1.2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] [-- Attachment #2: Type: text/plain, Size: 153 bytes --] _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 21:55 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 21:55 UTC (permalink / raw) To: Paul Bolle Cc: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1: Type: Text/Plain, Size: 663 bytes --] On Saturday 28 March 2015 12:04:20 Paul Bolle wrote: > On Sat, 2015-03-28 at 11:24 +0100, Pali Rohár wrote: > > --- a/drivers/hwmon/Kconfig > > +++ b/drivers/hwmon/Kconfig > > @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 > > > > This driver provides support for the Ultra45 workstation > > environmental sensors. > > > > +config SENSORS_DELL_SMM > > + tristate "Dell laptop SMM BIOS hwmon driver" > > + depends ON X86 > > How did this past your testing? > Hello, I have tested compilation only with out of tree make command with manual CONFIG_SENSORS_DELL_SMM and CONFIG_I8K options. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 21:55 ` Pali Rohár @ 2015-03-28 22:06 ` Paul Bolle -1 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-28 22:06 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gU2F0LCAyMDE1LTAzLTI4IGF0IDIyOjU1ICswMTAwLCBQYWxpIFJvaMOhciB3cm90ZToKPiBJ IGhhdmUgdGVzdGVkIGNvbXBpbGF0aW9uIG9ubHkgd2l0aCBvdXQgb2YgdHJlZSBtYWtlIGNvbW1h bmQgd2l0aCAKPiBtYW51YWwgQ09ORklHX1NFTlNPUlNfREVMTF9TTU0gYW5kIENPTkZJR19JOEsg b3B0aW9ucy4KCk5vdCBzdXJlIHdoYXQgeW91IG1lYW4gaGVyZS4gSSBjYW4ndCBnZXQgdGhpbmdz IHBhc3QgdGhpcyBlcnJvcjoKICAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZzoxNzIxOiBzeW50YXgg ZXJyb3IKICAgIGRyaXZlcnMvaHdtb24vS2NvbmZpZzoxNzIwOiBpbnZhbGlkIG9wdGlvbgogICAg bWFrZVsxXTogKioqIFtvbGRjb25maWddIEVycm9yIDEKICAgIG1ha2U6ICoqKiBbb2xkY29uZmln XSBFcnJvciAyCgpUaGFua3MsCgoKUGF1bCBCb2xsZQoKCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5z b3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 22:06 ` Paul Bolle 0 siblings, 0 replies; 86+ messages in thread From: Paul Bolle @ 2015-03-28 22:06 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Sat, 2015-03-28 at 22:55 +0100, Pali Rohár wrote: > I have tested compilation only with out of tree make command with > manual CONFIG_SENSORS_DELL_SMM and CONFIG_I8K options. Not sure what you mean here. I can't get things past this error: drivers/hwmon/Kconfig:1721: syntax error drivers/hwmon/Kconfig:1720: invalid option make[1]: *** [oldconfig] Error 1 make: *** [oldconfig] Error 2 Thanks, Paul Bolle ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 22:06 ` Paul Bolle @ 2015-03-28 22:19 ` Steven Honeyman -1 siblings, 0 replies; 86+ messages in thread From: Steven Honeyman @ 2015-03-28 22:19 UTC (permalink / raw) To: Paul Bolle Cc: Pali Rohár, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMjggTWFyY2ggMjAxNSBhdCAyMjowMCwgUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwu Y29tPiB3cm90ZToKPiBPbiBTYXR1cmRheSAyOCBNYXJjaCAyMDE1IDEzOjU0OjUxIFN0ZXZlbiBI b25leW1hbiB3cm90ZToKPj4gaThrLXZpcnR1YWwtMAo+PiBBZGFwdGVyOiBWaXJ0dWFsIGRldmlj ZQo+PiBQcm9jZXNzb3IgRmFuOiAzMTcxIFJQTQo+PiBDUFU6ICAgICAgICAgICAgKzUyLjDCsEMK Pj4gQW1iaWVudDogICAgICAgICs0Ni4wwrBDCj4+IFNPRElNTTogICAgICAgICArNDAuMMKwQwo+ PiAtLS0tLQo+Pgo+PiBBbWJpZW50IGFuZCBTT0RJTU0gbG9vayBzd2FwcGVkIC0gYnV0IGl0J3Mg cHJvYmFibHkganVzdAo+PiBhbm90aGVyIERlbGwgZXJyb3IuIEkgcmVhbGx5IG5lZWQgdG8gbG9v ayBhdCBnZXR0aW5nIGNvcmVib290Cj4+IG9uIHRoaXMgdGhpbmcuCj4+Cj4KPiBCb3RoIHBhdGNo ZXMgZG8gbm90IGNoYW5nZSBhbnkgY29kZS4gU28gdGhlcmUgc2hvdWxkIG5vdCBiZSBhbnkKPiB0 eXBlIHN3YXBwZWQgd2l0aCBvciB3aXRob3V0IG15IHBhdGNoLgo+Cj4gQ3B1IHR5cGUgaXMgcmVx dWVzdGVkIHZpYSBTTU0gaW4gc2FtZSB3YXkgYXMgaXQgaXMgZG9pbmcgb2xkIERPUwo+IGV4ZWN1 dGFibGUuIFNvIHRoZXJlIGNhbiBiZSBtYXliZSBwcm9ibGVtIGluIERFTEwgU01NIGhhbmRsZXIg dG9vCj4gb3IgbWF5YmUganVzdCBJIGRpZCBub3QgdW5kZXJzdGFuZCBjb3JyZWN0bHkgYXNzZW1i bGVyIGR1bXAgb2YKPiBET1MgZXhlY3V0YWJsZS4uLgo+CgpJcyB0aGVyZSBzb21lIHdheSB0aGF0 IEkgY2FuIGZpbmQgb3V0IGZvciB5b3U/IEkndmUgZ290IGEgV2luZG93cwpwYXJ0aXRpb24gc29t ZXdoZXJlLCBvciBET1MgYm9vdCBkaXNrIHNob3VsZCBiZSBlYXN5IGVub3VnaCBpZiB0aGlzCnBy b2dyYW0gd29ya3Mgb24gbmV3IGhhcmR3YXJlLgpJZiBJIGtuZXcgd2hlcmUgdGhlIHNlbnNvcnMg d2VyZSBwbGFjZWQgSSBjb3VsZCBjb29sIG9uZSBvZiB0aGVtLgoKCk9uIDI4IE1hcmNoIDIwMTUg YXQgMjI6MDQsIFBhbGkgUm9ow6FyIDxwYWxpLnJvaGFyQGdtYWlsLmNvbT4gd3JvdGU6Cj4gSSB0 aGluayB0aGF0IHNldHRpbmcgQ09ORklHX0k4SyB0byB0cmlzdGF0ZSAoWS9NL04pIGRvZXMgbm90 IG1ha2UKPiBzZW5zZS4uLiBDT05GSUdfSThLIGp1c3QgY29udHJvbCBpZiAvcHJvYy9pOGsgd2ls bCBiZSBjb21waWxlZAo+IGludG8gZGVsbC1zbW0taHdtb24gb3Igbm90LgoKVHJ5IGFuZCBzZWxl Y3QgZGVsbC1zbW0taHdtb24gYXMgYSBtb2R1bGUsIHdpdGggaThrIGVuYWJsZWQgYXMgd2VsbC4u LgoKCk9uIDI4IE1hcmNoIDIwMTUgYXQgMjI6MDYsIFBhdWwgQm9sbGUgPHBlYm9sbGVAdGlzY2Fs aS5ubD4gd3JvdGU6Cj4gT24gU2F0LCAyMDE1LTAzLTI4IGF0IDIyOjU1ICswMTAwLCBQYWxpIFJv aMOhciB3cm90ZToKPj4gSSBoYXZlIHRlc3RlZCBjb21waWxhdGlvbiBvbmx5IHdpdGggb3V0IG9m IHRyZWUgbWFrZSBjb21tYW5kIHdpdGgKPj4gbWFudWFsIENPTkZJR19TRU5TT1JTX0RFTExfU01N IGFuZCBDT05GSUdfSThLIG9wdGlvbnMuCj4KPiBOb3Qgc3VyZSB3aGF0IHlvdSBtZWFuIGhlcmUu IEkgY2FuJ3QgZ2V0IHRoaW5ncyBwYXN0IHRoaXMgZXJyb3I6Cj4gICAgIGRyaXZlcnMvaHdtb24v S2NvbmZpZzoxNzIxOiBzeW50YXggZXJyb3IKPiAgICAgZHJpdmVycy9od21vbi9LY29uZmlnOjE3 MjA6IGludmFsaWQgb3B0aW9uCgotLS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcKKysrIGIvZHJp dmVycy9od21vbi9LY29uZmlnCkBAIC0xNzA1LDggKzE3MDUsOCBAQAoKIGNvbmZpZyBTRU5TT1JT X0RFTExfU01NCiAgICAgdHJpc3RhdGUgIkRlbGwgbGFwdG9wIFNNTSBCSU9TIGh3bW9uIGRyaXZl ciIKLSAgICBkZXBlbmRzIE9OIFg4NgotICAgIC0tLWhlbHAtLS0KKyAgICBkZXBlbmRzIG9uIFg4 NgorICAgIGhlbHAKICAgICAgIFRoaXMgaHdtb24gZHJpdmVyIGFkZHMgc3VwcG9ydCBmb3IgcmVw b3J0aW5nIHRlbXBlcmF0dXJlIG9mIGRpZmZlcmVudAogICAgICAgc2Vuc29ycyBhbmQgY29udHJv bHMgdGhlIGZhbnMgb24gRGVsbCBsYXB0b3BzIHZpYSBTeXN0ZW0gTWFuYWdlbWVudAogICAgICAg TW9kZSBwcm92aWRlZCBieSBEZWxsIEJJT1MuCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxt LXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 22:19 ` Steven Honeyman 0 siblings, 0 replies; 86+ messages in thread From: Steven Honeyman @ 2015-03-28 22:19 UTC (permalink / raw) To: Paul Bolle Cc: Pali Rohár, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 28 March 2015 at 22:00, Pali Rohár <pali.rohar@gmail.com> wrote: > On Saturday 28 March 2015 13:54:51 Steven Honeyman wrote: >> i8k-virtual-0 >> Adapter: Virtual device >> Processor Fan: 3171 RPM >> CPU: +52.0°C >> Ambient: +46.0°C >> SODIMM: +40.0°C >> ----- >> >> Ambient and SODIMM look swapped - but it's probably just >> another Dell error. I really need to look at getting coreboot >> on this thing. >> > > Both patches do not change any code. So there should not be any > type swapped with or without my patch. > > Cpu type is requested via SMM in same way as it is doing old DOS > executable. So there can be maybe problem in DELL SMM handler too > or maybe just I did not understand correctly assembler dump of > DOS executable... > Is there some way that I can find out for you? I've got a Windows partition somewhere, or DOS boot disk should be easy enough if this program works on new hardware. If I knew where the sensors were placed I could cool one of them. On 28 March 2015 at 22:04, Pali Rohár <pali.rohar@gmail.com> wrote: > I think that setting CONFIG_I8K to tristate (Y/M/N) does not make > sense... CONFIG_I8K just control if /proc/i8k will be compiled > into dell-smm-hwmon or not. Try and select dell-smm-hwmon as a module, with i8k enabled as well... On 28 March 2015 at 22:06, Paul Bolle <pebolle@tiscali.nl> wrote: > On Sat, 2015-03-28 at 22:55 +0100, Pali Rohár wrote: >> I have tested compilation only with out of tree make command with >> manual CONFIG_SENSORS_DELL_SMM and CONFIG_I8K options. > > Not sure what you mean here. I can't get things past this error: > drivers/hwmon/Kconfig:1721: syntax error > drivers/hwmon/Kconfig:1720: invalid option --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -1705,8 +1705,8 @@ config SENSORS_DELL_SMM tristate "Dell laptop SMM BIOS hwmon driver" - depends ON X86 - ---help--- + depends on X86 + help This hwmon driver adds support for reporting temperature of different sensors and controls the fans on Dell laptops via System Management Mode provided by Dell BIOS. ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 22:19 ` Steven Honeyman @ 2015-03-28 22:33 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 22:33 UTC (permalink / raw) To: Steven Honeyman Cc: Paul Bolle, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1.1: Type: Text/Plain, Size: 3284 bytes --] On Saturday 28 March 2015 23:19:04 Steven Honeyman wrote: > On 28 March 2015 at 22:00, Pali Rohár <pali.rohar@gmail.com> > wrote: > > On Saturday 28 March 2015 13:54:51 Steven Honeyman wrote: > >> i8k-virtual-0 > >> Adapter: Virtual device > >> Processor Fan: 3171 RPM > >> CPU: +52.0°C > >> Ambient: +46.0°C > >> SODIMM: +40.0°C > >> ----- > >> > >> Ambient and SODIMM look swapped - but it's probably just > >> another Dell error. I really need to look at getting > >> coreboot on this thing. > > > > Both patches do not change any code. So there should not be > > any type swapped with or without my patch. > > > > Cpu type is requested via SMM in same way as it is doing old > > DOS executable. So there can be maybe problem in DELL SMM > > handler too or maybe just I did not understand correctly > > assembler dump of DOS executable... > > Is there some way that I can find out for you? I've got a > Windows partition somewhere, or DOS boot disk should be easy > enough if this program works on new hardware. > If I knew where the sensors were placed I could cool one of > them. > Maybe DOS executable is just too old... and need to use new one. I extracted diagnostic application from BIOS package (EFI binary which show temperature in BIOS) for my laptop, but decoding instructions of this big graphic binary is beyond my power. But it looks like it calls same SMM inb/outb calls, so SMM code in BIOS handler was not changed. So if you want to fix this problem, next step is to disassemble or understand new modern EFI diag binary... I think it would be better to locate on which bus are sensors connected (smbus? isa? pci?), find out HW chips and wrote native kernel drivers for them... I scanned smbus (intel controller connected on pci) on my E6440 but there is no additional/unknown device. I have no idea where else could be sensor device connected and accessible (from SMM or kernel mode). > On 28 March 2015 at 22:04, Pali Rohár <pali.rohar@gmail.com> > wrote: > > I think that setting CONFIG_I8K to tristate (Y/M/N) does not > > make sense... CONFIG_I8K just control if /proc/i8k will be > > compiled into dell-smm-hwmon or not. > > Try and select dell-smm-hwmon as a module, with i8k enabled as > well... > Got it. > On 28 March 2015 at 22:06, Paul Bolle <pebolle@tiscali.nl> > wrote: > > On Sat, 2015-03-28 at 22:55 +0100, Pali Rohár wrote: > >> I have tested compilation only with out of tree make > >> command with manual CONFIG_SENSORS_DELL_SMM and CONFIG_I8K > >> options. > > > > Not sure what you mean here. I can't get things past this > > error: > > drivers/hwmon/Kconfig:1721: syntax error > > drivers/hwmon/Kconfig:1720: invalid option > > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -1705,8 +1705,8 @@ > > config SENSORS_DELL_SMM > tristate "Dell laptop SMM BIOS hwmon driver" > - depends ON X86 > - ---help--- > + depends on X86 > + help > This hwmon driver adds support for reporting > temperature of different sensors and controls the fans on > Dell laptops via System Management Mode provided by Dell > BIOS. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #1.2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] [-- Attachment #2: Type: text/plain, Size: 153 bytes --] _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 22:33 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 22:33 UTC (permalink / raw) To: Steven Honeyman Cc: Paul Bolle, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1: Type: Text/Plain, Size: 3284 bytes --] On Saturday 28 March 2015 23:19:04 Steven Honeyman wrote: > On 28 March 2015 at 22:00, Pali Rohár <pali.rohar@gmail.com> > wrote: > > On Saturday 28 March 2015 13:54:51 Steven Honeyman wrote: > >> i8k-virtual-0 > >> Adapter: Virtual device > >> Processor Fan: 3171 RPM > >> CPU: +52.0°C > >> Ambient: +46.0°C > >> SODIMM: +40.0°C > >> ----- > >> > >> Ambient and SODIMM look swapped - but it's probably just > >> another Dell error. I really need to look at getting > >> coreboot on this thing. > > > > Both patches do not change any code. So there should not be > > any type swapped with or without my patch. > > > > Cpu type is requested via SMM in same way as it is doing old > > DOS executable. So there can be maybe problem in DELL SMM > > handler too or maybe just I did not understand correctly > > assembler dump of DOS executable... > > Is there some way that I can find out for you? I've got a > Windows partition somewhere, or DOS boot disk should be easy > enough if this program works on new hardware. > If I knew where the sensors were placed I could cool one of > them. > Maybe DOS executable is just too old... and need to use new one. I extracted diagnostic application from BIOS package (EFI binary which show temperature in BIOS) for my laptop, but decoding instructions of this big graphic binary is beyond my power. But it looks like it calls same SMM inb/outb calls, so SMM code in BIOS handler was not changed. So if you want to fix this problem, next step is to disassemble or understand new modern EFI diag binary... I think it would be better to locate on which bus are sensors connected (smbus? isa? pci?), find out HW chips and wrote native kernel drivers for them... I scanned smbus (intel controller connected on pci) on my E6440 but there is no additional/unknown device. I have no idea where else could be sensor device connected and accessible (from SMM or kernel mode). > On 28 March 2015 at 22:04, Pali Rohár <pali.rohar@gmail.com> > wrote: > > I think that setting CONFIG_I8K to tristate (Y/M/N) does not > > make sense... CONFIG_I8K just control if /proc/i8k will be > > compiled into dell-smm-hwmon or not. > > Try and select dell-smm-hwmon as a module, with i8k enabled as > well... > Got it. > On 28 March 2015 at 22:06, Paul Bolle <pebolle@tiscali.nl> > wrote: > > On Sat, 2015-03-28 at 22:55 +0100, Pali Rohár wrote: > >> I have tested compilation only with out of tree make > >> command with manual CONFIG_SENSORS_DELL_SMM and CONFIG_I8K > >> options. > > > > Not sure what you mean here. I can't get things past this > > error: > > drivers/hwmon/Kconfig:1721: syntax error > > drivers/hwmon/Kconfig:1720: invalid option > > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -1705,8 +1705,8 @@ > > config SENSORS_DELL_SMM > tristate "Dell laptop SMM BIOS hwmon driver" > - depends ON X86 > - ---help--- > + depends on X86 > + help > This hwmon driver adds support for reporting > temperature of different sensors and controls the fans on > Dell laptops via System Management Mode provided by Dell > BIOS. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 22:33 ` Pali Rohár @ 2015-03-30 7:44 ` Jean Delvare -1 siblings, 0 replies; 86+ messages in thread From: Jean Delvare @ 2015-03-30 7:44 UTC (permalink / raw) To: Pali Rohár Cc: Steven Honeyman, Paul Bolle, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gU2F0LCAyOCBNYXIgMjAxNSAyMzozMzo0NiArMDEwMCwgUGFsaSBSb2jDoXIgd3JvdGU6Cj4g SSB0aGluayBpdCB3b3VsZCBiZSBiZXR0ZXIgdG8gbG9jYXRlIG9uIHdoaWNoIGJ1cyBhcmUgc2Vu c29ycyAKPiBjb25uZWN0ZWQgKHNtYnVzPyBpc2E/IHBjaT8pLCBmaW5kIG91dCBIVyBjaGlwcyBh bmQgd3JvdGUgbmF0aXZlIAo+IGtlcm5lbCBkcml2ZXJzIGZvciB0aGVtLi4uCj4gCj4gSSBzY2Fu bmVkIHNtYnVzIChpbnRlbCBjb250cm9sbGVyIGNvbm5lY3RlZCBvbiBwY2kpIG9uIG15IEU2NDQw IAo+IGJ1dCB0aGVyZSBpcyBubyBhZGRpdGlvbmFsL3Vua25vd24gZGV2aWNlLiBJIGhhdmUgbm8g aWRlYSB3aGVyZSAKPiBlbHNlIGNvdWxkIGJlIHNlbnNvciBkZXZpY2UgY29ubmVjdGVkIGFuZCBh Y2Nlc3NpYmxlIChmcm9tIFNNTSBvciAKPiBrZXJuZWwgbW9kZSkuCgpBcyBtdWNoIGFzIEkgaGF0 ZSBTTU0sIG5hdGl2ZSBhY2Nlc3MgdG8gYSBCSU9TLW93bmVkIGRldmljZSBpcyBub3QgYQpnb29k IGlkZWEsIGFzIGlzIGl0IGRhbmdlcm91c2x5IHJhY3kuIElmIGFueXRoaW5nLCB3ZSBhcmUgY3Vy cmVudGx5CnRyeWluZyB0byBtb3ZlIF9hd2F5XyBmcm9tIG5hdGl2ZSBkcml2ZXJzIG9uIGEgbnVt YmVyIG9mIHN5c3RlbXMKKGJhc2ljYWxseSBhbGwgc3lzdGVtcyB3aGVyZSBhY3BpX2VuZm9yY2Vf cmVzb3VyY2VzPWxheCBpcyBuZWVkZWQuKQoKT24geDg2LCBpZGVhbGx5IEFDUEkgd291bGQgb2Zm ZXIgYSBzdGFuZGFyZCBpbnRlcmZhY2UgdG8gdGhlIGhhcmR3YXJlCm1vbml0b3JpbmcgY2hpcCBh bmQgdGhlIE9TIHdvdWxkIG5lZWQgYSBzaW5nbGUgZHJpdmVyIGZvciBhbGwgYm9hcmRzCm91dCB0 aGVyZS4gRmFpbGluZyB0aGF0LCBBQ1BJIHNob3VsZCBwcm92aWRlIGEgY2xlYW4gYW5kIHNhZmUg d2F5IHRvCmFjY2VzcyB0aGUgY2hpcCdzIHJlZ2lzdGVycyAocmVhZDogc29tZSBtdXRleCB0byBh dm9pZCBjb25jdXJyZW50CmFjY2VzcyB0byB0aGUgcmVnaXN0ZXJzIGJ5IHRoZSBCSU9TIGFuZCB0 aGUgT1MuKQoKLS0gCkplYW4gRGVsdmFyZQpTVVNFIEwzIFN1cHBvcnQKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0 CmxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21h aWxtYW4vbGlzdGluZm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-30 7:44 ` Jean Delvare 0 siblings, 0 replies; 86+ messages in thread From: Jean Delvare @ 2015-03-30 7:44 UTC (permalink / raw) To: Pali Rohár Cc: Steven Honeyman, Paul Bolle, Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Valdis Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Sat, 28 Mar 2015 23:33:46 +0100, Pali Rohár wrote: > I think it would be better to locate on which bus are sensors > connected (smbus? isa? pci?), find out HW chips and wrote native > kernel drivers for them... > > I scanned smbus (intel controller connected on pci) on my E6440 > but there is no additional/unknown device. I have no idea where > else could be sensor device connected and accessible (from SMM or > kernel mode). As much as I hate SMM, native access to a BIOS-owned device is not a good idea, as is it dangerously racy. If anything, we are currently trying to move _away_ from native drivers on a number of systems (basically all systems where acpi_enforce_resources=lax is needed.) On x86, ideally ACPI would offer a standard interface to the hardware monitoring chip and the OS would need a single driver for all boards out there. Failing that, ACPI should provide a clean and safe way to access the chip's registers (read: some mutex to avoid concurrent access to the registers by the BIOS and the OS.) -- Jean Delvare SUSE L3 Support ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 10:24 ` Pali Rohár @ 2015-03-28 14:23 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 14:23 UTC (permalink / raw) To: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMDMvMjgvMjAxNSAwMzoyNCBBTSwgUGFsaSBSb2jDoXIgd3JvdGU6Cj4gVGhpcyBwYXRjaCBz cGxpdHMgQ09ORklHX0k4SyBjb21waWxlIG9wdGlvbiB0byBTRU5TT1JTX0RFTExfU01NIGFuZCBD T05GSUdfSThLLgo+IE9wdGlvbiBTRU5TT1JTX0RFTExfU01NIGlzIG5vdyB1c2VkIHRvIGVuYWJs ZSBjb21waWxhdGlvbiBvZiBkZWxsLXNtbS1od21vbgo+IGRyaXZlciBhbmQgb2xkIENPTkZJR19J OEsgb3B0aW9uIHRvIGVuYWJsZSAvcHJvYy9pOGsgaW50ZXJmYWNlIGluIGRyaXZlci4KPgo+IFNv IHRoaXMgY2hhbmdlIGFsbG93cyB0byBjb21waWxlIGRlbGwtc21tLWh3bW9uIGRyaXZlciB3aXRo b3V0IGxlZ2FjeSAvcHJvYy9pOGsKPiBpbnRlcmZhY2Ugd2hpY2ggaXMgbmVlZGVkIG9ubHkgZm9y IG9sZCBEZWxsIEluc3BpcmlvbiBtb2RlbHMgb3IgZm9yIHVzZXJzcGFjZQo+IGk4a3V0aWxzIHBh Y2thZ2UuCj4KPiBGb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSB3aGVuIENPTkZJR19JOEsgaXMg ZW5hYmxlZCB0aGVuIGFsc28gU0VOU09SU19ERUxMX1NNTQo+IGlzIGVuYWJsZWQgYW5kIHNvIGRy aXZlciBkZWxsLXNtbS1od21vbiAod2l0aCAvcHJvYy9pOGspIGlzIGNvbXBpbGVkLgo+Cj4gU2ln bmVkLW9mZi1ieTogUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPgo+IC0tLQo+ICAg YXJjaC94ODYvS2NvbmZpZyAgICAgICAgICAgICAgIHwgICAyNSArKysrKysrKystLS0tLS0tLS0t LS0tLS0tCj4gICBkcml2ZXJzL2h3bW9uL0tjb25maWcgICAgICAgICAgfCAgIDExICsrKysrKysr KysrCj4gICBkcml2ZXJzL2h3bW9uL01ha2VmaWxlICAgICAgICAgfCAgICAyICstCj4gICBkcml2 ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMgfCAgIDIwICsrKysrKysrKysrKysrKystLS0tCj4g ICA0IGZpbGVzIGNoYW5nZWQsIDM3IGluc2VydGlvbnMoKyksIDIxIGRlbGV0aW9ucygtKQo+Cj4g ZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25maWcgYi9hcmNoL3g4Ni9LY29uZmlnCj4gaW5kZXgg YjdkMzFjYS4uOGQwMjY2YiAxMDA2NDQKPiAtLS0gYS9hcmNoL3g4Ni9LY29uZmlnCj4gKysrIGIv YXJjaC94ODYvS2NvbmZpZwo+IEBAIC0xMDYzLDI0ICsxMDYzLDE3IEBAIGNvbmZpZyBUT1NISUJB Cj4gICAJICBTYXkgTiBvdGhlcndpc2UuCj4KPiAgIGNvbmZpZyBJOEsKPiAtCXRyaXN0YXRlICJE ZWxsIGxhcHRvcCBzdXBwb3J0Igo+IC0Jc2VsZWN0IEhXTU9OCj4gKwlib29sICJEZWxsIGk4ayBs ZWdhY3kgbGFwdG9wIHN1cHBvcnQiCgp0cmlzdGF0ZSBhbmQgc3RpbGwgInNlbGVjdCBIV01PTiIu Cgo+ICsJc2VsZWN0IFNFTlNPUlNfREVMTF9TTU0KPiAgIAktLS1oZWxwLS0tCj4gLQkgIFRoaXMg YWRkcyBhIGRyaXZlciB0byBzYWZlbHkgYWNjZXNzIHRoZSBTeXN0ZW0gTWFuYWdlbWVudCBNb2Rl Cj4gLQkgIG9mIHRoZSBDUFUgb24gdGhlIERlbGwgSW5zcGlyb24gODAwMC4gVGhlIFN5c3RlbSBN YW5hZ2VtZW50IE1vZGUKPiAtCSAgaXMgdXNlZCB0byByZWFkIGNwdSB0ZW1wZXJhdHVyZSBhbmQg Y29vbGluZyBmYW4gc3RhdHVzIGFuZCB0bwo+IC0JICBjb250cm9sIHRoZSBmYW5zIG9uIHRoZSBJ OEsgcG9ydGFibGVzLgo+ICsJICBUaGlzIG9wdGlvbnMgZW5hYmxlcyBsZWdhY3kgL3Byb2MvaThr IHVzZXJzcGFjZSBpbnRlcmZhY2UgaW4KPiArCSAgZGVsbC1zbW0taHdtb24gZHJpdmVyLiBDaGFy YWN0ZXIgZmlsZSAvcHJvYy9pOGsgcmVwb3J0cyBwb3dlciBhbmQKPiArCSAgaG90a2V5IHN0YXR1 cyBvbiBvbGQgRGVsbCBsYXB0b3BzIChsaWtlIERlbGwgSW5zcGlyb24gODAwMCkgdmlhCj4gKwkg IFN5c3RlbSBNYW5hZ2VtZW50IE1vZGUgcHJvdmlkZWQgYnkgRGVsbCBCSU9TLiBUaGlzIC9wcm9j L2k4ayBpbnRlcmZhY2UKPiArCSAgaXMgYWxzbyB1c2VkIGJ5IHVzZXJzcGFjZSBwYWNrYWdlIGk4 a3V0aWxzIHRvIGNvbnRyb2wgbGFwdG9wIGZhbnMuCj4KPiAtCSAgVGhpcyBkcml2ZXIgaGFzIGJl ZW4gdGVzdGVkIG9ubHkgb24gdGhlIEluc3Bpcm9uIDgwMDAgYnV0IGl0IG1heQo+IC0JICBhbHNv IHdvcmsgd2l0aCBvdGhlciBEZWxsIGxhcHRvcHMuIFlvdSBjYW4gZm9yY2UgbG9hZGluZyBvbiBv dGhlcgo+IC0JICBtb2RlbHMgYnkgcGFzc2luZyB0aGUgcGFyYW1ldGVyIGBmb3JjZT0xJyB0byB0 aGUgbW9kdWxlLiBVc2UgYXQKPiAtCSAgeW91ciBvd24gcmlzay4KPiAtCj4gLQkgIEZvciBpbmZv cm1hdGlvbiBvbiB1dGlsaXRpZXMgdG8gbWFrZSB1c2Ugb2YgdGhpcyBkcml2ZXIgc2VlIHRoZQo+ IC0JICBJOEsgTGludXggdXRpbGl0aWVzIHdlYiBzaXRlIGF0Ogo+IC0JICA8aHR0cDovL3Blb3Bs ZS5kZWJpYW4ub3JnL35kei9pOGsvPgo+IC0KPiAtCSAgU2F5IFkgaWYgeW91IGludGVuZCB0byBy dW4gdGhpcyBrZXJuZWwgb24gYSBEZWxsIEluc3Bpcm9uIDgwMDAuCj4gKwkgIFNheSBZIGlmIHlv dSBpbnRlbmQgdG8gcnVuIHRoaXMga2VybmVsIG9uIG9sZCBEZWxsIGxhcHRvcHMgb3Igd2FudCB0 bwo+ICsJICB1c2UgdXNlcnNwYWNlIHBhY2thZ2UgaThrdXRpbHMuCj4gICAJICBTYXkgTiBvdGhl cndpc2UuCj4KPiAgIGNvbmZpZyBYODZfUkVCT09URklYVVBTCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvaHdtb24vS2NvbmZpZyBiL2RyaXZlcnMvaHdtb24vS2NvbmZpZwo+IGluZGV4IDExMGZhZGUu Ljg2ZWViN2QgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9od21vbi9LY29uZmlnCj4gKysrIGIvZHJp dmVycy9od21vbi9LY29uZmlnCj4gQEAgLTE3MDMsNiArMTcwMywxNyBAQCBjb25maWcgU0VOU09S U19VTFRSQTQ1Cj4gICAJICBUaGlzIGRyaXZlciBwcm92aWRlcyBzdXBwb3J0IGZvciB0aGUgVWx0 cmE0NSB3b3Jrc3RhdGlvbiBlbnZpcm9ubWVudGFsCj4gICAJICBzZW5zb3JzLgo+Cj4gK2NvbmZp ZyBTRU5TT1JTX0RFTExfU01NCj4gKwl0cmlzdGF0ZSAiRGVsbCBsYXB0b3AgU01NIEJJT1MgaHdt b24gZHJpdmVyIgo+ICsJZGVwZW5kcyBPTiBYODYKCldvbmRlcmluZyBhcyB3ZWxsIC4uIC5kaWQg eW91IHRlc3QgdGhpcyA/Cgo+ICsJLS0taGVscC0tLQo+ICsJICBUaGlzIGh3bW9uIGRyaXZlciBh ZGRzIHN1cHBvcnQgZm9yIHJlcG9ydGluZyB0ZW1wZXJhdHVyZSBvZiBkaWZmZXJlbnQKPiArCSAg c2Vuc29ycyBhbmQgY29udHJvbHMgdGhlIGZhbnMgb24gRGVsbCBsYXB0b3BzIHZpYSBTeXN0ZW0g TWFuYWdlbWVudAo+ICsJICBNb2RlIHByb3ZpZGVkIGJ5IERlbGwgQklPUy4KPiArCj4gKwkgIFdo ZW4gb3B0aW9uIEk4SyBpcyBhbHNvIGVuYWJsZWQgdGhpcyBkcml2ZXIgcHJvdmlkZXMgbGVnYWN5 IC9wcm9jL2k4awo+ICsJICB1c2Vyc3BhY2UgaW50ZXJmYWNlIGZvciBpOGt1dGlscyBwYWNrYWdl Lgo+ICsKUGxlYXNlIGFkZCB0aGlzIGluIGFscGhhYmV0aWMgb3JkZXIuCgo+ICAgaWYgQUNQSQo+ Cj4gICBjb21tZW50ICJBQ1BJIGRyaXZlcnMiCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24v TWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4gaW5kZXggMWMzZTQ1OC4uOWVlYzYx NCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9o d21vbi9NYWtlZmlsZQo+IEBAIC0xNTUsNyArMTU1LDcgQEAgb2JqLSQoQ09ORklHX1NFTlNPUlNf VzgzTDc4NVRTKQkrPSB3ODNsNzg1dHMubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfVzgzTDc4 Nk5HKQkrPSB3ODNsNzg2bmcubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzFYKQkrPSB3 bTgzMXgtaHdtb24ubwo+ICAgb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzUwKQkrPSB3bTgzNTAt aHdtb24ubwo+IC1vYmotJChDT05GSUdfSThLKQkJKz0gZGVsbC1zbW0taHdtb24ubwo+ICtvYmot JChDT05GSUdfU0VOU09SU19ERUxMX1NNTSkJKz0gZGVsbC1zbW0taHdtb24ubwoKU2FtZSBoZXJl LgoKPgo+ICAgb2JqLSQoQ09ORklHX1BNQlVTKQkJKz0gcG1idXMvCj4KPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIGIvZHJpdmVycy9od21vbi9kZWxsLXNtbS1o d21vbi5jCj4gaW5kZXggMmIwNGU0Zi4uZTk2NjFkYyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2h3 bW9uL2RlbGwtc21tLWh3bW9uLmMKPiArKysgYi9kcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9u LmMKPiBAQCAtODEsNyArODEsNyBAQCBzdGF0aWMgdWludCBpOGtfZmFuX21heCA9IEk4S19GQU5f SElHSDsKPgo+ICAgTU9EVUxFX0FVVEhPUigiTWFzc2ltbyBEYWwgWm90dG8gKGR6QGRlYmlhbi5v cmcpIik7Cj4gICBNT0RVTEVfQVVUSE9SKCJQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5j b20+Iik7Cj4gLU1PRFVMRV9ERVNDUklQVElPTigiRHJpdmVyIGZvciBhY2Nlc3NpbmcgU01NIEJJ T1Mgb24gRGVsbCBsYXB0b3BzIik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiRGVsbCBsYXB0b3Ag U01NIEJJT1MgaHdtb24gZHJpdmVyIik7Cj4gICBNT0RVTEVfTElDRU5TRSgiR1BMIik7Cj4gICBN T0RVTEVfQUxJQVMoImk4ayIpOwo+Cj4gQEAgLTkzLDYgKzkzLDcgQEAgc3RhdGljIGJvb2wgaWdu b3JlX2RtaTsKPiAgIG1vZHVsZV9wYXJhbShpZ25vcmVfZG1pLCBib29sLCAwKTsKPiAgIE1PRFVM RV9QQVJNX0RFU0MoaWdub3JlX2RtaSwgIkNvbnRpbnVlIHByb2JpbmcgaGFyZHdhcmUgZXZlbiBp ZiBETUkgZGF0YSBkb2VzIG5vdCBtYXRjaCIpOwo+Cj4gKyNpZmRlZiBDT05GSUdfSThLCj4gICBz dGF0aWMgYm9vbCByZXN0cmljdGVkOwo+ICAgbW9kdWxlX3BhcmFtKHJlc3RyaWN0ZWQsIGJvb2ws IDApOwo+ICAgTU9EVUxFX1BBUk1fREVTQyhyZXN0cmljdGVkLCAiQWxsb3cgZmFuIGNvbnRyb2wg aWYgU1lTX0FETUlOIGNhcGFiaWxpdHkgc2V0Iik7Cj4gQEAgLTEwMCw2ICsxMDEsNyBAQCBNT0RV TEVfUEFSTV9ERVNDKHJlc3RyaWN0ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4g Y2FwYWJpbGl0eSBzZXQiKTsKPiAgIHN0YXRpYyBib29sIHBvd2VyX3N0YXR1czsKPiAgIG1vZHVs ZV9wYXJhbShwb3dlcl9zdGF0dXMsIGJvb2wsIDA2MDApOwo+ICAgTU9EVUxFX1BBUk1fREVTQyhw b3dlcl9zdGF0dXMsICJSZXBvcnQgcG93ZXIgc3RhdHVzIGluIC9wcm9jL2k4ayIpOwo+ICsjZW5k aWYKPgo+ICAgc3RhdGljIHVpbnQgZmFuX211bHQ7Cj4gICBtb2R1bGVfcGFyYW0oZmFuX211bHQs IHVpbnQsIDApOwo+IEBAIC0xMDksNiArMTExLDcgQEAgc3RhdGljIHVpbnQgZmFuX21heDsKPiAg IG1vZHVsZV9wYXJhbShmYW5fbWF4LCB1aW50LCAwKTsKPiAgIE1PRFVMRV9QQVJNX0RFU0MoZmFu X21heCwgIk1heGltdW0gY29uZmlndXJhYmxlIGZhbiBzcGVlZCAoZGVmYXVsdDogYXV0b2RldGVj dCkiKTsKPgo+ICsjaWZkZWYgQ09ORklHX0k4Swo+ICAgc3RhdGljIGludCBpOGtfb3Blbl9mcyhz dHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSk7Cj4gICBzdGF0aWMgbG9uZyBp OGtfaW9jdGwoc3RydWN0IGZpbGUgKiwgdW5zaWduZWQgaW50LCB1bnNpZ25lZCBsb25nKTsKPgo+ IEBAIC0xMjAsNiArMTIzLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMg aThrX2ZvcHMgPSB7Cj4gICAJLnJlbGVhc2UJPSBzaW5nbGVfcmVsZWFzZSwKPiAgIAkudW5sb2Nr ZWRfaW9jdGwJPSBpOGtfaW9jdGwsCj4gICB9Owo+ICsjZW5kaWYKPgo+ICAgc3RydWN0IHNtbV9y ZWdzIHsKPiAgIAl1bnNpZ25lZCBpbnQgZWF4Owo+IEBAIC0yMjAsNiArMjI0LDcgQEAgb3V0Ogo+ ICAgCXJldHVybiByYzsKPiAgIH0KPgo+ICsjaWZkZWYgQ09ORklHX0k4Swo+ICAgLyoKPiAgICAq IFJlYWQgdGhlIEZuIGtleSBzdGF0dXMuCj4gICAgKi8KPiBAQCAtMjU4LDYgKzI2Myw3IEBAIHN0 YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9pZCkKPgo+ICAgCXJldHVybiAocmVncy5l YXggJiAweGZmKSA9PSBJOEtfUE9XRVJfQUMgPyBJOEtfQUMgOiBJOEtfQkFUVEVSWTsKPiAgIH0K PiArI2VuZGlmCj4KPiAgIC8qCj4gICAgKiBSZWFkIHRoZSBmYW4gc3RhdHVzLgo+IEBAIC0zNzgs NiArMzg0LDcgQEAgc3RhdGljIGludCBpOGtfZ2V0X2RlbGxfc2lnbmF0dXJlKGludCByZXFfZm4p Cj4gICAJcmV0dXJuIHJlZ3MuZWF4ID09IDExNDU2NTE1MjcgJiYgcmVncy5lZHggPT0gMTE0NTM5 MjIwNCA/IDAgOiAtMTsKPiAgIH0KPgo+ICsjaWZkZWYgQ09ORklHX0k4Swo+ICAgc3RhdGljIGlu dAo+ICAgaThrX2lvY3RsX3VubG9ja2VkKHN0cnVjdCBmaWxlICpmcCwgdW5zaWduZWQgaW50IGNt ZCwgdW5zaWduZWQgbG9uZyBhcmcpCj4gICB7Cj4gQEAgLTUyNSw2ICs1MzIsNyBAQCBzdGF0aWMg aW50IGk4a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQo+ ICAgewo+ICAgCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBpOGtfcHJvY19zaG93LCBOVUxMKTsK PiAgIH0KPiArI2VuZGlmCj4KPgo+ICAgLyoKPiBAQCAtOTc0LDE3ICs5ODIsMTcgQEAgc3RhdGlj IGludCBfX2luaXQgaThrX3Byb2JlKHZvaWQpCj4KPiAgIHN0YXRpYyBpbnQgX19pbml0IGk4a19p bml0KHZvaWQpCj4gICB7Cj4gLQlzdHJ1Y3QgcHJvY19kaXJfZW50cnkgKnByb2NfaThrOwo+ICAg CWludCBlcnI7Cj4KPiAgIAkvKiBBcmUgd2UgcnVubmluZyBvbiBhbiBzdXBwb3J0ZWQgbGFwdG9w PyAqLwo+ICAgCWlmIChpOGtfcHJvYmUoKSkKPiAgIAkJcmV0dXJuIC1FTk9ERVY7Cj4KPiArI2lm ZGVmIENPTkZJR19JOEsKPiAgIAkvKiBSZWdpc3RlciB0aGUgcHJvYyBlbnRyeSAqLwo+IC0JcHJv Y19pOGsgPSBwcm9jX2NyZWF0ZSgiaThrIiwgMCwgTlVMTCwgJmk4a19mb3BzKTsKPiAtCWlmICgh cHJvY19pOGspCj4gKwlpZiAoIXByb2NfY3JlYXRlKCJpOGsiLCAwLCBOVUxMLCAmaThrX2ZvcHMp KQo+ICAgCQlyZXR1cm4gLUVOT0VOVDsKCkkgd291bGQgcHJlZmVyIG5vdCB0byBmYWlsIGhlcmUg YnV0IHJlcG9ydCBhIHdhcm5pbmcuClRoaXMgaXMgbm8gbG9uZ2VyIGEgZmF0YWwgY29uZGl0aW9u LgoKPiArI2VuZGlmCj4KPiAgIAllcnIgPSBpOGtfaW5pdF9od21vbigpOwo+ICAgCWlmIChlcnIp Cj4gQEAgLTk5MywxNCArMTAwMSwxOCBAQCBzdGF0aWMgaW50IF9faW5pdCBpOGtfaW5pdCh2b2lk KQo+ICAgCXJldHVybiAwOwo+Cj4gICAgZXhpdF9yZW1vdmVfcHJvYzoKPiArI2lmZGVmIENPTkZJ R19JOEsKPiAgIAlyZW1vdmVfcHJvY19lbnRyeSgiaThrIiwgTlVMTCk7Cj4gKyNlbmRpZgo+ICAg CXJldHVybiBlcnI7Cj4gICB9Cj4KPiAgIHN0YXRpYyB2b2lkIF9fZXhpdCBpOGtfZXhpdCh2b2lk KQo+ICAgewo+ICAgCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGk4a19od21vbl9kZXYpOwo+ICsj aWZkZWYgQ09ORklHX0k4Swo+ICAgCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBOVUxMKTsKPiAr I2VuZGlmCj4gICB9Cj4KPiAgIG1vZHVsZV9pbml0KGk4a19pbml0KTsKPgoKQ2FuIHlvdSBtb3Zl IGFsbCB0aGUgY29uZGl0aW9uYWwgZnVuY3Rpb25zIGFuZCBnbG9iYWwgdmFyaWFibGVzIHRvZ2V0 aGVyCnVuZGVyIGEgc2luZ2xlICNpZmRlZiA/IFRoYXQgc2hvdWxkIGluY2x1ZGUgZnVuY3Rpb25z IHRvIGNyZWF0ZSB0aGUgcHJvYwplbnRyaWVzLCBhbmQgc2hpbSBmdW5jdGlvbnMgZm9yIHRoZSBz YW1lIGlmIEk4SyBpcyBub3QgY29uZmlndXJlZC4KCkFsc28sIHRoZSAjaWZkZWYgd291bGQgbm90 IGNvdmVyIHRoZSBjYXNlIHdoZXJlIEk4SyBpcyBjb25maWd1cmVkIGFzIG1vZHVsZQoodGhlcmUg aXMgbm8gcmVhc29uIHRvIGZvcmNlIGl0IHRvIGJvb2wpLiBZb3Ugc2hvdWxkIHVzZSAiI2lmIElT X0VOQUJMRUQoQ09ORklHX0k4SykiCmluc3RlYWQuCgpUaGFua3MsCkd1ZW50ZXIKCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxp bmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3Jz Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 14:23 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-28 14:23 UTC (permalink / raw) To: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 03/28/2015 03:24 AM, Pali Rohár wrote: > This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. > Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon > driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. > > So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k > interface which is needed only for old Dell Inspirion models or for userspace > i8kutils package. > > For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM > is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > arch/x86/Kconfig | 25 +++++++++---------------- > drivers/hwmon/Kconfig | 11 +++++++++++ > drivers/hwmon/Makefile | 2 +- > drivers/hwmon/dell-smm-hwmon.c | 20 ++++++++++++++++---- > 4 files changed, 37 insertions(+), 21 deletions(-) > > diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig > index b7d31ca..8d0266b 100644 > --- a/arch/x86/Kconfig > +++ b/arch/x86/Kconfig > @@ -1063,24 +1063,17 @@ config TOSHIBA > Say N otherwise. > > config I8K > - tristate "Dell laptop support" > - select HWMON > + bool "Dell i8k legacy laptop support" tristate and still "select HWMON". > + select SENSORS_DELL_SMM > ---help--- > - This adds a driver to safely access the System Management Mode > - of the CPU on the Dell Inspiron 8000. The System Management Mode > - is used to read cpu temperature and cooling fan status and to > - control the fans on the I8K portables. > + This options enables legacy /proc/i8k userspace interface in > + dell-smm-hwmon driver. Character file /proc/i8k reports power and > + hotkey status on old Dell laptops (like Dell Inspiron 8000) via > + System Management Mode provided by Dell BIOS. This /proc/i8k interface > + is also used by userspace package i8kutils to control laptop fans. > > - This driver has been tested only on the Inspiron 8000 but it may > - also work with other Dell laptops. You can force loading on other > - models by passing the parameter `force=1' to the module. Use at > - your own risk. > - > - For information on utilities to make use of this driver see the > - I8K Linux utilities web site at: > - <http://people.debian.org/~dz/i8k/> > - > - Say Y if you intend to run this kernel on a Dell Inspiron 8000. > + Say Y if you intend to run this kernel on old Dell laptops or want to > + use userspace package i8kutils. > Say N otherwise. > > config X86_REBOOTFIXUPS > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > index 110fade..86eeb7d 100644 > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -1703,6 +1703,17 @@ config SENSORS_ULTRA45 > This driver provides support for the Ultra45 workstation environmental > sensors. > > +config SENSORS_DELL_SMM > + tristate "Dell laptop SMM BIOS hwmon driver" > + depends ON X86 Wondering as well .. .did you test this ? > + ---help--- > + This hwmon driver adds support for reporting temperature of different > + sensors and controls the fans on Dell laptops via System Management > + Mode provided by Dell BIOS. > + > + When option I8K is also enabled this driver provides legacy /proc/i8k > + userspace interface for i8kutils package. > + Please add this in alphabetic order. > if ACPI > > comment "ACPI drivers" > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > index 1c3e458..9eec614 100644 > --- a/drivers/hwmon/Makefile > +++ b/drivers/hwmon/Makefile > @@ -155,7 +155,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o > obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o > obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o > obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o > -obj-$(CONFIG_I8K) += dell-smm-hwmon.o > +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o Same here. > > obj-$(CONFIG_PMBUS) += pmbus/ > > diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c > index 2b04e4f..e9661dc 100644 > --- a/drivers/hwmon/dell-smm-hwmon.c > +++ b/drivers/hwmon/dell-smm-hwmon.c > @@ -81,7 +81,7 @@ static uint i8k_fan_max = I8K_FAN_HIGH; > > MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); > MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); > -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); > +MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); > MODULE_LICENSE("GPL"); > MODULE_ALIAS("i8k"); > > @@ -93,6 +93,7 @@ static bool ignore_dmi; > module_param(ignore_dmi, bool, 0); > MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); > > +#ifdef CONFIG_I8K > static bool restricted; > module_param(restricted, bool, 0); > MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > @@ -100,6 +101,7 @@ MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > static bool power_status; > module_param(power_status, bool, 0600); > MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); > +#endif > > static uint fan_mult; > module_param(fan_mult, uint, 0); > @@ -109,6 +111,7 @@ static uint fan_max; > module_param(fan_max, uint, 0); > MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); > > +#ifdef CONFIG_I8K > static int i8k_open_fs(struct inode *inode, struct file *file); > static long i8k_ioctl(struct file *, unsigned int, unsigned long); > > @@ -120,6 +123,7 @@ static const struct file_operations i8k_fops = { > .release = single_release, > .unlocked_ioctl = i8k_ioctl, > }; > +#endif > > struct smm_regs { > unsigned int eax; > @@ -220,6 +224,7 @@ out: > return rc; > } > > +#ifdef CONFIG_I8K > /* > * Read the Fn key status. > */ > @@ -258,6 +263,7 @@ static int i8k_get_power_status(void) > > return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; > } > +#endif > > /* > * Read the fan status. > @@ -378,6 +384,7 @@ static int i8k_get_dell_signature(int req_fn) > return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; > } > > +#ifdef CONFIG_I8K > static int > i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) > { > @@ -525,6 +532,7 @@ static int i8k_open_fs(struct inode *inode, struct file *file) > { > return single_open(file, i8k_proc_show, NULL); > } > +#endif > > > /* > @@ -974,17 +982,17 @@ static int __init i8k_probe(void) > > static int __init i8k_init(void) > { > - struct proc_dir_entry *proc_i8k; > int err; > > /* Are we running on an supported laptop? */ > if (i8k_probe()) > return -ENODEV; > > +#ifdef CONFIG_I8K > /* Register the proc entry */ > - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); > - if (!proc_i8k) > + if (!proc_create("i8k", 0, NULL, &i8k_fops)) > return -ENOENT; I would prefer not to fail here but report a warning. This is no longer a fatal condition. > +#endif > > err = i8k_init_hwmon(); > if (err) > @@ -993,14 +1001,18 @@ static int __init i8k_init(void) > return 0; > > exit_remove_proc: > +#ifdef CONFIG_I8K > remove_proc_entry("i8k", NULL); > +#endif > return err; > } > > static void __exit i8k_exit(void) > { > hwmon_device_unregister(i8k_hwmon_dev); > +#ifdef CONFIG_I8K > remove_proc_entry("i8k", NULL); > +#endif > } > > module_init(i8k_init); > Can you move all the conditional functions and global variables together under a single #ifdef ? That should include functions to create the proc entries, and shim functions for the same if I8K is not configured. Also, the #ifdef would not cover the case where I8K is configured as module (there is no reason to force it to bool). You should use "#if IS_ENABLED(CONFIG_I8K)" instead. Thanks, Guenter ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-28 14:23 ` Guenter Roeck @ 2015-03-28 22:04 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 22:04 UTC (permalink / raw) To: Guenter Roeck Cc: Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1.1: Type: Text/Plain, Size: 2050 bytes --] On Saturday 28 March 2015 15:23:15 Guenter Roeck wrote: > > + ---help--- > > + This hwmon driver adds support for reporting temperature > > of different + sensors and controls the fans on Dell > > laptops via System Management + Mode provided by Dell > > BIOS. > > + > > + When option I8K is also enabled this driver provides > > legacy /proc/i8k + userspace interface for i8kutils > > package. > > + > > Please add this in alphabetic order. > ok > > if ACPI > > > > comment "ACPI drivers" > > > > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > > index 1c3e458..9eec614 100644 > > --- a/drivers/hwmon/Makefile > > +++ b/drivers/hwmon/Makefile > > @@ -155,7 +155,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += > > w83l785ts.o > > > > obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o > > obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o > > obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o > > > > -obj-$(CONFIG_I8K) += dell-smm-hwmon.o > > +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o > > Same here. > ok > > - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); > > - if (!proc_i8k) > > + if (!proc_create("i8k", 0, NULL, &i8k_fops)) > > > > return -ENOENT; > > I would prefer not to fail here but report a warning. > This is no longer a fatal condition. > ok, no problem > > Can you move all the conditional functions and global > variables together under a single #ifdef ? That should > include functions to create the proc entries, and shim > functions for the same if I8K is not configured. > ok, I will move procfs code to one location. > Also, the #ifdef would not cover the case where I8K is > configured as module (there is no reason to force it to > bool). You should use "#if IS_ENABLED(CONFIG_I8K)" instead. > I think that setting CONFIG_I8K to tristate (Y/M/N) does not make sense... CONFIG_I8K just control if /proc/i8k will be compiled into dell-smm-hwmon or not. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #1.2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] [-- Attachment #2: Type: text/plain, Size: 153 bytes --] _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-28 22:04 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-28 22:04 UTC (permalink / raw) To: Guenter Roeck Cc: Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1: Type: Text/Plain, Size: 2050 bytes --] On Saturday 28 March 2015 15:23:15 Guenter Roeck wrote: > > + ---help--- > > + This hwmon driver adds support for reporting temperature > > of different + sensors and controls the fans on Dell > > laptops via System Management + Mode provided by Dell > > BIOS. > > + > > + When option I8K is also enabled this driver provides > > legacy /proc/i8k + userspace interface for i8kutils > > package. > > + > > Please add this in alphabetic order. > ok > > if ACPI > > > > comment "ACPI drivers" > > > > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > > index 1c3e458..9eec614 100644 > > --- a/drivers/hwmon/Makefile > > +++ b/drivers/hwmon/Makefile > > @@ -155,7 +155,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += > > w83l785ts.o > > > > obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o > > obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o > > obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o > > > > -obj-$(CONFIG_I8K) += dell-smm-hwmon.o > > +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o > > Same here. > ok > > - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); > > - if (!proc_i8k) > > + if (!proc_create("i8k", 0, NULL, &i8k_fops)) > > > > return -ENOENT; > > I would prefer not to fail here but report a warning. > This is no longer a fatal condition. > ok, no problem > > Can you move all the conditional functions and global > variables together under a single #ifdef ? That should > include functions to create the proc entries, and shim > functions for the same if I8K is not configured. > ok, I will move procfs code to one location. > Also, the #ifdef would not cover the case where I8K is > configured as module (there is no reason to force it to > bool). You should use "#if IS_ENABLED(CONFIG_I8K)" instead. > I think that setting CONFIG_I8K to tristate (Y/M/N) does not make sense... CONFIG_I8K just control if /proc/i8k will be compiled into dell-smm-hwmon or not. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] ^ permalink raw reply [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-03-28 10:24 ` Pali Rohár @ 2015-03-29 12:57 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-29 12:57 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBwYXRjaCBzZXJpZXMgbW92ZXMgZHJpdmVycy9jaGFyL2k4ay5jIHRvIGRyaXZlcnMvaHdt b24vZGVsbC1zbW0taHdtb24uYwphbmQgYWxsb3dzIHRvIGNvbXBpbGUgaHdtb24gZHJpdmVyIHdp dGhvdXQgL3Byb2MvaThrIGZpbGUuCgpQYWxpIFJvaMOhciAoMik6CiAgaHdtb246IFJlbmFtZSBp OGsgZHJpdmVyIHRvIGRlbGwtc21tLWh3bW9uIGFuZCBtb3ZlIGl0IHRvIGh3bW9uIHRyZWUKICBo d21vbjogQWxsb3cgdG8gY29tcGlsZSBkZWxsLXNtbS1od21vbiBkcml2ZXIgd2l0aG91dCAvcHJv Yy9pOGsKCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgfCAgICA0ICstCiBhcmNoL3g4 Ni9LY29uZmlnICAgICAgICAgICAgICAgfCAgIDI1ICstCiBkcml2ZXJzL2NoYXIvTWFrZWZpbGUg ICAgICAgICAgfCAgICAxIC0KIGRyaXZlcnMvY2hhci9pOGsuYyAgICAgICAgICAgICB8IDEwMDUg LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2h3bW9uL0tj b25maWcgICAgICAgICAgfCAgIDExICsKIGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgICAgICAgICB8 ICAgIDEgKwogZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIHwgMTAyNSArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiA3IGZpbGVzIGNoYW5nZWQsIDEwNDkgaW5z ZXJ0aW9ucygrKSwgMTAyMyBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L2NoYXIvaThrLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3 bW9uLmMKCi0tIAoxLjcuOS41CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KbG0tc2Vuc29ycyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3Jz Lm9yZwpodHRwOi8vbGlzdHMubG0tc2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5z b3Jz ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-03-29 12:57 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-29 12:57 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c and allows to compile hwmon driver without /proc/i8k file. Pali Rohár (2): hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k MAINTAINERS | 4 +- arch/x86/Kconfig | 25 +- drivers/char/Makefile | 1 - drivers/char/i8k.c | 1005 --------------------------------------- drivers/hwmon/Kconfig | 11 + drivers/hwmon/Makefile | 1 + drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 1049 insertions(+), 1023 deletions(-) delete mode 100644 drivers/char/i8k.c create mode 100644 drivers/hwmon/dell-smm-hwmon.c -- 1.7.9.5 ^ permalink raw reply [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH v2 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree 2015-03-29 12:57 ` Pali Rohár @ 2015-03-29 12:57 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-29 12:57 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBjb21taXQgbW92ZXMgaThrIGRyaXZlciB0byBod21vbiB0cmVlIHVuZGVyIG5hbWUgZGVs bC1zbW0taHdtb24gd2hpY2ggaXMKYmV0dGVyIG5hbWUgdGhlbiBhYmJyZXZpYXRpb24gaThrLiBG b3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSBpcyBhZGRlZCBtYWNybwpNT0RVTEVfQUxJQVMoImk4 ayIpIHNvIG1vZHByb2JlIHdpbGwgbG9hZCBkcml2ZXIgYWxzbyBvbGQgbmFtZSBpOGsuIENPTkZJ R19JOEsKY29tcGlsZSBvcHRpb24gd2FzIG5vdCBjaGFuZ2VkLgoKVGhpcyBjb21taXQgYWxzbyBh ZGRzIG1lIGFzIG1haW50YWluZXIgb2YgdGhpcyBuZXcgZGVsbC1zbW0taHdtb24gZHJpdmVyIGFu ZApyZW1vdmUgR3VlbnRlciBSb2VjayBmcm9tIGxpc3Qgd2hvIGlzIGltcGxpY2l0IG1haW50YWlu ZXIgYWxsIGh3bW9uIGRyaXZlcnMuCgpTaWduZWQtb2ZmLWJ5OiBQYWxpIFJvaMOhciA8cGFsaS5y b2hhckBnbWFpbC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgIHwgICAg NCArLQogZHJpdmVycy9jaGFyL01ha2VmaWxlICAgICAgICAgIHwgICAgMSAtCiBkcml2ZXJzL2No YXIvaThrLmMgICAgICAgICAgICAgfCAxMDA1IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQogZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgIHwgICAgMSArCiBkcml2 ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMgfCAxMDA3ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgMTAxMCBpbnNlcnRpb25zKCspLCAx MDA4IGRlbGV0aW9ucygtKQogZGVsZXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY2hhci9pOGsuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwoKZGlmZiAt LWdpdCBhL01BSU5UQUlORVJTIGIvTUFJTlRBSU5FUlMKaW5kZXggODhjMDljYS4uZTU0YTA3ZSAx MDA2NDQKLS0tIGEvTUFJTlRBSU5FUlMKKysrIGIvTUFJTlRBSU5FUlMKQEAgLTMwNjMsOSArMzA2 Myw5IEBAIFM6CU1haW50YWluZWQKIEY6CWRyaXZlcnMvcGxhdGZvcm0veDg2L2RlbGwtbGFwdG9w LmMKIAogREVMTCBMQVBUT1AgU01NIERSSVZFUgotTToJR3VlbnRlciBSb2VjayA8bGludXhAcm9l Y2stdXMubmV0PgorTToJUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPgogUzoJTWFp bnRhaW5lZAotRjoJZHJpdmVycy9jaGFyL2k4ay5jCitGOglkcml2ZXJzL2h3bW9uL2RlbGwtc21t LWh3bW9uLmMKIEY6CWluY2x1ZGUvdWFwaS9saW51eC9pOGsuaAogCiBERUxMIFNZU1RFTVMgTUFO QUdFTUVOVCBCQVNFIERSSVZFUiAoZGNkYmFzKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL01h a2VmaWxlIGIvZHJpdmVycy9jaGFyL01ha2VmaWxlCmluZGV4IGQwNmNkZTI2Li4xZDljZjAwIDEw MDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9jaGFyL01ha2Vm aWxlCkBAIC0zNiw3ICszNiw2IEBAIGVsc2UKICAgb2JqLSQoQ09ORklHX05WUkFNKQkrPSBudnJh bS5vCiBlbmRpZgogb2JqLSQoQ09ORklHX1RPU0hJQkEpCQkrPSB0b3NoaWJhLm8KLW9iai0kKENP TkZJR19JOEspCQkrPSBpOGsubwogb2JqLSQoQ09ORklHX0RTMTYyMCkJCSs9IGRzMTYyMC5vCiBv YmotJChDT05GSUdfSFdfUkFORE9NKQkJKz0gaHdfcmFuZG9tLwogb2JqLSQoQ09ORklHX1BQREVW KQkJKz0gcHBkZXYubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2k4ay5jIGIvZHJpdmVycy9j aGFyL2k4ay5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyNGNjNGVkLi4wMDAwMDAw Ci0tLSBhL2RyaXZlcnMvY2hhci9pOGsuYworKysgL2Rldi9udWxsCkBAIC0xLDEwMDUgKzAsMCBA QAotLyoKLSAqIGk4ay5jIC0tIExpbnV4IGRyaXZlciBmb3IgYWNjZXNzaW5nIHRoZSBTTU0gQklP UyBvbiBEZWxsIGxhcHRvcHMuCi0gKgotICogQ29weXJpZ2h0IChDKSAyMDAxICBNYXNzaW1vIERh bCBab3R0byA8ZHpAZGViaWFuLm9yZz4KLSAqCi0gKiBId21vbiBpbnRlZ3JhdGlvbjoKLSAqIENv cHlyaWdodCAoQykgMjAxMSAgSmVhbiBEZWx2YXJlIDxqZGVsdmFyZUBzdXNlLmRlPgotICogQ29w eXJpZ2h0IChDKSAyMDEzLCAyMDE0ICBHdWVudGVyIFJvZWNrIDxsaW51eEByb2Vjay11cy5uZXQ+ Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMTQgIFBhbGkgUm9ow6FyIDxwYWxpLnJvaGFyQGdtYWlsLmNv bT4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAotICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlCi0gKiBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55 Ci0gKiBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKLSAqIFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V Ci0gKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKi8KLQotI2Rl ZmluZSBwcl9mbXQoZm10KSBLQlVJTERfTU9ETkFNRSAiOiAiIGZtdAotCi0jaW5jbHVkZSA8bGlu dXgvZGVsYXkuaD4KLSNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLSNpbmNsdWRlIDxsaW51eC90 eXBlcy5oPgotI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KLSNpbmNsdWRlIDxsaW51eC9wcm9jX2Zz Lmg+Ci0jaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KLSNpbmNsdWRlIDxsaW51eC9kbWkuaD4K LSNpbmNsdWRlIDxsaW51eC9jYXBhYmlsaXR5Lmg+Ci0jaW5jbHVkZSA8bGludXgvbXV0ZXguaD4K LSNpbmNsdWRlIDxsaW51eC9od21vbi5oPgotI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+ Ci0jaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgotI2luY2x1ZGUgPGxpbnV4L2lvLmg+Ci0jaW5j bHVkZSA8bGludXgvc2NoZWQuaD4KLQotI2luY2x1ZGUgPGxpbnV4L2k4ay5oPgotCi0jZGVmaW5l IEk4S19TTU1fRk5fU1RBVFVTCTB4MDAyNQotI2RlZmluZSBJOEtfU01NX1BPV0VSX1NUQVRVUwkw eDAwNjkKLSNkZWZpbmUgSThLX1NNTV9TRVRfRkFOCQkweDAxYTMKLSNkZWZpbmUgSThLX1NNTV9H RVRfRkFOCQkweDAwYTMKLSNkZWZpbmUgSThLX1NNTV9HRVRfU1BFRUQJMHgwMmEzCi0jZGVmaW5l IEk4S19TTU1fR0VUX0ZBTl9UWVBFCTB4MDNhMwotI2RlZmluZSBJOEtfU01NX0dFVF9OT01fU1BF RUQJMHgwNGEzCi0jZGVmaW5lIEk4S19TTU1fR0VUX1RFTVAJMHgxMGEzCi0jZGVmaW5lIEk4S19T TU1fR0VUX1RFTVBfVFlQRQkweDExYTMKLSNkZWZpbmUgSThLX1NNTV9HRVRfREVMTF9TSUcxCTB4 ZmVhMwotI2RlZmluZSBJOEtfU01NX0dFVF9ERUxMX1NJRzIJMHhmZmEzCi0KLSNkZWZpbmUgSThL X0ZBTl9NVUxUCQkzMAotI2RlZmluZSBJOEtfRkFOX01BWF9SUE0JCTMwMDAwCi0jZGVmaW5lIEk4 S19NQVhfVEVNUAkJMTI3Ci0KLSNkZWZpbmUgSThLX0ZOX05PTkUJCTB4MDAKLSNkZWZpbmUgSThL X0ZOX1VQCQkweDAxCi0jZGVmaW5lIEk4S19GTl9ET1dOCQkweDAyCi0jZGVmaW5lIEk4S19GTl9N VVRFCQkweDA0Ci0jZGVmaW5lIEk4S19GTl9NQVNLCQkweDA3Ci0jZGVmaW5lIEk4S19GTl9TSElG VAkJOAotCi0jZGVmaW5lIEk4S19QT1dFUl9BQwkJMHgwNQotI2RlZmluZSBJOEtfUE9XRVJfQkFU VEVSWQkweDAxCi0KLXN0YXRpYyBERUZJTkVfTVVURVgoaThrX211dGV4KTsKLXN0YXRpYyBjaGFy IGJpb3NfdmVyc2lvbls0XTsKLXN0YXRpYyBzdHJ1Y3QgZGV2aWNlICppOGtfaHdtb25fZGV2Owot c3RhdGljIHUzMiBpOGtfaHdtb25fZmxhZ3M7Ci1zdGF0aWMgdWludCBpOGtfZmFuX211bHQgPSBJ OEtfRkFOX01VTFQ7Ci1zdGF0aWMgdWludCBpOGtfcHdtX211bHQ7Ci1zdGF0aWMgdWludCBpOGtf ZmFuX21heCA9IEk4S19GQU5fSElHSDsKLQotI2RlZmluZSBJOEtfSFdNT05fSEFWRV9URU1QMQko MSA8PCAwKQotI2RlZmluZSBJOEtfSFdNT05fSEFWRV9URU1QMgkoMSA8PCAxKQotI2RlZmluZSBJ OEtfSFdNT05fSEFWRV9URU1QMwkoMSA8PCAyKQotI2RlZmluZSBJOEtfSFdNT05fSEFWRV9URU1Q NAkoMSA8PCAzKQotI2RlZmluZSBJOEtfSFdNT05fSEFWRV9GQU4xCSgxIDw8IDQpCi0jZGVmaW5l IEk4S19IV01PTl9IQVZFX0ZBTjIJKDEgPDwgNSkKLQotTU9EVUxFX0FVVEhPUigiTWFzc2ltbyBE YWwgWm90dG8gKGR6QGRlYmlhbi5vcmcpIik7Ci1NT0RVTEVfREVTQ1JJUFRJT04oIkRyaXZlciBm b3IgYWNjZXNzaW5nIFNNTSBCSU9TIG9uIERlbGwgbGFwdG9wcyIpOwotTU9EVUxFX0xJQ0VOU0Uo IkdQTCIpOwotCi1zdGF0aWMgYm9vbCBmb3JjZTsKLW1vZHVsZV9wYXJhbShmb3JjZSwgYm9vbCwg MCk7Ci1NT0RVTEVfUEFSTV9ERVNDKGZvcmNlLCAiRm9yY2UgbG9hZGluZyB3aXRob3V0IGNoZWNr aW5nIGZvciBzdXBwb3J0ZWQgbW9kZWxzIik7Ci0KLXN0YXRpYyBib29sIGlnbm9yZV9kbWk7Ci1t b2R1bGVfcGFyYW0oaWdub3JlX2RtaSwgYm9vbCwgMCk7Ci1NT0RVTEVfUEFSTV9ERVNDKGlnbm9y ZV9kbWksICJDb250aW51ZSBwcm9iaW5nIGhhcmR3YXJlIGV2ZW4gaWYgRE1JIGRhdGEgZG9lcyBu b3QgbWF0Y2giKTsKLQotc3RhdGljIGJvb2wgcmVzdHJpY3RlZDsKLW1vZHVsZV9wYXJhbShyZXN0 cmljdGVkLCBib29sLCAwKTsKLU1PRFVMRV9QQVJNX0RFU0MocmVzdHJpY3RlZCwgIkFsbG93IGZh biBjb250cm9sIGlmIFNZU19BRE1JTiBjYXBhYmlsaXR5IHNldCIpOwotCi1zdGF0aWMgYm9vbCBw b3dlcl9zdGF0dXM7Ci1tb2R1bGVfcGFyYW0ocG93ZXJfc3RhdHVzLCBib29sLCAwNjAwKTsKLU1P RFVMRV9QQVJNX0RFU0MocG93ZXJfc3RhdHVzLCAiUmVwb3J0IHBvd2VyIHN0YXR1cyBpbiAvcHJv Yy9pOGsiKTsKLQotc3RhdGljIHVpbnQgZmFuX211bHQ7Ci1tb2R1bGVfcGFyYW0oZmFuX211bHQs IHVpbnQsIDApOwotTU9EVUxFX1BBUk1fREVTQyhmYW5fbXVsdCwgIkZhY3RvciB0byBtdWx0aXBs eSBmYW4gc3BlZWQgd2l0aCAoZGVmYXVsdDogYXV0b2RldGVjdCkiKTsKLQotc3RhdGljIHVpbnQg ZmFuX21heDsKLW1vZHVsZV9wYXJhbShmYW5fbWF4LCB1aW50LCAwKTsKLU1PRFVMRV9QQVJNX0RF U0MoZmFuX21heCwgIk1heGltdW0gY29uZmlndXJhYmxlIGZhbiBzcGVlZCAoZGVmYXVsdDogYXV0 b2RldGVjdCkiKTsKLQotc3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5vZGUgKmlub2Rl LCBzdHJ1Y3QgZmlsZSAqZmlsZSk7Ci1zdGF0aWMgbG9uZyBpOGtfaW9jdGwoc3RydWN0IGZpbGUg KiwgdW5zaWduZWQgaW50LCB1bnNpZ25lZCBsb25nKTsKLQotc3RhdGljIGNvbnN0IHN0cnVjdCBm aWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7Ci0JLm93bmVyCQk9IFRISVNfTU9EVUxFLAotCS5v cGVuCQk9IGk4a19vcGVuX2ZzLAotCS5yZWFkCQk9IHNlcV9yZWFkLAotCS5sbHNlZWsJCT0gc2Vx X2xzZWVrLAotCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVhc2UsCi0JLnVubG9ja2VkX2lvY3RsCT0g aThrX2lvY3RsLAotfTsKLQotc3RydWN0IHNtbV9yZWdzIHsKLQl1bnNpZ25lZCBpbnQgZWF4Owot CXVuc2lnbmVkIGludCBlYnggX19wYWNrZWQ7Ci0JdW5zaWduZWQgaW50IGVjeCBfX3BhY2tlZDsK LQl1bnNpZ25lZCBpbnQgZWR4IF9fcGFja2VkOwotCXVuc2lnbmVkIGludCBlc2kgX19wYWNrZWQ7 Ci0JdW5zaWduZWQgaW50IGVkaSBfX3BhY2tlZDsKLX07Ci0KLXN0YXRpYyBpbmxpbmUgY29uc3Qg Y2hhciAqaThrX2dldF9kbWlfZGF0YShpbnQgZmllbGQpCi17Ci0JY29uc3QgY2hhciAqZG1pX2Rh dGEgPSBkbWlfZ2V0X3N5c3RlbV9pbmZvKGZpZWxkKTsKLQotCXJldHVybiBkbWlfZGF0YSAmJiAq ZG1pX2RhdGEgPyBkbWlfZGF0YSA6ICI/IjsKLX0KLQotLyoKLSAqIENhbGwgdGhlIFN5c3RlbSBN YW5hZ2VtZW50IE1vZGUgQklPUy4gQ29kZSBwcm92aWRlZCBieSBKb25hdGhhbiBCdXp6YXJkLgot ICovCi1zdGF0aWMgaW50IGk4a19zbW0oc3RydWN0IHNtbV9yZWdzICpyZWdzKQotewotCWludCBy YzsKLQlpbnQgZWF4ID0gcmVncy0+ZWF4OwotCWNwdW1hc2tfdmFyX3Qgb2xkX21hc2s7Ci0KLQkv KiBTTU0gcmVxdWlyZXMgQ1BVIDAgKi8KLQlpZiAoIWFsbG9jX2NwdW1hc2tfdmFyKCZvbGRfbWFz aywgR0ZQX0tFUk5FTCkpCi0JCXJldHVybiAtRU5PTUVNOwotCWNwdW1hc2tfY29weShvbGRfbWFz aywgJmN1cnJlbnQtPmNwdXNfYWxsb3dlZCk7Ci0JcmMgPSBzZXRfY3B1c19hbGxvd2VkX3B0cihj dXJyZW50LCBjcHVtYXNrX29mKDApKTsKLQlpZiAocmMpCi0JCWdvdG8gb3V0OwotCWlmIChzbXBf cHJvY2Vzc29yX2lkKCkgIT0gMCkgewotCQlyYyA9IC1FQlVTWTsKLQkJZ290byBvdXQ7Ci0JfQot Ci0jaWYgZGVmaW5lZChDT05GSUdfWDg2XzY0KQotCWFzbSB2b2xhdGlsZSgicHVzaHEgJSVyYXhc blx0IgotCQkibW92bCAwKCUlcmF4KSwlJWVkeFxuXHQiCi0JCSJwdXNocSAlJXJkeFxuXHQiCi0J CSJtb3ZsIDQoJSVyYXgpLCUlZWJ4XG5cdCIKLQkJIm1vdmwgOCglJXJheCksJSVlY3hcblx0Igot CQkibW92bCAxMiglJXJheCksJSVlZHhcblx0IgotCQkibW92bCAxNiglJXJheCksJSVlc2lcblx0 IgotCQkibW92bCAyMCglJXJheCksJSVlZGlcblx0IgotCQkicG9wcSAlJXJheFxuXHQiCi0JCSJv dXQgJSVhbCwkMHhiMlxuXHQiCi0JCSJvdXQgJSVhbCwkMHg4NFxuXHQiCi0JCSJ4Y2hncSAlJXJh eCwoJSVyc3ApXG5cdCIKLQkJIm1vdmwgJSVlYngsNCglJXJheClcblx0IgotCQkibW92bCAlJWVj eCw4KCUlcmF4KVxuXHQiCi0JCSJtb3ZsICUlZWR4LDEyKCUlcmF4KVxuXHQiCi0JCSJtb3ZsICUl ZXNpLDE2KCUlcmF4KVxuXHQiCi0JCSJtb3ZsICUlZWRpLDIwKCUlcmF4KVxuXHQiCi0JCSJwb3Bx ICUlcmR4XG5cdCIKLQkJIm1vdmwgJSVlZHgsMCglJXJheClcblx0IgotCQkicHVzaGZxXG5cdCIK LQkJInBvcHEgJSVyYXhcblx0IgotCQkiYW5kbCAkMSwlJWVheFxuIgotCQk6ICI9YSIocmMpCi0J CTogICAgImEiKHJlZ3MpCi0JCTogICAgIiVlYngiLCAiJWVjeCIsICIlZWR4IiwgIiVlc2kiLCAi JWVkaSIsICJtZW1vcnkiKTsKLSNlbHNlCi0JYXNtIHZvbGF0aWxlKCJwdXNobCAlJWVheFxuXHQi Ci0JICAgICJtb3ZsIDAoJSVlYXgpLCUlZWR4XG5cdCIKLQkgICAgInB1c2ggJSVlZHhcblx0Igot CSAgICAibW92bCA0KCUlZWF4KSwlJWVieFxuXHQiCi0JICAgICJtb3ZsIDgoJSVlYXgpLCUlZWN4 XG5cdCIKLQkgICAgIm1vdmwgMTIoJSVlYXgpLCUlZWR4XG5cdCIKLQkgICAgIm1vdmwgMTYoJSVl YXgpLCUlZXNpXG5cdCIKLQkgICAgIm1vdmwgMjAoJSVlYXgpLCUlZWRpXG5cdCIKLQkgICAgInBv cGwgJSVlYXhcblx0IgotCSAgICAib3V0ICUlYWwsJDB4YjJcblx0IgotCSAgICAib3V0ICUlYWws JDB4ODRcblx0IgotCSAgICAieGNoZ2wgJSVlYXgsKCUlZXNwKVxuXHQiCi0JICAgICJtb3ZsICUl ZWJ4LDQoJSVlYXgpXG5cdCIKLQkgICAgIm1vdmwgJSVlY3gsOCglJWVheClcblx0IgotCSAgICAi bW92bCAlJWVkeCwxMiglJWVheClcblx0IgotCSAgICAibW92bCAlJWVzaSwxNiglJWVheClcblx0 IgotCSAgICAibW92bCAlJWVkaSwyMCglJWVheClcblx0IgotCSAgICAicG9wbCAlJWVkeFxuXHQi Ci0JICAgICJtb3ZsICUlZWR4LDAoJSVlYXgpXG5cdCIKLQkgICAgImxhaGZcblx0IgotCSAgICAi c2hybCAkOCwlJWVheFxuXHQiCi0JICAgICJhbmRsICQxLCUlZWF4XG4iCi0JICAgIDogIj1hIihy YykKLQkgICAgOiAgICAiYSIocmVncykKLQkgICAgOiAgICAiJWVieCIsICIlZWN4IiwgIiVlZHgi LCAiJWVzaSIsICIlZWRpIiwgIm1lbW9yeSIpOwotI2VuZGlmCi0JaWYgKHJjICE9IDAgfHwgKHJl Z3MtPmVheCAmIDB4ZmZmZikgPT0gMHhmZmZmIHx8IHJlZ3MtPmVheCA9PSBlYXgpCi0JCXJjID0g LUVJTlZBTDsKLQotb3V0OgotCXNldF9jcHVzX2FsbG93ZWRfcHRyKGN1cnJlbnQsIG9sZF9tYXNr KTsKLQlmcmVlX2NwdW1hc2tfdmFyKG9sZF9tYXNrKTsKLQlyZXR1cm4gcmM7Ci19Ci0KLS8qCi0g KiBSZWFkIHRoZSBGbiBrZXkgc3RhdHVzLgotICovCi1zdGF0aWMgaW50IGk4a19nZXRfZm5fc3Rh dHVzKHZvaWQpCi17Ci0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0ZO X1NUQVRVUywgfTsKLQlpbnQgcmM7Ci0KLQlyYyA9IGk4a19zbW0oJnJlZ3MpOwotCWlmIChyYyA8 IDApCi0JCXJldHVybiByYzsKLQotCXN3aXRjaCAoKHJlZ3MuZWF4ID4+IEk4S19GTl9TSElGVCkg JiBJOEtfRk5fTUFTSykgewotCWNhc2UgSThLX0ZOX1VQOgotCQlyZXR1cm4gSThLX1ZPTF9VUDsK LQljYXNlIEk4S19GTl9ET1dOOgotCQlyZXR1cm4gSThLX1ZPTF9ET1dOOwotCWNhc2UgSThLX0ZO X01VVEU6Ci0JCXJldHVybiBJOEtfVk9MX01VVEU7Ci0JZGVmYXVsdDoKLQkJcmV0dXJuIDA7Ci0J fQotfQotCi0vKgotICogUmVhZCB0aGUgcG93ZXIgc3RhdHVzLgotICovCi1zdGF0aWMgaW50IGk4 a19nZXRfcG93ZXJfc3RhdHVzKHZvaWQpCi17Ci0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5l YXggPSBJOEtfU01NX1BPV0VSX1NUQVRVUywgfTsKLQlpbnQgcmM7Ci0KLQlyYyA9IGk4a19zbW0o JnJlZ3MpOwotCWlmIChyYyA8IDApCi0JCXJldHVybiByYzsKLQotCXJldHVybiAocmVncy5lYXgg JiAweGZmKSA9PSBJOEtfUE9XRVJfQUMgPyBJOEtfQUMgOiBJOEtfQkFUVEVSWTsKLX0KLQotLyoK LSAqIFJlYWQgdGhlIGZhbiBzdGF0dXMuCi0gKi8KLXN0YXRpYyBpbnQgaThrX2dldF9mYW5fc3Rh dHVzKGludCBmYW4pCi17Ci0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01N X0dFVF9GQU4sIH07Ci0KLQlyZWdzLmVieCA9IGZhbiAmIDB4ZmY7Ci0JcmV0dXJuIGk4a19zbW0o JnJlZ3MpID8gOiByZWdzLmVheCAmIDB4ZmY7Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBmYW4gc3Bl ZWQgaW4gUlBNLgotICovCi1zdGF0aWMgaW50IGk4a19nZXRfZmFuX3NwZWVkKGludCBmYW4pCi17 Ci0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0dFVF9TUEVFRCwgfTsK LQotCXJlZ3MuZWJ4ID0gZmFuICYgMHhmZjsKLQlyZXR1cm4gaThrX3NtbSgmcmVncykgPyA6IChy ZWdzLmVheCAmIDB4ZmZmZikgKiBpOGtfZmFuX211bHQ7Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBm YW4gdHlwZS4KLSAqLwotc3RhdGljIGludCBpOGtfZ2V0X2Zhbl90eXBlKGludCBmYW4pCi17Ci0J c3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0dFVF9GQU5fVFlQRSwgfTsK LQotCXJlZ3MuZWJ4ID0gZmFuICYgMHhmZjsKLQlyZXR1cm4gaThrX3NtbSgmcmVncykgPyA6IHJl Z3MuZWF4ICYgMHhmZjsKLX0KLQotLyoKLSAqIFJlYWQgdGhlIGZhbiBub21pbmFsIHJwbSBmb3Ig c3BlY2lmaWMgZmFuIHNwZWVkLgotICovCi1zdGF0aWMgaW50IGk4a19nZXRfZmFuX25vbWluYWxf c3BlZWQoaW50IGZhbiwgaW50IHNwZWVkKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAu ZWF4ID0gSThLX1NNTV9HRVRfTk9NX1NQRUVELCB9OwotCi0JcmVncy5lYnggPSAoZmFuICYgMHhm ZikgfCAoc3BlZWQgPDwgOCk7Ci0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiAocmVncy5lYXgg JiAweGZmZmYpICogaThrX2Zhbl9tdWx0OwotfQotCi0vKgotICogU2V0IHRoZSBmYW4gc3BlZWQg KG9mZiwgbG93LCBoaWdoKS4gUmV0dXJucyB0aGUgbmV3IGZhbiBzdGF0dXMuCi0gKi8KLXN0YXRp YyBpbnQgaThrX3NldF9mYW4oaW50IGZhbiwgaW50IHNwZWVkKQotewotCXN0cnVjdCBzbW1fcmVn cyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9TRVRfRkFOLCB9OwotCi0Jc3BlZWQgPSAoc3BlZWQg PCAwKSA/IDAgOiAoKHNwZWVkID4gaThrX2Zhbl9tYXgpID8gaThrX2Zhbl9tYXggOiBzcGVlZCk7 Ci0JcmVncy5lYnggPSAoZmFuICYgMHhmZikgfCAoc3BlZWQgPDwgOCk7Ci0KLQlyZXR1cm4gaThr X3NtbSgmcmVncykgPyA6IGk4a19nZXRfZmFuX3N0YXR1cyhmYW4pOwotfQotCi1zdGF0aWMgaW50 IGk4a19nZXRfdGVtcF90eXBlKGludCBzZW5zb3IpCi17Ci0Jc3RydWN0IHNtbV9yZWdzIHJlZ3Mg PSB7IC5lYXggPSBJOEtfU01NX0dFVF9URU1QX1RZUEUsIH07Ci0KLQlyZWdzLmVieCA9IHNlbnNv ciAmIDB4ZmY7Ci0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiByZWdzLmVheCAmIDB4ZmY7Ci19 Ci0KLS8qCi0gKiBSZWFkIHRoZSBjcHUgdGVtcGVyYXR1cmUuCi0gKi8KLXN0YXRpYyBpbnQgX2k4 a19nZXRfdGVtcChpbnQgc2Vuc29yKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0gewotCQku ZWF4ID0gSThLX1NNTV9HRVRfVEVNUCwKLQkJLmVieCA9IHNlbnNvciAmIDB4ZmYsCi0JfTsKLQot CXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAweGZmOwotfQotCi1zdGF0aWMg aW50IGk4a19nZXRfdGVtcChpbnQgc2Vuc29yKQotewotCWludCB0ZW1wID0gX2k4a19nZXRfdGVt cChzZW5zb3IpOwotCi0JLyoKLQkgKiBTb21ldGltZXMgdGhlIHRlbXBlcmF0dXJlIHNlbnNvciBy ZXR1cm5zIDB4OTksIHdoaWNoIGlzIG91dCBvZiByYW5nZS4KLQkgKiBJbiB0aGlzIGNhc2Ugd2Ug cmV0cnkgKG9uY2UpIGJlZm9yZSByZXR1cm5pbmcgYW4gZXJyb3IuCi0JICMgMTAwMzY1NTEzNyAw MDAwMDA1OCAwMDAwNWE0YgotCSAjIDEwMDM2NTUxMzggMDAwMDAwOTkgMDAwMDNhODAgPC0tLSAw eDk5ID0gMTUzIGRlZ3JlZXMKLQkgIyAxMDAzNjU1MTM5IDAwMDAwMDU0IDAwMDA1YzUyCi0JICov Ci0JaWYgKHRlbXAgPT0gMHg5OSkgewotCQltc2xlZXAoMTAwKTsKLQkJdGVtcCA9IF9pOGtfZ2V0 X3RlbXAoc2Vuc29yKTsKLQl9Ci0JLyoKLQkgKiBSZXR1cm4gLUVOT0RBVEEgZm9yIGFsbCBpbnZh bGlkIHRlbXBlcmF0dXJlcy4KLQkgKgotCSAqIEtub3duIGluc3RhbmNlcyBhcmUgdGhlIDB4OTkg dmFsdWUgYXMgc2VlbiBhYm92ZSBhcyB3ZWxsIGFzCi0JICogMHhjMSAoMTkzKSwgd2hpY2ggbWF5 IGJlIHJldHVybmVkIHdoZW4gdHJ5aW5nIHRvIHJlYWQgdGhlIEdQVQotCSAqIHRlbXBlcmF0dXJl IGlmIHRoZSBzeXN0ZW0gc3VwcG9ydHMgYSBHUFUgYW5kIGl0IGlzIGN1cnJlbnRseQotCSAqIHR1 cm5lZCBvZmYuCi0JICovCi0JaWYgKHRlbXAgPiBJOEtfTUFYX1RFTVApCi0JCXJldHVybiAtRU5P REFUQTsKLQotCXJldHVybiB0ZW1wOwotfQotCi1zdGF0aWMgaW50IGk4a19nZXRfZGVsbF9zaWdu YXR1cmUoaW50IHJlcV9mbikKLXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IHJl cV9mbiwgfTsKLQlpbnQgcmM7Ci0KLQlyYyA9IGk4a19zbW0oJnJlZ3MpOwotCWlmIChyYyA8IDAp Ci0JCXJldHVybiByYzsKLQotCXJldHVybiByZWdzLmVheCA9PSAxMTQ1NjUxNTI3ICYmIHJlZ3Mu ZWR4ID09IDExNDUzOTIyMDQgPyAwIDogLTE7Ci19Ci0KLXN0YXRpYyBpbnQKLWk4a19pb2N0bF91 bmxvY2tlZChzdHJ1Y3QgZmlsZSAqZnAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcg YXJnKQotewotCWludCB2YWwgPSAwOwotCWludCBzcGVlZDsKLQl1bnNpZ25lZCBjaGFyIGJ1ZmZb MTZdOwotCWludCBfX3VzZXIgKmFyZ3AgPSAoaW50IF9fdXNlciAqKWFyZzsKLQotCWlmICghYXJn cCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlzd2l0Y2ggKGNtZCkgewotCWNhc2UgSThLX0JJT1Nf VkVSU0lPTjoKLQkJdmFsID0gKGJpb3NfdmVyc2lvblswXSA8PCAxNikgfAotCQkJCShiaW9zX3Zl cnNpb25bMV0gPDwgOCkgfCBiaW9zX3ZlcnNpb25bMl07Ci0JCWJyZWFrOwotCi0JY2FzZSBJOEtf TUFDSElORV9JRDoKLQkJbWVtc2V0KGJ1ZmYsIDAsIDE2KTsKLQkJc3RybGNweShidWZmLCBpOGtf Z2V0X2RtaV9kYXRhKERNSV9QUk9EVUNUX1NFUklBTCksCi0JCQlzaXplb2YoYnVmZikpOwotCQli cmVhazsKLQotCWNhc2UgSThLX0ZOX1NUQVRVUzoKLQkJdmFsID0gaThrX2dldF9mbl9zdGF0dXMo KTsKLQkJYnJlYWs7Ci0KLQljYXNlIEk4S19QT1dFUl9TVEFUVVM6Ci0JCXZhbCA9IGk4a19nZXRf cG93ZXJfc3RhdHVzKCk7Ci0JCWJyZWFrOwotCi0JY2FzZSBJOEtfR0VUX1RFTVA6Ci0JCXZhbCA9 IGk4a19nZXRfdGVtcCgwKTsKLQkJYnJlYWs7Ci0KLQljYXNlIEk4S19HRVRfU1BFRUQ6Ci0JCWlm IChjb3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBzaXplb2YoaW50KSkpCi0JCQlyZXR1cm4gLUVG QVVMVDsKLQotCQl2YWwgPSBpOGtfZ2V0X2Zhbl9zcGVlZCh2YWwpOwotCQlicmVhazsKLQotCWNh c2UgSThLX0dFVF9GQU46Ci0JCWlmIChjb3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBzaXplb2Yo aW50KSkpCi0JCQlyZXR1cm4gLUVGQVVMVDsKLQotCQl2YWwgPSBpOGtfZ2V0X2Zhbl9zdGF0dXMo dmFsKTsKLQkJYnJlYWs7Ci0KLQljYXNlIEk4S19TRVRfRkFOOgotCQlpZiAocmVzdHJpY3RlZCAm JiAhY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKLQkJCXJldHVybiAtRVBFUk07Ci0KLQkJaWYgKGNv cHlfZnJvbV91c2VyKCZ2YWwsIGFyZ3AsIHNpemVvZihpbnQpKSkKLQkJCXJldHVybiAtRUZBVUxU OwotCi0JCWlmIChjb3B5X2Zyb21fdXNlcigmc3BlZWQsIGFyZ3AgKyAxLCBzaXplb2YoaW50KSkp Ci0JCQlyZXR1cm4gLUVGQVVMVDsKLQotCQl2YWwgPSBpOGtfc2V0X2Zhbih2YWwsIHNwZWVkKTsK LQkJYnJlYWs7Ci0KLQlkZWZhdWx0OgotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlpZiAodmFs IDwgMCkKLQkJcmV0dXJuIHZhbDsKLQotCXN3aXRjaCAoY21kKSB7Ci0JY2FzZSBJOEtfQklPU19W RVJTSU9OOgotCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZ2YWwsIDQpKQotCQkJcmV0dXJuIC1F RkFVTFQ7Ci0KLQkJYnJlYWs7Ci0JY2FzZSBJOEtfTUFDSElORV9JRDoKLQkJaWYgKGNvcHlfdG9f dXNlcihhcmdwLCBidWZmLCAxNikpCi0JCQlyZXR1cm4gLUVGQVVMVDsKLQotCQlicmVhazsKLQlk ZWZhdWx0OgotCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZ2YWwsIHNpemVvZihpbnQpKSkKLQkJ CXJldHVybiAtRUZBVUxUOwotCi0JCWJyZWFrOwotCX0KLQotCXJldHVybiAwOwotfQotCi1zdGF0 aWMgbG9uZyBpOGtfaW9jdGwoc3RydWN0IGZpbGUgKmZwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNp Z25lZCBsb25nIGFyZykKLXsKLQlsb25nIHJldDsKLQotCW11dGV4X2xvY2soJmk4a19tdXRleCk7 Ci0JcmV0ID0gaThrX2lvY3RsX3VubG9ja2VkKGZwLCBjbWQsIGFyZyk7Ci0JbXV0ZXhfdW5sb2Nr KCZpOGtfbXV0ZXgpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotLyoKLSAqIFByaW50IHRoZSBpbmZv cm1hdGlvbiBmb3IgL3Byb2MvaThrLgotICovCi1zdGF0aWMgaW50IGk4a19wcm9jX3Nob3coc3Ry dWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKm9mZnNldCkKLXsKLQlpbnQgZm5fa2V5LCBjcHVfdGVt cCwgYWNfcG93ZXI7Ci0JaW50IGxlZnRfZmFuLCByaWdodF9mYW4sIGxlZnRfc3BlZWQsIHJpZ2h0 X3NwZWVkOwotCi0JY3B1X3RlbXAJPSBpOGtfZ2V0X3RlbXAoMCk7CQkJLyogMTExMDAgwrVzICov Ci0JbGVmdF9mYW4JPSBpOGtfZ2V0X2Zhbl9zdGF0dXMoSThLX0ZBTl9MRUZUKTsJLyogICA1ODAg wrVzICovCi0JcmlnaHRfZmFuCT0gaThrX2dldF9mYW5fc3RhdHVzKEk4S19GQU5fUklHSFQpOwkv KiAgIDU4MCDCtXMgKi8KLQlsZWZ0X3NwZWVkCT0gaThrX2dldF9mYW5fc3BlZWQoSThLX0ZBTl9M RUZUKTsJLyogICA1ODAgwrVzICovCi0JcmlnaHRfc3BlZWQJPSBpOGtfZ2V0X2Zhbl9zcGVlZChJ OEtfRkFOX1JJR0hUKTsJLyogICA1ODAgwrVzICovCi0JZm5fa2V5CQk9IGk4a19nZXRfZm5fc3Rh dHVzKCk7CQkJLyogICA3NTAgwrVzICovCi0JaWYgKHBvd2VyX3N0YXR1cykKLQkJYWNfcG93ZXIg PSBpOGtfZ2V0X3Bvd2VyX3N0YXR1cygpOwkJLyogMTQ3MDAgwrVzICovCi0JZWxzZQotCQlhY19w b3dlciA9IC0xOwotCi0JLyoKLQkgKiBJbmZvOgotCSAqCi0JICogMSkgIEZvcm1hdCB2ZXJzaW9u ICh0aGlzIHdpbGwgY2hhbmdlIGlmIGZvcm1hdCBjaGFuZ2VzKQotCSAqIDIpICBCSU9TIHZlcnNp b24KLQkgKiAzKSAgQklPUyBtYWNoaW5lIElECi0JICogNCkgIENwdSB0ZW1wZXJhdHVyZQotCSAq IDUpICBMZWZ0IGZhbiBzdGF0dXMKLQkgKiA2KSAgUmlnaHQgZmFuIHN0YXR1cwotCSAqIDcpICBM ZWZ0IGZhbiBzcGVlZAotCSAqIDgpICBSaWdodCBmYW4gc3BlZWQKLQkgKiA5KSAgQUMgcG93ZXIK LQkgKiAxMCkgRm4gS2V5IHN0YXR1cwotCSAqLwotCXJldHVybiBzZXFfcHJpbnRmKHNlcSwgIiVz ICVzICVzICVkICVkICVkICVkICVkICVkICVkXG4iLAotCQkJICBJOEtfUFJPQ19GTVQsCi0JCQkg IGJpb3NfdmVyc2lvbiwKLQkJCSAgaThrX2dldF9kbWlfZGF0YShETUlfUFJPRFVDVF9TRVJJQUwp LAotCQkJICBjcHVfdGVtcCwKLQkJCSAgbGVmdF9mYW4sIHJpZ2h0X2ZhbiwgbGVmdF9zcGVlZCwg cmlnaHRfc3BlZWQsCi0JCQkgIGFjX3Bvd2VyLCBmbl9rZXkpOwotfQotCi1zdGF0aWMgaW50IGk4 a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQotewotCXJl dHVybiBzaW5nbGVfb3BlbihmaWxlLCBpOGtfcHJvY19zaG93LCBOVUxMKTsKLX0KLQotCi0vKgot ICogSHdtb24gaW50ZXJmYWNlCi0gKi8KLQotc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3df dGVtcF9sYWJlbChzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJp YnV0ZSAqZGV2YXR0ciwKLQkJCQkJIGNoYXIgKmJ1ZikKLXsKLQlzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IGxhYmVsc1tdID0gewotCQkiQ1BVIiwKLQkJIkdQVSIsCi0JCSJTT0RJTU0iLAotCQki T3RoZXIiLAotCQkiQW1iaWVudCIsCi0JCSJPdGhlciIsCi0JfTsKLQlpbnQgaW5kZXggPSB0b19z ZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4OwotCWludCB0eXBlOwotCi0JdHlwZSA9IGk4 a19nZXRfdGVtcF90eXBlKGluZGV4KTsKLQlpZiAodHlwZSA8IDApCi0JCXJldHVybiB0eXBlOwot CWlmICh0eXBlID49IEFSUkFZX1NJWkUobGFiZWxzKSkKLQkJdHlwZSA9IEFSUkFZX1NJWkUobGFi ZWxzKSAtIDE7Ci0JcmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIsIGxhYmVsc1t0eXBlXSk7Ci19 Ci0KLXN0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zaG93X3RlbXAoc3RydWN0IGRldmljZSAqZGV2 LAotCQkJCSAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLAotCQkJCSAgIGNoYXIg KmJ1ZikKLXsKLQlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4 OwotCWludCB0ZW1wOwotCi0JdGVtcCA9IGk4a19nZXRfdGVtcChpbmRleCk7Ci0JaWYgKHRlbXAg PCAwKQotCQlyZXR1cm4gdGVtcDsKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgdGVtcCAq IDEwMDApOwotfQotCi1zdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2hvd19mYW5fbGFiZWwoc3Ry dWN0IGRldmljZSAqZGV2LAotCQkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwK LQkJCQkJY2hhciAqYnVmKQotewotCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbGFiZWxzW10g PSB7Ci0JCSJQcm9jZXNzb3IgRmFuIiwKLQkJIk1vdGhlcmJvYXJkIEZhbiIsCi0JCSJWaWRlbyBG YW4iLAotCQkiUG93ZXIgU3VwcGx5IEZhbiIsCi0JCSJDaGlwc2V0IEZhbiIsCi0JCSJPdGhlciBG YW4iLAotCX07Ci0JaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRl eDsKLQlib29sIGRvY2sgPSBmYWxzZTsKLQlpbnQgdHlwZTsKLQotCXR5cGUgPSBpOGtfZ2V0X2Zh bl90eXBlKGluZGV4KTsKLQlpZiAodHlwZSA8IDApCi0JCXJldHVybiB0eXBlOwotCi0JaWYgKHR5 cGUgJiAweDEwKSB7Ci0JCWRvY2sgPSB0cnVlOwotCQl0eXBlICY9IDB4MEY7Ci0JfQotCi0JaWYg KHR5cGUgPj0gQVJSQVlfU0laRShsYWJlbHMpKQotCQl0eXBlID0gKEFSUkFZX1NJWkUobGFiZWxz KSAtIDEpOwotCi0JcmV0dXJuIHNwcmludGYoYnVmLCAiJXMlc1xuIiwgKGRvY2sgPyAiRG9ja2lu ZyAiIDogIiIpLCBsYWJlbHNbdHlwZV0pOwotfQotCi1zdGF0aWMgc3NpemVfdCBpOGtfaHdtb25f c2hvd19mYW4oc3RydWN0IGRldmljZSAqZGV2LAotCQkJCSAgc3RydWN0IGRldmljZV9hdHRyaWJ1 dGUgKmRldmF0dHIsCi0JCQkJICBjaGFyICpidWYpCi17Ci0JaW50IGluZGV4ID0gdG9fc2Vuc29y X2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKLQlpbnQgZmFuX3NwZWVkOwotCi0JZmFuX3NwZWVk ID0gaThrX2dldF9mYW5fc3BlZWQoaW5kZXgpOwotCWlmIChmYW5fc3BlZWQgPCAwKQotCQlyZXR1 cm4gZmFuX3NwZWVkOwotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBmYW5fc3BlZWQpOwot fQotCi1zdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2hvd19wd20oc3RydWN0IGRldmljZSAqZGV2 LAotCQkJCSAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCi0JCQkJICBjaGFyICpi dWYpCi17Ci0JaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsK LQlpbnQgc3RhdHVzOwotCi0Jc3RhdHVzID0gaThrX2dldF9mYW5fc3RhdHVzKGluZGV4KTsKLQlp ZiAoc3RhdHVzIDwgMCkKLQkJcmV0dXJuIC1FSU87Ci0JcmV0dXJuIHNwcmludGYoYnVmLCAiJWRc biIsIGNsYW1wX3ZhbChzdGF0dXMgKiBpOGtfcHdtX211bHQsIDAsIDI1NSkpOwotfQotCi1zdGF0 aWMgc3NpemVfdCBpOGtfaHdtb25fc2V0X3B3bShzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJIHN0 cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAotCQkJCSBjb25zdCBjaGFyICpidWYsIHNpemVf dCBjb3VudCkKLXsKLQlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0ciktPmluZGV4 OwotCXVuc2lnbmVkIGxvbmcgdmFsOwotCWludCBlcnI7Ci0KLQllcnIgPSBrc3RydG91bChidWYs IDEwLCAmdmFsKTsKLQlpZiAoZXJyKQotCQlyZXR1cm4gZXJyOwotCXZhbCA9IGNsYW1wX3ZhbChE SVZfUk9VTkRfQ0xPU0VTVCh2YWwsIGk4a19wd21fbXVsdCksIDAsIGk4a19mYW5fbWF4KTsKLQot CW11dGV4X2xvY2soJmk4a19tdXRleCk7Ci0JZXJyID0gaThrX3NldF9mYW4oaW5kZXgsIHZhbCk7 Ci0JbXV0ZXhfdW5sb2NrKCZpOGtfbXV0ZXgpOwotCi0JcmV0dXJuIGVyciA8IDAgPyAtRUlPIDog Y291bnQ7Ci19Ci0KLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfaW5wdXQsIFNfSVJV R08sIGk4a19od21vbl9zaG93X3RlbXAsIE5VTEwsIDApOwotc3RhdGljIFNFTlNPUl9ERVZJQ0Vf QVRUUih0ZW1wMV9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbCwgTlVM TCwKLQkJCSAgMCk7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAyX2lucHV0LCBTX0lS VUdPLCBpOGtfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAxKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNF X0FUVFIodGVtcDJfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwsIE5V TEwsCi0JCQkgIDEpOwotc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wM19pbnB1dCwgU19J UlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcCwgTlVMTCwgMik7Ci1zdGF0aWMgU0VOU09SX0RFVklD RV9BVFRSKHRlbXAzX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wX2xhYmVsLCBO VUxMLAotCQkJICAyKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDRfaW5wdXQsIFNf SVJVR08sIGk4a19od21vbl9zaG93X3RlbXAsIE5VTEwsIDMpOwotc3RhdGljIFNFTlNPUl9ERVZJ Q0VfQVRUUih0ZW1wNF9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbCwg TlVMTCwKLQkJCSAgMyk7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGZhbjFfaW5wdXQsIFNf SVJVR08sIGk4a19od21vbl9zaG93X2ZhbiwgTlVMTCwgMCk7Ci1zdGF0aWMgU0VOU09SX0RFVklD RV9BVFRSKGZhbjFfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9zaG93X2Zhbl9sYWJlbCwgTlVM TCwKLQkJCSAgMCk7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHB3bTEsIFNfSVJVR08gfCBT X0lXVVNSLCBpOGtfaHdtb25fc2hvd19wd20sCi0JCQkgIGk4a19od21vbl9zZXRfcHdtLCAwKTsK LXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFuMl9pbnB1dCwgU19JUlVHTywgaThrX2h3bW9u X3Nob3dfZmFuLCBOVUxMLAotCQkJICAxKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFu Ml9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuX2xhYmVsLCBOVUxMLAotCQkJICAx KTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocHdtMiwgU19JUlVHTyB8IFNfSVdVU1IsIGk4 a19od21vbl9zaG93X3B3bSwKLQkJCSAgaThrX2h3bW9uX3NldF9wd20sIDEpOwotCi1zdGF0aWMg c3RydWN0IGF0dHJpYnV0ZSAqaThrX2F0dHJzW10gPSB7Ci0JJnNlbnNvcl9kZXZfYXR0cl90ZW1w MV9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiAwICovCi0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9s YWJlbC5kZXZfYXR0ci5hdHRyLAkvKiAxICovCi0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wMl9pbnB1 dC5kZXZfYXR0ci5hdHRyLAkvKiAyICovCi0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wMl9sYWJlbC5k ZXZfYXR0ci5hdHRyLAkvKiAzICovCi0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wM19pbnB1dC5kZXZf YXR0ci5hdHRyLAkvKiA0ICovCi0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wM19sYWJlbC5kZXZfYXR0 ci5hdHRyLAkvKiA1ICovCi0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wNF9pbnB1dC5kZXZfYXR0ci5h dHRyLAkvKiA2ICovCi0JJnNlbnNvcl9kZXZfYXR0cl90ZW1wNF9sYWJlbC5kZXZfYXR0ci5hdHRy LAkvKiA3ICovCi0JJnNlbnNvcl9kZXZfYXR0cl9mYW4xX2lucHV0LmRldl9hdHRyLmF0dHIsCS8q IDggKi8KLQkmc2Vuc29yX2Rldl9hdHRyX2ZhbjFfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogOSAq LwotCSZzZW5zb3JfZGV2X2F0dHJfcHdtMS5kZXZfYXR0ci5hdHRyLAkJLyogMTAgKi8KLQkmc2Vu c29yX2Rldl9hdHRyX2ZhbjJfaW5wdXQuZGV2X2F0dHIuYXR0ciwJLyogMTEgKi8KLQkmc2Vuc29y X2Rldl9hdHRyX2ZhbjJfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogMTIgKi8KLQkmc2Vuc29yX2Rl dl9hdHRyX3B3bTIuZGV2X2F0dHIuYXR0ciwJCS8qIDEzICovCi0JTlVMTAotfTsKLQotc3RhdGlj IHVtb2RlX3QgaThrX2lzX3Zpc2libGUoc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBhdHRy aWJ1dGUgKmF0dHIsCi0JCQkgICAgICBpbnQgaW5kZXgpCi17Ci0JaWYgKGluZGV4ID49IDAgJiYg aW5kZXggPD0gMSAmJgotCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RF TVAxKSkKLQkJcmV0dXJuIDA7Ci0JaWYgKGluZGV4ID49IDIgJiYgaW5kZXggPD0gMyAmJgotCSAg ICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVAyKSkKLQkJcmV0dXJuIDA7 Ci0JaWYgKGluZGV4ID49IDQgJiYgaW5kZXggPD0gNSAmJgotCSAgICAhKGk4a19od21vbl9mbGFn cyAmIEk4S19IV01PTl9IQVZFX1RFTVAzKSkKLQkJcmV0dXJuIDA7Ci0JaWYgKGluZGV4ID49IDYg JiYgaW5kZXggPD0gNyAmJgotCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZF X1RFTVA0KSkKLQkJcmV0dXJuIDA7Ci0JaWYgKGluZGV4ID49IDggJiYgaW5kZXggPD0gMTAgJiYK LQkgICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9GQU4xKSkKLQkJcmV0dXJu IDA7Ci0JaWYgKGluZGV4ID49IDExICYmIGluZGV4IDw9IDEzICYmCi0JICAgICEoaThrX2h3bW9u X2ZsYWdzICYgSThLX0hXTU9OX0hBVkVfRkFOMikpCi0JCXJldHVybiAwOwotCi0JcmV0dXJuIGF0 dHItPm1vZGU7Ci19Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGk4a19n cm91cCA9IHsKLQkuYXR0cnMgPSBpOGtfYXR0cnMsCi0JLmlzX3Zpc2libGUgPSBpOGtfaXNfdmlz aWJsZSwKLX07Ci1fX0FUVFJJQlVURV9HUk9VUFMoaThrKTsKLQotc3RhdGljIGludCBfX2luaXQg aThrX2luaXRfaHdtb24odm9pZCkKLXsKLQlpbnQgZXJyOwotCi0JaThrX2h3bW9uX2ZsYWdzID0g MDsKLQotCS8qIENQVSB0ZW1wZXJhdHVyZSBhdHRyaWJ1dGVzLCBpZiB0ZW1wZXJhdHVyZSB0eXBl IGlzIE9LICovCi0JZXJyID0gaThrX2dldF90ZW1wX3R5cGUoMCk7Ci0JaWYgKGVyciA+PSAwKQot CQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVfVEVNUDE7Ci0JLyogY2hlY2sgZm9y IGFkZGl0aW9uYWwgdGVtcGVyYXR1cmUgc2Vuc29ycyAqLwotCWVyciA9IGk4a19nZXRfdGVtcF90 eXBlKDEpOwotCWlmIChlcnIgPj0gMCkKLQkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9I QVZFX1RFTVAyOwotCWVyciA9IGk4a19nZXRfdGVtcF90eXBlKDIpOwotCWlmIChlcnIgPj0gMCkK LQkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RFTVAzOwotCWVyciA9IGk4a19n ZXRfdGVtcF90eXBlKDMpOwotCWlmIChlcnIgPj0gMCkKLQkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4 S19IV01PTl9IQVZFX1RFTVA0OwotCi0JLyogRmlyc3QgZmFuIGF0dHJpYnV0ZXMsIGlmIGZhbiB0 eXBlIGlzIE9LICovCi0JZXJyID0gaThrX2dldF9mYW5fdHlwZSgwKTsKLQlpZiAoZXJyID49IDAp Ci0JCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9GQU4xOwotCi0JLyogU2Vjb25k IGZhbiBhdHRyaWJ1dGVzLCBpZiBmYW4gdHlwZSBpcyBPSyAqLwotCWVyciA9IGk4a19nZXRfZmFu X3R5cGUoMSk7Ci0JaWYgKGVyciA+PSAwKQotCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9O X0hBVkVfRkFOMjsKLQotCWk4a19od21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0 aF9ncm91cHMoTlVMTCwgImk4ayIsIE5VTEwsCi0JCQkJCQkJICBpOGtfZ3JvdXBzKTsKLQlpZiAo SVNfRVJSKGk4a19od21vbl9kZXYpKSB7Ci0JCWVyciA9IFBUUl9FUlIoaThrX2h3bW9uX2Rldik7 Ci0JCWk4a19od21vbl9kZXYgPSBOVUxMOwotCQlwcl9lcnIoImh3bW9uIHJlZ2lzdHJhdGlvbiBm YWlsZWQgKCVkKVxuIiwgZXJyKTsKLQkJcmV0dXJuIGVycjsKLQl9Ci0JcmV0dXJuIDA7Ci19Ci0K LXN0cnVjdCBpOGtfY29uZmlnX2RhdGEgewotCXVpbnQgZmFuX211bHQ7Ci0JdWludCBmYW5fbWF4 OwotfTsKLQotZW51bSBpOGtfY29uZmlncyB7Ci0JREVMTF9MQVRJVFVERV9ENTIwLAotCURFTExf UFJFQ0lTSU9OXzQ5MCwKLQlERUxMX1NUVURJTywKLQlERUxMX1hQUywKLX07Ci0KLXN0YXRpYyBj b25zdCBzdHJ1Y3QgaThrX2NvbmZpZ19kYXRhIGk4a19jb25maWdfZGF0YVtdID0gewotCVtERUxM X0xBVElUVURFX0Q1MjBdID0gewotCQkuZmFuX211bHQgPSAxLAotCQkuZmFuX21heCA9IEk4S19G QU5fVFVSQk8sCi0JfSwKLQlbREVMTF9QUkVDSVNJT05fNDkwXSA9IHsKLQkJLmZhbl9tdWx0ID0g MSwKLQkJLmZhbl9tYXggPSBJOEtfRkFOX1RVUkJPLAotCX0sCi0JW0RFTExfU1RVRElPXSA9IHsK LQkJLmZhbl9tdWx0ID0gMSwKLQkJLmZhbl9tYXggPSBJOEtfRkFOX0hJR0gsCi0JfSwKLQlbREVM TF9YUFNdID0gewotCQkuZmFuX211bHQgPSAxLAotCQkuZmFuX21heCA9IEk4S19GQU5fSElHSCwK LQl9LAotfTsKLQotc3RhdGljIHN0cnVjdCBkbWlfc3lzdGVtX2lkIGk4a19kbWlfdGFibGVbXSBf X2luaXRkYXRhID0gewotCXsKLQkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24iLAotCQkubWF0Y2hl cyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgQ29tcHV0ZXIiKSwKLQkJ CURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiSW5zcGlyb24iKSwKLQkJfSwKLQl9LAotCXsK LQkJLmlkZW50ID0gIkRlbGwgTGF0aXR1ZGUiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRD SChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgQ29tcHV0ZXIiKSwKLQkJCURNSV9NQVRDSChETUlfUFJP RFVDVF9OQU1FLCAiTGF0aXR1ZGUiKSwKLQkJfSwKLQl9LAotCXsKLQkJLmlkZW50ID0gIkRlbGwg SW5zcGlyb24gMiIsCi0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9S LCAiRGVsbCBJbmMuIiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkluc3Bpcm9u IiksCi0JCX0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIExhdGl0dWRlIEQ1MjAiLAotCQku bWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAot CQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJMYXRpdHVkZSBENTIwIiksCi0JCX0sCi0J CS5kcml2ZXJfZGF0YSA9ICh2b2lkICopJmk4a19jb25maWdfZGF0YVtERUxMX0xBVElUVURFX0Q1 MjBdLAotCX0sCi0JewotCQkuaWRlbnQgPSAiRGVsbCBMYXRpdHVkZSAyIiwKLQkJLm1hdGNoZXMg PSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKLQkJCURNSV9N QVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTGF0aXR1ZGUiKSwKLQkJfSwKLQl9LAotCXsJLyogVUsg SW5zcGlyb24gNjQwMCAgKi8KLQkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24gMyIsCi0JCS5tYXRj aGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCi0JCQlE TUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIk1NMDYxIiksCi0JCX0sCi0JfSwKLQl7Ci0JCS5p ZGVudCA9ICJEZWxsIEluc3Bpcm9uIDMiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChE TUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05B TUUsICJNUDA2MSIpLAotCQl9LAotCX0sCi0JewotCQkuaWRlbnQgPSAiRGVsbCBQcmVjaXNpb24g NDkwIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxs IEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLAotCQkJCSAgIlByZWNpc2lv biBXb3JrU3RhdGlvbiA0OTAiKSwKLQkJfSwKLQkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikmaThr X2NvbmZpZ19kYXRhW0RFTExfUFJFQ0lTSU9OXzQ5MF0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJE ZWxsIFByZWNpc2lvbiIsCi0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVO RE9SLCAiRGVsbCBJbmMuIiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlByZWNp c2lvbiIpLAotCQl9LAotCX0sCi0JewotCQkuaWRlbnQgPSAiRGVsbCBWb3N0cm8iLAotCQkubWF0 Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJ RE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJWb3N0cm8iKSwKLQkJfSwKLQl9LAotCXsKLQkJ LmlkZW50ID0gIkRlbGwgWFBTNDIxIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1J X1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1F LCAiWFBTIEw0MjFYIiksCi0JCX0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIFN0dWRpbyIs Ci0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMu IiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlN0dWRpbyIpLAotCQl9LAotCQku ZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9TVFVESU9dLAotCX0s Ci0JewotCQkuaWRlbnQgPSAiRGVsbCBYUFMgMTMiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9N QVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9E VUNUX05BTUUsICJYUFMxMyIpLAotCQl9LAotCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtf Y29uZmlnX2RhdGFbREVMTF9YUFNdLAotCX0sCi0JewotCQkuaWRlbnQgPSAiRGVsbCBYUFMgTTE0 MCIsCi0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJ bmMuIiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIk1YQzA1MSIpLAotCQl9LAot CQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9YUFNdLAotCX0s Ci0JeyB9Ci19OwotCi1NT0RVTEVfREVWSUNFX1RBQkxFKGRtaSwgaThrX2RtaV90YWJsZSk7Ci0K LS8qCi0gKiBQcm9iZSBmb3IgdGhlIHByZXNlbmNlIG9mIGEgc3VwcG9ydGVkIGxhcHRvcC4KLSAq Lwotc3RhdGljIGludCBfX2luaXQgaThrX3Byb2JlKHZvaWQpCi17Ci0JY29uc3Qgc3RydWN0IGRt aV9zeXN0ZW1faWQgKmlkOwotCWludCBmYW4sIHJldDsKLQotCS8qCi0JICogR2V0IERNSSBpbmZv cm1hdGlvbgotCSAqLwotCWlmICghZG1pX2NoZWNrX3N5c3RlbShpOGtfZG1pX3RhYmxlKSkgewot CQlpZiAoIWlnbm9yZV9kbWkgJiYgIWZvcmNlKQotCQkJcmV0dXJuIC1FTk9ERVY7Ci0KLQkJcHJf aW5mbygibm90IHJ1bm5pbmcgb24gYSBzdXBwb3J0ZWQgRGVsbCBzeXN0ZW0uXG4iKTsKLQkJcHJf aW5mbygidmVuZG9yPSVzLCBtb2RlbD0lcywgdmVyc2lvbj0lc1xuIiwKLQkJCWk4a19nZXRfZG1p X2RhdGEoRE1JX1NZU19WRU5ET1IpLAotCQkJaThrX2dldF9kbWlfZGF0YShETUlfUFJPRFVDVF9O QU1FKSwKLQkJCWk4a19nZXRfZG1pX2RhdGEoRE1JX0JJT1NfVkVSU0lPTikpOwotCX0KLQotCXN0 cmxjcHkoYmlvc192ZXJzaW9uLCBpOGtfZ2V0X2RtaV9kYXRhKERNSV9CSU9TX1ZFUlNJT04pLAot CQlzaXplb2YoYmlvc192ZXJzaW9uKSk7Ci0KLQkvKgotCSAqIEdldCBTTU0gRGVsbCBzaWduYXR1 cmUKLQkgKi8KLQlpZiAoaThrX2dldF9kZWxsX3NpZ25hdHVyZShJOEtfU01NX0dFVF9ERUxMX1NJ RzEpICYmCi0JICAgIGk4a19nZXRfZGVsbF9zaWduYXR1cmUoSThLX1NNTV9HRVRfREVMTF9TSUcy KSkgewotCQlwcl9lcnIoInVuYWJsZSB0byBnZXQgU01NIERlbGwgc2lnbmF0dXJlXG4iKTsKLQkJ aWYgKCFmb3JjZSkKLQkJCXJldHVybiAtRU5PREVWOwotCX0KLQotCS8qCi0JICogU2V0IGZhbiBt dWx0aXBsaWVyIGFuZCBtYXhpbWFsIGZhbiBzcGVlZCBmcm9tIGRtaSBjb25maWcKLQkgKiBWYWx1 ZXMgc3BlY2lmaWVkIGluIG1vZHVsZSBwYXJhbWV0ZXJzIG92ZXJyaWRlIHZhbHVlcyBmcm9tIGRt aQotCSAqLwotCWlkID0gZG1pX2ZpcnN0X21hdGNoKGk4a19kbWlfdGFibGUpOwotCWlmIChpZCAm JiBpZC0+ZHJpdmVyX2RhdGEpIHsKLQkJY29uc3Qgc3RydWN0IGk4a19jb25maWdfZGF0YSAqY29u ZiA9IGlkLT5kcml2ZXJfZGF0YTsKLQkJaWYgKCFmYW5fbXVsdCAmJiBjb25mLT5mYW5fbXVsdCkK LQkJCWZhbl9tdWx0ID0gY29uZi0+ZmFuX211bHQ7Ci0JCWlmICghZmFuX21heCAmJiBjb25mLT5m YW5fbWF4KQotCQkJZmFuX21heCA9IGNvbmYtPmZhbl9tYXg7Ci0JfQotCi0JaThrX2Zhbl9tYXgg PSBmYW5fbWF4ID8gOiBJOEtfRkFOX0hJR0g7CS8qIE11c3Qgbm90IGJlIDAgKi8KLQlpOGtfcHdt X211bHQgPSBESVZfUk9VTkRfVVAoMjU1LCBpOGtfZmFuX21heCk7Ci0KLQlpZiAoIWZhbl9tdWx0 KSB7Ci0JCS8qCi0JCSAqIEF1dG9kZXRlY3QgZmFuIG11bHRpcGxpZXIgYmFzZWQgb24gbm9taW5h bCBycG0KLQkJICogSWYgZmFuIHJlcG9ydHMgcnBtIHZhbHVlIHRvbyBoaWdoIHRoZW4gc2V0IG11 bHRpcGxpZXIgdG8gMQotCQkgKi8KLQkJZm9yIChmYW4gPSAwOyBmYW4gPCAyOyArK2Zhbikgewot CQkJcmV0ID0gaThrX2dldF9mYW5fbm9taW5hbF9zcGVlZChmYW4sIGk4a19mYW5fbWF4KTsKLQkJ CWlmIChyZXQgPCAwKQotCQkJCWNvbnRpbnVlOwotCQkJaWYgKHJldCA+IEk4S19GQU5fTUFYX1JQ TSkKLQkJCQlpOGtfZmFuX211bHQgPSAxOwotCQkJYnJlYWs7Ci0JCX0KLQl9IGVsc2UgewotCQkv KiBGYW4gbXVsdGlwbGllciB3YXMgc3BlY2lmaWVkIGluIG1vZHVsZSBwYXJhbSBvciBpbiBkbWkg Ki8KLQkJaThrX2Zhbl9tdWx0ID0gZmFuX211bHQ7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0 YXRpYyBpbnQgX19pbml0IGk4a19pbml0KHZvaWQpCi17Ci0Jc3RydWN0IHByb2NfZGlyX2VudHJ5 ICpwcm9jX2k4azsKLQlpbnQgZXJyOwotCi0JLyogQXJlIHdlIHJ1bm5pbmcgb24gYW4gc3VwcG9y dGVkIGxhcHRvcD8gKi8KLQlpZiAoaThrX3Byb2JlKCkpCi0JCXJldHVybiAtRU5PREVWOwotCi0J LyogUmVnaXN0ZXIgdGhlIHByb2MgZW50cnkgKi8KLQlwcm9jX2k4ayA9IHByb2NfY3JlYXRlKCJp OGsiLCAwLCBOVUxMLCAmaThrX2ZvcHMpOwotCWlmICghcHJvY19pOGspCi0JCXJldHVybiAtRU5P RU5UOwotCi0JZXJyID0gaThrX2luaXRfaHdtb24oKTsKLQlpZiAoZXJyKQotCQlnb3RvIGV4aXRf cmVtb3ZlX3Byb2M7Ci0KLQlyZXR1cm4gMDsKLQotIGV4aXRfcmVtb3ZlX3Byb2M6Ci0JcmVtb3Zl X3Byb2NfZW50cnkoImk4ayIsIE5VTEwpOwotCXJldHVybiBlcnI7Ci19Ci0KLXN0YXRpYyB2b2lk IF9fZXhpdCBpOGtfZXhpdCh2b2lkKQotewotCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGk4a19o d21vbl9kZXYpOwotCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBOVUxMKTsKLX0KLQotbW9kdWxl X2luaXQoaThrX2luaXQpOwotbW9kdWxlX2V4aXQoaThrX2V4aXQpOwpkaWZmIC0tZ2l0IGEvZHJp dmVycy9od21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKaW5kZXggNmM5NDE0 Ny4uMWMzZTQ1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQorKysgYi9kcml2 ZXJzL2h3bW9uL01ha2VmaWxlCkBAIC0xNTUsNiArMTU1LDcgQEAgb2JqLSQoQ09ORklHX1NFTlNP UlNfVzgzTDc4NVRTKQkrPSB3ODNsNzg1dHMubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfVzgzTDc4 Nk5HKQkrPSB3ODNsNzg2bmcubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzFYKQkrPSB3bTgz MXgtaHdtb24ubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzUwKQkrPSB3bTgzNTAtaHdtb24u bworb2JqLSQoQ09ORklHX0k4SykJCSs9IGRlbGwtc21tLWh3bW9uLm8KIAogb2JqLSQoQ09ORklH X1BNQlVTKQkJKz0gcG1idXMvCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vZGVsbC1zbW0t aHdtb24uYyBiL2RyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwpuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4yYjA0ZTRmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9o d21vbi9kZWxsLXNtbS1od21vbi5jCkBAIC0wLDAgKzEsMTAwNyBAQAorLyoKKyAqIGRlbGwtc21t LWh3bW9uLmMgLS0gTGludXggZHJpdmVyIGZvciBhY2Nlc3NpbmcgdGhlIFNNTSBCSU9TIG9uIERl bGwgbGFwdG9wcy4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDEgIE1hc3NpbW8gRGFsIFpvdHRv IDxkekBkZWJpYW4ub3JnPgorICoKKyAqIEh3bW9uIGludGVncmF0aW9uOgorICogQ29weXJpZ2h0 IChDKSAyMDExICBKZWFuIERlbHZhcmUgPGpkZWx2YXJlQHN1c2UuZGU+CisgKiBDb3B5cmlnaHQg KEMpIDIwMTMsIDIwMTQgIEd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVzLm5ldD4KKyAqIENv cHlyaWdodCAoQykgMjAxNCwgMjAxNSAgUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29t PgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyAqIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkK KyAqIGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRB QklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUK KyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjZGVm aW5lIHByX2ZtdChmbXQpIEtCVUlMRF9NT0ROQU1FICI6ICIgZm10CisKKyNpbmNsdWRlIDxsaW51 eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3R5 cGVzLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMu aD4KKyNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2RtaS5oPgor I2luY2x1ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KKyNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgor I2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+CisjaW5jbHVkZSA8bGludXgvaHdtb24tc3lzZnMuaD4K KyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNs dWRlIDxsaW51eC9zY2hlZC5oPgorCisjaW5jbHVkZSA8bGludXgvaThrLmg+CisKKyNkZWZpbmUg SThLX1NNTV9GTl9TVEFUVVMJMHgwMDI1CisjZGVmaW5lIEk4S19TTU1fUE9XRVJfU1RBVFVTCTB4 MDA2OQorI2RlZmluZSBJOEtfU01NX1NFVF9GQU4JCTB4MDFhMworI2RlZmluZSBJOEtfU01NX0dF VF9GQU4JCTB4MDBhMworI2RlZmluZSBJOEtfU01NX0dFVF9TUEVFRAkweDAyYTMKKyNkZWZpbmUg SThLX1NNTV9HRVRfRkFOX1RZUEUJMHgwM2EzCisjZGVmaW5lIEk4S19TTU1fR0VUX05PTV9TUEVF RAkweDA0YTMKKyNkZWZpbmUgSThLX1NNTV9HRVRfVEVNUAkweDEwYTMKKyNkZWZpbmUgSThLX1NN TV9HRVRfVEVNUF9UWVBFCTB4MTFhMworI2RlZmluZSBJOEtfU01NX0dFVF9ERUxMX1NJRzEJMHhm ZWEzCisjZGVmaW5lIEk4S19TTU1fR0VUX0RFTExfU0lHMgkweGZmYTMKKworI2RlZmluZSBJOEtf RkFOX01VTFQJCTMwCisjZGVmaW5lIEk4S19GQU5fTUFYX1JQTQkJMzAwMDAKKyNkZWZpbmUgSThL X01BWF9URU1QCQkxMjcKKworI2RlZmluZSBJOEtfRk5fTk9ORQkJMHgwMAorI2RlZmluZSBJOEtf Rk5fVVAJCTB4MDEKKyNkZWZpbmUgSThLX0ZOX0RPV04JCTB4MDIKKyNkZWZpbmUgSThLX0ZOX01V VEUJCTB4MDQKKyNkZWZpbmUgSThLX0ZOX01BU0sJCTB4MDcKKyNkZWZpbmUgSThLX0ZOX1NISUZU CQk4CisKKyNkZWZpbmUgSThLX1BPV0VSX0FDCQkweDA1CisjZGVmaW5lIEk4S19QT1dFUl9CQVRU RVJZCTB4MDEKKworc3RhdGljIERFRklORV9NVVRFWChpOGtfbXV0ZXgpOworc3RhdGljIGNoYXIg Ymlvc192ZXJzaW9uWzRdOworc3RhdGljIHN0cnVjdCBkZXZpY2UgKmk4a19od21vbl9kZXY7Citz dGF0aWMgdTMyIGk4a19od21vbl9mbGFnczsKK3N0YXRpYyB1aW50IGk4a19mYW5fbXVsdCA9IEk4 S19GQU5fTVVMVDsKK3N0YXRpYyB1aW50IGk4a19wd21fbXVsdDsKK3N0YXRpYyB1aW50IGk4a19m YW5fbWF4ID0gSThLX0ZBTl9ISUdIOworCisjZGVmaW5lIEk4S19IV01PTl9IQVZFX1RFTVAxCSgx IDw8IDApCisjZGVmaW5lIEk4S19IV01PTl9IQVZFX1RFTVAyCSgxIDw8IDEpCisjZGVmaW5lIEk4 S19IV01PTl9IQVZFX1RFTVAzCSgxIDw8IDIpCisjZGVmaW5lIEk4S19IV01PTl9IQVZFX1RFTVA0 CSgxIDw8IDMpCisjZGVmaW5lIEk4S19IV01PTl9IQVZFX0ZBTjEJKDEgPDwgNCkKKyNkZWZpbmUg SThLX0hXTU9OX0hBVkVfRkFOMgkoMSA8PCA1KQorCitNT0RVTEVfQVVUSE9SKCJNYXNzaW1vIERh bCBab3R0byAoZHpAZGViaWFuLm9yZykiKTsKK01PRFVMRV9BVVRIT1IoIlBhbGkgUm9ow6FyIDxw YWxpLnJvaGFyQGdtYWlsLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiRHJpdmVyIGZvciBh Y2Nlc3NpbmcgU01NIEJJT1Mgb24gRGVsbCBsYXB0b3BzIik7CitNT0RVTEVfTElDRU5TRSgiR1BM Iik7CitNT0RVTEVfQUxJQVMoImk4ayIpOworCitzdGF0aWMgYm9vbCBmb3JjZTsKK21vZHVsZV9w YXJhbShmb3JjZSwgYm9vbCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKGZvcmNlLCAiRm9yY2UgbG9h ZGluZyB3aXRob3V0IGNoZWNraW5nIGZvciBzdXBwb3J0ZWQgbW9kZWxzIik7CisKK3N0YXRpYyBi b29sIGlnbm9yZV9kbWk7Cittb2R1bGVfcGFyYW0oaWdub3JlX2RtaSwgYm9vbCwgMCk7CitNT0RV TEVfUEFSTV9ERVNDKGlnbm9yZV9kbWksICJDb250aW51ZSBwcm9iaW5nIGhhcmR3YXJlIGV2ZW4g aWYgRE1JIGRhdGEgZG9lcyBub3QgbWF0Y2giKTsKKworc3RhdGljIGJvb2wgcmVzdHJpY3RlZDsK K21vZHVsZV9wYXJhbShyZXN0cmljdGVkLCBib29sLCAwKTsKK01PRFVMRV9QQVJNX0RFU0MocmVz dHJpY3RlZCwgIkFsbG93IGZhbiBjb250cm9sIGlmIFNZU19BRE1JTiBjYXBhYmlsaXR5IHNldCIp OworCitzdGF0aWMgYm9vbCBwb3dlcl9zdGF0dXM7Cittb2R1bGVfcGFyYW0ocG93ZXJfc3RhdHVz LCBib29sLCAwNjAwKTsKK01PRFVMRV9QQVJNX0RFU0MocG93ZXJfc3RhdHVzLCAiUmVwb3J0IHBv d2VyIHN0YXR1cyBpbiAvcHJvYy9pOGsiKTsKKworc3RhdGljIHVpbnQgZmFuX211bHQ7Cittb2R1 bGVfcGFyYW0oZmFuX211bHQsIHVpbnQsIDApOworTU9EVUxFX1BBUk1fREVTQyhmYW5fbXVsdCwg IkZhY3RvciB0byBtdWx0aXBseSBmYW4gc3BlZWQgd2l0aCAoZGVmYXVsdDogYXV0b2RldGVjdCki KTsKKworc3RhdGljIHVpbnQgZmFuX21heDsKK21vZHVsZV9wYXJhbShmYW5fbWF4LCB1aW50LCAw KTsKK01PRFVMRV9QQVJNX0RFU0MoZmFuX21heCwgIk1heGltdW0gY29uZmlndXJhYmxlIGZhbiBz cGVlZCAoZGVmYXVsdDogYXV0b2RldGVjdCkiKTsKKworc3RhdGljIGludCBpOGtfb3Blbl9mcyhz dHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSk7CitzdGF0aWMgbG9uZyBpOGtf aW9jdGwoc3RydWN0IGZpbGUgKiwgdW5zaWduZWQgaW50LCB1bnNpZ25lZCBsb25nKTsKKworc3Rh dGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7CisJLm93bmVyCQk9 IFRISVNfTU9EVUxFLAorCS5vcGVuCQk9IGk4a19vcGVuX2ZzLAorCS5yZWFkCQk9IHNlcV9yZWFk LAorCS5sbHNlZWsJCT0gc2VxX2xzZWVrLAorCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVhc2UsCisJ LnVubG9ja2VkX2lvY3RsCT0gaThrX2lvY3RsLAorfTsKKworc3RydWN0IHNtbV9yZWdzIHsKKwl1 bnNpZ25lZCBpbnQgZWF4OworCXVuc2lnbmVkIGludCBlYnggX19wYWNrZWQ7CisJdW5zaWduZWQg aW50IGVjeCBfX3BhY2tlZDsKKwl1bnNpZ25lZCBpbnQgZWR4IF9fcGFja2VkOworCXVuc2lnbmVk IGludCBlc2kgX19wYWNrZWQ7CisJdW5zaWduZWQgaW50IGVkaSBfX3BhY2tlZDsKK307CisKK3N0 YXRpYyBpbmxpbmUgY29uc3QgY2hhciAqaThrX2dldF9kbWlfZGF0YShpbnQgZmllbGQpCit7CisJ Y29uc3QgY2hhciAqZG1pX2RhdGEgPSBkbWlfZ2V0X3N5c3RlbV9pbmZvKGZpZWxkKTsKKworCXJl dHVybiBkbWlfZGF0YSAmJiAqZG1pX2RhdGEgPyBkbWlfZGF0YSA6ICI/IjsKK30KKworLyoKKyAq IENhbGwgdGhlIFN5c3RlbSBNYW5hZ2VtZW50IE1vZGUgQklPUy4gQ29kZSBwcm92aWRlZCBieSBK b25hdGhhbiBCdXp6YXJkLgorICovCitzdGF0aWMgaW50IGk4a19zbW0oc3RydWN0IHNtbV9yZWdz ICpyZWdzKQoreworCWludCByYzsKKwlpbnQgZWF4ID0gcmVncy0+ZWF4OworCWNwdW1hc2tfdmFy X3Qgb2xkX21hc2s7CisKKwkvKiBTTU0gcmVxdWlyZXMgQ1BVIDAgKi8KKwlpZiAoIWFsbG9jX2Nw dW1hc2tfdmFyKCZvbGRfbWFzaywgR0ZQX0tFUk5FTCkpCisJCXJldHVybiAtRU5PTUVNOworCWNw dW1hc2tfY29weShvbGRfbWFzaywgJmN1cnJlbnQtPmNwdXNfYWxsb3dlZCk7CisJcmMgPSBzZXRf Y3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBjcHVtYXNrX29mKDApKTsKKwlpZiAocmMpCisJCWdv dG8gb3V0OworCWlmIChzbXBfcHJvY2Vzc29yX2lkKCkgIT0gMCkgeworCQlyYyA9IC1FQlVTWTsK KwkJZ290byBvdXQ7CisJfQorCisjaWYgZGVmaW5lZChDT05GSUdfWDg2XzY0KQorCWFzbSB2b2xh dGlsZSgicHVzaHEgJSVyYXhcblx0IgorCQkibW92bCAwKCUlcmF4KSwlJWVkeFxuXHQiCisJCSJw dXNocSAlJXJkeFxuXHQiCisJCSJtb3ZsIDQoJSVyYXgpLCUlZWJ4XG5cdCIKKwkJIm1vdmwgOCgl JXJheCksJSVlY3hcblx0IgorCQkibW92bCAxMiglJXJheCksJSVlZHhcblx0IgorCQkibW92bCAx NiglJXJheCksJSVlc2lcblx0IgorCQkibW92bCAyMCglJXJheCksJSVlZGlcblx0IgorCQkicG9w cSAlJXJheFxuXHQiCisJCSJvdXQgJSVhbCwkMHhiMlxuXHQiCisJCSJvdXQgJSVhbCwkMHg4NFxu XHQiCisJCSJ4Y2hncSAlJXJheCwoJSVyc3ApXG5cdCIKKwkJIm1vdmwgJSVlYngsNCglJXJheClc blx0IgorCQkibW92bCAlJWVjeCw4KCUlcmF4KVxuXHQiCisJCSJtb3ZsICUlZWR4LDEyKCUlcmF4 KVxuXHQiCisJCSJtb3ZsICUlZXNpLDE2KCUlcmF4KVxuXHQiCisJCSJtb3ZsICUlZWRpLDIwKCUl cmF4KVxuXHQiCisJCSJwb3BxICUlcmR4XG5cdCIKKwkJIm1vdmwgJSVlZHgsMCglJXJheClcblx0 IgorCQkicHVzaGZxXG5cdCIKKwkJInBvcHEgJSVyYXhcblx0IgorCQkiYW5kbCAkMSwlJWVheFxu IgorCQk6ICI9YSIocmMpCisJCTogICAgImEiKHJlZ3MpCisJCTogICAgIiVlYngiLCAiJWVjeCIs ICIlZWR4IiwgIiVlc2kiLCAiJWVkaSIsICJtZW1vcnkiKTsKKyNlbHNlCisJYXNtIHZvbGF0aWxl KCJwdXNobCAlJWVheFxuXHQiCisJICAgICJtb3ZsIDAoJSVlYXgpLCUlZWR4XG5cdCIKKwkgICAg InB1c2ggJSVlZHhcblx0IgorCSAgICAibW92bCA0KCUlZWF4KSwlJWVieFxuXHQiCisJICAgICJt b3ZsIDgoJSVlYXgpLCUlZWN4XG5cdCIKKwkgICAgIm1vdmwgMTIoJSVlYXgpLCUlZWR4XG5cdCIK KwkgICAgIm1vdmwgMTYoJSVlYXgpLCUlZXNpXG5cdCIKKwkgICAgIm1vdmwgMjAoJSVlYXgpLCUl ZWRpXG5cdCIKKwkgICAgInBvcGwgJSVlYXhcblx0IgorCSAgICAib3V0ICUlYWwsJDB4YjJcblx0 IgorCSAgICAib3V0ICUlYWwsJDB4ODRcblx0IgorCSAgICAieGNoZ2wgJSVlYXgsKCUlZXNwKVxu XHQiCisJICAgICJtb3ZsICUlZWJ4LDQoJSVlYXgpXG5cdCIKKwkgICAgIm1vdmwgJSVlY3gsOCgl JWVheClcblx0IgorCSAgICAibW92bCAlJWVkeCwxMiglJWVheClcblx0IgorCSAgICAibW92bCAl JWVzaSwxNiglJWVheClcblx0IgorCSAgICAibW92bCAlJWVkaSwyMCglJWVheClcblx0IgorCSAg ICAicG9wbCAlJWVkeFxuXHQiCisJICAgICJtb3ZsICUlZWR4LDAoJSVlYXgpXG5cdCIKKwkgICAg ImxhaGZcblx0IgorCSAgICAic2hybCAkOCwlJWVheFxuXHQiCisJICAgICJhbmRsICQxLCUlZWF4 XG4iCisJICAgIDogIj1hIihyYykKKwkgICAgOiAgICAiYSIocmVncykKKwkgICAgOiAgICAiJWVi eCIsICIlZWN4IiwgIiVlZHgiLCAiJWVzaSIsICIlZWRpIiwgIm1lbW9yeSIpOworI2VuZGlmCisJ aWYgKHJjICE9IDAgfHwgKHJlZ3MtPmVheCAmIDB4ZmZmZikgPT0gMHhmZmZmIHx8IHJlZ3MtPmVh eCA9PSBlYXgpCisJCXJjID0gLUVJTlZBTDsKKworb3V0OgorCXNldF9jcHVzX2FsbG93ZWRfcHRy KGN1cnJlbnQsIG9sZF9tYXNrKTsKKwlmcmVlX2NwdW1hc2tfdmFyKG9sZF9tYXNrKTsKKwlyZXR1 cm4gcmM7Cit9CisKKy8qCisgKiBSZWFkIHRoZSBGbiBrZXkgc3RhdHVzLgorICovCitzdGF0aWMg aW50IGk4a19nZXRfZm5fc3RhdHVzKHZvaWQpCit7CisJc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7 IC5lYXggPSBJOEtfU01NX0ZOX1NUQVRVUywgfTsKKwlpbnQgcmM7CisKKwlyYyA9IGk4a19zbW0o JnJlZ3MpOworCWlmIChyYyA8IDApCisJCXJldHVybiByYzsKKworCXN3aXRjaCAoKHJlZ3MuZWF4 ID4+IEk4S19GTl9TSElGVCkgJiBJOEtfRk5fTUFTSykgeworCWNhc2UgSThLX0ZOX1VQOgorCQly ZXR1cm4gSThLX1ZPTF9VUDsKKwljYXNlIEk4S19GTl9ET1dOOgorCQlyZXR1cm4gSThLX1ZPTF9E T1dOOworCWNhc2UgSThLX0ZOX01VVEU6CisJCXJldHVybiBJOEtfVk9MX01VVEU7CisJZGVmYXVs dDoKKwkJcmV0dXJuIDA7CisJfQorfQorCisvKgorICogUmVhZCB0aGUgcG93ZXIgc3RhdHVzLgor ICovCitzdGF0aWMgaW50IGk4a19nZXRfcG93ZXJfc3RhdHVzKHZvaWQpCit7CisJc3RydWN0IHNt bV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX1BPV0VSX1NUQVRVUywgfTsKKwlpbnQgcmM7 CisKKwlyYyA9IGk4a19zbW0oJnJlZ3MpOworCWlmIChyYyA8IDApCisJCXJldHVybiByYzsKKwor CXJldHVybiAocmVncy5lYXggJiAweGZmKSA9PSBJOEtfUE9XRVJfQUMgPyBJOEtfQUMgOiBJOEtf QkFUVEVSWTsKK30KKworLyoKKyAqIFJlYWQgdGhlIGZhbiBzdGF0dXMuCisgKi8KK3N0YXRpYyBp bnQgaThrX2dldF9mYW5fc3RhdHVzKGludCBmYW4pCit7CisJc3RydWN0IHNtbV9yZWdzIHJlZ3Mg PSB7IC5lYXggPSBJOEtfU01NX0dFVF9GQU4sIH07CisKKwlyZWdzLmVieCA9IGZhbiAmIDB4ZmY7 CisJcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiByZWdzLmVheCAmIDB4ZmY7Cit9CisKKy8qCisg KiBSZWFkIHRoZSBmYW4gc3BlZWQgaW4gUlBNLgorICovCitzdGF0aWMgaW50IGk4a19nZXRfZmFu X3NwZWVkKGludCBmYW4pCit7CisJc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtf U01NX0dFVF9TUEVFRCwgfTsKKworCXJlZ3MuZWJ4ID0gZmFuICYgMHhmZjsKKwlyZXR1cm4gaThr X3NtbSgmcmVncykgPyA6IChyZWdzLmVheCAmIDB4ZmZmZikgKiBpOGtfZmFuX211bHQ7Cit9CisK Ky8qCisgKiBSZWFkIHRoZSBmYW4gdHlwZS4KKyAqLworc3RhdGljIGludCBpOGtfZ2V0X2Zhbl90 eXBlKGludCBmYW4pCit7CisJc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01N X0dFVF9GQU5fVFlQRSwgfTsKKworCXJlZ3MuZWJ4ID0gZmFuICYgMHhmZjsKKwlyZXR1cm4gaThr X3NtbSgmcmVncykgPyA6IHJlZ3MuZWF4ICYgMHhmZjsKK30KKworLyoKKyAqIFJlYWQgdGhlIGZh biBub21pbmFsIHJwbSBmb3Igc3BlY2lmaWMgZmFuIHNwZWVkLgorICovCitzdGF0aWMgaW50IGk4 a19nZXRfZmFuX25vbWluYWxfc3BlZWQoaW50IGZhbiwgaW50IHNwZWVkKQoreworCXN0cnVjdCBz bW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfTk9NX1NQRUVELCB9OworCisJcmVn cy5lYnggPSAoZmFuICYgMHhmZikgfCAoc3BlZWQgPDwgOCk7CisJcmV0dXJuIGk4a19zbW0oJnJl Z3MpID8gOiAocmVncy5lYXggJiAweGZmZmYpICogaThrX2Zhbl9tdWx0OworfQorCisvKgorICog U2V0IHRoZSBmYW4gc3BlZWQgKG9mZiwgbG93LCBoaWdoKS4gUmV0dXJucyB0aGUgbmV3IGZhbiBz dGF0dXMuCisgKi8KK3N0YXRpYyBpbnQgaThrX3NldF9mYW4oaW50IGZhbiwgaW50IHNwZWVkKQor eworCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9TRVRfRkFOLCB9Owor CisJc3BlZWQgPSAoc3BlZWQgPCAwKSA/IDAgOiAoKHNwZWVkID4gaThrX2Zhbl9tYXgpID8gaThr X2Zhbl9tYXggOiBzcGVlZCk7CisJcmVncy5lYnggPSAoZmFuICYgMHhmZikgfCAoc3BlZWQgPDwg OCk7CisKKwlyZXR1cm4gaThrX3NtbSgmcmVncykgPyA6IGk4a19nZXRfZmFuX3N0YXR1cyhmYW4p OworfQorCitzdGF0aWMgaW50IGk4a19nZXRfdGVtcF90eXBlKGludCBzZW5zb3IpCit7CisJc3Ry dWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0dFVF9URU1QX1RZUEUsIH07CisK KwlyZWdzLmVieCA9IHNlbnNvciAmIDB4ZmY7CisJcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiBy ZWdzLmVheCAmIDB4ZmY7Cit9CisKKy8qCisgKiBSZWFkIHRoZSBjcHUgdGVtcGVyYXR1cmUuCisg Ki8KK3N0YXRpYyBpbnQgX2k4a19nZXRfdGVtcChpbnQgc2Vuc29yKQoreworCXN0cnVjdCBzbW1f cmVncyByZWdzID0geworCQkuZWF4ID0gSThLX1NNTV9HRVRfVEVNUCwKKwkJLmVieCA9IHNlbnNv ciAmIDB4ZmYsCisJfTsKKworCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAw eGZmOworfQorCitzdGF0aWMgaW50IGk4a19nZXRfdGVtcChpbnQgc2Vuc29yKQoreworCWludCB0 ZW1wID0gX2k4a19nZXRfdGVtcChzZW5zb3IpOworCisJLyoKKwkgKiBTb21ldGltZXMgdGhlIHRl bXBlcmF0dXJlIHNlbnNvciByZXR1cm5zIDB4OTksIHdoaWNoIGlzIG91dCBvZiByYW5nZS4KKwkg KiBJbiB0aGlzIGNhc2Ugd2UgcmV0cnkgKG9uY2UpIGJlZm9yZSByZXR1cm5pbmcgYW4gZXJyb3Iu CisJICMgMTAwMzY1NTEzNyAwMDAwMDA1OCAwMDAwNWE0YgorCSAjIDEwMDM2NTUxMzggMDAwMDAw OTkgMDAwMDNhODAgPC0tLSAweDk5ID0gMTUzIGRlZ3JlZXMKKwkgIyAxMDAzNjU1MTM5IDAwMDAw MDU0IDAwMDA1YzUyCisJICovCisJaWYgKHRlbXAgPT0gMHg5OSkgeworCQltc2xlZXAoMTAwKTsK KwkJdGVtcCA9IF9pOGtfZ2V0X3RlbXAoc2Vuc29yKTsKKwl9CisJLyoKKwkgKiBSZXR1cm4gLUVO T0RBVEEgZm9yIGFsbCBpbnZhbGlkIHRlbXBlcmF0dXJlcy4KKwkgKgorCSAqIEtub3duIGluc3Rh bmNlcyBhcmUgdGhlIDB4OTkgdmFsdWUgYXMgc2VlbiBhYm92ZSBhcyB3ZWxsIGFzCisJICogMHhj MSAoMTkzKSwgd2hpY2ggbWF5IGJlIHJldHVybmVkIHdoZW4gdHJ5aW5nIHRvIHJlYWQgdGhlIEdQ VQorCSAqIHRlbXBlcmF0dXJlIGlmIHRoZSBzeXN0ZW0gc3VwcG9ydHMgYSBHUFUgYW5kIGl0IGlz IGN1cnJlbnRseQorCSAqIHR1cm5lZCBvZmYuCisJICovCisJaWYgKHRlbXAgPiBJOEtfTUFYX1RF TVApCisJCXJldHVybiAtRU5PREFUQTsKKworCXJldHVybiB0ZW1wOworfQorCitzdGF0aWMgaW50 IGk4a19nZXRfZGVsbF9zaWduYXR1cmUoaW50IHJlcV9mbikKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3Mg cmVncyA9IHsgLmVheCA9IHJlcV9mbiwgfTsKKwlpbnQgcmM7CisKKwlyYyA9IGk4a19zbW0oJnJl Z3MpOworCWlmIChyYyA8IDApCisJCXJldHVybiByYzsKKworCXJldHVybiByZWdzLmVheCA9PSAx MTQ1NjUxNTI3ICYmIHJlZ3MuZWR4ID09IDExNDUzOTIyMDQgPyAwIDogLTE7Cit9CisKK3N0YXRp YyBpbnQKK2k4a19pb2N0bF91bmxvY2tlZChzdHJ1Y3QgZmlsZSAqZnAsIHVuc2lnbmVkIGludCBj bWQsIHVuc2lnbmVkIGxvbmcgYXJnKQoreworCWludCB2YWwgPSAwOworCWludCBzcGVlZDsKKwl1 bnNpZ25lZCBjaGFyIGJ1ZmZbMTZdOworCWludCBfX3VzZXIgKmFyZ3AgPSAoaW50IF9fdXNlciAq KWFyZzsKKworCWlmICghYXJncCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzd2l0Y2ggKGNtZCkg eworCWNhc2UgSThLX0JJT1NfVkVSU0lPTjoKKwkJdmFsID0gKGJpb3NfdmVyc2lvblswXSA8PCAx NikgfAorCQkJCShiaW9zX3ZlcnNpb25bMV0gPDwgOCkgfCBiaW9zX3ZlcnNpb25bMl07CisJCWJy ZWFrOworCisJY2FzZSBJOEtfTUFDSElORV9JRDoKKwkJbWVtc2V0KGJ1ZmYsIDAsIDE2KTsKKwkJ c3RybGNweShidWZmLCBpOGtfZ2V0X2RtaV9kYXRhKERNSV9QUk9EVUNUX1NFUklBTCksCisJCQlz aXplb2YoYnVmZikpOworCQlicmVhazsKKworCWNhc2UgSThLX0ZOX1NUQVRVUzoKKwkJdmFsID0g aThrX2dldF9mbl9zdGF0dXMoKTsKKwkJYnJlYWs7CisKKwljYXNlIEk4S19QT1dFUl9TVEFUVVM6 CisJCXZhbCA9IGk4a19nZXRfcG93ZXJfc3RhdHVzKCk7CisJCWJyZWFrOworCisJY2FzZSBJOEtf R0VUX1RFTVA6CisJCXZhbCA9IGk4a19nZXRfdGVtcCgwKTsKKwkJYnJlYWs7CisKKwljYXNlIEk4 S19HRVRfU1BFRUQ6CisJCWlmIChjb3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBzaXplb2YoaW50 KSkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKworCQl2YWwgPSBpOGtfZ2V0X2Zhbl9zcGVlZCh2YWwp OworCQlicmVhazsKKworCWNhc2UgSThLX0dFVF9GQU46CisJCWlmIChjb3B5X2Zyb21fdXNlcigm dmFsLCBhcmdwLCBzaXplb2YoaW50KSkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKworCQl2YWwgPSBp OGtfZ2V0X2Zhbl9zdGF0dXModmFsKTsKKwkJYnJlYWs7CisKKwljYXNlIEk4S19TRVRfRkFOOgor CQlpZiAocmVzdHJpY3RlZCAmJiAhY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKKwkJCXJldHVybiAt RVBFUk07CisKKwkJaWYgKGNvcHlfZnJvbV91c2VyKCZ2YWwsIGFyZ3AsIHNpemVvZihpbnQpKSkK KwkJCXJldHVybiAtRUZBVUxUOworCisJCWlmIChjb3B5X2Zyb21fdXNlcigmc3BlZWQsIGFyZ3Ag KyAxLCBzaXplb2YoaW50KSkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKworCQl2YWwgPSBpOGtfc2V0 X2Zhbih2YWwsIHNwZWVkKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVJTlZB TDsKKwl9CisKKwlpZiAodmFsIDwgMCkKKwkJcmV0dXJuIHZhbDsKKworCXN3aXRjaCAoY21kKSB7 CisJY2FzZSBJOEtfQklPU19WRVJTSU9OOgorCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZ2YWws IDQpKQorCQkJcmV0dXJuIC1FRkFVTFQ7CisKKwkJYnJlYWs7CisJY2FzZSBJOEtfTUFDSElORV9J RDoKKwkJaWYgKGNvcHlfdG9fdXNlcihhcmdwLCBidWZmLCAxNikpCisJCQlyZXR1cm4gLUVGQVVM VDsKKworCQlicmVhazsKKwlkZWZhdWx0OgorCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZ2YWws IHNpemVvZihpbnQpKSkKKwkJCXJldHVybiAtRUZBVUxUOworCisJCWJyZWFrOworCX0KKworCXJl dHVybiAwOworfQorCitzdGF0aWMgbG9uZyBpOGtfaW9jdGwoc3RydWN0IGZpbGUgKmZwLCB1bnNp Z25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlsb25nIHJldDsKKworCW11dGV4 X2xvY2soJmk4a19tdXRleCk7CisJcmV0ID0gaThrX2lvY3RsX3VubG9ja2VkKGZwLCBjbWQsIGFy Zyk7CisJbXV0ZXhfdW5sb2NrKCZpOGtfbXV0ZXgpOworCisJcmV0dXJuIHJldDsKK30KKworLyoK KyAqIFByaW50IHRoZSBpbmZvcm1hdGlvbiBmb3IgL3Byb2MvaThrLgorICovCitzdGF0aWMgaW50 IGk4a19wcm9jX3Nob3coc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKm9mZnNldCkKK3sKKwlp bnQgZm5fa2V5LCBjcHVfdGVtcCwgYWNfcG93ZXI7CisJaW50IGxlZnRfZmFuLCByaWdodF9mYW4s IGxlZnRfc3BlZWQsIHJpZ2h0X3NwZWVkOworCisJY3B1X3RlbXAJPSBpOGtfZ2V0X3RlbXAoMCk7 CQkJLyogMTExMDAgwrVzICovCisJbGVmdF9mYW4JPSBpOGtfZ2V0X2Zhbl9zdGF0dXMoSThLX0ZB Tl9MRUZUKTsJLyogICA1ODAgwrVzICovCisJcmlnaHRfZmFuCT0gaThrX2dldF9mYW5fc3RhdHVz KEk4S19GQU5fUklHSFQpOwkvKiAgIDU4MCDCtXMgKi8KKwlsZWZ0X3NwZWVkCT0gaThrX2dldF9m YW5fc3BlZWQoSThLX0ZBTl9MRUZUKTsJLyogICA1ODAgwrVzICovCisJcmlnaHRfc3BlZWQJPSBp OGtfZ2V0X2Zhbl9zcGVlZChJOEtfRkFOX1JJR0hUKTsJLyogICA1ODAgwrVzICovCisJZm5fa2V5 CQk9IGk4a19nZXRfZm5fc3RhdHVzKCk7CQkJLyogICA3NTAgwrVzICovCisJaWYgKHBvd2VyX3N0 YXR1cykKKwkJYWNfcG93ZXIgPSBpOGtfZ2V0X3Bvd2VyX3N0YXR1cygpOwkJLyogMTQ3MDAgwrVz ICovCisJZWxzZQorCQlhY19wb3dlciA9IC0xOworCisJLyoKKwkgKiBJbmZvOgorCSAqCisJICog MSkgIEZvcm1hdCB2ZXJzaW9uICh0aGlzIHdpbGwgY2hhbmdlIGlmIGZvcm1hdCBjaGFuZ2VzKQor CSAqIDIpICBCSU9TIHZlcnNpb24KKwkgKiAzKSAgQklPUyBtYWNoaW5lIElECisJICogNCkgIENw dSB0ZW1wZXJhdHVyZQorCSAqIDUpICBMZWZ0IGZhbiBzdGF0dXMKKwkgKiA2KSAgUmlnaHQgZmFu IHN0YXR1cworCSAqIDcpICBMZWZ0IGZhbiBzcGVlZAorCSAqIDgpICBSaWdodCBmYW4gc3BlZWQK KwkgKiA5KSAgQUMgcG93ZXIKKwkgKiAxMCkgRm4gS2V5IHN0YXR1cworCSAqLworCXJldHVybiBz ZXFfcHJpbnRmKHNlcSwgIiVzICVzICVzICVkICVkICVkICVkICVkICVkICVkXG4iLAorCQkJICBJ OEtfUFJPQ19GTVQsCisJCQkgIGJpb3NfdmVyc2lvbiwKKwkJCSAgaThrX2dldF9kbWlfZGF0YShE TUlfUFJPRFVDVF9TRVJJQUwpLAorCQkJICBjcHVfdGVtcCwKKwkJCSAgbGVmdF9mYW4sIHJpZ2h0 X2ZhbiwgbGVmdF9zcGVlZCwgcmlnaHRfc3BlZWQsCisJCQkgIGFjX3Bvd2VyLCBmbl9rZXkpOwor fQorCitzdGF0aWMgaW50IGk4a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBm aWxlICpmaWxlKQoreworCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBpOGtfcHJvY19zaG93LCBO VUxMKTsKK30KKworCisvKgorICogSHdtb24gaW50ZXJmYWNlCisgKi8KKworc3RhdGljIHNzaXpl X3QgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbChzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCSBz dHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKKwkJCQkJIGNoYXIgKmJ1ZikKK3sKKwlz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGxhYmVsc1tdID0geworCQkiQ1BVIiwKKwkJIkdQVSIs CisJCSJTT0RJTU0iLAorCQkiT3RoZXIiLAorCQkiQW1iaWVudCIsCisJCSJPdGhlciIsCisJfTsK KwlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4OworCWludCB0 eXBlOworCisJdHlwZSA9IGk4a19nZXRfdGVtcF90eXBlKGluZGV4KTsKKwlpZiAodHlwZSA8IDAp CisJCXJldHVybiB0eXBlOworCWlmICh0eXBlID49IEFSUkFZX1NJWkUobGFiZWxzKSkKKwkJdHlw ZSA9IEFSUkFZX1NJWkUobGFiZWxzKSAtIDE7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIs IGxhYmVsc1t0eXBlXSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zaG93X3RlbXAo c3RydWN0IGRldmljZSAqZGV2LAorCQkJCSAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZh dHRyLAorCQkJCSAgIGNoYXIgKmJ1ZikKK3sKKwlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0 dHIoZGV2YXR0ciktPmluZGV4OworCWludCB0ZW1wOworCisJdGVtcCA9IGk4a19nZXRfdGVtcChp bmRleCk7CisJaWYgKHRlbXAgPCAwKQorCQlyZXR1cm4gdGVtcDsKKwlyZXR1cm4gc3ByaW50Zihi dWYsICIlZFxuIiwgdGVtcCAqIDEwMDApOworfQorCitzdGF0aWMgc3NpemVfdCBpOGtfaHdtb25f c2hvd19mYW5fbGFiZWwoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCQlzdHJ1Y3QgZGV2aWNlX2F0 dHJpYnV0ZSAqZGV2YXR0ciwKKwkJCQkJY2hhciAqYnVmKQoreworCXN0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgbGFiZWxzW10gPSB7CisJCSJQcm9jZXNzb3IgRmFuIiwKKwkJIk1vdGhlcmJvYXJk IEZhbiIsCisJCSJWaWRlbyBGYW4iLAorCQkiUG93ZXIgU3VwcGx5IEZhbiIsCisJCSJDaGlwc2V0 IEZhbiIsCisJCSJPdGhlciBGYW4iLAorCX07CisJaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9h dHRyKGRldmF0dHIpLT5pbmRleDsKKwlib29sIGRvY2sgPSBmYWxzZTsKKwlpbnQgdHlwZTsKKwor CXR5cGUgPSBpOGtfZ2V0X2Zhbl90eXBlKGluZGV4KTsKKwlpZiAodHlwZSA8IDApCisJCXJldHVy biB0eXBlOworCisJaWYgKHR5cGUgJiAweDEwKSB7CisJCWRvY2sgPSB0cnVlOworCQl0eXBlICY9 IDB4MEY7CisJfQorCisJaWYgKHR5cGUgPj0gQVJSQVlfU0laRShsYWJlbHMpKQorCQl0eXBlID0g KEFSUkFZX1NJWkUobGFiZWxzKSAtIDEpOworCisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXMlc1xu IiwgKGRvY2sgPyAiRG9ja2luZyAiIDogIiIpLCBsYWJlbHNbdHlwZV0pOworfQorCitzdGF0aWMg c3NpemVfdCBpOGtfaHdtb25fc2hvd19mYW4oc3RydWN0IGRldmljZSAqZGV2LAorCQkJCSAgc3Ry dWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCisJCQkJICBjaGFyICpidWYpCit7CisJaW50 IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKKwlpbnQgZmFuX3Nw ZWVkOworCisJZmFuX3NwZWVkID0gaThrX2dldF9mYW5fc3BlZWQoaW5kZXgpOworCWlmIChmYW5f c3BlZWQgPCAwKQorCQlyZXR1cm4gZmFuX3NwZWVkOworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVk XG4iLCBmYW5fc3BlZWQpOworfQorCitzdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2hvd19wd20o c3RydWN0IGRldmljZSAqZGV2LAorCQkJCSAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0 dHIsCisJCQkJICBjaGFyICpidWYpCit7CisJaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRy KGRldmF0dHIpLT5pbmRleDsKKwlpbnQgc3RhdHVzOworCisJc3RhdHVzID0gaThrX2dldF9mYW5f c3RhdHVzKGluZGV4KTsKKwlpZiAoc3RhdHVzIDwgMCkKKwkJcmV0dXJuIC1FSU87CisJcmV0dXJu IHNwcmludGYoYnVmLCAiJWRcbiIsIGNsYW1wX3ZhbChzdGF0dXMgKiBpOGtfcHdtX211bHQsIDAs IDI1NSkpOworfQorCitzdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2V0X3B3bShzdHJ1Y3QgZGV2 aWNlICpkZXYsCisJCQkJIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJCSBjb25z dCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2 X2F0dHIoYXR0ciktPmluZGV4OworCXVuc2lnbmVkIGxvbmcgdmFsOworCWludCBlcnI7CisKKwll cnIgPSBrc3RydG91bChidWYsIDEwLCAmdmFsKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOwor CXZhbCA9IGNsYW1wX3ZhbChESVZfUk9VTkRfQ0xPU0VTVCh2YWwsIGk4a19wd21fbXVsdCksIDAs IGk4a19mYW5fbWF4KTsKKworCW11dGV4X2xvY2soJmk4a19tdXRleCk7CisJZXJyID0gaThrX3Nl dF9mYW4oaW5kZXgsIHZhbCk7CisJbXV0ZXhfdW5sb2NrKCZpOGtfbXV0ZXgpOworCisJcmV0dXJu IGVyciA8IDAgPyAtRUlPIDogY291bnQ7Cit9CisKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIo dGVtcDFfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXAsIE5VTEwsIDApOworc3Rh dGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3No b3dfdGVtcF9sYWJlbCwgTlVMTCwKKwkJCSAgMCk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRS KHRlbXAyX2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAxKTsKK3N0 YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDJfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9z aG93X3RlbXBfbGFiZWwsIE5VTEwsCisJCQkgIDEpOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRU Uih0ZW1wM19pbnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcCwgTlVMTCwgMik7Citz dGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAzX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25f c2hvd190ZW1wX2xhYmVsLCBOVUxMLAorCQkJICAyKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FU VFIodGVtcDRfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXAsIE5VTEwsIDMpOwor c3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wNF9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9u X3Nob3dfdGVtcF9sYWJlbCwgTlVMTCwKKwkJCSAgMyk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9B VFRSKGZhbjFfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X2ZhbiwgTlVMTCwgMCk7Citz dGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGZhbjFfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9z aG93X2Zhbl9sYWJlbCwgTlVMTCwKKwkJCSAgMCk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRS KHB3bTEsIFNfSVJVR08gfCBTX0lXVVNSLCBpOGtfaHdtb25fc2hvd19wd20sCisJCQkgIGk4a19o d21vbl9zZXRfcHdtLCAwKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFuMl9pbnB1dCwg U19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuLCBOVUxMLAorCQkJICAxKTsKK3N0YXRpYyBTRU5T T1JfREVWSUNFX0FUVFIoZmFuMl9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuX2xh YmVsLCBOVUxMLAorCQkJICAxKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocHdtMiwgU19J UlVHTyB8IFNfSVdVU1IsIGk4a19od21vbl9zaG93X3B3bSwKKwkJCSAgaThrX2h3bW9uX3NldF9w d20sIDEpOworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqaThrX2F0dHJzW10gPSB7CisJJnNl bnNvcl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiAwICovCisJJnNlbnNv cl9kZXZfYXR0cl90ZW1wMV9sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiAxICovCisJJnNlbnNvcl9k ZXZfYXR0cl90ZW1wMl9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiAyICovCisJJnNlbnNvcl9kZXZf YXR0cl90ZW1wMl9sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiAzICovCisJJnNlbnNvcl9kZXZfYXR0 cl90ZW1wM19pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiA0ICovCisJJnNlbnNvcl9kZXZfYXR0cl90 ZW1wM19sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiA1ICovCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1w NF9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiA2ICovCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wNF9s YWJlbC5kZXZfYXR0ci5hdHRyLAkvKiA3ICovCisJJnNlbnNvcl9kZXZfYXR0cl9mYW4xX2lucHV0 LmRldl9hdHRyLmF0dHIsCS8qIDggKi8KKwkmc2Vuc29yX2Rldl9hdHRyX2ZhbjFfbGFiZWwuZGV2 X2F0dHIuYXR0ciwJLyogOSAqLworCSZzZW5zb3JfZGV2X2F0dHJfcHdtMS5kZXZfYXR0ci5hdHRy LAkJLyogMTAgKi8KKwkmc2Vuc29yX2Rldl9hdHRyX2ZhbjJfaW5wdXQuZGV2X2F0dHIuYXR0ciwJ LyogMTEgKi8KKwkmc2Vuc29yX2Rldl9hdHRyX2ZhbjJfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyog MTIgKi8KKwkmc2Vuc29yX2Rldl9hdHRyX3B3bTIuZGV2X2F0dHIuYXR0ciwJCS8qIDEzICovCisJ TlVMTAorfTsKKworc3RhdGljIHVtb2RlX3QgaThrX2lzX3Zpc2libGUoc3RydWN0IGtvYmplY3Qg KmtvYmosIHN0cnVjdCBhdHRyaWJ1dGUgKmF0dHIsCisJCQkgICAgICBpbnQgaW5kZXgpCit7CisJ aWYgKGluZGV4ID49IDAgJiYgaW5kZXggPD0gMSAmJgorCSAgICAhKGk4a19od21vbl9mbGFncyAm IEk4S19IV01PTl9IQVZFX1RFTVAxKSkKKwkJcmV0dXJuIDA7CisJaWYgKGluZGV4ID49IDIgJiYg aW5kZXggPD0gMyAmJgorCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RF TVAyKSkKKwkJcmV0dXJuIDA7CisJaWYgKGluZGV4ID49IDQgJiYgaW5kZXggPD0gNSAmJgorCSAg ICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVAzKSkKKwkJcmV0dXJuIDA7 CisJaWYgKGluZGV4ID49IDYgJiYgaW5kZXggPD0gNyAmJgorCSAgICAhKGk4a19od21vbl9mbGFn cyAmIEk4S19IV01PTl9IQVZFX1RFTVA0KSkKKwkJcmV0dXJuIDA7CisJaWYgKGluZGV4ID49IDgg JiYgaW5kZXggPD0gMTAgJiYKKwkgICAgIShpOGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFW RV9GQU4xKSkKKwkJcmV0dXJuIDA7CisJaWYgKGluZGV4ID49IDExICYmIGluZGV4IDw9IDEzICYm CisJICAgICEoaThrX2h3bW9uX2ZsYWdzICYgSThLX0hXTU9OX0hBVkVfRkFOMikpCisJCXJldHVy biAwOworCisJcmV0dXJuIGF0dHItPm1vZGU7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0 cmlidXRlX2dyb3VwIGk4a19ncm91cCA9IHsKKwkuYXR0cnMgPSBpOGtfYXR0cnMsCisJLmlzX3Zp c2libGUgPSBpOGtfaXNfdmlzaWJsZSwKK307CitfX0FUVFJJQlVURV9HUk9VUFMoaThrKTsKKwor c3RhdGljIGludCBfX2luaXQgaThrX2luaXRfaHdtb24odm9pZCkKK3sKKwlpbnQgZXJyOworCisJ aThrX2h3bW9uX2ZsYWdzID0gMDsKKworCS8qIENQVSB0ZW1wZXJhdHVyZSBhdHRyaWJ1dGVzLCBp ZiB0ZW1wZXJhdHVyZSB0eXBlIGlzIE9LICovCisJZXJyID0gaThrX2dldF90ZW1wX3R5cGUoMCk7 CisJaWYgKGVyciA+PSAwKQorCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVfVEVN UDE7CisJLyogY2hlY2sgZm9yIGFkZGl0aW9uYWwgdGVtcGVyYXR1cmUgc2Vuc29ycyAqLworCWVy ciA9IGk4a19nZXRfdGVtcF90eXBlKDEpOworCWlmIChlcnIgPj0gMCkKKwkJaThrX2h3bW9uX2Zs YWdzIHw9IEk4S19IV01PTl9IQVZFX1RFTVAyOworCWVyciA9IGk4a19nZXRfdGVtcF90eXBlKDIp OworCWlmIChlcnIgPj0gMCkKKwkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RF TVAzOworCWVyciA9IGk4a19nZXRfdGVtcF90eXBlKDMpOworCWlmIChlcnIgPj0gMCkKKwkJaThr X2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RFTVA0OworCisJLyogRmlyc3QgZmFuIGF0 dHJpYnV0ZXMsIGlmIGZhbiB0eXBlIGlzIE9LICovCisJZXJyID0gaThrX2dldF9mYW5fdHlwZSgw KTsKKwlpZiAoZXJyID49IDApCisJCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9G QU4xOworCisJLyogU2Vjb25kIGZhbiBhdHRyaWJ1dGVzLCBpZiBmYW4gdHlwZSBpcyBPSyAqLwor CWVyciA9IGk4a19nZXRfZmFuX3R5cGUoMSk7CisJaWYgKGVyciA+PSAwKQorCQlpOGtfaHdtb25f ZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVfRkFOMjsKKworCWk4a19od21vbl9kZXYgPSBod21vbl9k ZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoTlVMTCwgImk4ayIsIE5VTEwsCisJCQkJCQkJICBp OGtfZ3JvdXBzKTsKKwlpZiAoSVNfRVJSKGk4a19od21vbl9kZXYpKSB7CisJCWVyciA9IFBUUl9F UlIoaThrX2h3bW9uX2Rldik7CisJCWk4a19od21vbl9kZXYgPSBOVUxMOworCQlwcl9lcnIoImh3 bW9uIHJlZ2lzdHJhdGlvbiBmYWlsZWQgKCVkKVxuIiwgZXJyKTsKKwkJcmV0dXJuIGVycjsKKwl9 CisJcmV0dXJuIDA7Cit9CisKK3N0cnVjdCBpOGtfY29uZmlnX2RhdGEgeworCXVpbnQgZmFuX211 bHQ7CisJdWludCBmYW5fbWF4OworfTsKKworZW51bSBpOGtfY29uZmlncyB7CisJREVMTF9MQVRJ VFVERV9ENTIwLAorCURFTExfUFJFQ0lTSU9OXzQ5MCwKKwlERUxMX1NUVURJTywKKwlERUxMX1hQ UywKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaThrX2NvbmZpZ19kYXRhIGk4a19jb25maWdf ZGF0YVtdID0geworCVtERUxMX0xBVElUVURFX0Q1MjBdID0geworCQkuZmFuX211bHQgPSAxLAor CQkuZmFuX21heCA9IEk4S19GQU5fVFVSQk8sCisJfSwKKwlbREVMTF9QUkVDSVNJT05fNDkwXSA9 IHsKKwkJLmZhbl9tdWx0ID0gMSwKKwkJLmZhbl9tYXggPSBJOEtfRkFOX1RVUkJPLAorCX0sCisJ W0RFTExfU1RVRElPXSA9IHsKKwkJLmZhbl9tdWx0ID0gMSwKKwkJLmZhbl9tYXggPSBJOEtfRkFO X0hJR0gsCisJfSwKKwlbREVMTF9YUFNdID0geworCQkuZmFuX211bHQgPSAxLAorCQkuZmFuX21h eCA9IEk4S19GQU5fSElHSCwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBkbWlfc3lzdGVtX2lk IGk4a19kbWlfdGFibGVbXSBfX2luaXRkYXRhID0geworCXsKKwkJLmlkZW50ID0gIkRlbGwgSW5z cGlyb24iLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRl bGwgQ29tcHV0ZXIiKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiSW5zcGlyb24i KSwKKwkJfSwKKwl9LAorCXsKKwkJLmlkZW50ID0gIkRlbGwgTGF0aXR1ZGUiLAorCQkubWF0Y2hl cyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgQ29tcHV0ZXIiKSwKKwkJ CURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTGF0aXR1ZGUiKSwKKwkJfSwKKwl9LAorCXsK KwkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24gMiIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01B VENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RV Q1RfTkFNRSwgIkluc3Bpcm9uIiksCisJCX0sCisJfSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIExh dGl0dWRlIEQ1MjAiLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRP UiwgIkRlbGwgSW5jLiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJMYXRpdHVk ZSBENTIwIiksCisJCX0sCisJCS5kcml2ZXJfZGF0YSA9ICh2b2lkICopJmk4a19jb25maWdfZGF0 YVtERUxMX0xBVElUVURFX0Q1MjBdLAorCX0sCisJeworCQkuaWRlbnQgPSAiRGVsbCBMYXRpdHVk ZSAyIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxs IEluYy4iKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTGF0aXR1ZGUiKSwKKwkJ fSwKKwl9LAorCXsJLyogVUsgSW5zcGlyb24gNjQwMCAgKi8KKwkJLmlkZW50ID0gIkRlbGwgSW5z cGlyb24gMyIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAi RGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIk1NMDYxIiksCisJ CX0sCisJfSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIDMiLAorCQkubWF0Y2hlcyA9 IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJRE1JX01B VENIKERNSV9QUk9EVUNUX05BTUUsICJNUDA2MSIpLAorCQl9LAorCX0sCisJeworCQkuaWRlbnQg PSAiRGVsbCBQcmVjaXNpb24gNDkwIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1J X1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1F LAorCQkJCSAgIlByZWNpc2lvbiBXb3JrU3RhdGlvbiA0OTAiKSwKKwkJfSwKKwkJLmRyaXZlcl9k YXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfUFJFQ0lTSU9OXzQ5MF0sCisJfSwK Kwl7CisJCS5pZGVudCA9ICJEZWxsIFByZWNpc2lvbiIsCisJCS5tYXRjaGVzID0geworCQkJRE1J X01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BS T0RVQ1RfTkFNRSwgIlByZWNpc2lvbiIpLAorCQl9LAorCX0sCisJeworCQkuaWRlbnQgPSAiRGVs bCBWb3N0cm8iLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwg IkRlbGwgSW5jLiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJWb3N0cm8iKSwK KwkJfSwKKwl9LAorCXsKKwkJLmlkZW50ID0gIkRlbGwgWFBTNDIxIiwKKwkJLm1hdGNoZXMgPSB7 CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKKwkJCURNSV9NQVRD SChETUlfUFJPRFVDVF9OQU1FLCAiWFBTIEw0MjFYIiksCisJCX0sCisJfSwKKwl7CisJCS5pZGVu dCA9ICJEZWxsIFN0dWRpbyIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERNSV9TWVNf VkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlN0 dWRpbyIpLAorCQl9LAorCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2RhdGFb REVMTF9TVFVESU9dLAorCX0sCisJeworCQkuaWRlbnQgPSAiRGVsbCBYUFMgMTMiLAorCQkubWF0 Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJ RE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJYUFMxMyIpLAorCQl9LAorCQkuZHJpdmVyX2Rh dGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9YUFNdLAorCX0sCisJeworCQkuaWRl bnQgPSAiRGVsbCBYUFMgTTE0MCIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERNSV9T WVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwg Ik1YQzA1MSIpLAorCQl9LAorCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2Rh dGFbREVMTF9YUFNdLAorCX0sCisJeyB9Cit9OworCitNT0RVTEVfREVWSUNFX1RBQkxFKGRtaSwg aThrX2RtaV90YWJsZSk7CisKKy8qCisgKiBQcm9iZSBmb3IgdGhlIHByZXNlbmNlIG9mIGEgc3Vw cG9ydGVkIGxhcHRvcC4KKyAqLworc3RhdGljIGludCBfX2luaXQgaThrX3Byb2JlKHZvaWQpCit7 CisJY29uc3Qgc3RydWN0IGRtaV9zeXN0ZW1faWQgKmlkOworCWludCBmYW4sIHJldDsKKworCS8q CisJICogR2V0IERNSSBpbmZvcm1hdGlvbgorCSAqLworCWlmICghZG1pX2NoZWNrX3N5c3RlbShp OGtfZG1pX3RhYmxlKSkgeworCQlpZiAoIWlnbm9yZV9kbWkgJiYgIWZvcmNlKQorCQkJcmV0dXJu IC1FTk9ERVY7CisKKwkJcHJfaW5mbygibm90IHJ1bm5pbmcgb24gYSBzdXBwb3J0ZWQgRGVsbCBz eXN0ZW0uXG4iKTsKKwkJcHJfaW5mbygidmVuZG9yPSVzLCBtb2RlbD0lcywgdmVyc2lvbj0lc1xu IiwKKwkJCWk4a19nZXRfZG1pX2RhdGEoRE1JX1NZU19WRU5ET1IpLAorCQkJaThrX2dldF9kbWlf ZGF0YShETUlfUFJPRFVDVF9OQU1FKSwKKwkJCWk4a19nZXRfZG1pX2RhdGEoRE1JX0JJT1NfVkVS U0lPTikpOworCX0KKworCXN0cmxjcHkoYmlvc192ZXJzaW9uLCBpOGtfZ2V0X2RtaV9kYXRhKERN SV9CSU9TX1ZFUlNJT04pLAorCQlzaXplb2YoYmlvc192ZXJzaW9uKSk7CisKKwkvKgorCSAqIEdl dCBTTU0gRGVsbCBzaWduYXR1cmUKKwkgKi8KKwlpZiAoaThrX2dldF9kZWxsX3NpZ25hdHVyZShJ OEtfU01NX0dFVF9ERUxMX1NJRzEpICYmCisJICAgIGk4a19nZXRfZGVsbF9zaWduYXR1cmUoSThL X1NNTV9HRVRfREVMTF9TSUcyKSkgeworCQlwcl9lcnIoInVuYWJsZSB0byBnZXQgU01NIERlbGwg c2lnbmF0dXJlXG4iKTsKKwkJaWYgKCFmb3JjZSkKKwkJCXJldHVybiAtRU5PREVWOworCX0KKwor CS8qCisJICogU2V0IGZhbiBtdWx0aXBsaWVyIGFuZCBtYXhpbWFsIGZhbiBzcGVlZCBmcm9tIGRt aSBjb25maWcKKwkgKiBWYWx1ZXMgc3BlY2lmaWVkIGluIG1vZHVsZSBwYXJhbWV0ZXJzIG92ZXJy aWRlIHZhbHVlcyBmcm9tIGRtaQorCSAqLworCWlkID0gZG1pX2ZpcnN0X21hdGNoKGk4a19kbWlf dGFibGUpOworCWlmIChpZCAmJiBpZC0+ZHJpdmVyX2RhdGEpIHsKKwkJY29uc3Qgc3RydWN0IGk4 a19jb25maWdfZGF0YSAqY29uZiA9IGlkLT5kcml2ZXJfZGF0YTsKKwkJaWYgKCFmYW5fbXVsdCAm JiBjb25mLT5mYW5fbXVsdCkKKwkJCWZhbl9tdWx0ID0gY29uZi0+ZmFuX211bHQ7CisJCWlmICgh ZmFuX21heCAmJiBjb25mLT5mYW5fbWF4KQorCQkJZmFuX21heCA9IGNvbmYtPmZhbl9tYXg7CisJ fQorCisJaThrX2Zhbl9tYXggPSBmYW5fbWF4ID8gOiBJOEtfRkFOX0hJR0g7CS8qIE11c3Qgbm90 IGJlIDAgKi8KKwlpOGtfcHdtX211bHQgPSBESVZfUk9VTkRfVVAoMjU1LCBpOGtfZmFuX21heCk7 CisKKwlpZiAoIWZhbl9tdWx0KSB7CisJCS8qCisJCSAqIEF1dG9kZXRlY3QgZmFuIG11bHRpcGxp ZXIgYmFzZWQgb24gbm9taW5hbCBycG0KKwkJICogSWYgZmFuIHJlcG9ydHMgcnBtIHZhbHVlIHRv byBoaWdoIHRoZW4gc2V0IG11bHRpcGxpZXIgdG8gMQorCQkgKi8KKwkJZm9yIChmYW4gPSAwOyBm YW4gPCAyOyArK2ZhbikgeworCQkJcmV0ID0gaThrX2dldF9mYW5fbm9taW5hbF9zcGVlZChmYW4s IGk4a19mYW5fbWF4KTsKKwkJCWlmIChyZXQgPCAwKQorCQkJCWNvbnRpbnVlOworCQkJaWYgKHJl dCA+IEk4S19GQU5fTUFYX1JQTSkKKwkJCQlpOGtfZmFuX211bHQgPSAxOworCQkJYnJlYWs7CisJ CX0KKwl9IGVsc2UgeworCQkvKiBGYW4gbXVsdGlwbGllciB3YXMgc3BlY2lmaWVkIGluIG1vZHVs ZSBwYXJhbSBvciBpbiBkbWkgKi8KKwkJaThrX2Zhbl9tdWx0ID0gZmFuX211bHQ7CisJfQorCisJ cmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IGk4a19pbml0KHZvaWQpCit7CisJc3Ry dWN0IHByb2NfZGlyX2VudHJ5ICpwcm9jX2k4azsKKwlpbnQgZXJyOworCisJLyogQXJlIHdlIHJ1 bm5pbmcgb24gYW4gc3VwcG9ydGVkIGxhcHRvcD8gKi8KKwlpZiAoaThrX3Byb2JlKCkpCisJCXJl dHVybiAtRU5PREVWOworCisJLyogUmVnaXN0ZXIgdGhlIHByb2MgZW50cnkgKi8KKwlwcm9jX2k4 ayA9IHByb2NfY3JlYXRlKCJpOGsiLCAwLCBOVUxMLCAmaThrX2ZvcHMpOworCWlmICghcHJvY19p OGspCisJCXJldHVybiAtRU5PRU5UOworCisJZXJyID0gaThrX2luaXRfaHdtb24oKTsKKwlpZiAo ZXJyKQorCQlnb3RvIGV4aXRfcmVtb3ZlX3Byb2M7CisKKwlyZXR1cm4gMDsKKworIGV4aXRfcmVt b3ZlX3Byb2M6CisJcmVtb3ZlX3Byb2NfZW50cnkoImk4ayIsIE5VTEwpOworCXJldHVybiBlcnI7 Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBpOGtfZXhpdCh2b2lkKQoreworCWh3bW9uX2Rldmlj ZV91bnJlZ2lzdGVyKGk4a19od21vbl9kZXYpOworCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBO VUxMKTsKK30KKworbW9kdWxlX2luaXQoaThrX2luaXQpOworbW9kdWxlX2V4aXQoaThrX2V4aXQp OwotLSAKMS43LjkuNQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0CmxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcK aHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxtYW4vbGlzdGluZm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH v2 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree @ 2015-03-29 12:57 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-29 12:57 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This commit moves i8k driver to hwmon tree under name dell-smm-hwmon which is better name then abbreviation i8k. For backward compatibility is added macro MODULE_ALIAS("i8k") so modprobe will load driver also old name i8k. CONFIG_I8K compile option was not changed. This commit also adds me as maintainer of this new dell-smm-hwmon driver and remove Guenter Roeck from list who is implicit maintainer all hwmon drivers. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- MAINTAINERS | 4 +- drivers/char/Makefile | 1 - drivers/char/i8k.c | 1005 --------------------------------------- drivers/hwmon/Makefile | 1 + drivers/hwmon/dell-smm-hwmon.c | 1007 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 1010 insertions(+), 1008 deletions(-) delete mode 100644 drivers/char/i8k.c create mode 100644 drivers/hwmon/dell-smm-hwmon.c diff --git a/MAINTAINERS b/MAINTAINERS index 88c09ca..e54a07e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3063,9 +3063,9 @@ S: Maintained F: drivers/platform/x86/dell-laptop.c DELL LAPTOP SMM DRIVER -M: Guenter Roeck <linux@roeck-us.net> +M: Pali Rohár <pali.rohar@gmail.com> S: Maintained -F: drivers/char/i8k.c +F: drivers/hwmon/dell-smm-hwmon.c F: include/uapi/linux/i8k.h DELL SYSTEMS MANAGEMENT BASE DRIVER (dcdbas) diff --git a/drivers/char/Makefile b/drivers/char/Makefile index d06cde26..1d9cf00 100644 --- a/drivers/char/Makefile +++ b/drivers/char/Makefile @@ -36,7 +36,6 @@ else obj-$(CONFIG_NVRAM) += nvram.o endif obj-$(CONFIG_TOSHIBA) += toshiba.o -obj-$(CONFIG_I8K) += i8k.o obj-$(CONFIG_DS1620) += ds1620.o obj-$(CONFIG_HW_RANDOM) += hw_random/ obj-$(CONFIG_PPDEV) += ppdev.o diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c deleted file mode 100644 index 24cc4ed..0000000 --- a/drivers/char/i8k.c +++ /dev/null @@ -1,1005 +0,0 @@ -/* - * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops. - * - * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> - * - * Hwmon integration: - * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> - * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> - * Copyright (C) 2014 Pali Rohár <pali.rohar@gmail.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, 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. - */ - -#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt - -#include <linux/delay.h> -#include <linux/module.h> -#include <linux/types.h> -#include <linux/init.h> -#include <linux/proc_fs.h> -#include <linux/seq_file.h> -#include <linux/dmi.h> -#include <linux/capability.h> -#include <linux/mutex.h> -#include <linux/hwmon.h> -#include <linux/hwmon-sysfs.h> -#include <linux/uaccess.h> -#include <linux/io.h> -#include <linux/sched.h> - -#include <linux/i8k.h> - -#define I8K_SMM_FN_STATUS 0x0025 -#define I8K_SMM_POWER_STATUS 0x0069 -#define I8K_SMM_SET_FAN 0x01a3 -#define I8K_SMM_GET_FAN 0x00a3 -#define I8K_SMM_GET_SPEED 0x02a3 -#define I8K_SMM_GET_FAN_TYPE 0x03a3 -#define I8K_SMM_GET_NOM_SPEED 0x04a3 -#define I8K_SMM_GET_TEMP 0x10a3 -#define I8K_SMM_GET_TEMP_TYPE 0x11a3 -#define I8K_SMM_GET_DELL_SIG1 0xfea3 -#define I8K_SMM_GET_DELL_SIG2 0xffa3 - -#define I8K_FAN_MULT 30 -#define I8K_FAN_MAX_RPM 30000 -#define I8K_MAX_TEMP 127 - -#define I8K_FN_NONE 0x00 -#define I8K_FN_UP 0x01 -#define I8K_FN_DOWN 0x02 -#define I8K_FN_MUTE 0x04 -#define I8K_FN_MASK 0x07 -#define I8K_FN_SHIFT 8 - -#define I8K_POWER_AC 0x05 -#define I8K_POWER_BATTERY 0x01 - -static DEFINE_MUTEX(i8k_mutex); -static char bios_version[4]; -static struct device *i8k_hwmon_dev; -static u32 i8k_hwmon_flags; -static uint i8k_fan_mult = I8K_FAN_MULT; -static uint i8k_pwm_mult; -static uint i8k_fan_max = I8K_FAN_HIGH; - -#define I8K_HWMON_HAVE_TEMP1 (1 << 0) -#define I8K_HWMON_HAVE_TEMP2 (1 << 1) -#define I8K_HWMON_HAVE_TEMP3 (1 << 2) -#define I8K_HWMON_HAVE_TEMP4 (1 << 3) -#define I8K_HWMON_HAVE_FAN1 (1 << 4) -#define I8K_HWMON_HAVE_FAN2 (1 << 5) - -MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); -MODULE_LICENSE("GPL"); - -static bool force; -module_param(force, bool, 0); -MODULE_PARM_DESC(force, "Force loading without checking for supported models"); - -static bool ignore_dmi; -module_param(ignore_dmi, bool, 0); -MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); - -static bool restricted; -module_param(restricted, bool, 0); -MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); - -static bool power_status; -module_param(power_status, bool, 0600); -MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); - -static uint fan_mult; -module_param(fan_mult, uint, 0); -MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); - -static uint fan_max; -module_param(fan_max, uint, 0); -MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); - -static int i8k_open_fs(struct inode *inode, struct file *file); -static long i8k_ioctl(struct file *, unsigned int, unsigned long); - -static const struct file_operations i8k_fops = { - .owner = THIS_MODULE, - .open = i8k_open_fs, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, - .unlocked_ioctl = i8k_ioctl, -}; - -struct smm_regs { - unsigned int eax; - unsigned int ebx __packed; - unsigned int ecx __packed; - unsigned int edx __packed; - unsigned int esi __packed; - unsigned int edi __packed; -}; - -static inline const char *i8k_get_dmi_data(int field) -{ - const char *dmi_data = dmi_get_system_info(field); - - return dmi_data && *dmi_data ? dmi_data : "?"; -} - -/* - * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. - */ -static int i8k_smm(struct smm_regs *regs) -{ - int rc; - int eax = regs->eax; - cpumask_var_t old_mask; - - /* SMM requires CPU 0 */ - if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) - return -ENOMEM; - cpumask_copy(old_mask, ¤t->cpus_allowed); - rc = set_cpus_allowed_ptr(current, cpumask_of(0)); - if (rc) - goto out; - if (smp_processor_id() != 0) { - rc = -EBUSY; - goto out; - } - -#if defined(CONFIG_X86_64) - asm volatile("pushq %%rax\n\t" - "movl 0(%%rax),%%edx\n\t" - "pushq %%rdx\n\t" - "movl 4(%%rax),%%ebx\n\t" - "movl 8(%%rax),%%ecx\n\t" - "movl 12(%%rax),%%edx\n\t" - "movl 16(%%rax),%%esi\n\t" - "movl 20(%%rax),%%edi\n\t" - "popq %%rax\n\t" - "out %%al,$0xb2\n\t" - "out %%al,$0x84\n\t" - "xchgq %%rax,(%%rsp)\n\t" - "movl %%ebx,4(%%rax)\n\t" - "movl %%ecx,8(%%rax)\n\t" - "movl %%edx,12(%%rax)\n\t" - "movl %%esi,16(%%rax)\n\t" - "movl %%edi,20(%%rax)\n\t" - "popq %%rdx\n\t" - "movl %%edx,0(%%rax)\n\t" - "pushfq\n\t" - "popq %%rax\n\t" - "andl $1,%%eax\n" - : "=a"(rc) - : "a"(regs) - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); -#else - asm volatile("pushl %%eax\n\t" - "movl 0(%%eax),%%edx\n\t" - "push %%edx\n\t" - "movl 4(%%eax),%%ebx\n\t" - "movl 8(%%eax),%%ecx\n\t" - "movl 12(%%eax),%%edx\n\t" - "movl 16(%%eax),%%esi\n\t" - "movl 20(%%eax),%%edi\n\t" - "popl %%eax\n\t" - "out %%al,$0xb2\n\t" - "out %%al,$0x84\n\t" - "xchgl %%eax,(%%esp)\n\t" - "movl %%ebx,4(%%eax)\n\t" - "movl %%ecx,8(%%eax)\n\t" - "movl %%edx,12(%%eax)\n\t" - "movl %%esi,16(%%eax)\n\t" - "movl %%edi,20(%%eax)\n\t" - "popl %%edx\n\t" - "movl %%edx,0(%%eax)\n\t" - "lahf\n\t" - "shrl $8,%%eax\n\t" - "andl $1,%%eax\n" - : "=a"(rc) - : "a"(regs) - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); -#endif - if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) - rc = -EINVAL; - -out: - set_cpus_allowed_ptr(current, old_mask); - free_cpumask_var(old_mask); - return rc; -} - -/* - * Read the Fn key status. - */ -static int i8k_get_fn_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { - case I8K_FN_UP: - return I8K_VOL_UP; - case I8K_FN_DOWN: - return I8K_VOL_DOWN; - case I8K_FN_MUTE: - return I8K_VOL_MUTE; - default: - return 0; - } -} - -/* - * Read the power status. - */ -static int i8k_get_power_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; -} - -/* - * Read the fan status. - */ -static int i8k_get_fan_status(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the fan speed in RPM. - */ -static int i8k_get_fan_speed(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; -} - -/* - * Read the fan type. - */ -static int i8k_get_fan_type(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the fan nominal rpm for specific fan speed. - */ -static int i8k_get_fan_nominal_speed(int fan, int speed) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; - - regs.ebx = (fan & 0xff) | (speed << 8); - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; -} - -/* - * Set the fan speed (off, low, high). Returns the new fan status. - */ -static int i8k_set_fan(int fan, int speed) -{ - struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; - - speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); - regs.ebx = (fan & 0xff) | (speed << 8); - - return i8k_smm(®s) ? : i8k_get_fan_status(fan); -} - -static int i8k_get_temp_type(int sensor) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; - - regs.ebx = sensor & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the cpu temperature. - */ -static int _i8k_get_temp(int sensor) -{ - struct smm_regs regs = { - .eax = I8K_SMM_GET_TEMP, - .ebx = sensor & 0xff, - }; - - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -static int i8k_get_temp(int sensor) -{ - int temp = _i8k_get_temp(sensor); - - /* - * Sometimes the temperature sensor returns 0x99, which is out of range. - * In this case we retry (once) before returning an error. - # 1003655137 00000058 00005a4b - # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees - # 1003655139 00000054 00005c52 - */ - if (temp == 0x99) { - msleep(100); - temp = _i8k_get_temp(sensor); - } - /* - * Return -ENODATA for all invalid temperatures. - * - * Known instances are the 0x99 value as seen above as well as - * 0xc1 (193), which may be returned when trying to read the GPU - * temperature if the system supports a GPU and it is currently - * turned off. - */ - if (temp > I8K_MAX_TEMP) - return -ENODATA; - - return temp; -} - -static int i8k_get_dell_signature(int req_fn) -{ - struct smm_regs regs = { .eax = req_fn, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; -} - -static int -i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) -{ - int val = 0; - int speed; - unsigned char buff[16]; - int __user *argp = (int __user *)arg; - - if (!argp) - return -EINVAL; - - switch (cmd) { - case I8K_BIOS_VERSION: - val = (bios_version[0] << 16) | - (bios_version[1] << 8) | bios_version[2]; - break; - - case I8K_MACHINE_ID: - memset(buff, 0, 16); - strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), - sizeof(buff)); - break; - - case I8K_FN_STATUS: - val = i8k_get_fn_status(); - break; - - case I8K_POWER_STATUS: - val = i8k_get_power_status(); - break; - - case I8K_GET_TEMP: - val = i8k_get_temp(0); - break; - - case I8K_GET_SPEED: - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - val = i8k_get_fan_speed(val); - break; - - case I8K_GET_FAN: - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - val = i8k_get_fan_status(val); - break; - - case I8K_SET_FAN: - if (restricted && !capable(CAP_SYS_ADMIN)) - return -EPERM; - - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - if (copy_from_user(&speed, argp + 1, sizeof(int))) - return -EFAULT; - - val = i8k_set_fan(val, speed); - break; - - default: - return -EINVAL; - } - - if (val < 0) - return val; - - switch (cmd) { - case I8K_BIOS_VERSION: - if (copy_to_user(argp, &val, 4)) - return -EFAULT; - - break; - case I8K_MACHINE_ID: - if (copy_to_user(argp, buff, 16)) - return -EFAULT; - - break; - default: - if (copy_to_user(argp, &val, sizeof(int))) - return -EFAULT; - - break; - } - - return 0; -} - -static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) -{ - long ret; - - mutex_lock(&i8k_mutex); - ret = i8k_ioctl_unlocked(fp, cmd, arg); - mutex_unlock(&i8k_mutex); - - return ret; -} - -/* - * Print the information for /proc/i8k. - */ -static int i8k_proc_show(struct seq_file *seq, void *offset) -{ - int fn_key, cpu_temp, ac_power; - int left_fan, right_fan, left_speed, right_speed; - - cpu_temp = i8k_get_temp(0); /* 11100 µs */ - left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ - right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ - left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ - right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ - fn_key = i8k_get_fn_status(); /* 750 µs */ - if (power_status) - ac_power = i8k_get_power_status(); /* 14700 µs */ - else - ac_power = -1; - - /* - * Info: - * - * 1) Format version (this will change if format changes) - * 2) BIOS version - * 3) BIOS machine ID - * 4) Cpu temperature - * 5) Left fan status - * 6) Right fan status - * 7) Left fan speed - * 8) Right fan speed - * 9) AC power - * 10) Fn Key status - */ - return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", - I8K_PROC_FMT, - bios_version, - i8k_get_dmi_data(DMI_PRODUCT_SERIAL), - cpu_temp, - left_fan, right_fan, left_speed, right_speed, - ac_power, fn_key); -} - -static int i8k_open_fs(struct inode *inode, struct file *file) -{ - return single_open(file, i8k_proc_show, NULL); -} - - -/* - * Hwmon interface - */ - -static ssize_t i8k_hwmon_show_temp_label(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - static const char * const labels[] = { - "CPU", - "GPU", - "SODIMM", - "Other", - "Ambient", - "Other", - }; - int index = to_sensor_dev_attr(devattr)->index; - int type; - - type = i8k_get_temp_type(index); - if (type < 0) - return type; - if (type >= ARRAY_SIZE(labels)) - type = ARRAY_SIZE(labels) - 1; - return sprintf(buf, "%s\n", labels[type]); -} - -static ssize_t i8k_hwmon_show_temp(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int temp; - - temp = i8k_get_temp(index); - if (temp < 0) - return temp; - return sprintf(buf, "%d\n", temp * 1000); -} - -static ssize_t i8k_hwmon_show_fan_label(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - static const char * const labels[] = { - "Processor Fan", - "Motherboard Fan", - "Video Fan", - "Power Supply Fan", - "Chipset Fan", - "Other Fan", - }; - int index = to_sensor_dev_attr(devattr)->index; - bool dock = false; - int type; - - type = i8k_get_fan_type(index); - if (type < 0) - return type; - - if (type & 0x10) { - dock = true; - type &= 0x0F; - } - - if (type >= ARRAY_SIZE(labels)) - type = (ARRAY_SIZE(labels) - 1); - - return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); -} - -static ssize_t i8k_hwmon_show_fan(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int fan_speed; - - fan_speed = i8k_get_fan_speed(index); - if (fan_speed < 0) - return fan_speed; - return sprintf(buf, "%d\n", fan_speed); -} - -static ssize_t i8k_hwmon_show_pwm(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int status; - - status = i8k_get_fan_status(index); - if (status < 0) - return -EIO; - return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); -} - -static ssize_t i8k_hwmon_set_pwm(struct device *dev, - struct device_attribute *attr, - const char *buf, size_t count) -{ - int index = to_sensor_dev_attr(attr)->index; - unsigned long val; - int err; - - err = kstrtoul(buf, 10, &val); - if (err) - return err; - val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); - - mutex_lock(&i8k_mutex); - err = i8k_set_fan(index, val); - mutex_unlock(&i8k_mutex); - - return err < 0 ? -EIO : count; -} - -static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); -static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 0); -static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); -static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 1); -static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); -static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 2); -static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); -static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 3); -static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); -static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, - 0); -static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, - i8k_hwmon_set_pwm, 0); -static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, - 1); -static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, - 1); -static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, - i8k_hwmon_set_pwm, 1); - -static struct attribute *i8k_attrs[] = { - &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ - &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ - &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ - &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ - &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ - &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ - &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ - &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ - &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ - &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ - &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ - &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ - &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ - &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ - NULL -}; - -static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, - int index) -{ - if (index >= 0 && index <= 1 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) - return 0; - if (index >= 2 && index <= 3 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) - return 0; - if (index >= 4 && index <= 5 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) - return 0; - if (index >= 6 && index <= 7 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) - return 0; - if (index >= 8 && index <= 10 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) - return 0; - if (index >= 11 && index <= 13 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) - return 0; - - return attr->mode; -} - -static const struct attribute_group i8k_group = { - .attrs = i8k_attrs, - .is_visible = i8k_is_visible, -}; -__ATTRIBUTE_GROUPS(i8k); - -static int __init i8k_init_hwmon(void) -{ - int err; - - i8k_hwmon_flags = 0; - - /* CPU temperature attributes, if temperature type is OK */ - err = i8k_get_temp_type(0); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; - /* check for additional temperature sensors */ - err = i8k_get_temp_type(1); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; - err = i8k_get_temp_type(2); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; - err = i8k_get_temp_type(3); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; - - /* First fan attributes, if fan type is OK */ - err = i8k_get_fan_type(0); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; - - /* Second fan attributes, if fan type is OK */ - err = i8k_get_fan_type(1); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; - - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, - i8k_groups); - if (IS_ERR(i8k_hwmon_dev)) { - err = PTR_ERR(i8k_hwmon_dev); - i8k_hwmon_dev = NULL; - pr_err("hwmon registration failed (%d)\n", err); - return err; - } - return 0; -} - -struct i8k_config_data { - uint fan_mult; - uint fan_max; -}; - -enum i8k_configs { - DELL_LATITUDE_D520, - DELL_PRECISION_490, - DELL_STUDIO, - DELL_XPS, -}; - -static const struct i8k_config_data i8k_config_data[] = { - [DELL_LATITUDE_D520] = { - .fan_mult = 1, - .fan_max = I8K_FAN_TURBO, - }, - [DELL_PRECISION_490] = { - .fan_mult = 1, - .fan_max = I8K_FAN_TURBO, - }, - [DELL_STUDIO] = { - .fan_mult = 1, - .fan_max = I8K_FAN_HIGH, - }, - [DELL_XPS] = { - .fan_mult = 1, - .fan_max = I8K_FAN_HIGH, - }, -}; - -static struct dmi_system_id i8k_dmi_table[] __initdata = { - { - .ident = "Dell Inspiron", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), - }, - }, - { - .ident = "Dell Latitude", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), - }, - }, - { - .ident = "Dell Inspiron 2", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), - }, - }, - { - .ident = "Dell Latitude D520", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), - }, - .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], - }, - { - .ident = "Dell Latitude 2", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), - }, - }, - { /* UK Inspiron 6400 */ - .ident = "Dell Inspiron 3", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), - }, - }, - { - .ident = "Dell Inspiron 3", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), - }, - }, - { - .ident = "Dell Precision 490", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, - "Precision WorkStation 490"), - }, - .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], - }, - { - .ident = "Dell Precision", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), - }, - }, - { - .ident = "Dell Vostro", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), - }, - }, - { - .ident = "Dell XPS421", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), - }, - }, - { - .ident = "Dell Studio", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), - }, - .driver_data = (void *)&i8k_config_data[DELL_STUDIO], - }, - { - .ident = "Dell XPS 13", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), - }, - .driver_data = (void *)&i8k_config_data[DELL_XPS], - }, - { - .ident = "Dell XPS M140", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), - }, - .driver_data = (void *)&i8k_config_data[DELL_XPS], - }, - { } -}; - -MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); - -/* - * Probe for the presence of a supported laptop. - */ -static int __init i8k_probe(void) -{ - const struct dmi_system_id *id; - int fan, ret; - - /* - * Get DMI information - */ - if (!dmi_check_system(i8k_dmi_table)) { - if (!ignore_dmi && !force) - return -ENODEV; - - pr_info("not running on a supported Dell system.\n"); - pr_info("vendor=%s, model=%s, version=%s\n", - i8k_get_dmi_data(DMI_SYS_VENDOR), - i8k_get_dmi_data(DMI_PRODUCT_NAME), - i8k_get_dmi_data(DMI_BIOS_VERSION)); - } - - strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), - sizeof(bios_version)); - - /* - * Get SMM Dell signature - */ - if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && - i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { - pr_err("unable to get SMM Dell signature\n"); - if (!force) - return -ENODEV; - } - - /* - * Set fan multiplier and maximal fan speed from dmi config - * Values specified in module parameters override values from dmi - */ - id = dmi_first_match(i8k_dmi_table); - if (id && id->driver_data) { - const struct i8k_config_data *conf = id->driver_data; - if (!fan_mult && conf->fan_mult) - fan_mult = conf->fan_mult; - if (!fan_max && conf->fan_max) - fan_max = conf->fan_max; - } - - i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ - i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); - - if (!fan_mult) { - /* - * Autodetect fan multiplier based on nominal rpm - * If fan reports rpm value too high then set multiplier to 1 - */ - for (fan = 0; fan < 2; ++fan) { - ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); - if (ret < 0) - continue; - if (ret > I8K_FAN_MAX_RPM) - i8k_fan_mult = 1; - break; - } - } else { - /* Fan multiplier was specified in module param or in dmi */ - i8k_fan_mult = fan_mult; - } - - return 0; -} - -static int __init i8k_init(void) -{ - struct proc_dir_entry *proc_i8k; - int err; - - /* Are we running on an supported laptop? */ - if (i8k_probe()) - return -ENODEV; - - /* Register the proc entry */ - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); - if (!proc_i8k) - return -ENOENT; - - err = i8k_init_hwmon(); - if (err) - goto exit_remove_proc; - - return 0; - - exit_remove_proc: - remove_proc_entry("i8k", NULL); - return err; -} - -static void __exit i8k_exit(void) -{ - hwmon_device_unregister(i8k_hwmon_dev); - remove_proc_entry("i8k", NULL); -} - -module_init(i8k_init); -module_exit(i8k_exit); diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 6c94147..1c3e458 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -155,6 +155,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o +obj-$(CONFIG_I8K) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c new file mode 100644 index 0000000..2b04e4f --- /dev/null +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -0,0 +1,1007 @@ +/* + * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops. + * + * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> + * + * Hwmon integration: + * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> + * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> + * Copyright (C) 2014, 2015 Pali Rohár <pali.rohar@gmail.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, 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. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/delay.h> +#include <linux/module.h> +#include <linux/types.h> +#include <linux/init.h> +#include <linux/proc_fs.h> +#include <linux/seq_file.h> +#include <linux/dmi.h> +#include <linux/capability.h> +#include <linux/mutex.h> +#include <linux/hwmon.h> +#include <linux/hwmon-sysfs.h> +#include <linux/uaccess.h> +#include <linux/io.h> +#include <linux/sched.h> + +#include <linux/i8k.h> + +#define I8K_SMM_FN_STATUS 0x0025 +#define I8K_SMM_POWER_STATUS 0x0069 +#define I8K_SMM_SET_FAN 0x01a3 +#define I8K_SMM_GET_FAN 0x00a3 +#define I8K_SMM_GET_SPEED 0x02a3 +#define I8K_SMM_GET_FAN_TYPE 0x03a3 +#define I8K_SMM_GET_NOM_SPEED 0x04a3 +#define I8K_SMM_GET_TEMP 0x10a3 +#define I8K_SMM_GET_TEMP_TYPE 0x11a3 +#define I8K_SMM_GET_DELL_SIG1 0xfea3 +#define I8K_SMM_GET_DELL_SIG2 0xffa3 + +#define I8K_FAN_MULT 30 +#define I8K_FAN_MAX_RPM 30000 +#define I8K_MAX_TEMP 127 + +#define I8K_FN_NONE 0x00 +#define I8K_FN_UP 0x01 +#define I8K_FN_DOWN 0x02 +#define I8K_FN_MUTE 0x04 +#define I8K_FN_MASK 0x07 +#define I8K_FN_SHIFT 8 + +#define I8K_POWER_AC 0x05 +#define I8K_POWER_BATTERY 0x01 + +static DEFINE_MUTEX(i8k_mutex); +static char bios_version[4]; +static struct device *i8k_hwmon_dev; +static u32 i8k_hwmon_flags; +static uint i8k_fan_mult = I8K_FAN_MULT; +static uint i8k_pwm_mult; +static uint i8k_fan_max = I8K_FAN_HIGH; + +#define I8K_HWMON_HAVE_TEMP1 (1 << 0) +#define I8K_HWMON_HAVE_TEMP2 (1 << 1) +#define I8K_HWMON_HAVE_TEMP3 (1 << 2) +#define I8K_HWMON_HAVE_TEMP4 (1 << 3) +#define I8K_HWMON_HAVE_FAN1 (1 << 4) +#define I8K_HWMON_HAVE_FAN2 (1 << 5) + +MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); +MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); +MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("i8k"); + +static bool force; +module_param(force, bool, 0); +MODULE_PARM_DESC(force, "Force loading without checking for supported models"); + +static bool ignore_dmi; +module_param(ignore_dmi, bool, 0); +MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); + +static bool restricted; +module_param(restricted, bool, 0); +MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); + +static bool power_status; +module_param(power_status, bool, 0600); +MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); + +static uint fan_mult; +module_param(fan_mult, uint, 0); +MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); + +static uint fan_max; +module_param(fan_max, uint, 0); +MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); + +static int i8k_open_fs(struct inode *inode, struct file *file); +static long i8k_ioctl(struct file *, unsigned int, unsigned long); + +static const struct file_operations i8k_fops = { + .owner = THIS_MODULE, + .open = i8k_open_fs, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .unlocked_ioctl = i8k_ioctl, +}; + +struct smm_regs { + unsigned int eax; + unsigned int ebx __packed; + unsigned int ecx __packed; + unsigned int edx __packed; + unsigned int esi __packed; + unsigned int edi __packed; +}; + +static inline const char *i8k_get_dmi_data(int field) +{ + const char *dmi_data = dmi_get_system_info(field); + + return dmi_data && *dmi_data ? dmi_data : "?"; +} + +/* + * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. + */ +static int i8k_smm(struct smm_regs *regs) +{ + int rc; + int eax = regs->eax; + cpumask_var_t old_mask; + + /* SMM requires CPU 0 */ + if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) + return -ENOMEM; + cpumask_copy(old_mask, ¤t->cpus_allowed); + rc = set_cpus_allowed_ptr(current, cpumask_of(0)); + if (rc) + goto out; + if (smp_processor_id() != 0) { + rc = -EBUSY; + goto out; + } + +#if defined(CONFIG_X86_64) + asm volatile("pushq %%rax\n\t" + "movl 0(%%rax),%%edx\n\t" + "pushq %%rdx\n\t" + "movl 4(%%rax),%%ebx\n\t" + "movl 8(%%rax),%%ecx\n\t" + "movl 12(%%rax),%%edx\n\t" + "movl 16(%%rax),%%esi\n\t" + "movl 20(%%rax),%%edi\n\t" + "popq %%rax\n\t" + "out %%al,$0xb2\n\t" + "out %%al,$0x84\n\t" + "xchgq %%rax,(%%rsp)\n\t" + "movl %%ebx,4(%%rax)\n\t" + "movl %%ecx,8(%%rax)\n\t" + "movl %%edx,12(%%rax)\n\t" + "movl %%esi,16(%%rax)\n\t" + "movl %%edi,20(%%rax)\n\t" + "popq %%rdx\n\t" + "movl %%edx,0(%%rax)\n\t" + "pushfq\n\t" + "popq %%rax\n\t" + "andl $1,%%eax\n" + : "=a"(rc) + : "a"(regs) + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); +#else + asm volatile("pushl %%eax\n\t" + "movl 0(%%eax),%%edx\n\t" + "push %%edx\n\t" + "movl 4(%%eax),%%ebx\n\t" + "movl 8(%%eax),%%ecx\n\t" + "movl 12(%%eax),%%edx\n\t" + "movl 16(%%eax),%%esi\n\t" + "movl 20(%%eax),%%edi\n\t" + "popl %%eax\n\t" + "out %%al,$0xb2\n\t" + "out %%al,$0x84\n\t" + "xchgl %%eax,(%%esp)\n\t" + "movl %%ebx,4(%%eax)\n\t" + "movl %%ecx,8(%%eax)\n\t" + "movl %%edx,12(%%eax)\n\t" + "movl %%esi,16(%%eax)\n\t" + "movl %%edi,20(%%eax)\n\t" + "popl %%edx\n\t" + "movl %%edx,0(%%eax)\n\t" + "lahf\n\t" + "shrl $8,%%eax\n\t" + "andl $1,%%eax\n" + : "=a"(rc) + : "a"(regs) + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); +#endif + if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) + rc = -EINVAL; + +out: + set_cpus_allowed_ptr(current, old_mask); + free_cpumask_var(old_mask); + return rc; +} + +/* + * Read the Fn key status. + */ +static int i8k_get_fn_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { + case I8K_FN_UP: + return I8K_VOL_UP; + case I8K_FN_DOWN: + return I8K_VOL_DOWN; + case I8K_FN_MUTE: + return I8K_VOL_MUTE; + default: + return 0; + } +} + +/* + * Read the power status. + */ +static int i8k_get_power_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; +} + +/* + * Read the fan status. + */ +static int i8k_get_fan_status(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the fan speed in RPM. + */ +static int i8k_get_fan_speed(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; +} + +/* + * Read the fan type. + */ +static int i8k_get_fan_type(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the fan nominal rpm for specific fan speed. + */ +static int i8k_get_fan_nominal_speed(int fan, int speed) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; + + regs.ebx = (fan & 0xff) | (speed << 8); + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; +} + +/* + * Set the fan speed (off, low, high). Returns the new fan status. + */ +static int i8k_set_fan(int fan, int speed) +{ + struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; + + speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); + regs.ebx = (fan & 0xff) | (speed << 8); + + return i8k_smm(®s) ? : i8k_get_fan_status(fan); +} + +static int i8k_get_temp_type(int sensor) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; + + regs.ebx = sensor & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the cpu temperature. + */ +static int _i8k_get_temp(int sensor) +{ + struct smm_regs regs = { + .eax = I8K_SMM_GET_TEMP, + .ebx = sensor & 0xff, + }; + + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +static int i8k_get_temp(int sensor) +{ + int temp = _i8k_get_temp(sensor); + + /* + * Sometimes the temperature sensor returns 0x99, which is out of range. + * In this case we retry (once) before returning an error. + # 1003655137 00000058 00005a4b + # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees + # 1003655139 00000054 00005c52 + */ + if (temp == 0x99) { + msleep(100); + temp = _i8k_get_temp(sensor); + } + /* + * Return -ENODATA for all invalid temperatures. + * + * Known instances are the 0x99 value as seen above as well as + * 0xc1 (193), which may be returned when trying to read the GPU + * temperature if the system supports a GPU and it is currently + * turned off. + */ + if (temp > I8K_MAX_TEMP) + return -ENODATA; + + return temp; +} + +static int i8k_get_dell_signature(int req_fn) +{ + struct smm_regs regs = { .eax = req_fn, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; +} + +static int +i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) +{ + int val = 0; + int speed; + unsigned char buff[16]; + int __user *argp = (int __user *)arg; + + if (!argp) + return -EINVAL; + + switch (cmd) { + case I8K_BIOS_VERSION: + val = (bios_version[0] << 16) | + (bios_version[1] << 8) | bios_version[2]; + break; + + case I8K_MACHINE_ID: + memset(buff, 0, 16); + strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + sizeof(buff)); + break; + + case I8K_FN_STATUS: + val = i8k_get_fn_status(); + break; + + case I8K_POWER_STATUS: + val = i8k_get_power_status(); + break; + + case I8K_GET_TEMP: + val = i8k_get_temp(0); + break; + + case I8K_GET_SPEED: + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + val = i8k_get_fan_speed(val); + break; + + case I8K_GET_FAN: + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + val = i8k_get_fan_status(val); + break; + + case I8K_SET_FAN: + if (restricted && !capable(CAP_SYS_ADMIN)) + return -EPERM; + + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + if (copy_from_user(&speed, argp + 1, sizeof(int))) + return -EFAULT; + + val = i8k_set_fan(val, speed); + break; + + default: + return -EINVAL; + } + + if (val < 0) + return val; + + switch (cmd) { + case I8K_BIOS_VERSION: + if (copy_to_user(argp, &val, 4)) + return -EFAULT; + + break; + case I8K_MACHINE_ID: + if (copy_to_user(argp, buff, 16)) + return -EFAULT; + + break; + default: + if (copy_to_user(argp, &val, sizeof(int))) + return -EFAULT; + + break; + } + + return 0; +} + +static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) +{ + long ret; + + mutex_lock(&i8k_mutex); + ret = i8k_ioctl_unlocked(fp, cmd, arg); + mutex_unlock(&i8k_mutex); + + return ret; +} + +/* + * Print the information for /proc/i8k. + */ +static int i8k_proc_show(struct seq_file *seq, void *offset) +{ + int fn_key, cpu_temp, ac_power; + int left_fan, right_fan, left_speed, right_speed; + + cpu_temp = i8k_get_temp(0); /* 11100 µs */ + left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ + right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ + left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ + right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ + fn_key = i8k_get_fn_status(); /* 750 µs */ + if (power_status) + ac_power = i8k_get_power_status(); /* 14700 µs */ + else + ac_power = -1; + + /* + * Info: + * + * 1) Format version (this will change if format changes) + * 2) BIOS version + * 3) BIOS machine ID + * 4) Cpu temperature + * 5) Left fan status + * 6) Right fan status + * 7) Left fan speed + * 8) Right fan speed + * 9) AC power + * 10) Fn Key status + */ + return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", + I8K_PROC_FMT, + bios_version, + i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + cpu_temp, + left_fan, right_fan, left_speed, right_speed, + ac_power, fn_key); +} + +static int i8k_open_fs(struct inode *inode, struct file *file) +{ + return single_open(file, i8k_proc_show, NULL); +} + + +/* + * Hwmon interface + */ + +static ssize_t i8k_hwmon_show_temp_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + static const char * const labels[] = { + "CPU", + "GPU", + "SODIMM", + "Other", + "Ambient", + "Other", + }; + int index = to_sensor_dev_attr(devattr)->index; + int type; + + type = i8k_get_temp_type(index); + if (type < 0) + return type; + if (type >= ARRAY_SIZE(labels)) + type = ARRAY_SIZE(labels) - 1; + return sprintf(buf, "%s\n", labels[type]); +} + +static ssize_t i8k_hwmon_show_temp(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int temp; + + temp = i8k_get_temp(index); + if (temp < 0) + return temp; + return sprintf(buf, "%d\n", temp * 1000); +} + +static ssize_t i8k_hwmon_show_fan_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + static const char * const labels[] = { + "Processor Fan", + "Motherboard Fan", + "Video Fan", + "Power Supply Fan", + "Chipset Fan", + "Other Fan", + }; + int index = to_sensor_dev_attr(devattr)->index; + bool dock = false; + int type; + + type = i8k_get_fan_type(index); + if (type < 0) + return type; + + if (type & 0x10) { + dock = true; + type &= 0x0F; + } + + if (type >= ARRAY_SIZE(labels)) + type = (ARRAY_SIZE(labels) - 1); + + return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); +} + +static ssize_t i8k_hwmon_show_fan(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int fan_speed; + + fan_speed = i8k_get_fan_speed(index); + if (fan_speed < 0) + return fan_speed; + return sprintf(buf, "%d\n", fan_speed); +} + +static ssize_t i8k_hwmon_show_pwm(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int status; + + status = i8k_get_fan_status(index); + if (status < 0) + return -EIO; + return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); +} + +static ssize_t i8k_hwmon_set_pwm(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int index = to_sensor_dev_attr(attr)->index; + unsigned long val; + int err; + + err = kstrtoul(buf, 10, &val); + if (err) + return err; + val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); + + mutex_lock(&i8k_mutex); + err = i8k_set_fan(index, val); + mutex_unlock(&i8k_mutex); + + return err < 0 ? -EIO : count; +} + +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 0); +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); +static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 1); +static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); +static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 2); +static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); +static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 3); +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); +static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, + 0); +static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, + i8k_hwmon_set_pwm, 0); +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, + 1); +static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, + 1); +static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, + i8k_hwmon_set_pwm, 1); + +static struct attribute *i8k_attrs[] = { + &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ + &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ + &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ + &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ + &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ + &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ + &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ + &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ + &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ + &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ + &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ + &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ + &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ + &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ + NULL +}; + +static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, + int index) +{ + if (index >= 0 && index <= 1 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) + return 0; + if (index >= 2 && index <= 3 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) + return 0; + if (index >= 4 && index <= 5 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) + return 0; + if (index >= 6 && index <= 7 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) + return 0; + if (index >= 8 && index <= 10 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) + return 0; + if (index >= 11 && index <= 13 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) + return 0; + + return attr->mode; +} + +static const struct attribute_group i8k_group = { + .attrs = i8k_attrs, + .is_visible = i8k_is_visible, +}; +__ATTRIBUTE_GROUPS(i8k); + +static int __init i8k_init_hwmon(void) +{ + int err; + + i8k_hwmon_flags = 0; + + /* CPU temperature attributes, if temperature type is OK */ + err = i8k_get_temp_type(0); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; + /* check for additional temperature sensors */ + err = i8k_get_temp_type(1); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; + err = i8k_get_temp_type(2); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; + err = i8k_get_temp_type(3); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; + + /* First fan attributes, if fan type is OK */ + err = i8k_get_fan_type(0); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; + + /* Second fan attributes, if fan type is OK */ + err = i8k_get_fan_type(1); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; + + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, + i8k_groups); + if (IS_ERR(i8k_hwmon_dev)) { + err = PTR_ERR(i8k_hwmon_dev); + i8k_hwmon_dev = NULL; + pr_err("hwmon registration failed (%d)\n", err); + return err; + } + return 0; +} + +struct i8k_config_data { + uint fan_mult; + uint fan_max; +}; + +enum i8k_configs { + DELL_LATITUDE_D520, + DELL_PRECISION_490, + DELL_STUDIO, + DELL_XPS, +}; + +static const struct i8k_config_data i8k_config_data[] = { + [DELL_LATITUDE_D520] = { + .fan_mult = 1, + .fan_max = I8K_FAN_TURBO, + }, + [DELL_PRECISION_490] = { + .fan_mult = 1, + .fan_max = I8K_FAN_TURBO, + }, + [DELL_STUDIO] = { + .fan_mult = 1, + .fan_max = I8K_FAN_HIGH, + }, + [DELL_XPS] = { + .fan_mult = 1, + .fan_max = I8K_FAN_HIGH, + }, +}; + +static struct dmi_system_id i8k_dmi_table[] __initdata = { + { + .ident = "Dell Inspiron", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), + }, + }, + { + .ident = "Dell Latitude", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), + }, + }, + { + .ident = "Dell Inspiron 2", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), + }, + }, + { + .ident = "Dell Latitude D520", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), + }, + .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], + }, + { + .ident = "Dell Latitude 2", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), + }, + }, + { /* UK Inspiron 6400 */ + .ident = "Dell Inspiron 3", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), + }, + }, + { + .ident = "Dell Inspiron 3", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), + }, + }, + { + .ident = "Dell Precision 490", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, + "Precision WorkStation 490"), + }, + .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], + }, + { + .ident = "Dell Precision", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), + }, + }, + { + .ident = "Dell Vostro", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), + }, + }, + { + .ident = "Dell XPS421", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), + }, + }, + { + .ident = "Dell Studio", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), + }, + .driver_data = (void *)&i8k_config_data[DELL_STUDIO], + }, + { + .ident = "Dell XPS 13", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), + }, + .driver_data = (void *)&i8k_config_data[DELL_XPS], + }, + { + .ident = "Dell XPS M140", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), + }, + .driver_data = (void *)&i8k_config_data[DELL_XPS], + }, + { } +}; + +MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); + +/* + * Probe for the presence of a supported laptop. + */ +static int __init i8k_probe(void) +{ + const struct dmi_system_id *id; + int fan, ret; + + /* + * Get DMI information + */ + if (!dmi_check_system(i8k_dmi_table)) { + if (!ignore_dmi && !force) + return -ENODEV; + + pr_info("not running on a supported Dell system.\n"); + pr_info("vendor=%s, model=%s, version=%s\n", + i8k_get_dmi_data(DMI_SYS_VENDOR), + i8k_get_dmi_data(DMI_PRODUCT_NAME), + i8k_get_dmi_data(DMI_BIOS_VERSION)); + } + + strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), + sizeof(bios_version)); + + /* + * Get SMM Dell signature + */ + if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && + i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { + pr_err("unable to get SMM Dell signature\n"); + if (!force) + return -ENODEV; + } + + /* + * Set fan multiplier and maximal fan speed from dmi config + * Values specified in module parameters override values from dmi + */ + id = dmi_first_match(i8k_dmi_table); + if (id && id->driver_data) { + const struct i8k_config_data *conf = id->driver_data; + if (!fan_mult && conf->fan_mult) + fan_mult = conf->fan_mult; + if (!fan_max && conf->fan_max) + fan_max = conf->fan_max; + } + + i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ + i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); + + if (!fan_mult) { + /* + * Autodetect fan multiplier based on nominal rpm + * If fan reports rpm value too high then set multiplier to 1 + */ + for (fan = 0; fan < 2; ++fan) { + ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); + if (ret < 0) + continue; + if (ret > I8K_FAN_MAX_RPM) + i8k_fan_mult = 1; + break; + } + } else { + /* Fan multiplier was specified in module param or in dmi */ + i8k_fan_mult = fan_mult; + } + + return 0; +} + +static int __init i8k_init(void) +{ + struct proc_dir_entry *proc_i8k; + int err; + + /* Are we running on an supported laptop? */ + if (i8k_probe()) + return -ENODEV; + + /* Register the proc entry */ + proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); + if (!proc_i8k) + return -ENOENT; + + err = i8k_init_hwmon(); + if (err) + goto exit_remove_proc; + + return 0; + + exit_remove_proc: + remove_proc_entry("i8k", NULL); + return err; +} + +static void __exit i8k_exit(void) +{ + hwmon_device_unregister(i8k_hwmon_dev); + remove_proc_entry("i8k", NULL); +} + +module_init(i8k_init); +module_exit(i8k_exit); -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH v2 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-29 12:57 ` Pali Rohár @ 2015-03-29 12:57 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-29 12:57 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBwYXRjaCBzcGxpdHMgQ09ORklHX0k4SyBjb21waWxlIG9wdGlvbiB0byBTRU5TT1JTX0RF TExfU01NIGFuZCBDT05GSUdfSThLLgpPcHRpb24gU0VOU09SU19ERUxMX1NNTSBpcyBub3cgdXNl ZCB0byBlbmFibGUgY29tcGlsYXRpb24gb2YgZGVsbC1zbW0taHdtb24KZHJpdmVyIGFuZCBvbGQg Q09ORklHX0k4SyBvcHRpb24gdG8gZW5hYmxlIC9wcm9jL2k4ayBpbnRlcmZhY2UgaW4gZHJpdmVy LgoKU28gdGhpcyBjaGFuZ2UgYWxsb3dzIHRvIGNvbXBpbGUgZGVsbC1zbW0taHdtb24gZHJpdmVy IHdpdGhvdXQgbGVnYWN5IC9wcm9jL2k4awppbnRlcmZhY2Ugd2hpY2ggaXMgbmVlZGVkIG9ubHkg Zm9yIG9sZCBEZWxsIEluc3BpcmlvbiBtb2RlbHMgb3IgZm9yIHVzZXJzcGFjZQppOGt1dGlscyBw YWNrYWdlLgoKRm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2hlbiBDT05GSUdfSThLIGlzIGVu YWJsZWQgdGhlbiBhbHNvIFNFTlNPUlNfREVMTF9TTU0KaXMgZW5hYmxlZCBhbmQgc28gZHJpdmVy IGRlbGwtc21tLWh3bW9uICh3aXRoIC9wcm9jL2k4aykgaXMgY29tcGlsZWQuCgpTaWduZWQtb2Zm LWJ5OiBQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Ci0tLQogYXJjaC94ODYvS2Nv bmZpZyAgICAgICAgICAgICAgIHwgICAyNSArKystLS0tCiBkcml2ZXJzL2h3bW9uL0tjb25maWcg ICAgICAgICAgfCAgIDExICsrKwogZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgIHwgICAg MiArLQogZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIHwgIDE1MCArKysrKysrKysrKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tCiA0IGZpbGVzIGNoYW5nZWQsIDEwNiBpbnNlcnRp b25zKCspLCA4MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9LY29uZmlnIGIv YXJjaC94ODYvS2NvbmZpZwppbmRleCBiN2QzMWNhLi4wZjczYWZkIDEwMDY0NAotLS0gYS9hcmNo L3g4Ni9LY29uZmlnCisrKyBiL2FyY2gveDg2L0tjb25maWcKQEAgLTEwNjMsMjQgKzEwNjMsMTkg QEAgY29uZmlnIFRPU0hJQkEKIAkgIFNheSBOIG90aGVyd2lzZS4KIAogY29uZmlnIEk4SwotCXRy aXN0YXRlICJEZWxsIGxhcHRvcCBzdXBwb3J0IgorCXRyaXN0YXRlICJEZWxsIGk4ayBsZWdhY3kg bGFwdG9wIHN1cHBvcnQiCiAJc2VsZWN0IEhXTU9OCisJc2VsZWN0IFNFTlNPUlNfREVMTF9TTU0K IAktLS1oZWxwLS0tCi0JICBUaGlzIGFkZHMgYSBkcml2ZXIgdG8gc2FmZWx5IGFjY2VzcyB0aGUg U3lzdGVtIE1hbmFnZW1lbnQgTW9kZQotCSAgb2YgdGhlIENQVSBvbiB0aGUgRGVsbCBJbnNwaXJv biA4MDAwLiBUaGUgU3lzdGVtIE1hbmFnZW1lbnQgTW9kZQotCSAgaXMgdXNlZCB0byByZWFkIGNw dSB0ZW1wZXJhdHVyZSBhbmQgY29vbGluZyBmYW4gc3RhdHVzIGFuZCB0bwotCSAgY29udHJvbCB0 aGUgZmFucyBvbiB0aGUgSThLIHBvcnRhYmxlcy4KKwkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgbGVn YWN5IC9wcm9jL2k4ayB1c2Vyc3BhY2UgaW50ZXJmYWNlIGluIGh3bW9uCisJICBkZWxsLXNtbS1o d21vbiBkcml2ZXIuIENoYXJhY3RlciBmaWxlIC9wcm9jL2k4ayByZXBvcnRzIGJpb3MgdmVyc2lv biwKKwkgIHRlbXBlcmF0dXJlIGFuZCBhbGxvd3MgY29udHJvbGxpbmcgZmFuIHNwZWVkcyBvZiBE ZWxsIGxhcHRvcHMgdmlhCisJICBTeXN0ZW0gTWFuYWdlbWVudCBNb2RlLiBGb3Igb2xkIERlbGwg bGFwdG9wcyAobGlrZSBEZWxsIEluc3Bpcm9uIDgwMDApCisJICBpdCByZXBvcnRzIGFsc28gcG93 ZXIgYW5kIGhvdGtleSBzdGF0dXMuIEZvciBmYW4gc3BlZWQgY29udHJvbCBpcworCSAgbmVlZGVk IHVzZXJzcGFjZSBwYWNrYWdlIGk4a3V0aWxzLgogCi0JICBUaGlzIGRyaXZlciBoYXMgYmVlbiB0 ZXN0ZWQgb25seSBvbiB0aGUgSW5zcGlyb24gODAwMCBidXQgaXQgbWF5Ci0JICBhbHNvIHdvcmsg d2l0aCBvdGhlciBEZWxsIGxhcHRvcHMuIFlvdSBjYW4gZm9yY2UgbG9hZGluZyBvbiBvdGhlcgot CSAgbW9kZWxzIGJ5IHBhc3NpbmcgdGhlIHBhcmFtZXRlciBgZm9yY2U9MScgdG8gdGhlIG1vZHVs ZS4gVXNlIGF0Ci0JICB5b3VyIG93biByaXNrLgotCi0JICBGb3IgaW5mb3JtYXRpb24gb24gdXRp bGl0aWVzIHRvIG1ha2UgdXNlIG9mIHRoaXMgZHJpdmVyIHNlZSB0aGUKLQkgIEk4SyBMaW51eCB1 dGlsaXRpZXMgd2ViIHNpdGUgYXQ6Ci0JICA8aHR0cDovL3Blb3BsZS5kZWJpYW4ub3JnL35kei9p OGsvPgotCi0JICBTYXkgWSBpZiB5b3UgaW50ZW5kIHRvIHJ1biB0aGlzIGtlcm5lbCBvbiBhIERl bGwgSW5zcGlyb24gODAwMC4KKwkgIFNheSBZIGlmIHlvdSBpbnRlbmQgdG8gcnVuIHRoaXMga2Vy bmVsIG9uIG9sZCBEZWxsIGxhcHRvcHMgb3Igd2FudCB0bworCSAgdXNlIHVzZXJzcGFjZSBwYWNr YWdlIGk4a3V0aWxzLgogCSAgU2F5IE4gb3RoZXJ3aXNlLgogCiBjb25maWcgWDg2X1JFQk9PVEZJ WFVQUwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21vbi9L Y29uZmlnCmluZGV4IDExMGZhZGUuLjkwOTA3OTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24v S2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTM3MSw2ICszNzEsMTcgQEAg Y29uZmlnIFNFTlNPUlNfRFMxNjIxCiAJICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBh cyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCiAJICB3aWxsIGJlIGNhbGxlZCBkczE2MjEu CiAKK2NvbmZpZyBTRU5TT1JTX0RFTExfU01NCisJdHJpc3RhdGUgIkRlbGwgbGFwdG9wIFNNTSBC SU9TIGh3bW9uIGRyaXZlciIKKwlkZXBlbmRzIG9uIFg4NiAmJiBETUkKKwloZWxwCisJICBUaGlz IGh3bW9uIGRyaXZlciBhZGRzIHN1cHBvcnQgZm9yIHJlcG9ydGluZyB0ZW1wZXJhdHVyZSBvZiBk aWZmZXJlbnQKKwkgIHNlbnNvcnMgYW5kIGNvbnRyb2xzIHRoZSBmYW5zIG9uIERlbGwgbGFwdG9w cyB2aWEgU3lzdGVtIE1hbmFnZW1lbnQKKwkgIE1vZGUgcHJvdmlkZWQgYnkgRGVsbCBCSU9TLgor CisJICBXaGVuIG9wdGlvbiBJOEsgaXMgYWxzbyBlbmFibGVkIHRoaXMgZHJpdmVyIHByb3ZpZGVz IGxlZ2FjeSAvcHJvYy9pOGsKKwkgIHVzZXJzcGFjZSBpbnRlcmZhY2UgZm9yIGk4a3V0aWxzIHBh Y2thZ2UuCisKIGNvbmZpZyBTRU5TT1JTX0RBOTA1Ml9BREMKIAl0cmlzdGF0ZSAiRGlhbG9nIERB OTA1Mi9EQTkwNTMgQURDIgogCWRlcGVuZHMgb24gUE1JQ19EQTkwNTIKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCmluZGV4IDFjM2U0 NTguLjg5YTAwZTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKKysrIGIvZHJp dmVycy9od21vbi9NYWtlZmlsZQpAQCAtNDksNiArNDksNyBAQCBvYmotJChDT05GSUdfU0VOU09S U19BVFhQMSkJKz0gYXR4cDEubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfQ09SRVRFTVApCSs9IGNv cmV0ZW1wLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0RBOTA1Ml9BREMpKz0gZGE5MDUyLWh3bW9u Lm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0RBOTA1NSkrPSBkYTkwNTUtaHdtb24ubworb2JqLSQo Q09ORklHX1NFTlNPUlNfREVMTF9TTU0pCSs9IGRlbGwtc21tLWh3bW9uLm8KIG9iai0kKENPTkZJ R19TRU5TT1JTX0RNRTE3MzcpCSs9IGRtZTE3Mzcubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfRFM2 MjApCSs9IGRzNjIwLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0RTMTYyMSkJKz0gZHMxNjIxLm8K QEAgLTE1NSw3ICsxNTYsNiBAQCBvYmotJChDT05GSUdfU0VOU09SU19XODNMNzg1VFMpCSs9IHc4 M2w3ODV0cy5vCiBvYmotJChDT05GSUdfU0VOU09SU19XODNMNzg2TkcpCSs9IHc4M2w3ODZuZy5v CiBvYmotJChDT05GSUdfU0VOU09SU19XTTgzMVgpCSs9IHdtODMxeC1od21vbi5vCiBvYmotJChD T05GSUdfU0VOU09SU19XTTgzNTApCSs9IHdtODM1MC1od21vbi5vCi1vYmotJChDT05GSUdfSThL KQkJKz0gZGVsbC1zbW0taHdtb24ubwogCiBvYmotJChDT05GSUdfUE1CVVMpCQkrPSBwbWJ1cy8K IApkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIGIvZHJpdmVycy9o d21vbi9kZWxsLXNtbS1od21vbi5jCmluZGV4IDJiMDRlNGYuLjM3ODc5M2EgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYworKysgYi9kcml2ZXJzL2h3bW9uL2RlbGwt c21tLWh3bW9uLmMKQEAgLTgxLDcgKzgxLDcgQEAgc3RhdGljIHVpbnQgaThrX2Zhbl9tYXggPSBJ OEtfRkFOX0hJR0g7CiAKIE1PRFVMRV9BVVRIT1IoIk1hc3NpbW8gRGFsIFpvdHRvIChkekBkZWJp YW4ub3JnKSIpOwogTU9EVUxFX0FVVEhPUigiUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwu Y29tPiIpOwotTU9EVUxFX0RFU0NSSVBUSU9OKCJEcml2ZXIgZm9yIGFjY2Vzc2luZyBTTU0gQklP UyBvbiBEZWxsIGxhcHRvcHMiKTsKK01PRFVMRV9ERVNDUklQVElPTigiRGVsbCBsYXB0b3AgU01N IEJJT1MgaHdtb24gZHJpdmVyIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfQUxJ QVMoImk4ayIpOwogCkBAIC05Myw2ICs5Myw3IEBAIHN0YXRpYyBib29sIGlnbm9yZV9kbWk7CiBt b2R1bGVfcGFyYW0oaWdub3JlX2RtaSwgYm9vbCwgMCk7CiBNT0RVTEVfUEFSTV9ERVNDKGlnbm9y ZV9kbWksICJDb250aW51ZSBwcm9iaW5nIGhhcmR3YXJlIGV2ZW4gaWYgRE1JIGRhdGEgZG9lcyBu b3QgbWF0Y2giKTsKIAorI2lmIElTX0VOQUJMRUQoQ09ORklHX0k4SykKIHN0YXRpYyBib29sIHJl c3RyaWN0ZWQ7CiBtb2R1bGVfcGFyYW0ocmVzdHJpY3RlZCwgYm9vbCwgMCk7CiBNT0RVTEVfUEFS TV9ERVNDKHJlc3RyaWN0ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJp bGl0eSBzZXQiKTsKQEAgLTEwMCw2ICsxMDEsNyBAQCBNT0RVTEVfUEFSTV9ERVNDKHJlc3RyaWN0 ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJpbGl0eSBzZXQiKTsKIHN0 YXRpYyBib29sIHBvd2VyX3N0YXR1czsKIG1vZHVsZV9wYXJhbShwb3dlcl9zdGF0dXMsIGJvb2ws IDA2MDApOwogTU9EVUxFX1BBUk1fREVTQyhwb3dlcl9zdGF0dXMsICJSZXBvcnQgcG93ZXIgc3Rh dHVzIGluIC9wcm9jL2k4ayIpOworI2VuZGlmCiAKIHN0YXRpYyB1aW50IGZhbl9tdWx0OwogbW9k dWxlX3BhcmFtKGZhbl9tdWx0LCB1aW50LCAwKTsKQEAgLTEwOSwxOCArMTExLDYgQEAgc3RhdGlj IHVpbnQgZmFuX21heDsKIG1vZHVsZV9wYXJhbShmYW5fbWF4LCB1aW50LCAwKTsKIE1PRFVMRV9Q QVJNX0RFU0MoZmFuX21heCwgIk1heGltdW0gY29uZmlndXJhYmxlIGZhbiBzcGVlZCAoZGVmYXVs dDogYXV0b2RldGVjdCkiKTsKIAotc3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5vZGUg Kmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSk7Ci1zdGF0aWMgbG9uZyBpOGtfaW9jdGwoc3RydWN0 IGZpbGUgKiwgdW5zaWduZWQgaW50LCB1bnNpZ25lZCBsb25nKTsKLQotc3RhdGljIGNvbnN0IHN0 cnVjdCBmaWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7Ci0JLm93bmVyCQk9IFRISVNfTU9EVUxF LAotCS5vcGVuCQk9IGk4a19vcGVuX2ZzLAotCS5yZWFkCQk9IHNlcV9yZWFkLAotCS5sbHNlZWsJ CT0gc2VxX2xzZWVrLAotCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVhc2UsCi0JLnVubG9ja2VkX2lv Y3RsCT0gaThrX2lvY3RsLAotfTsKLQogc3RydWN0IHNtbV9yZWdzIHsKIAl1bnNpZ25lZCBpbnQg ZWF4OwogCXVuc2lnbmVkIGludCBlYnggX19wYWNrZWQ7CkBAIC0yMjEsNDUgKzIxMSw2IEBAIG91 dDoKIH0KIAogLyoKLSAqIFJlYWQgdGhlIEZuIGtleSBzdGF0dXMuCi0gKi8KLXN0YXRpYyBpbnQg aThrX2dldF9mbl9zdGF0dXModm9pZCkKLXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVh eCA9IEk4S19TTU1fRk5fU1RBVFVTLCB9OwotCWludCByYzsKLQotCXJjID0gaThrX3NtbSgmcmVn cyk7Ci0JaWYgKHJjIDwgMCkKLQkJcmV0dXJuIHJjOwotCi0Jc3dpdGNoICgocmVncy5lYXggPj4g SThLX0ZOX1NISUZUKSAmIEk4S19GTl9NQVNLKSB7Ci0JY2FzZSBJOEtfRk5fVVA6Ci0JCXJldHVy biBJOEtfVk9MX1VQOwotCWNhc2UgSThLX0ZOX0RPV046Ci0JCXJldHVybiBJOEtfVk9MX0RPV047 Ci0JY2FzZSBJOEtfRk5fTVVURToKLQkJcmV0dXJuIEk4S19WT0xfTVVURTsKLQlkZWZhdWx0Ogot CQlyZXR1cm4gMDsKLQl9Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBwb3dlciBzdGF0dXMuCi0gKi8K LXN0YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9pZCkKLXsKLQlzdHJ1Y3Qgc21tX3Jl Z3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fUE9XRVJfU1RBVFVTLCB9OwotCWludCByYzsKLQot CXJjID0gaThrX3NtbSgmcmVncyk7Ci0JaWYgKHJjIDwgMCkKLQkJcmV0dXJuIHJjOwotCi0JcmV0 dXJuIChyZWdzLmVheCAmIDB4ZmYpID09IEk4S19QT1dFUl9BQyA/IEk4S19BQyA6IEk4S19CQVRU RVJZOwotfQotCi0vKgogICogUmVhZCB0aGUgZmFuIHN0YXR1cy4KICAqLwogc3RhdGljIGludCBp OGtfZ2V0X2Zhbl9zdGF0dXMoaW50IGZhbikKQEAgLTM3OCw2ICszMjksNTEgQEAgc3RhdGljIGlu dCBpOGtfZ2V0X2RlbGxfc2lnbmF0dXJlKGludCByZXFfZm4pCiAJcmV0dXJuIHJlZ3MuZWF4ID09 IDExNDU2NTE1MjcgJiYgcmVncy5lZHggPT0gMTE0NTM5MjIwNCA/IDAgOiAtMTsKIH0KIAorI2lm IElTX0VOQUJMRUQoQ09ORklHX0k4SykKKworLyoKKyAqIFJlYWQgdGhlIEZuIGtleSBzdGF0dXMu CisgKi8KK3N0YXRpYyBpbnQgaThrX2dldF9mbl9zdGF0dXModm9pZCkKK3sKKwlzdHJ1Y3Qgc21t X3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fRk5fU1RBVFVTLCB9OworCWludCByYzsKKwor CXJjID0gaThrX3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJcmV0dXJuIHJjOworCisJc3dp dGNoICgocmVncy5lYXggPj4gSThLX0ZOX1NISUZUKSAmIEk4S19GTl9NQVNLKSB7CisJY2FzZSBJ OEtfRk5fVVA6CisJCXJldHVybiBJOEtfVk9MX1VQOworCWNhc2UgSThLX0ZOX0RPV046CisJCXJl dHVybiBJOEtfVk9MX0RPV047CisJY2FzZSBJOEtfRk5fTVVURToKKwkJcmV0dXJuIEk4S19WT0xf TVVURTsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9Cit9CisKKy8qCisgKiBSZWFkIHRoZSBw b3dlciBzdGF0dXMuCisgKi8KK3N0YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9pZCkK K3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fUE9XRVJfU1RBVFVT LCB9OworCWludCByYzsKKworCXJjID0gaThrX3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJ cmV0dXJuIHJjOworCisJcmV0dXJuIChyZWdzLmVheCAmIDB4ZmYpID09IEk4S19QT1dFUl9BQyA/ IEk4S19BQyA6IEk4S19CQVRURVJZOworfQorCisvKgorICogUHJvY2ZzIGludGVyZmFjZQorICov CisKIHN0YXRpYyBpbnQKIGk4a19pb2N0bF91bmxvY2tlZChzdHJ1Y3QgZmlsZSAqZnAsIHVuc2ln bmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQogewpAQCAtNTI2LDYgKzUyMiwzNyBAQCBz dGF0aWMgaW50IGk4a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpm aWxlKQogCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBpOGtfcHJvY19zaG93LCBOVUxMKTsKIH0K IAorc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7CisJLm93 bmVyCQk9IFRISVNfTU9EVUxFLAorCS5vcGVuCQk9IGk4a19vcGVuX2ZzLAorCS5yZWFkCQk9IHNl cV9yZWFkLAorCS5sbHNlZWsJCT0gc2VxX2xzZWVrLAorCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVh c2UsCisJLnVubG9ja2VkX2lvY3RsCT0gaThrX2lvY3RsLAorfTsKKworc3RhdGljIHZvaWQgX19p bml0IGk4a19pbml0X3Byb2Nmcyh2b2lkKQoreworCS8qIFJlZ2lzdGVyIHRoZSBwcm9jIGVudHJ5 ICovCisJcHJvY19jcmVhdGUoImk4ayIsIDAsIE5VTEwsICZpOGtfZm9wcyk7Cit9CisKK3N0YXRp YyB2b2lkIF9fZXhpdCBpOGtfZXhpdF9wcm9jZnModm9pZCkKK3sKKwlyZW1vdmVfcHJvY19lbnRy eSgiaThrIiwgTlVMTCk7Cit9CisKKyNlbHNlCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2luaXQg aThrX2luaXRfcHJvY2ZzKHZvaWQpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2V4aXQg aThrX2V4aXRfcHJvY2ZzKHZvaWQpCit7Cit9CisKKyNlbmRpZgogCiAvKgogICogSHdtb24gaW50 ZXJmYWNlCkBAIC03NDgsOCArNzc1LDggQEAgc3RhdGljIGludCBfX2luaXQgaThrX2luaXRfaHdt b24odm9pZCkKIAlpZiAoZXJyID49IDApCiAJCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05f SEFWRV9GQU4yOwogCi0JaThrX2h3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRo X2dyb3VwcyhOVUxMLCAiaThrIiwgTlVMTCwKLQkJCQkJCQkgIGk4a19ncm91cHMpOworCWk4a19o d21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoTlVMTCwgImRlbGwt c21tIiwKKwkJCQkJCQkgIE5VTEwsIGk4a19ncm91cHMpOwogCWlmIChJU19FUlIoaThrX2h3bW9u X2RldikpIHsKIAkJZXJyID0gUFRSX0VSUihpOGtfaHdtb25fZGV2KTsKIAkJaThrX2h3bW9uX2Rl diA9IE5VTEw7CkBAIC05NzQsMzMgKzEwMDEsMjQgQEAgc3RhdGljIGludCBfX2luaXQgaThrX3By b2JlKHZvaWQpCiAKIHN0YXRpYyBpbnQgX19pbml0IGk4a19pbml0KHZvaWQpCiB7Ci0Jc3RydWN0 IHByb2NfZGlyX2VudHJ5ICpwcm9jX2k4azsKIAlpbnQgZXJyOwogCiAJLyogQXJlIHdlIHJ1bm5p bmcgb24gYW4gc3VwcG9ydGVkIGxhcHRvcD8gKi8KIAlpZiAoaThrX3Byb2JlKCkpCiAJCXJldHVy biAtRU5PREVWOwogCi0JLyogUmVnaXN0ZXIgdGhlIHByb2MgZW50cnkgKi8KLQlwcm9jX2k4ayA9 IHByb2NfY3JlYXRlKCJpOGsiLCAwLCBOVUxMLCAmaThrX2ZvcHMpOwotCWlmICghcHJvY19pOGsp Ci0JCXJldHVybiAtRU5PRU5UOwotCiAJZXJyID0gaThrX2luaXRfaHdtb24oKTsKIAlpZiAoZXJy KQotCQlnb3RvIGV4aXRfcmVtb3ZlX3Byb2M7CisJCXJldHVybiBlcnI7CiAKKwlpOGtfaW5pdF9w cm9jZnMoKTsKIAlyZXR1cm4gMDsKLQotIGV4aXRfcmVtb3ZlX3Byb2M6Ci0JcmVtb3ZlX3Byb2Nf ZW50cnkoImk4ayIsIE5VTEwpOwotCXJldHVybiBlcnI7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhp dCBpOGtfZXhpdCh2b2lkKQogewogCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGk4a19od21vbl9k ZXYpOwotCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBOVUxMKTsKKwlpOGtfZXhpdF9wcm9jZnMo KTsKIH0KIAogbW9kdWxlX2luaXQoaThrX2luaXQpOwotLSAKMS43LjkuNQoKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBs aXN0CmxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3Jn L21haWxtYW4vbGlzdGluZm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH v2 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-03-29 12:57 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-03-29 12:57 UTC (permalink / raw) To: Guenter Roeck, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k interface which is needed only for old Dell Inspirion models or for userspace i8kutils package. For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- arch/x86/Kconfig | 25 +++---- drivers/hwmon/Kconfig | 11 +++ drivers/hwmon/Makefile | 2 +- drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ 4 files changed, 106 insertions(+), 82 deletions(-) diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index b7d31ca..0f73afd 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -1063,24 +1063,19 @@ config TOSHIBA Say N otherwise. config I8K - tristate "Dell laptop support" + tristate "Dell i8k legacy laptop support" select HWMON + select SENSORS_DELL_SMM ---help--- - This adds a driver to safely access the System Management Mode - of the CPU on the Dell Inspiron 8000. The System Management Mode - is used to read cpu temperature and cooling fan status and to - control the fans on the I8K portables. + This option enables legacy /proc/i8k userspace interface in hwmon + dell-smm-hwmon driver. Character file /proc/i8k reports bios version, + temperature and allows controlling fan speeds of Dell laptops via + System Management Mode. For old Dell laptops (like Dell Inspiron 8000) + it reports also power and hotkey status. For fan speed control is + needed userspace package i8kutils. - This driver has been tested only on the Inspiron 8000 but it may - also work with other Dell laptops. You can force loading on other - models by passing the parameter `force=1' to the module. Use at - your own risk. - - For information on utilities to make use of this driver see the - I8K Linux utilities web site at: - <http://people.debian.org/~dz/i8k/> - - Say Y if you intend to run this kernel on a Dell Inspiron 8000. + Say Y if you intend to run this kernel on old Dell laptops or want to + use userspace package i8kutils. Say N otherwise. config X86_REBOOTFIXUPS diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 110fade..9090790 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -371,6 +371,17 @@ config SENSORS_DS1621 This driver can also be built as a module. If so, the module will be called ds1621. +config SENSORS_DELL_SMM + tristate "Dell laptop SMM BIOS hwmon driver" + depends on X86 && DMI + help + This hwmon driver adds support for reporting temperature of different + sensors and controls the fans on Dell laptops via System Management + Mode provided by Dell BIOS. + + When option I8K is also enabled this driver provides legacy /proc/i8k + userspace interface for i8kutils package. + config SENSORS_DA9052_ADC tristate "Dialog DA9052/DA9053 ADC" depends on PMIC_DA9052 diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 1c3e458..89a00e9 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -49,6 +49,7 @@ obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o obj-$(CONFIG_SENSORS_CORETEMP) += coretemp.o obj-$(CONFIG_SENSORS_DA9052_ADC)+= da9052-hwmon.o obj-$(CONFIG_SENSORS_DA9055)+= da9055-hwmon.o +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o obj-$(CONFIG_SENSORS_DME1737) += dme1737.o obj-$(CONFIG_SENSORS_DS620) += ds620.o obj-$(CONFIG_SENSORS_DS1621) += ds1621.o @@ -155,7 +156,6 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o -obj-$(CONFIG_I8K) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c index 2b04e4f..378793a 100644 --- a/drivers/hwmon/dell-smm-hwmon.c +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -81,7 +81,7 @@ static uint i8k_fan_max = I8K_FAN_HIGH; MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); +MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS("i8k"); @@ -93,6 +93,7 @@ static bool ignore_dmi; module_param(ignore_dmi, bool, 0); MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); +#if IS_ENABLED(CONFIG_I8K) static bool restricted; module_param(restricted, bool, 0); MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); @@ -100,6 +101,7 @@ MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); static bool power_status; module_param(power_status, bool, 0600); MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); +#endif static uint fan_mult; module_param(fan_mult, uint, 0); @@ -109,18 +111,6 @@ static uint fan_max; module_param(fan_max, uint, 0); MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); -static int i8k_open_fs(struct inode *inode, struct file *file); -static long i8k_ioctl(struct file *, unsigned int, unsigned long); - -static const struct file_operations i8k_fops = { - .owner = THIS_MODULE, - .open = i8k_open_fs, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, - .unlocked_ioctl = i8k_ioctl, -}; - struct smm_regs { unsigned int eax; unsigned int ebx __packed; @@ -221,45 +211,6 @@ out: } /* - * Read the Fn key status. - */ -static int i8k_get_fn_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { - case I8K_FN_UP: - return I8K_VOL_UP; - case I8K_FN_DOWN: - return I8K_VOL_DOWN; - case I8K_FN_MUTE: - return I8K_VOL_MUTE; - default: - return 0; - } -} - -/* - * Read the power status. - */ -static int i8k_get_power_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; -} - -/* * Read the fan status. */ static int i8k_get_fan_status(int fan) @@ -378,6 +329,51 @@ static int i8k_get_dell_signature(int req_fn) return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; } +#if IS_ENABLED(CONFIG_I8K) + +/* + * Read the Fn key status. + */ +static int i8k_get_fn_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { + case I8K_FN_UP: + return I8K_VOL_UP; + case I8K_FN_DOWN: + return I8K_VOL_DOWN; + case I8K_FN_MUTE: + return I8K_VOL_MUTE; + default: + return 0; + } +} + +/* + * Read the power status. + */ +static int i8k_get_power_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; +} + +/* + * Procfs interface + */ + static int i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) { @@ -526,6 +522,37 @@ static int i8k_open_fs(struct inode *inode, struct file *file) return single_open(file, i8k_proc_show, NULL); } +static const struct file_operations i8k_fops = { + .owner = THIS_MODULE, + .open = i8k_open_fs, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .unlocked_ioctl = i8k_ioctl, +}; + +static void __init i8k_init_procfs(void) +{ + /* Register the proc entry */ + proc_create("i8k", 0, NULL, &i8k_fops); +} + +static void __exit i8k_exit_procfs(void) +{ + remove_proc_entry("i8k", NULL); +} + +#else + +static inline void __init i8k_init_procfs(void) +{ +} + +static inline void __exit i8k_exit_procfs(void) +{ +} + +#endif /* * Hwmon interface @@ -748,8 +775,8 @@ static int __init i8k_init_hwmon(void) if (err >= 0) i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, - i8k_groups); + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "dell-smm", + NULL, i8k_groups); if (IS_ERR(i8k_hwmon_dev)) { err = PTR_ERR(i8k_hwmon_dev); i8k_hwmon_dev = NULL; @@ -974,33 +1001,24 @@ static int __init i8k_probe(void) static int __init i8k_init(void) { - struct proc_dir_entry *proc_i8k; int err; /* Are we running on an supported laptop? */ if (i8k_probe()) return -ENODEV; - /* Register the proc entry */ - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); - if (!proc_i8k) - return -ENOENT; - err = i8k_init_hwmon(); if (err) - goto exit_remove_proc; + return err; + i8k_init_procfs(); return 0; - - exit_remove_proc: - remove_proc_entry("i8k", NULL); - return err; } static void __exit i8k_exit(void) { hwmon_device_unregister(i8k_hwmon_dev); - remove_proc_entry("i8k", NULL); + i8k_exit_procfs(); } module_init(i8k_init); -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-03-29 12:57 ` Pali Rohár @ 2015-04-28 12:38 ` Greg Kroah-Hartman -1 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-28 12:38 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Sun, Mar 29, 2015 at 02:57:39PM +0200, Pali Rohár wrote: > This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. > Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon > driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. > > So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k > interface which is needed only for old Dell Inspirion models or for userspace > i8kutils package. > > For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM > is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > arch/x86/Kconfig | 25 +++---- > drivers/hwmon/Kconfig | 11 +++ > drivers/hwmon/Makefile | 2 +- > drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ > 4 files changed, 106 insertions(+), 82 deletions(-) This doesn't apply to 4.1-rc1, so I can't apply this series now. Can you respin it and resend? thanks, greg k-h _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-04-28 12:38 ` Greg Kroah-Hartman 0 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-28 12:38 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Sun, Mar 29, 2015 at 02:57:39PM +0200, Pali Rohár wrote: > This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. > Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon > driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. > > So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k > interface which is needed only for old Dell Inspirion models or for userspace > i8kutils package. > > For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM > is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > arch/x86/Kconfig | 25 +++---- > drivers/hwmon/Kconfig | 11 +++ > drivers/hwmon/Makefile | 2 +- > drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ > 4 files changed, 106 insertions(+), 82 deletions(-) This doesn't apply to 4.1-rc1, so I can't apply this series now. Can you respin it and resend? thanks, greg k-h ^ permalink raw reply [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree 2015-04-28 12:38 ` Greg Kroah-Hartman @ 2015-04-29 11:41 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-29 11:41 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBjb21taXQgbW92ZXMgaThrIGRyaXZlciB0byBod21vbiB0cmVlIHVuZGVyIG5hbWUgZGVs bC1zbW0taHdtb24gd2hpY2ggaXMKYmV0dGVyIG5hbWUgdGhlbiBhYmJyZXZpYXRpb24gaThrLiBG b3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSBpcyBhZGRlZCBtYWNybwpNT0RVTEVfQUxJQVMoImk4 ayIpIHNvIG1vZHByb2JlIHdpbGwgbG9hZCBkcml2ZXIgYWxzbyBvbGQgbmFtZSBpOGsuIENPTkZJ R19JOEsKY29tcGlsZSBvcHRpb24gd2FzIG5vdCBjaGFuZ2VkLgoKVGhpcyBjb21taXQgYWxzbyBh ZGRzIG1lIGFzIG1haW50YWluZXIgb2YgdGhpcyBuZXcgZGVsbC1zbW0taHdtb24gZHJpdmVyIGFu ZApyZW1vdmUgR3VlbnRlciBSb2VjayBmcm9tIGxpc3Qgd2hvIGlzIGltcGxpY2l0IG1haW50YWlu ZXIgYWxsIGh3bW9uIGRyaXZlcnMuCgpTaWduZWQtb2ZmLWJ5OiBQYWxpIFJvaMOhciA8cGFsaS5y b2hhckBnbWFpbC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgIHwgICAg NCArLQogZHJpdmVycy9jaGFyL01ha2VmaWxlICAgICAgICAgIHwgICAgMSAtCiBkcml2ZXJzL2No YXIvaThrLmMgICAgICAgICAgICAgfCAxMDA3IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQogZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgIHwgICAgMSArCiBkcml2 ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMgfCAxMDA5ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgMTAxMiBpbnNlcnRpb25zKCspLCAx MDEwIGRlbGV0aW9ucygtKQogZGVsZXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY2hhci9pOGsuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwoKZGlmZiAt LWdpdCBhL01BSU5UQUlORVJTIGIvTUFJTlRBSU5FUlMKaW5kZXggMmU1YmJjMC4uMDE0YzE1ZiAx MDA2NDQKLS0tIGEvTUFJTlRBSU5FUlMKKysrIGIvTUFJTlRBSU5FUlMKQEAgLTMwNzcsOSArMzA3 Nyw5IEBAIFM6CU1haW50YWluZWQKIEY6CWRyaXZlcnMvcGxhdGZvcm0veDg2L2RlbGwtc21vODgw MC5jCiAKIERFTEwgTEFQVE9QIFNNTSBEUklWRVIKLU06CUd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJv ZWNrLXVzLm5ldD4KK006CVBhbGkgUm9ow6FyIDxwYWxpLnJvaGFyQGdtYWlsLmNvbT4KIFM6CU1h aW50YWluZWQKLUY6CWRyaXZlcnMvY2hhci9pOGsuYworRjoJZHJpdmVycy9od21vbi9kZWxsLXNt bS1od21vbi5jCiBGOglpbmNsdWRlL3VhcGkvbGludXgvaThrLmgKIAogREVMTCBTWVNURU1TIE1B TkFHRU1FTlQgQkFTRSBEUklWRVIgKGRjZGJhcykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9N YWtlZmlsZSBiL2RyaXZlcnMvY2hhci9NYWtlZmlsZQppbmRleCBkMDZjZGUyNi4uMWQ5Y2YwMCAx MDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvY2hhci9NYWtl ZmlsZQpAQCAtMzYsNyArMzYsNiBAQCBlbHNlCiAgIG9iai0kKENPTkZJR19OVlJBTSkJKz0gbnZy YW0ubwogZW5kaWYKIG9iai0kKENPTkZJR19UT1NISUJBKQkJKz0gdG9zaGliYS5vCi1vYmotJChD T05GSUdfSThLKQkJKz0gaThrLm8KIG9iai0kKENPTkZJR19EUzE2MjApCQkrPSBkczE2MjAubwog b2JqLSQoQ09ORklHX0hXX1JBTkRPTSkJCSs9IGh3X3JhbmRvbS8KIG9iai0kKENPTkZJR19QUERF VikJCSs9IHBwZGV2Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9pOGsuYyBiL2RyaXZlcnMv Y2hhci9pOGsuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTQzMDQ4Yi4uMDAwMDAw MAotLS0gYS9kcml2ZXJzL2NoYXIvaThrLmMKKysrIC9kZXYvbnVsbApAQCAtMSwxMDA3ICswLDAg QEAKLS8qCi0gKiBpOGsuYyAtLSBMaW51eCBkcml2ZXIgZm9yIGFjY2Vzc2luZyB0aGUgU01NIEJJ T1Mgb24gRGVsbCBsYXB0b3BzLgotICoKLSAqIENvcHlyaWdodCAoQykgMjAwMSAgTWFzc2ltbyBE YWwgWm90dG8gPGR6QGRlYmlhbi5vcmc+Ci0gKgotICogSHdtb24gaW50ZWdyYXRpb246Ci0gKiBD b3B5cmlnaHQgKEMpIDIwMTEgIEplYW4gRGVsdmFyZSA8amRlbHZhcmVAc3VzZS5kZT4KLSAqIENv cHlyaWdodCAoQykgMjAxMywgMjAxNCAgR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0 PgotICogQ29weXJpZ2h0IChDKSAyMDE0ICBQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5j b20+Ci0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKLSAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZQotICogRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pIGFu eQotICogbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQg aW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0Ci0gKiBXSVRIT1VUIEFOWSBX QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdO VQotICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICovCi0KLSNk ZWZpbmUgcHJfZm10KGZtdCkgS0JVSUxEX01PRE5BTUUgIjogIiBmbXQKLQotI2luY2x1ZGUgPGxp bnV4L2RlbGF5Lmg+Ci0jaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Ci0jaW5jbHVkZSA8bGludXgv dHlwZXMuaD4KLSNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Ci0jaW5jbHVkZSA8bGludXgvcHJvY19m cy5oPgotI2luY2x1ZGUgPGxpbnV4L3NlcV9maWxlLmg+Ci0jaW5jbHVkZSA8bGludXgvZG1pLmg+ Ci0jaW5jbHVkZSA8bGludXgvY2FwYWJpbGl0eS5oPgotI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+ Ci0jaW5jbHVkZSA8bGludXgvaHdtb24uaD4KLSNpbmNsdWRlIDxsaW51eC9od21vbi1zeXNmcy5o PgotI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KLSNpbmNsdWRlIDxsaW51eC9pby5oPgotI2lu Y2x1ZGUgPGxpbnV4L3NjaGVkLmg+Ci0KLSNpbmNsdWRlIDxsaW51eC9pOGsuaD4KLQotI2RlZmlu ZSBJOEtfU01NX0ZOX1NUQVRVUwkweDAwMjUKLSNkZWZpbmUgSThLX1NNTV9QT1dFUl9TVEFUVVMJ MHgwMDY5Ci0jZGVmaW5lIEk4S19TTU1fU0VUX0ZBTgkJMHgwMWEzCi0jZGVmaW5lIEk4S19TTU1f R0VUX0ZBTgkJMHgwMGEzCi0jZGVmaW5lIEk4S19TTU1fR0VUX1NQRUVECTB4MDJhMwotI2RlZmlu ZSBJOEtfU01NX0dFVF9GQU5fVFlQRQkweDAzYTMKLSNkZWZpbmUgSThLX1NNTV9HRVRfTk9NX1NQ RUVECTB4MDRhMwotI2RlZmluZSBJOEtfU01NX0dFVF9URU1QCTB4MTBhMwotI2RlZmluZSBJOEtf U01NX0dFVF9URU1QX1RZUEUJMHgxMWEzCi0jZGVmaW5lIEk4S19TTU1fR0VUX0RFTExfU0lHMQkw eGZlYTMKLSNkZWZpbmUgSThLX1NNTV9HRVRfREVMTF9TSUcyCTB4ZmZhMwotCi0jZGVmaW5lIEk4 S19GQU5fTVVMVAkJMzAKLSNkZWZpbmUgSThLX0ZBTl9NQVhfUlBNCQkzMDAwMAotI2RlZmluZSBJ OEtfTUFYX1RFTVAJCTEyNwotCi0jZGVmaW5lIEk4S19GTl9OT05FCQkweDAwCi0jZGVmaW5lIEk4 S19GTl9VUAkJMHgwMQotI2RlZmluZSBJOEtfRk5fRE9XTgkJMHgwMgotI2RlZmluZSBJOEtfRk5f TVVURQkJMHgwNAotI2RlZmluZSBJOEtfRk5fTUFTSwkJMHgwNwotI2RlZmluZSBJOEtfRk5fU0hJ RlQJCTgKLQotI2RlZmluZSBJOEtfUE9XRVJfQUMJCTB4MDUKLSNkZWZpbmUgSThLX1BPV0VSX0JB VFRFUlkJMHgwMQotCi1zdGF0aWMgREVGSU5FX01VVEVYKGk4a19tdXRleCk7Ci1zdGF0aWMgY2hh ciBiaW9zX3ZlcnNpb25bNF07Ci1zdGF0aWMgc3RydWN0IGRldmljZSAqaThrX2h3bW9uX2RldjsK LXN0YXRpYyB1MzIgaThrX2h3bW9uX2ZsYWdzOwotc3RhdGljIHVpbnQgaThrX2Zhbl9tdWx0ID0g SThLX0ZBTl9NVUxUOwotc3RhdGljIHVpbnQgaThrX3B3bV9tdWx0Owotc3RhdGljIHVpbnQgaThr X2Zhbl9tYXggPSBJOEtfRkFOX0hJR0g7Ci0KLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDEJ KDEgPDwgMCkKLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDIJKDEgPDwgMSkKLSNkZWZpbmUg SThLX0hXTU9OX0hBVkVfVEVNUDMJKDEgPDwgMikKLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVN UDQJKDEgPDwgMykKLSNkZWZpbmUgSThLX0hXTU9OX0hBVkVfRkFOMQkoMSA8PCA0KQotI2RlZmlu ZSBJOEtfSFdNT05fSEFWRV9GQU4yCSgxIDw8IDUpCi0KLU1PRFVMRV9BVVRIT1IoIk1hc3NpbW8g RGFsIFpvdHRvIChkekBkZWJpYW4ub3JnKSIpOwotTU9EVUxFX0RFU0NSSVBUSU9OKCJEcml2ZXIg Zm9yIGFjY2Vzc2luZyBTTU0gQklPUyBvbiBEZWxsIGxhcHRvcHMiKTsKLU1PRFVMRV9MSUNFTlNF KCJHUEwiKTsKLQotc3RhdGljIGJvb2wgZm9yY2U7Ci1tb2R1bGVfcGFyYW0oZm9yY2UsIGJvb2ws IDApOwotTU9EVUxFX1BBUk1fREVTQyhmb3JjZSwgIkZvcmNlIGxvYWRpbmcgd2l0aG91dCBjaGVj a2luZyBmb3Igc3VwcG9ydGVkIG1vZGVscyIpOwotCi1zdGF0aWMgYm9vbCBpZ25vcmVfZG1pOwot bW9kdWxlX3BhcmFtKGlnbm9yZV9kbWksIGJvb2wsIDApOwotTU9EVUxFX1BBUk1fREVTQyhpZ25v cmVfZG1pLCAiQ29udGludWUgcHJvYmluZyBoYXJkd2FyZSBldmVuIGlmIERNSSBkYXRhIGRvZXMg bm90IG1hdGNoIik7Ci0KLXN0YXRpYyBib29sIHJlc3RyaWN0ZWQ7Ci1tb2R1bGVfcGFyYW0ocmVz dHJpY3RlZCwgYm9vbCwgMCk7Ci1NT0RVTEVfUEFSTV9ERVNDKHJlc3RyaWN0ZWQsICJBbGxvdyBm YW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJpbGl0eSBzZXQiKTsKLQotc3RhdGljIGJvb2wg cG93ZXJfc3RhdHVzOwotbW9kdWxlX3BhcmFtKHBvd2VyX3N0YXR1cywgYm9vbCwgMDYwMCk7Ci1N T0RVTEVfUEFSTV9ERVNDKHBvd2VyX3N0YXR1cywgIlJlcG9ydCBwb3dlciBzdGF0dXMgaW4gL3By b2MvaThrIik7Ci0KLXN0YXRpYyB1aW50IGZhbl9tdWx0OwotbW9kdWxlX3BhcmFtKGZhbl9tdWx0 LCB1aW50LCAwKTsKLU1PRFVMRV9QQVJNX0RFU0MoZmFuX211bHQsICJGYWN0b3IgdG8gbXVsdGlw bHkgZmFuIHNwZWVkIHdpdGggKGRlZmF1bHQ6IGF1dG9kZXRlY3QpIik7Ci0KLXN0YXRpYyB1aW50 IGZhbl9tYXg7Ci1tb2R1bGVfcGFyYW0oZmFuX21heCwgdWludCwgMCk7Ci1NT0RVTEVfUEFSTV9E RVNDKGZhbl9tYXgsICJNYXhpbXVtIGNvbmZpZ3VyYWJsZSBmYW4gc3BlZWQgKGRlZmF1bHQ6IGF1 dG9kZXRlY3QpIik7Ci0KLXN0YXRpYyBpbnQgaThrX29wZW5fZnMoc3RydWN0IGlub2RlICppbm9k ZSwgc3RydWN0IGZpbGUgKmZpbGUpOwotc3RhdGljIGxvbmcgaThrX2lvY3RsKHN0cnVjdCBmaWxl ICosIHVuc2lnbmVkIGludCwgdW5zaWduZWQgbG9uZyk7Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3Qg ZmlsZV9vcGVyYXRpb25zIGk4a19mb3BzID0gewotCS5vd25lcgkJPSBUSElTX01PRFVMRSwKLQku b3BlbgkJPSBpOGtfb3Blbl9mcywKLQkucmVhZAkJPSBzZXFfcmVhZCwKLQkubGxzZWVrCQk9IHNl cV9sc2VlaywKLQkucmVsZWFzZQk9IHNpbmdsZV9yZWxlYXNlLAotCS51bmxvY2tlZF9pb2N0bAk9 IGk4a19pb2N0bCwKLX07Ci0KLXN0cnVjdCBzbW1fcmVncyB7Ci0JdW5zaWduZWQgaW50IGVheDsK LQl1bnNpZ25lZCBpbnQgZWJ4IF9fcGFja2VkOwotCXVuc2lnbmVkIGludCBlY3ggX19wYWNrZWQ7 Ci0JdW5zaWduZWQgaW50IGVkeCBfX3BhY2tlZDsKLQl1bnNpZ25lZCBpbnQgZXNpIF9fcGFja2Vk OwotCXVuc2lnbmVkIGludCBlZGkgX19wYWNrZWQ7Ci19OwotCi1zdGF0aWMgaW5saW5lIGNvbnN0 IGNoYXIgKmk4a19nZXRfZG1pX2RhdGEoaW50IGZpZWxkKQotewotCWNvbnN0IGNoYXIgKmRtaV9k YXRhID0gZG1pX2dldF9zeXN0ZW1faW5mbyhmaWVsZCk7Ci0KLQlyZXR1cm4gZG1pX2RhdGEgJiYg KmRtaV9kYXRhID8gZG1pX2RhdGEgOiAiPyI7Ci19Ci0KLS8qCi0gKiBDYWxsIHRoZSBTeXN0ZW0g TWFuYWdlbWVudCBNb2RlIEJJT1MuIENvZGUgcHJvdmlkZWQgYnkgSm9uYXRoYW4gQnV6emFyZC4K LSAqLwotc3RhdGljIGludCBpOGtfc21tKHN0cnVjdCBzbW1fcmVncyAqcmVncykKLXsKLQlpbnQg cmM7Ci0JaW50IGVheCA9IHJlZ3MtPmVheDsKLQljcHVtYXNrX3Zhcl90IG9sZF9tYXNrOwotCi0J LyogU01NIHJlcXVpcmVzIENQVSAwICovCi0JaWYgKCFhbGxvY19jcHVtYXNrX3Zhcigmb2xkX21h c2ssIEdGUF9LRVJORUwpKQotCQlyZXR1cm4gLUVOT01FTTsKLQljcHVtYXNrX2NvcHkob2xkX21h c2ssICZjdXJyZW50LT5jcHVzX2FsbG93ZWQpOwotCXJjID0gc2V0X2NwdXNfYWxsb3dlZF9wdHIo Y3VycmVudCwgY3B1bWFza19vZigwKSk7Ci0JaWYgKHJjKQotCQlnb3RvIG91dDsKLQlpZiAoc21w X3Byb2Nlc3Nvcl9pZCgpICE9IDApIHsKLQkJcmMgPSAtRUJVU1k7Ci0JCWdvdG8gb3V0OwotCX0K LQotI2lmIGRlZmluZWQoQ09ORklHX1g4Nl82NCkKLQlhc20gdm9sYXRpbGUoInB1c2hxICUlcmF4 XG5cdCIKLQkJIm1vdmwgMCglJXJheCksJSVlZHhcblx0IgotCQkicHVzaHEgJSVyZHhcblx0Igot CQkibW92bCA0KCUlcmF4KSwlJWVieFxuXHQiCi0JCSJtb3ZsIDgoJSVyYXgpLCUlZWN4XG5cdCIK LQkJIm1vdmwgMTIoJSVyYXgpLCUlZWR4XG5cdCIKLQkJIm1vdmwgMTYoJSVyYXgpLCUlZXNpXG5c dCIKLQkJIm1vdmwgMjAoJSVyYXgpLCUlZWRpXG5cdCIKLQkJInBvcHEgJSVyYXhcblx0IgotCQki b3V0ICUlYWwsJDB4YjJcblx0IgotCQkib3V0ICUlYWwsJDB4ODRcblx0IgotCQkieGNoZ3EgJSVy YXgsKCUlcnNwKVxuXHQiCi0JCSJtb3ZsICUlZWJ4LDQoJSVyYXgpXG5cdCIKLQkJIm1vdmwgJSVl Y3gsOCglJXJheClcblx0IgotCQkibW92bCAlJWVkeCwxMiglJXJheClcblx0IgotCQkibW92bCAl JWVzaSwxNiglJXJheClcblx0IgotCQkibW92bCAlJWVkaSwyMCglJXJheClcblx0IgotCQkicG9w cSAlJXJkeFxuXHQiCi0JCSJtb3ZsICUlZWR4LDAoJSVyYXgpXG5cdCIKLQkJInB1c2hmcVxuXHQi Ci0JCSJwb3BxICUlcmF4XG5cdCIKLQkJImFuZGwgJDEsJSVlYXhcbiIKLQkJOiAiPWEiKHJjKQot CQk6ICAgICJhIihyZWdzKQotCQk6ICAgICIlZWJ4IiwgIiVlY3giLCAiJWVkeCIsICIlZXNpIiwg IiVlZGkiLCAibWVtb3J5Iik7Ci0jZWxzZQotCWFzbSB2b2xhdGlsZSgicHVzaGwgJSVlYXhcblx0 IgotCSAgICAibW92bCAwKCUlZWF4KSwlJWVkeFxuXHQiCi0JICAgICJwdXNoICUlZWR4XG5cdCIK LQkgICAgIm1vdmwgNCglJWVheCksJSVlYnhcblx0IgotCSAgICAibW92bCA4KCUlZWF4KSwlJWVj eFxuXHQiCi0JICAgICJtb3ZsIDEyKCUlZWF4KSwlJWVkeFxuXHQiCi0JICAgICJtb3ZsIDE2KCUl ZWF4KSwlJWVzaVxuXHQiCi0JICAgICJtb3ZsIDIwKCUlZWF4KSwlJWVkaVxuXHQiCi0JICAgICJw b3BsICUlZWF4XG5cdCIKLQkgICAgIm91dCAlJWFsLCQweGIyXG5cdCIKLQkgICAgIm91dCAlJWFs LCQweDg0XG5cdCIKLQkgICAgInhjaGdsICUlZWF4LCglJWVzcClcblx0IgotCSAgICAibW92bCAl JWVieCw0KCUlZWF4KVxuXHQiCi0JICAgICJtb3ZsICUlZWN4LDgoJSVlYXgpXG5cdCIKLQkgICAg Im1vdmwgJSVlZHgsMTIoJSVlYXgpXG5cdCIKLQkgICAgIm1vdmwgJSVlc2ksMTYoJSVlYXgpXG5c dCIKLQkgICAgIm1vdmwgJSVlZGksMjAoJSVlYXgpXG5cdCIKLQkgICAgInBvcGwgJSVlZHhcblx0 IgotCSAgICAibW92bCAlJWVkeCwwKCUlZWF4KVxuXHQiCi0JICAgICJsYWhmXG5cdCIKLQkgICAg InNocmwgJDgsJSVlYXhcblx0IgotCSAgICAiYW5kbCAkMSwlJWVheFxuIgotCSAgICA6ICI9YSIo cmMpCi0JICAgIDogICAgImEiKHJlZ3MpCi0JICAgIDogICAgIiVlYngiLCAiJWVjeCIsICIlZWR4 IiwgIiVlc2kiLCAiJWVkaSIsICJtZW1vcnkiKTsKLSNlbmRpZgotCWlmIChyYyAhPSAwIHx8IChy ZWdzLT5lYXggJiAweGZmZmYpID09IDB4ZmZmZiB8fCByZWdzLT5lYXggPT0gZWF4KQotCQlyYyA9 IC1FSU5WQUw7Ci0KLW91dDoKLQlzZXRfY3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBvbGRfbWFz ayk7Ci0JZnJlZV9jcHVtYXNrX3ZhcihvbGRfbWFzayk7Ci0JcmV0dXJuIHJjOwotfQotCi0vKgot ICogUmVhZCB0aGUgRm4ga2V5IHN0YXR1cy4KLSAqLwotc3RhdGljIGludCBpOGtfZ2V0X2ZuX3N0 YXR1cyh2b2lkKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9G Tl9TVEFUVVMsIH07Ci0JaW50IHJjOwotCi0JcmMgPSBpOGtfc21tKCZyZWdzKTsKLQlpZiAocmMg PCAwKQotCQlyZXR1cm4gcmM7Ci0KLQlzd2l0Y2ggKChyZWdzLmVheCA+PiBJOEtfRk5fU0hJRlQp ICYgSThLX0ZOX01BU0spIHsKLQljYXNlIEk4S19GTl9VUDoKLQkJcmV0dXJuIEk4S19WT0xfVVA7 Ci0JY2FzZSBJOEtfRk5fRE9XTjoKLQkJcmV0dXJuIEk4S19WT0xfRE9XTjsKLQljYXNlIEk4S19G Tl9NVVRFOgotCQlyZXR1cm4gSThLX1ZPTF9NVVRFOwotCWRlZmF1bHQ6Ci0JCXJldHVybiAwOwot CX0KLX0KLQotLyoKLSAqIFJlYWQgdGhlIHBvd2VyIHN0YXR1cy4KLSAqLwotc3RhdGljIGludCBp OGtfZ2V0X3Bvd2VyX3N0YXR1cyh2b2lkKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAu ZWF4ID0gSThLX1NNTV9QT1dFUl9TVEFUVVMsIH07Ci0JaW50IHJjOwotCi0JcmMgPSBpOGtfc21t KCZyZWdzKTsKLQlpZiAocmMgPCAwKQotCQlyZXR1cm4gcmM7Ci0KLQlyZXR1cm4gKHJlZ3MuZWF4 ICYgMHhmZikgPT0gSThLX1BPV0VSX0FDID8gSThLX0FDIDogSThLX0JBVFRFUlk7Ci19Ci0KLS8q Ci0gKiBSZWFkIHRoZSBmYW4gc3RhdHVzLgotICovCi1zdGF0aWMgaW50IGk4a19nZXRfZmFuX3N0 YXR1cyhpbnQgZmFuKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NN TV9HRVRfRkFOLCB9OwotCi0JcmVncy5lYnggPSBmYW4gJiAweGZmOwotCXJldHVybiBpOGtfc21t KCZyZWdzKSA/IDogcmVncy5lYXggJiAweGZmOwotfQotCi0vKgotICogUmVhZCB0aGUgZmFuIHNw ZWVkIGluIFJQTS4KLSAqLwotc3RhdGljIGludCBpOGtfZ2V0X2Zhbl9zcGVlZChpbnQgZmFuKQot ewotCXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfU1BFRUQsIH07 Ci0KLQlyZWdzLmVieCA9IGZhbiAmIDB4ZmY7Ci0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiAo cmVncy5lYXggJiAweGZmZmYpICogaThrX2Zhbl9tdWx0OwotfQotCi0vKgotICogUmVhZCB0aGUg ZmFuIHR5cGUuCi0gKi8KLXN0YXRpYyBpbnQgaThrX2dldF9mYW5fdHlwZShpbnQgZmFuKQotewot CXN0cnVjdCBzbW1fcmVncyByZWdzID0geyAuZWF4ID0gSThLX1NNTV9HRVRfRkFOX1RZUEUsIH07 Ci0KLQlyZWdzLmVieCA9IGZhbiAmIDB4ZmY7Ci0JcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiBy ZWdzLmVheCAmIDB4ZmY7Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBmYW4gbm9taW5hbCBycG0gZm9y IHNwZWNpZmljIGZhbiBzcGVlZC4KLSAqLwotc3RhdGljIGludCBpOGtfZ2V0X2Zhbl9ub21pbmFs X3NwZWVkKGludCBmYW4sIGludCBzcGVlZCkKLXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsg LmVheCA9IEk4S19TTU1fR0VUX05PTV9TUEVFRCwgfTsKLQotCXJlZ3MuZWJ4ID0gKGZhbiAmIDB4 ZmYpIHwgKHNwZWVkIDw8IDgpOwotCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogKHJlZ3MuZWF4 ICYgMHhmZmZmKSAqIGk4a19mYW5fbXVsdDsKLX0KLQotLyoKLSAqIFNldCB0aGUgZmFuIHNwZWVk IChvZmYsIGxvdywgaGlnaCkuIFJldHVybnMgdGhlIG5ldyBmYW4gc3RhdHVzLgotICovCi1zdGF0 aWMgaW50IGk4a19zZXRfZmFuKGludCBmYW4sIGludCBzcGVlZCkKLXsKLQlzdHJ1Y3Qgc21tX3Jl Z3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fU0VUX0ZBTiwgfTsKLQotCXNwZWVkID0gKHNwZWVk IDwgMCkgPyAwIDogKChzcGVlZCA+IGk4a19mYW5fbWF4KSA/IGk4a19mYW5fbWF4IDogc3BlZWQp OwotCXJlZ3MuZWJ4ID0gKGZhbiAmIDB4ZmYpIHwgKHNwZWVkIDw8IDgpOwotCi0JcmV0dXJuIGk4 a19zbW0oJnJlZ3MpID8gOiBpOGtfZ2V0X2Zhbl9zdGF0dXMoZmFuKTsKLX0KLQotc3RhdGljIGlu dCBpOGtfZ2V0X3RlbXBfdHlwZShpbnQgc2Vuc29yKQotewotCXN0cnVjdCBzbW1fcmVncyByZWdz ID0geyAuZWF4ID0gSThLX1NNTV9HRVRfVEVNUF9UWVBFLCB9OwotCi0JcmVncy5lYnggPSBzZW5z b3IgJiAweGZmOwotCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAweGZmOwot fQotCi0vKgotICogUmVhZCB0aGUgY3B1IHRlbXBlcmF0dXJlLgotICovCi1zdGF0aWMgaW50IF9p OGtfZ2V0X3RlbXAoaW50IHNlbnNvcikKLXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsKLQkJ LmVheCA9IEk4S19TTU1fR0VUX1RFTVAsCi0JCS5lYnggPSBzZW5zb3IgJiAweGZmLAotCX07Ci0K LQlyZXR1cm4gaThrX3NtbSgmcmVncykgPyA6IHJlZ3MuZWF4ICYgMHhmZjsKLX0KLQotc3RhdGlj IGludCBpOGtfZ2V0X3RlbXAoaW50IHNlbnNvcikKLXsKLQlpbnQgdGVtcCA9IF9pOGtfZ2V0X3Rl bXAoc2Vuc29yKTsKLQotCS8qCi0JICogU29tZXRpbWVzIHRoZSB0ZW1wZXJhdHVyZSBzZW5zb3Ig cmV0dXJucyAweDk5LCB3aGljaCBpcyBvdXQgb2YgcmFuZ2UuCi0JICogSW4gdGhpcyBjYXNlIHdl IHJldHJ5IChvbmNlKSBiZWZvcmUgcmV0dXJuaW5nIGFuIGVycm9yLgotCSAjIDEwMDM2NTUxMzcg MDAwMDAwNTggMDAwMDVhNGIKLQkgIyAxMDAzNjU1MTM4IDAwMDAwMDk5IDAwMDAzYTgwIDwtLS0g MHg5OSA9IDE1MyBkZWdyZWVzCi0JICMgMTAwMzY1NTEzOSAwMDAwMDA1NCAwMDAwNWM1MgotCSAq LwotCWlmICh0ZW1wID09IDB4OTkpIHsKLQkJbXNsZWVwKDEwMCk7Ci0JCXRlbXAgPSBfaThrX2dl dF90ZW1wKHNlbnNvcik7Ci0JfQotCS8qCi0JICogUmV0dXJuIC1FTk9EQVRBIGZvciBhbGwgaW52 YWxpZCB0ZW1wZXJhdHVyZXMuCi0JICoKLQkgKiBLbm93biBpbnN0YW5jZXMgYXJlIHRoZSAweDk5 IHZhbHVlIGFzIHNlZW4gYWJvdmUgYXMgd2VsbCBhcwotCSAqIDB4YzEgKDE5MyksIHdoaWNoIG1h eSBiZSByZXR1cm5lZCB3aGVuIHRyeWluZyB0byByZWFkIHRoZSBHUFUKLQkgKiB0ZW1wZXJhdHVy ZSBpZiB0aGUgc3lzdGVtIHN1cHBvcnRzIGEgR1BVIGFuZCBpdCBpcyBjdXJyZW50bHkKLQkgKiB0 dXJuZWQgb2ZmLgotCSAqLwotCWlmICh0ZW1wID4gSThLX01BWF9URU1QKQotCQlyZXR1cm4gLUVO T0RBVEE7Ci0KLQlyZXR1cm4gdGVtcDsKLX0KLQotc3RhdGljIGludCBpOGtfZ2V0X2RlbGxfc2ln bmF0dXJlKGludCByZXFfZm4pCi17Ci0Jc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBy ZXFfZm4sIH07Ci0JaW50IHJjOwotCi0JcmMgPSBpOGtfc21tKCZyZWdzKTsKLQlpZiAocmMgPCAw KQotCQlyZXR1cm4gcmM7Ci0KLQlyZXR1cm4gcmVncy5lYXggPT0gMTE0NTY1MTUyNyAmJiByZWdz LmVkeCA9PSAxMTQ1MzkyMjA0ID8gMCA6IC0xOwotfQotCi1zdGF0aWMgaW50Ci1pOGtfaW9jdGxf dW5sb2NrZWQoc3RydWN0IGZpbGUgKmZwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25n IGFyZykKLXsKLQlpbnQgdmFsID0gMDsKLQlpbnQgc3BlZWQ7Ci0JdW5zaWduZWQgY2hhciBidWZm WzE2XTsKLQlpbnQgX191c2VyICphcmdwID0gKGludCBfX3VzZXIgKilhcmc7Ci0KLQlpZiAoIWFy Z3ApCi0JCXJldHVybiAtRUlOVkFMOwotCi0Jc3dpdGNoIChjbWQpIHsKLQljYXNlIEk4S19CSU9T X1ZFUlNJT046Ci0JCXZhbCA9IChiaW9zX3ZlcnNpb25bMF0gPDwgMTYpIHwKLQkJCQkoYmlvc192 ZXJzaW9uWzFdIDw8IDgpIHwgYmlvc192ZXJzaW9uWzJdOwotCQlicmVhazsKLQotCWNhc2UgSThL X01BQ0hJTkVfSUQ6Ci0JCW1lbXNldChidWZmLCAwLCAxNik7Ci0JCXN0cmxjcHkoYnVmZiwgaThr X2dldF9kbWlfZGF0YShETUlfUFJPRFVDVF9TRVJJQUwpLAotCQkJc2l6ZW9mKGJ1ZmYpKTsKLQkJ YnJlYWs7Ci0KLQljYXNlIEk4S19GTl9TVEFUVVM6Ci0JCXZhbCA9IGk4a19nZXRfZm5fc3RhdHVz KCk7Ci0JCWJyZWFrOwotCi0JY2FzZSBJOEtfUE9XRVJfU1RBVFVTOgotCQl2YWwgPSBpOGtfZ2V0 X3Bvd2VyX3N0YXR1cygpOwotCQlicmVhazsKLQotCWNhc2UgSThLX0dFVF9URU1QOgotCQl2YWwg PSBpOGtfZ2V0X3RlbXAoMCk7Ci0JCWJyZWFrOwotCi0JY2FzZSBJOEtfR0VUX1NQRUVEOgotCQlp ZiAoY29weV9mcm9tX3VzZXIoJnZhbCwgYXJncCwgc2l6ZW9mKGludCkpKQotCQkJcmV0dXJuIC1F RkFVTFQ7Ci0KLQkJdmFsID0gaThrX2dldF9mYW5fc3BlZWQodmFsKTsKLQkJYnJlYWs7Ci0KLQlj YXNlIEk4S19HRVRfRkFOOgotCQlpZiAoY29weV9mcm9tX3VzZXIoJnZhbCwgYXJncCwgc2l6ZW9m KGludCkpKQotCQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQkJdmFsID0gaThrX2dldF9mYW5fc3RhdHVz KHZhbCk7Ci0JCWJyZWFrOwotCi0JY2FzZSBJOEtfU0VUX0ZBTjoKLQkJaWYgKHJlc3RyaWN0ZWQg JiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCi0JCQlyZXR1cm4gLUVQRVJNOwotCi0JCWlmIChj b3B5X2Zyb21fdXNlcigmdmFsLCBhcmdwLCBzaXplb2YoaW50KSkpCi0JCQlyZXR1cm4gLUVGQVVM VDsKLQotCQlpZiAoY29weV9mcm9tX3VzZXIoJnNwZWVkLCBhcmdwICsgMSwgc2l6ZW9mKGludCkp KQotCQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQkJdmFsID0gaThrX3NldF9mYW4odmFsLCBzcGVlZCk7 Ci0JCWJyZWFrOwotCi0JZGVmYXVsdDoKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0JaWYgKHZh bCA8IDApCi0JCXJldHVybiB2YWw7Ci0KLQlzd2l0Y2ggKGNtZCkgewotCWNhc2UgSThLX0JJT1Nf VkVSU0lPTjoKLQkJaWYgKGNvcHlfdG9fdXNlcihhcmdwLCAmdmFsLCA0KSkKLQkJCXJldHVybiAt RUZBVUxUOwotCi0JCWJyZWFrOwotCWNhc2UgSThLX01BQ0hJTkVfSUQ6Ci0JCWlmIChjb3B5X3Rv X3VzZXIoYXJncCwgYnVmZiwgMTYpKQotCQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQkJYnJlYWs7Ci0J ZGVmYXVsdDoKLQkJaWYgKGNvcHlfdG9fdXNlcihhcmdwLCAmdmFsLCBzaXplb2YoaW50KSkpCi0J CQlyZXR1cm4gLUVGQVVMVDsKLQotCQlicmVhazsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3Rh dGljIGxvbmcgaThrX2lvY3RsKHN0cnVjdCBmaWxlICpmcCwgdW5zaWduZWQgaW50IGNtZCwgdW5z aWduZWQgbG9uZyBhcmcpCi17Ci0JbG9uZyByZXQ7Ci0KLQltdXRleF9sb2NrKCZpOGtfbXV0ZXgp OwotCXJldCA9IGk4a19pb2N0bF91bmxvY2tlZChmcCwgY21kLCBhcmcpOwotCW11dGV4X3VubG9j aygmaThrX211dGV4KTsKLQotCXJldHVybiByZXQ7Ci19Ci0KLS8qCi0gKiBQcmludCB0aGUgaW5m b3JtYXRpb24gZm9yIC9wcm9jL2k4ay4KLSAqLwotc3RhdGljIGludCBpOGtfcHJvY19zaG93KHN0 cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICpvZmZzZXQpCi17Ci0JaW50IGZuX2tleSwgY3B1X3Rl bXAsIGFjX3Bvd2VyOwotCWludCBsZWZ0X2ZhbiwgcmlnaHRfZmFuLCBsZWZ0X3NwZWVkLCByaWdo dF9zcGVlZDsKLQotCWNwdV90ZW1wCT0gaThrX2dldF90ZW1wKDApOwkJCS8qIDExMTAwIMK1cyAq LwotCWxlZnRfZmFuCT0gaThrX2dldF9mYW5fc3RhdHVzKEk4S19GQU5fTEVGVCk7CS8qICAgNTgw IMK1cyAqLwotCXJpZ2h0X2Zhbgk9IGk4a19nZXRfZmFuX3N0YXR1cyhJOEtfRkFOX1JJR0hUKTsJ LyogICA1ODAgwrVzICovCi0JbGVmdF9zcGVlZAk9IGk4a19nZXRfZmFuX3NwZWVkKEk4S19GQU5f TEVGVCk7CS8qICAgNTgwIMK1cyAqLwotCXJpZ2h0X3NwZWVkCT0gaThrX2dldF9mYW5fc3BlZWQo SThLX0ZBTl9SSUdIVCk7CS8qICAgNTgwIMK1cyAqLwotCWZuX2tleQkJPSBpOGtfZ2V0X2ZuX3N0 YXR1cygpOwkJCS8qICAgNzUwIMK1cyAqLwotCWlmIChwb3dlcl9zdGF0dXMpCi0JCWFjX3Bvd2Vy ID0gaThrX2dldF9wb3dlcl9zdGF0dXMoKTsJCS8qIDE0NzAwIMK1cyAqLwotCWVsc2UKLQkJYWNf cG93ZXIgPSAtMTsKLQotCS8qCi0JICogSW5mbzoKLQkgKgotCSAqIDEpICBGb3JtYXQgdmVyc2lv biAodGhpcyB3aWxsIGNoYW5nZSBpZiBmb3JtYXQgY2hhbmdlcykKLQkgKiAyKSAgQklPUyB2ZXJz aW9uCi0JICogMykgIEJJT1MgbWFjaGluZSBJRAotCSAqIDQpICBDcHUgdGVtcGVyYXR1cmUKLQkg KiA1KSAgTGVmdCBmYW4gc3RhdHVzCi0JICogNikgIFJpZ2h0IGZhbiBzdGF0dXMKLQkgKiA3KSAg TGVmdCBmYW4gc3BlZWQKLQkgKiA4KSAgUmlnaHQgZmFuIHNwZWVkCi0JICogOSkgIEFDIHBvd2Vy Ci0JICogMTApIEZuIEtleSBzdGF0dXMKLQkgKi8KLQlzZXFfcHJpbnRmKHNlcSwgIiVzICVzICVz ICVkICVkICVkICVkICVkICVkICVkXG4iLAotCQkgICBJOEtfUFJPQ19GTVQsCi0JCSAgIGJpb3Nf dmVyc2lvbiwKLQkJICAgaThrX2dldF9kbWlfZGF0YShETUlfUFJPRFVDVF9TRVJJQUwpLAotCQkg ICBjcHVfdGVtcCwKLQkJICAgbGVmdF9mYW4sIHJpZ2h0X2ZhbiwgbGVmdF9zcGVlZCwgcmlnaHRf c3BlZWQsCi0JCSAgIGFjX3Bvd2VyLCBmbl9rZXkpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRp YyBpbnQgaThrX29wZW5fZnMoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUp Ci17Ci0JcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIGk4a19wcm9jX3Nob3csIE5VTEwpOwotfQot Ci0KLS8qCi0gKiBId21vbiBpbnRlcmZhY2UKLSAqLwotCi1zdGF0aWMgc3NpemVfdCBpOGtfaHdt b25fc2hvd190ZW1wX2xhYmVsKHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCQkJIHN0cnVjdCBkZXZp Y2VfYXR0cmlidXRlICpkZXZhdHRyLAotCQkJCQkgY2hhciAqYnVmKQotewotCXN0YXRpYyBjb25z dCBjaGFyICogY29uc3QgbGFiZWxzW10gPSB7Ci0JCSJDUFUiLAotCQkiR1BVIiwKLQkJIlNPRElN TSIsCi0JCSJPdGhlciIsCi0JCSJBbWJpZW50IiwKLQkJIk90aGVyIiwKLQl9OwotCWludCBpbmRl eCA9IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZhdHRyKS0+aW5kZXg7Ci0JaW50IHR5cGU7Ci0KLQl0 eXBlID0gaThrX2dldF90ZW1wX3R5cGUoaW5kZXgpOwotCWlmICh0eXBlIDwgMCkKLQkJcmV0dXJu IHR5cGU7Ci0JaWYgKHR5cGUgPj0gQVJSQVlfU0laRShsYWJlbHMpKQotCQl0eXBlID0gQVJSQVlf U0laRShsYWJlbHMpIC0gMTsKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlc1xuIiwgbGFiZWxzW3R5 cGVdKTsKLX0KLQotc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3dfdGVtcChzdHJ1Y3QgZGV2 aWNlICpkZXYsCi0JCQkJICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCi0JCQkJ ICAgY2hhciAqYnVmKQotewotCWludCBpbmRleCA9IHRvX3NlbnNvcl9kZXZfYXR0cihkZXZhdHRy KS0+aW5kZXg7Ci0JaW50IHRlbXA7Ci0KLQl0ZW1wID0gaThrX2dldF90ZW1wKGluZGV4KTsKLQlp ZiAodGVtcCA8IDApCi0JCXJldHVybiB0ZW1wOwotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4i LCB0ZW1wICogMTAwMCk7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zaG93X2Zhbl9s YWJlbChzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpk ZXZhdHRyLAotCQkJCQljaGFyICpidWYpCi17Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBs YWJlbHNbXSA9IHsKLQkJIlByb2Nlc3NvciBGYW4iLAotCQkiTW90aGVyYm9hcmQgRmFuIiwKLQkJ IlZpZGVvIEZhbiIsCi0JCSJQb3dlciBTdXBwbHkgRmFuIiwKLQkJIkNoaXBzZXQgRmFuIiwKLQkJ Ik90aGVyIEZhbiIsCi0JfTsKLQlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0 ciktPmluZGV4OwotCWJvb2wgZG9jayA9IGZhbHNlOwotCWludCB0eXBlOwotCi0JdHlwZSA9IGk4 a19nZXRfZmFuX3R5cGUoaW5kZXgpOwotCWlmICh0eXBlIDwgMCkKLQkJcmV0dXJuIHR5cGU7Ci0K LQlpZiAodHlwZSAmIDB4MTApIHsKLQkJZG9jayA9IHRydWU7Ci0JCXR5cGUgJj0gMHgwRjsKLQl9 Ci0KLQlpZiAodHlwZSA+PSBBUlJBWV9TSVpFKGxhYmVscykpCi0JCXR5cGUgPSAoQVJSQVlfU0la RShsYWJlbHMpIC0gMSk7Ci0KLQlyZXR1cm4gc3ByaW50ZihidWYsICIlcyVzXG4iLCAoZG9jayA/ ICJEb2NraW5nICIgOiAiIiksIGxhYmVsc1t0eXBlXSk7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IGk4 a19od21vbl9zaG93X2ZhbihzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJICBzdHJ1Y3QgZGV2aWNl X2F0dHJpYnV0ZSAqZGV2YXR0ciwKLQkJCQkgIGNoYXIgKmJ1ZikKLXsKLQlpbnQgaW5kZXggPSB0 b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4OwotCWludCBmYW5fc3BlZWQ7Ci0KLQlm YW5fc3BlZWQgPSBpOGtfZ2V0X2Zhbl9zcGVlZChpbmRleCk7Ci0JaWYgKGZhbl9zcGVlZCA8IDAp Ci0JCXJldHVybiBmYW5fc3BlZWQ7Ci0JcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIGZhbl9z cGVlZCk7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zaG93X3B3bShzdHJ1Y3QgZGV2 aWNlICpkZXYsCi0JCQkJICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKLQkJCQkg IGNoYXIgKmJ1ZikKLXsKLQlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0cikt PmluZGV4OwotCWludCBzdGF0dXM7Ci0KLQlzdGF0dXMgPSBpOGtfZ2V0X2Zhbl9zdGF0dXMoaW5k ZXgpOwotCWlmIChzdGF0dXMgPCAwKQotCQlyZXR1cm4gLUVJTzsKLQlyZXR1cm4gc3ByaW50Zihi dWYsICIlZFxuIiwgY2xhbXBfdmFsKHN0YXR1cyAqIGk4a19wd21fbXVsdCwgMCwgMjU1KSk7Ci19 Ci0KLXN0YXRpYyBzc2l6ZV90IGk4a19od21vbl9zZXRfcHdtKHN0cnVjdCBkZXZpY2UgKmRldiwK LQkJCQkgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCi0JCQkJIGNvbnN0IGNoYXIgKmJ1 Ziwgc2l6ZV90IGNvdW50KQotewotCWludCBpbmRleCA9IHRvX3NlbnNvcl9kZXZfYXR0cihhdHRy KS0+aW5kZXg7Ci0JdW5zaWduZWQgbG9uZyB2YWw7Ci0JaW50IGVycjsKLQotCWVyciA9IGtzdHJ0 b3VsKGJ1ZiwgMTAsICZ2YWwpOwotCWlmIChlcnIpCi0JCXJldHVybiBlcnI7Ci0JdmFsID0gY2xh bXBfdmFsKERJVl9ST1VORF9DTE9TRVNUKHZhbCwgaThrX3B3bV9tdWx0KSwgMCwgaThrX2Zhbl9t YXgpOwotCi0JbXV0ZXhfbG9jaygmaThrX211dGV4KTsKLQllcnIgPSBpOGtfc2V0X2ZhbihpbmRl eCwgdmFsKTsKLQltdXRleF91bmxvY2soJmk4a19tdXRleCk7Ci0KLQlyZXR1cm4gZXJyIDwgMCA/ IC1FSU8gOiBjb3VudDsKLX0KLQotc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1 dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcCwgTlVMTCwgMCk7Ci1zdGF0aWMgU0VOU09S X0RFVklDRV9BVFRSKHRlbXAxX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wX2xh YmVsLCBOVUxMLAotCQkJICAwKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDJfaW5w dXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXAsIE5VTEwsIDEpOwotc3RhdGljIFNFTlNP Ul9ERVZJQ0VfQVRUUih0ZW1wMl9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcF9s YWJlbCwgTlVMTCwKLQkJCSAgMSk7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAzX2lu cHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1wLCBOVUxMLCAyKTsKLXN0YXRpYyBTRU5T T1JfREVWSUNFX0FUVFIodGVtcDNfbGFiZWwsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXBf bGFiZWwsIE5VTEwsCi0JCQkgIDIpOwotc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wNF9p bnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcCwgTlVMTCwgMyk7Ci1zdGF0aWMgU0VO U09SX0RFVklDRV9BVFRSKHRlbXA0X2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1w X2xhYmVsLCBOVUxMLAotCQkJICAzKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFuMV9p bnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuLCBOVUxMLCAwKTsKLXN0YXRpYyBTRU5T T1JfREVWSUNFX0FUVFIoZmFuMV9sYWJlbCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuX2xh YmVsLCBOVUxMLAotCQkJICAwKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIocHdtMSwgU19J UlVHTyB8IFNfSVdVU1IsIGk4a19od21vbl9zaG93X3B3bSwKLQkJCSAgaThrX2h3bW9uX3NldF9w d20sIDApOwotc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4yX2lucHV0LCBTX0lSVUdPLCBp OGtfaHdtb25fc2hvd19mYW4sIE5VTEwsCi0JCQkgIDEpOwotc3RhdGljIFNFTlNPUl9ERVZJQ0Vf QVRUUihmYW4yX2xhYmVsLCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd19mYW5fbGFiZWwsIE5VTEws Ci0JCQkgIDEpOwotc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihwd20yLCBTX0lSVUdPIHwgU19J V1VTUiwgaThrX2h3bW9uX3Nob3dfcHdtLAotCQkJICBpOGtfaHdtb25fc2V0X3B3bSwgMSk7Ci0K LXN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICppOGtfYXR0cnNbXSA9IHsKLQkmc2Vuc29yX2Rldl9h dHRyX3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIsCS8qIDAgKi8KLQkmc2Vuc29yX2Rldl9hdHRy X3RlbXAxX2xhYmVsLmRldl9hdHRyLmF0dHIsCS8qIDEgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX3Rl bXAyX2lucHV0LmRldl9hdHRyLmF0dHIsCS8qIDIgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX3RlbXAy X2xhYmVsLmRldl9hdHRyLmF0dHIsCS8qIDMgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX3RlbXAzX2lu cHV0LmRldl9hdHRyLmF0dHIsCS8qIDQgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX3RlbXAzX2xhYmVs LmRldl9hdHRyLmF0dHIsCS8qIDUgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX3RlbXA0X2lucHV0LmRl dl9hdHRyLmF0dHIsCS8qIDYgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX3RlbXA0X2xhYmVsLmRldl9h dHRyLmF0dHIsCS8qIDcgKi8KLQkmc2Vuc29yX2Rldl9hdHRyX2ZhbjFfaW5wdXQuZGV2X2F0dHIu YXR0ciwJLyogOCAqLwotCSZzZW5zb3JfZGV2X2F0dHJfZmFuMV9sYWJlbC5kZXZfYXR0ci5hdHRy LAkvKiA5ICovCi0JJnNlbnNvcl9kZXZfYXR0cl9wd20xLmRldl9hdHRyLmF0dHIsCQkvKiAxMCAq LwotCSZzZW5zb3JfZGV2X2F0dHJfZmFuMl9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiAxMSAqLwot CSZzZW5zb3JfZGV2X2F0dHJfZmFuMl9sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiAxMiAqLwotCSZz ZW5zb3JfZGV2X2F0dHJfcHdtMi5kZXZfYXR0ci5hdHRyLAkJLyogMTMgKi8KLQlOVUxMCi19Owot Ci1zdGF0aWMgdW1vZGVfdCBpOGtfaXNfdmlzaWJsZShzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3Ry dWN0IGF0dHJpYnV0ZSAqYXR0ciwKLQkJCSAgICAgIGludCBpbmRleCkKLXsKLQlpZiAoaW5kZXgg Pj0gMCAmJiBpbmRleCA8PSAxICYmCi0JICAgICEoaThrX2h3bW9uX2ZsYWdzICYgSThLX0hXTU9O X0hBVkVfVEVNUDEpKQotCQlyZXR1cm4gMDsKLQlpZiAoaW5kZXggPj0gMiAmJiBpbmRleCA8PSAz ICYmCi0JICAgICEoaThrX2h3bW9uX2ZsYWdzICYgSThLX0hXTU9OX0hBVkVfVEVNUDIpKQotCQly ZXR1cm4gMDsKLQlpZiAoaW5kZXggPj0gNCAmJiBpbmRleCA8PSA1ICYmCi0JICAgICEoaThrX2h3 bW9uX2ZsYWdzICYgSThLX0hXTU9OX0hBVkVfVEVNUDMpKQotCQlyZXR1cm4gMDsKLQlpZiAoaW5k ZXggPj0gNiAmJiBpbmRleCA8PSA3ICYmCi0JICAgICEoaThrX2h3bW9uX2ZsYWdzICYgSThLX0hX TU9OX0hBVkVfVEVNUDQpKQotCQlyZXR1cm4gMDsKLQlpZiAoaW5kZXggPj0gOCAmJiBpbmRleCA8 PSAxMCAmJgotCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX0ZBTjEpKQot CQlyZXR1cm4gMDsKLQlpZiAoaW5kZXggPj0gMTEgJiYgaW5kZXggPD0gMTMgJiYKLQkgICAgIShp OGtfaHdtb25fZmxhZ3MgJiBJOEtfSFdNT05fSEFWRV9GQU4yKSkKLQkJcmV0dXJuIDA7Ci0KLQly ZXR1cm4gYXR0ci0+bW9kZTsKLX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3Jv dXAgaThrX2dyb3VwID0gewotCS5hdHRycyA9IGk4a19hdHRycywKLQkuaXNfdmlzaWJsZSA9IGk4 a19pc192aXNpYmxlLAotfTsKLV9fQVRUUklCVVRFX0dST1VQUyhpOGspOwotCi1zdGF0aWMgaW50 IF9faW5pdCBpOGtfaW5pdF9od21vbih2b2lkKQotewotCWludCBlcnI7Ci0KLQlpOGtfaHdtb25f ZmxhZ3MgPSAwOwotCi0JLyogQ1BVIHRlbXBlcmF0dXJlIGF0dHJpYnV0ZXMsIGlmIHRlbXBlcmF0 dXJlIHR5cGUgaXMgT0sgKi8KLQllcnIgPSBpOGtfZ2V0X3RlbXBfdHlwZSgwKTsKLQlpZiAoZXJy ID49IDApCi0JCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9URU1QMTsKLQkvKiBj aGVjayBmb3IgYWRkaXRpb25hbCB0ZW1wZXJhdHVyZSBzZW5zb3JzICovCi0JZXJyID0gaThrX2dl dF90ZW1wX3R5cGUoMSk7Ci0JaWYgKGVyciA+PSAwKQotCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThL X0hXTU9OX0hBVkVfVEVNUDI7Ci0JZXJyID0gaThrX2dldF90ZW1wX3R5cGUoMik7Ci0JaWYgKGVy ciA+PSAwKQotCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVfVEVNUDM7Ci0JZXJy ID0gaThrX2dldF90ZW1wX3R5cGUoMyk7Ci0JaWYgKGVyciA+PSAwKQotCQlpOGtfaHdtb25fZmxh Z3MgfD0gSThLX0hXTU9OX0hBVkVfVEVNUDQ7Ci0KLQkvKiBGaXJzdCBmYW4gYXR0cmlidXRlcywg aWYgZmFuIHR5cGUgaXMgT0sgKi8KLQllcnIgPSBpOGtfZ2V0X2Zhbl90eXBlKDApOwotCWlmIChl cnIgPj0gMCkKLQkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX0ZBTjE7Ci0KLQkv KiBTZWNvbmQgZmFuIGF0dHJpYnV0ZXMsIGlmIGZhbiB0eXBlIGlzIE9LICovCi0JZXJyID0gaThr X2dldF9mYW5fdHlwZSgxKTsKLQlpZiAoZXJyID49IDApCi0JCWk4a19od21vbl9mbGFncyB8PSBJ OEtfSFdNT05fSEFWRV9GQU4yOwotCi0JaThrX2h3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdp c3Rlcl93aXRoX2dyb3VwcyhOVUxMLCAiaThrIiwgTlVMTCwKLQkJCQkJCQkgIGk4a19ncm91cHMp OwotCWlmIChJU19FUlIoaThrX2h3bW9uX2RldikpIHsKLQkJZXJyID0gUFRSX0VSUihpOGtfaHdt b25fZGV2KTsKLQkJaThrX2h3bW9uX2RldiA9IE5VTEw7Ci0JCXByX2VycigiaHdtb24gcmVnaXN0 cmF0aW9uIGZhaWxlZCAoJWQpXG4iLCBlcnIpOwotCQlyZXR1cm4gZXJyOwotCX0KLQlyZXR1cm4g MDsKLX0KLQotc3RydWN0IGk4a19jb25maWdfZGF0YSB7Ci0JdWludCBmYW5fbXVsdDsKLQl1aW50 IGZhbl9tYXg7Ci19OwotCi1lbnVtIGk4a19jb25maWdzIHsKLQlERUxMX0xBVElUVURFX0Q1MjAs Ci0JREVMTF9QUkVDSVNJT05fNDkwLAotCURFTExfU1RVRElPLAotCURFTExfWFBTLAotfTsKLQot c3RhdGljIGNvbnN0IHN0cnVjdCBpOGtfY29uZmlnX2RhdGEgaThrX2NvbmZpZ19kYXRhW10gPSB7 Ci0JW0RFTExfTEFUSVRVREVfRDUyMF0gPSB7Ci0JCS5mYW5fbXVsdCA9IDEsCi0JCS5mYW5fbWF4 ID0gSThLX0ZBTl9UVVJCTywKLQl9LAotCVtERUxMX1BSRUNJU0lPTl80OTBdID0gewotCQkuZmFu X211bHQgPSAxLAotCQkuZmFuX21heCA9IEk4S19GQU5fVFVSQk8sCi0JfSwKLQlbREVMTF9TVFVE SU9dID0gewotCQkuZmFuX211bHQgPSAxLAotCQkuZmFuX21heCA9IEk4S19GQU5fSElHSCwKLQl9 LAotCVtERUxMX1hQU10gPSB7Ci0JCS5mYW5fbXVsdCA9IDEsCi0JCS5mYW5fbWF4ID0gSThLX0ZB Tl9ISUdILAotCX0sCi19OwotCi1zdGF0aWMgc3RydWN0IGRtaV9zeXN0ZW1faWQgaThrX2RtaV90 YWJsZVtdIF9faW5pdGRhdGEgPSB7Ci0JewotCQkuaWRlbnQgPSAiRGVsbCBJbnNwaXJvbiIsCi0J CS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBDb21wdXRl ciIpLAotCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJJbnNwaXJvbiIpLAotCQl9LAot CX0sCi0JewotCQkuaWRlbnQgPSAiRGVsbCBMYXRpdHVkZSIsCi0JCS5tYXRjaGVzID0gewotCQkJ RE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBDb21wdXRlciIpLAotCQkJRE1JX01BVENI KERNSV9QUk9EVUNUX05BTUUsICJMYXRpdHVkZSIpLAotCQl9LAotCX0sCi0JewotCQkuaWRlbnQg PSAiRGVsbCBJbnNwaXJvbiAyIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZ U19WRU5ET1IsICJEZWxsIEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAi SW5zcGlyb24iKSwKLQkJfSwKLQl9LAotCXsKLQkJLmlkZW50ID0gIkRlbGwgTGF0aXR1ZGUgRDUy MCIsCi0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJ bmMuIiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkxhdGl0dWRlIEQ1MjAiKSwK LQkJfSwKLQkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfTEFU SVRVREVfRDUyMF0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIExhdGl0dWRlIDIiLAotCQku bWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAot CQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJMYXRpdHVkZSIpLAotCQl9LAotCX0sCi0J ewkvKiBVSyBJbnNwaXJvbiA2NDAwICAqLwotCQkuaWRlbnQgPSAiRGVsbCBJbnNwaXJvbiAzIiwK LQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4i KSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTU0wNjEiKSwKLQkJfSwKLQl9LAot CXsKLQkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24gMyIsCi0JCS5tYXRjaGVzID0gewotCQkJRE1J X01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCi0JCQlETUlfTUFUQ0goRE1JX1BS T0RVQ1RfTkFNRSwgIk1QMDYxIiksCi0JCX0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIFBy ZWNpc2lvbiA0OTAiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRP UiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsCi0JCQkJICAi UHJlY2lzaW9uIFdvcmtTdGF0aW9uIDQ5MCIpLAotCQl9LAotCQkuZHJpdmVyX2RhdGEgPSAodm9p ZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9QUkVDSVNJT05fNDkwXSwKLQl9LAotCXsKLQkJLmlk ZW50ID0gIkRlbGwgUHJlY2lzaW9uIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1J X1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1F LCAiUHJlY2lzaW9uIiksCi0JCX0sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIFZvc3RybyIs Ci0JCS5tYXRjaGVzID0gewotCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMu IiksCi0JCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlZvc3RybyIpLAotCQl9LAotCX0s Ci0JewotCQkuaWRlbnQgPSAiRGVsbCBYUFM0MjEiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9N QVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9E VUNUX05BTUUsICJYUFMgTDQyMVgiKSwKLQkJfSwKLQl9LAotCXsKLQkJLmlkZW50ID0gIkRlbGwg U3R1ZGlvIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJE ZWxsIEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiU3R1ZGlvIiksCi0J CX0sCi0JCS5kcml2ZXJfZGF0YSA9ICh2b2lkICopJmk4a19jb25maWdfZGF0YVtERUxMX1NUVURJ T10sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxsIFhQUyAxMyIsCi0JCS5tYXRjaGVzID0gewot CQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCi0JCQlETUlfTUFUQ0go RE1JX1BST0RVQ1RfTkFNRSwgIlhQUzEzIiksCi0JCX0sCi0JCS5kcml2ZXJfZGF0YSA9ICh2b2lk ICopJmk4a19jb25maWdfZGF0YVtERUxMX1hQU10sCi0JfSwKLQl7Ci0JCS5pZGVudCA9ICJEZWxs IFhQUyBNMTQwIiwKLQkJLm1hdGNoZXMgPSB7Ci0JCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1Is ICJEZWxsIEluYy4iKSwKLQkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTVhDMDUxIiks Ci0JCX0sCi0JCS5kcml2ZXJfZGF0YSA9ICh2b2lkICopJmk4a19jb25maWdfZGF0YVtERUxMX1hQ U10sCi0JfSwKLQl7IH0KLX07Ci0KLU1PRFVMRV9ERVZJQ0VfVEFCTEUoZG1pLCBpOGtfZG1pX3Rh YmxlKTsKLQotLyoKLSAqIFByb2JlIGZvciB0aGUgcHJlc2VuY2Ugb2YgYSBzdXBwb3J0ZWQgbGFw dG9wLgotICovCi1zdGF0aWMgaW50IF9faW5pdCBpOGtfcHJvYmUodm9pZCkKLXsKLQljb25zdCBz dHJ1Y3QgZG1pX3N5c3RlbV9pZCAqaWQ7Ci0JaW50IGZhbiwgcmV0OwotCi0JLyoKLQkgKiBHZXQg RE1JIGluZm9ybWF0aW9uCi0JICovCi0JaWYgKCFkbWlfY2hlY2tfc3lzdGVtKGk4a19kbWlfdGFi bGUpKSB7Ci0JCWlmICghaWdub3JlX2RtaSAmJiAhZm9yY2UpCi0JCQlyZXR1cm4gLUVOT0RFVjsK LQotCQlwcl9pbmZvKCJub3QgcnVubmluZyBvbiBhIHN1cHBvcnRlZCBEZWxsIHN5c3RlbS5cbiIp OwotCQlwcl9pbmZvKCJ2ZW5kb3I9JXMsIG1vZGVsPSVzLCB2ZXJzaW9uPSVzXG4iLAotCQkJaThr X2dldF9kbWlfZGF0YShETUlfU1lTX1ZFTkRPUiksCi0JCQlpOGtfZ2V0X2RtaV9kYXRhKERNSV9Q Uk9EVUNUX05BTUUpLAotCQkJaThrX2dldF9kbWlfZGF0YShETUlfQklPU19WRVJTSU9OKSk7Ci0J fQotCi0Jc3RybGNweShiaW9zX3ZlcnNpb24sIGk4a19nZXRfZG1pX2RhdGEoRE1JX0JJT1NfVkVS U0lPTiksCi0JCXNpemVvZihiaW9zX3ZlcnNpb24pKTsKLQotCS8qCi0JICogR2V0IFNNTSBEZWxs IHNpZ25hdHVyZQotCSAqLwotCWlmIChpOGtfZ2V0X2RlbGxfc2lnbmF0dXJlKEk4S19TTU1fR0VU X0RFTExfU0lHMSkgJiYKLQkgICAgaThrX2dldF9kZWxsX3NpZ25hdHVyZShJOEtfU01NX0dFVF9E RUxMX1NJRzIpKSB7Ci0JCXByX2VycigidW5hYmxlIHRvIGdldCBTTU0gRGVsbCBzaWduYXR1cmVc biIpOwotCQlpZiAoIWZvcmNlKQotCQkJcmV0dXJuIC1FTk9ERVY7Ci0JfQotCi0JLyoKLQkgKiBT ZXQgZmFuIG11bHRpcGxpZXIgYW5kIG1heGltYWwgZmFuIHNwZWVkIGZyb20gZG1pIGNvbmZpZwot CSAqIFZhbHVlcyBzcGVjaWZpZWQgaW4gbW9kdWxlIHBhcmFtZXRlcnMgb3ZlcnJpZGUgdmFsdWVz IGZyb20gZG1pCi0JICovCi0JaWQgPSBkbWlfZmlyc3RfbWF0Y2goaThrX2RtaV90YWJsZSk7Ci0J aWYgKGlkICYmIGlkLT5kcml2ZXJfZGF0YSkgewotCQljb25zdCBzdHJ1Y3QgaThrX2NvbmZpZ19k YXRhICpjb25mID0gaWQtPmRyaXZlcl9kYXRhOwotCQlpZiAoIWZhbl9tdWx0ICYmIGNvbmYtPmZh bl9tdWx0KQotCQkJZmFuX211bHQgPSBjb25mLT5mYW5fbXVsdDsKLQkJaWYgKCFmYW5fbWF4ICYm IGNvbmYtPmZhbl9tYXgpCi0JCQlmYW5fbWF4ID0gY29uZi0+ZmFuX21heDsKLQl9Ci0KLQlpOGtf ZmFuX21heCA9IGZhbl9tYXggPyA6IEk4S19GQU5fSElHSDsJLyogTXVzdCBub3QgYmUgMCAqLwot CWk4a19wd21fbXVsdCA9IERJVl9ST1VORF9VUCgyNTUsIGk4a19mYW5fbWF4KTsKLQotCWlmICgh ZmFuX211bHQpIHsKLQkJLyoKLQkJICogQXV0b2RldGVjdCBmYW4gbXVsdGlwbGllciBiYXNlZCBv biBub21pbmFsIHJwbQotCQkgKiBJZiBmYW4gcmVwb3J0cyBycG0gdmFsdWUgdG9vIGhpZ2ggdGhl biBzZXQgbXVsdGlwbGllciB0byAxCi0JCSAqLwotCQlmb3IgKGZhbiA9IDA7IGZhbiA8IDI7ICsr ZmFuKSB7Ci0JCQlyZXQgPSBpOGtfZ2V0X2Zhbl9ub21pbmFsX3NwZWVkKGZhbiwgaThrX2Zhbl9t YXgpOwotCQkJaWYgKHJldCA8IDApCi0JCQkJY29udGludWU7Ci0JCQlpZiAocmV0ID4gSThLX0ZB Tl9NQVhfUlBNKQotCQkJCWk4a19mYW5fbXVsdCA9IDE7Ci0JCQlicmVhazsKLQkJfQotCX0gZWxz ZSB7Ci0JCS8qIEZhbiBtdWx0aXBsaWVyIHdhcyBzcGVjaWZpZWQgaW4gbW9kdWxlIHBhcmFtIG9y IGluIGRtaSAqLwotCQlpOGtfZmFuX211bHQgPSBmYW5fbXVsdDsKLQl9Ci0KLQlyZXR1cm4gMDsK LX0KLQotc3RhdGljIGludCBfX2luaXQgaThrX2luaXQodm9pZCkKLXsKLQlzdHJ1Y3QgcHJvY19k aXJfZW50cnkgKnByb2NfaThrOwotCWludCBlcnI7Ci0KLQkvKiBBcmUgd2UgcnVubmluZyBvbiBh biBzdXBwb3J0ZWQgbGFwdG9wPyAqLwotCWlmIChpOGtfcHJvYmUoKSkKLQkJcmV0dXJuIC1FTk9E RVY7Ci0KLQkvKiBSZWdpc3RlciB0aGUgcHJvYyBlbnRyeSAqLwotCXByb2NfaThrID0gcHJvY19j cmVhdGUoImk4ayIsIDAsIE5VTEwsICZpOGtfZm9wcyk7Ci0JaWYgKCFwcm9jX2k4aykKLQkJcmV0 dXJuIC1FTk9FTlQ7Ci0KLQllcnIgPSBpOGtfaW5pdF9od21vbigpOwotCWlmIChlcnIpCi0JCWdv dG8gZXhpdF9yZW1vdmVfcHJvYzsKLQotCXJldHVybiAwOwotCi0gZXhpdF9yZW1vdmVfcHJvYzoK LQlyZW1vdmVfcHJvY19lbnRyeSgiaThrIiwgTlVMTCk7Ci0JcmV0dXJuIGVycjsKLX0KLQotc3Rh dGljIHZvaWQgX19leGl0IGk4a19leGl0KHZvaWQpCi17Ci0JaHdtb25fZGV2aWNlX3VucmVnaXN0 ZXIoaThrX2h3bW9uX2Rldik7Ci0JcmVtb3ZlX3Byb2NfZW50cnkoImk4ayIsIE5VTEwpOwotfQot Ci1tb2R1bGVfaW5pdChpOGtfaW5pdCk7Ci1tb2R1bGVfZXhpdChpOGtfZXhpdCk7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQppbmRl eCBiNGE0MGYxLi41MTUzM2FjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCisr KyBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKQEAgLTE1Niw2ICsxNTYsNyBAQCBvYmotJChDT05G SUdfU0VOU09SU19XODNMNzg1VFMpCSs9IHc4M2w3ODV0cy5vCiBvYmotJChDT05GSUdfU0VOU09S U19XODNMNzg2TkcpCSs9IHc4M2w3ODZuZy5vCiBvYmotJChDT05GSUdfU0VOU09SU19XTTgzMVgp CSs9IHdtODMxeC1od21vbi5vCiBvYmotJChDT05GSUdfU0VOU09SU19XTTgzNTApCSs9IHdtODM1 MC1od21vbi5vCitvYmotJChDT05GSUdfSThLKQkJKz0gZGVsbC1zbW0taHdtb24ubwogCiBvYmot JChDT05GSUdfUE1CVVMpCQkrPSBwbWJ1cy8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9k ZWxsLXNtbS1od21vbi5jIGIvZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY1ZDMxNGIKLS0tIC9kZXYvbnVsbAorKysgYi9k cml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMKQEAgLTAsMCArMSwxMDA5IEBACisvKgorICog ZGVsbC1zbW0taHdtb24uYyAtLSBMaW51eCBkcml2ZXIgZm9yIGFjY2Vzc2luZyB0aGUgU01NIEJJ T1Mgb24gRGVsbCBsYXB0b3BzLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwMSAgTWFzc2ltbyBE YWwgWm90dG8gPGR6QGRlYmlhbi5vcmc+CisgKgorICogSHdtb24gaW50ZWdyYXRpb246CisgKiBD b3B5cmlnaHQgKEMpIDIwMTEgIEplYW4gRGVsdmFyZSA8amRlbHZhcmVAc3VzZS5kZT4KKyAqIENv cHlyaWdodCAoQykgMjAxMywgMjAxNCAgR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0 PgorICogQ29weXJpZ2h0IChDKSAyMDE0LCAyMDE1ICBQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBn bWFpbC5jb20+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZQorICogRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRp b24pIGFueQorICogbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICov CisKKyNkZWZpbmUgcHJfZm10KGZtdCkgS0JVSUxEX01PRE5BTUUgIjogIiBmbXQKKworI2luY2x1 ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8 bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgv cHJvY19mcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NlcV9maWxlLmg+CisjaW5jbHVkZSA8bGludXgv ZG1pLmg+CisjaW5jbHVkZSA8bGludXgvY2FwYWJpbGl0eS5oPgorI2luY2x1ZGUgPGxpbnV4L211 dGV4Lmg+CisjaW5jbHVkZSA8bGludXgvaHdtb24uaD4KKyNpbmNsdWRlIDxsaW51eC9od21vbi1z eXNmcy5oPgorI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5o PgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CisKKyNpbmNsdWRlIDxsaW51eC9pOGsuaD4KKwor I2RlZmluZSBJOEtfU01NX0ZOX1NUQVRVUwkweDAwMjUKKyNkZWZpbmUgSThLX1NNTV9QT1dFUl9T VEFUVVMJMHgwMDY5CisjZGVmaW5lIEk4S19TTU1fU0VUX0ZBTgkJMHgwMWEzCisjZGVmaW5lIEk4 S19TTU1fR0VUX0ZBTgkJMHgwMGEzCisjZGVmaW5lIEk4S19TTU1fR0VUX1NQRUVECTB4MDJhMwor I2RlZmluZSBJOEtfU01NX0dFVF9GQU5fVFlQRQkweDAzYTMKKyNkZWZpbmUgSThLX1NNTV9HRVRf Tk9NX1NQRUVECTB4MDRhMworI2RlZmluZSBJOEtfU01NX0dFVF9URU1QCTB4MTBhMworI2RlZmlu ZSBJOEtfU01NX0dFVF9URU1QX1RZUEUJMHgxMWEzCisjZGVmaW5lIEk4S19TTU1fR0VUX0RFTExf U0lHMQkweGZlYTMKKyNkZWZpbmUgSThLX1NNTV9HRVRfREVMTF9TSUcyCTB4ZmZhMworCisjZGVm aW5lIEk4S19GQU5fTVVMVAkJMzAKKyNkZWZpbmUgSThLX0ZBTl9NQVhfUlBNCQkzMDAwMAorI2Rl ZmluZSBJOEtfTUFYX1RFTVAJCTEyNworCisjZGVmaW5lIEk4S19GTl9OT05FCQkweDAwCisjZGVm aW5lIEk4S19GTl9VUAkJMHgwMQorI2RlZmluZSBJOEtfRk5fRE9XTgkJMHgwMgorI2RlZmluZSBJ OEtfRk5fTVVURQkJMHgwNAorI2RlZmluZSBJOEtfRk5fTUFTSwkJMHgwNworI2RlZmluZSBJOEtf Rk5fU0hJRlQJCTgKKworI2RlZmluZSBJOEtfUE9XRVJfQUMJCTB4MDUKKyNkZWZpbmUgSThLX1BP V0VSX0JBVFRFUlkJMHgwMQorCitzdGF0aWMgREVGSU5FX01VVEVYKGk4a19tdXRleCk7CitzdGF0 aWMgY2hhciBiaW9zX3ZlcnNpb25bNF07CitzdGF0aWMgc3RydWN0IGRldmljZSAqaThrX2h3bW9u X2RldjsKK3N0YXRpYyB1MzIgaThrX2h3bW9uX2ZsYWdzOworc3RhdGljIHVpbnQgaThrX2Zhbl9t dWx0ID0gSThLX0ZBTl9NVUxUOworc3RhdGljIHVpbnQgaThrX3B3bV9tdWx0Oworc3RhdGljIHVp bnQgaThrX2Zhbl9tYXggPSBJOEtfRkFOX0hJR0g7CisKKyNkZWZpbmUgSThLX0hXTU9OX0hBVkVf VEVNUDEJKDEgPDwgMCkKKyNkZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDIJKDEgPDwgMSkKKyNk ZWZpbmUgSThLX0hXTU9OX0hBVkVfVEVNUDMJKDEgPDwgMikKKyNkZWZpbmUgSThLX0hXTU9OX0hB VkVfVEVNUDQJKDEgPDwgMykKKyNkZWZpbmUgSThLX0hXTU9OX0hBVkVfRkFOMQkoMSA8PCA0KQor I2RlZmluZSBJOEtfSFdNT05fSEFWRV9GQU4yCSgxIDw8IDUpCisKK01PRFVMRV9BVVRIT1IoIk1h c3NpbW8gRGFsIFpvdHRvIChkekBkZWJpYW4ub3JnKSIpOworTU9EVUxFX0FVVEhPUigiUGFsaSBS b2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJEcml2 ZXIgZm9yIGFjY2Vzc2luZyBTTU0gQklPUyBvbiBEZWxsIGxhcHRvcHMiKTsKK01PRFVMRV9MSUNF TlNFKCJHUEwiKTsKK01PRFVMRV9BTElBUygiaThrIik7CisKK3N0YXRpYyBib29sIGZvcmNlOwor bW9kdWxlX3BhcmFtKGZvcmNlLCBib29sLCAwKTsKK01PRFVMRV9QQVJNX0RFU0MoZm9yY2UsICJG b3JjZSBsb2FkaW5nIHdpdGhvdXQgY2hlY2tpbmcgZm9yIHN1cHBvcnRlZCBtb2RlbHMiKTsKKwor c3RhdGljIGJvb2wgaWdub3JlX2RtaTsKK21vZHVsZV9wYXJhbShpZ25vcmVfZG1pLCBib29sLCAw KTsKK01PRFVMRV9QQVJNX0RFU0MoaWdub3JlX2RtaSwgIkNvbnRpbnVlIHByb2JpbmcgaGFyZHdh cmUgZXZlbiBpZiBETUkgZGF0YSBkb2VzIG5vdCBtYXRjaCIpOworCitzdGF0aWMgYm9vbCByZXN0 cmljdGVkOworbW9kdWxlX3BhcmFtKHJlc3RyaWN0ZWQsIGJvb2wsIDApOworTU9EVUxFX1BBUk1f REVTQyhyZXN0cmljdGVkLCAiQWxsb3cgZmFuIGNvbnRyb2wgaWYgU1lTX0FETUlOIGNhcGFiaWxp dHkgc2V0Iik7CisKK3N0YXRpYyBib29sIHBvd2VyX3N0YXR1czsKK21vZHVsZV9wYXJhbShwb3dl cl9zdGF0dXMsIGJvb2wsIDA2MDApOworTU9EVUxFX1BBUk1fREVTQyhwb3dlcl9zdGF0dXMsICJS ZXBvcnQgcG93ZXIgc3RhdHVzIGluIC9wcm9jL2k4ayIpOworCitzdGF0aWMgdWludCBmYW5fbXVs dDsKK21vZHVsZV9wYXJhbShmYW5fbXVsdCwgdWludCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKGZh bl9tdWx0LCAiRmFjdG9yIHRvIG11bHRpcGx5IGZhbiBzcGVlZCB3aXRoIChkZWZhdWx0OiBhdXRv ZGV0ZWN0KSIpOworCitzdGF0aWMgdWludCBmYW5fbWF4OworbW9kdWxlX3BhcmFtKGZhbl9tYXgs IHVpbnQsIDApOworTU9EVUxFX1BBUk1fREVTQyhmYW5fbWF4LCAiTWF4aW11bSBjb25maWd1cmFi bGUgZmFuIHNwZWVkIChkZWZhdWx0OiBhdXRvZGV0ZWN0KSIpOworCitzdGF0aWMgaW50IGk4a19v cGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKTsKK3N0YXRpYyBs b25nIGk4a19pb2N0bChzdHJ1Y3QgZmlsZSAqLCB1bnNpZ25lZCBpbnQsIHVuc2lnbmVkIGxvbmcp OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBpOGtfZm9wcyA9IHsKKwku b3duZXIJCT0gVEhJU19NT0RVTEUsCisJLm9wZW4JCT0gaThrX29wZW5fZnMsCisJLnJlYWQJCT0g c2VxX3JlYWQsCisJLmxsc2VlawkJPSBzZXFfbHNlZWssCisJLnJlbGVhc2UJPSBzaW5nbGVfcmVs ZWFzZSwKKwkudW5sb2NrZWRfaW9jdGwJPSBpOGtfaW9jdGwsCit9OworCitzdHJ1Y3Qgc21tX3Jl Z3MgeworCXVuc2lnbmVkIGludCBlYXg7CisJdW5zaWduZWQgaW50IGVieCBfX3BhY2tlZDsKKwl1 bnNpZ25lZCBpbnQgZWN4IF9fcGFja2VkOworCXVuc2lnbmVkIGludCBlZHggX19wYWNrZWQ7CisJ dW5zaWduZWQgaW50IGVzaSBfX3BhY2tlZDsKKwl1bnNpZ25lZCBpbnQgZWRpIF9fcGFja2VkOwor fTsKKworc3RhdGljIGlubGluZSBjb25zdCBjaGFyICppOGtfZ2V0X2RtaV9kYXRhKGludCBmaWVs ZCkKK3sKKwljb25zdCBjaGFyICpkbWlfZGF0YSA9IGRtaV9nZXRfc3lzdGVtX2luZm8oZmllbGQp OworCisJcmV0dXJuIGRtaV9kYXRhICYmICpkbWlfZGF0YSA/IGRtaV9kYXRhIDogIj8iOworfQor CisvKgorICogQ2FsbCB0aGUgU3lzdGVtIE1hbmFnZW1lbnQgTW9kZSBCSU9TLiBDb2RlIHByb3Zp ZGVkIGJ5IEpvbmF0aGFuIEJ1enphcmQuCisgKi8KK3N0YXRpYyBpbnQgaThrX3NtbShzdHJ1Y3Qg c21tX3JlZ3MgKnJlZ3MpCit7CisJaW50IHJjOworCWludCBlYXggPSByZWdzLT5lYXg7CisJY3B1 bWFza192YXJfdCBvbGRfbWFzazsKKworCS8qIFNNTSByZXF1aXJlcyBDUFUgMCAqLworCWlmICgh YWxsb2NfY3B1bWFza192YXIoJm9sZF9tYXNrLCBHRlBfS0VSTkVMKSkKKwkJcmV0dXJuIC1FTk9N RU07CisJY3B1bWFza19jb3B5KG9sZF9tYXNrLCAmY3VycmVudC0+Y3B1c19hbGxvd2VkKTsKKwly YyA9IHNldF9jcHVzX2FsbG93ZWRfcHRyKGN1cnJlbnQsIGNwdW1hc2tfb2YoMCkpOworCWlmIChy YykKKwkJZ290byBvdXQ7CisJaWYgKHNtcF9wcm9jZXNzb3JfaWQoKSAhPSAwKSB7CisJCXJjID0g LUVCVVNZOworCQlnb3RvIG91dDsKKwl9CisKKyNpZiBkZWZpbmVkKENPTkZJR19YODZfNjQpCisJ YXNtIHZvbGF0aWxlKCJwdXNocSAlJXJheFxuXHQiCisJCSJtb3ZsIDAoJSVyYXgpLCUlZWR4XG5c dCIKKwkJInB1c2hxICUlcmR4XG5cdCIKKwkJIm1vdmwgNCglJXJheCksJSVlYnhcblx0IgorCQki bW92bCA4KCUlcmF4KSwlJWVjeFxuXHQiCisJCSJtb3ZsIDEyKCUlcmF4KSwlJWVkeFxuXHQiCisJ CSJtb3ZsIDE2KCUlcmF4KSwlJWVzaVxuXHQiCisJCSJtb3ZsIDIwKCUlcmF4KSwlJWVkaVxuXHQi CisJCSJwb3BxICUlcmF4XG5cdCIKKwkJIm91dCAlJWFsLCQweGIyXG5cdCIKKwkJIm91dCAlJWFs LCQweDg0XG5cdCIKKwkJInhjaGdxICUlcmF4LCglJXJzcClcblx0IgorCQkibW92bCAlJWVieCw0 KCUlcmF4KVxuXHQiCisJCSJtb3ZsICUlZWN4LDgoJSVyYXgpXG5cdCIKKwkJIm1vdmwgJSVlZHgs MTIoJSVyYXgpXG5cdCIKKwkJIm1vdmwgJSVlc2ksMTYoJSVyYXgpXG5cdCIKKwkJIm1vdmwgJSVl ZGksMjAoJSVyYXgpXG5cdCIKKwkJInBvcHEgJSVyZHhcblx0IgorCQkibW92bCAlJWVkeCwwKCUl cmF4KVxuXHQiCisJCSJwdXNoZnFcblx0IgorCQkicG9wcSAlJXJheFxuXHQiCisJCSJhbmRsICQx LCUlZWF4XG4iCisJCTogIj1hIihyYykKKwkJOiAgICAiYSIocmVncykKKwkJOiAgICAiJWVieCIs ICIlZWN4IiwgIiVlZHgiLCAiJWVzaSIsICIlZWRpIiwgIm1lbW9yeSIpOworI2Vsc2UKKwlhc20g dm9sYXRpbGUoInB1c2hsICUlZWF4XG5cdCIKKwkgICAgIm1vdmwgMCglJWVheCksJSVlZHhcblx0 IgorCSAgICAicHVzaCAlJWVkeFxuXHQiCisJICAgICJtb3ZsIDQoJSVlYXgpLCUlZWJ4XG5cdCIK KwkgICAgIm1vdmwgOCglJWVheCksJSVlY3hcblx0IgorCSAgICAibW92bCAxMiglJWVheCksJSVl ZHhcblx0IgorCSAgICAibW92bCAxNiglJWVheCksJSVlc2lcblx0IgorCSAgICAibW92bCAyMCgl JWVheCksJSVlZGlcblx0IgorCSAgICAicG9wbCAlJWVheFxuXHQiCisJICAgICJvdXQgJSVhbCwk MHhiMlxuXHQiCisJICAgICJvdXQgJSVhbCwkMHg4NFxuXHQiCisJICAgICJ4Y2hnbCAlJWVheCwo JSVlc3ApXG5cdCIKKwkgICAgIm1vdmwgJSVlYngsNCglJWVheClcblx0IgorCSAgICAibW92bCAl JWVjeCw4KCUlZWF4KVxuXHQiCisJICAgICJtb3ZsICUlZWR4LDEyKCUlZWF4KVxuXHQiCisJICAg ICJtb3ZsICUlZXNpLDE2KCUlZWF4KVxuXHQiCisJICAgICJtb3ZsICUlZWRpLDIwKCUlZWF4KVxu XHQiCisJICAgICJwb3BsICUlZWR4XG5cdCIKKwkgICAgIm1vdmwgJSVlZHgsMCglJWVheClcblx0 IgorCSAgICAibGFoZlxuXHQiCisJICAgICJzaHJsICQ4LCUlZWF4XG5cdCIKKwkgICAgImFuZGwg JDEsJSVlYXhcbiIKKwkgICAgOiAiPWEiKHJjKQorCSAgICA6ICAgICJhIihyZWdzKQorCSAgICA6 ICAgICIlZWJ4IiwgIiVlY3giLCAiJWVkeCIsICIlZXNpIiwgIiVlZGkiLCAibWVtb3J5Iik7Cisj ZW5kaWYKKwlpZiAocmMgIT0gMCB8fCAocmVncy0+ZWF4ICYgMHhmZmZmKSA9PSAweGZmZmYgfHwg cmVncy0+ZWF4ID09IGVheCkKKwkJcmMgPSAtRUlOVkFMOworCitvdXQ6CisJc2V0X2NwdXNfYWxs b3dlZF9wdHIoY3VycmVudCwgb2xkX21hc2spOworCWZyZWVfY3B1bWFza192YXIob2xkX21hc2sp OworCXJldHVybiByYzsKK30KKworLyoKKyAqIFJlYWQgdGhlIEZuIGtleSBzdGF0dXMuCisgKi8K K3N0YXRpYyBpbnQgaThrX2dldF9mbl9zdGF0dXModm9pZCkKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3Mg cmVncyA9IHsgLmVheCA9IEk4S19TTU1fRk5fU1RBVFVTLCB9OworCWludCByYzsKKworCXJjID0g aThrX3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJcmV0dXJuIHJjOworCisJc3dpdGNoICgo cmVncy5lYXggPj4gSThLX0ZOX1NISUZUKSAmIEk4S19GTl9NQVNLKSB7CisJY2FzZSBJOEtfRk5f VVA6CisJCXJldHVybiBJOEtfVk9MX1VQOworCWNhc2UgSThLX0ZOX0RPV046CisJCXJldHVybiBJ OEtfVk9MX0RPV047CisJY2FzZSBJOEtfRk5fTVVURToKKwkJcmV0dXJuIEk4S19WT0xfTVVURTsK KwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9Cit9CisKKy8qCisgKiBSZWFkIHRoZSBwb3dlciBz dGF0dXMuCisgKi8KK3N0YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9pZCkKK3sKKwlz dHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fUE9XRVJfU1RBVFVTLCB9Owor CWludCByYzsKKworCXJjID0gaThrX3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJcmV0dXJu IHJjOworCisJcmV0dXJuIChyZWdzLmVheCAmIDB4ZmYpID09IEk4S19QT1dFUl9BQyA/IEk4S19B QyA6IEk4S19CQVRURVJZOworfQorCisvKgorICogUmVhZCB0aGUgZmFuIHN0YXR1cy4KKyAqLwor c3RhdGljIGludCBpOGtfZ2V0X2Zhbl9zdGF0dXMoaW50IGZhbikKK3sKKwlzdHJ1Y3Qgc21tX3Jl Z3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fR0VUX0ZBTiwgfTsKKworCXJlZ3MuZWJ4ID0gZmFu ICYgMHhmZjsKKwlyZXR1cm4gaThrX3NtbSgmcmVncykgPyA6IHJlZ3MuZWF4ICYgMHhmZjsKK30K KworLyoKKyAqIFJlYWQgdGhlIGZhbiBzcGVlZCBpbiBSUE0uCisgKi8KK3N0YXRpYyBpbnQgaThr X2dldF9mYW5fc3BlZWQoaW50IGZhbikKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVh eCA9IEk4S19TTU1fR0VUX1NQRUVELCB9OworCisJcmVncy5lYnggPSBmYW4gJiAweGZmOworCXJl dHVybiBpOGtfc21tKCZyZWdzKSA/IDogKHJlZ3MuZWF4ICYgMHhmZmZmKSAqIGk4a19mYW5fbXVs dDsKK30KKworLyoKKyAqIFJlYWQgdGhlIGZhbiB0eXBlLgorICovCitzdGF0aWMgaW50IGk4a19n ZXRfZmFuX3R5cGUoaW50IGZhbikKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9 IEk4S19TTU1fR0VUX0ZBTl9UWVBFLCB9OworCisJcmVncy5lYnggPSBmYW4gJiAweGZmOworCXJl dHVybiBpOGtfc21tKCZyZWdzKSA/IDogcmVncy5lYXggJiAweGZmOworfQorCisvKgorICogUmVh ZCB0aGUgZmFuIG5vbWluYWwgcnBtIGZvciBzcGVjaWZpYyBmYW4gc3BlZWQuCisgKi8KK3N0YXRp YyBpbnQgaThrX2dldF9mYW5fbm9taW5hbF9zcGVlZChpbnQgZmFuLCBpbnQgc3BlZWQpCit7CisJ c3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX0dFVF9OT01fU1BFRUQsIH07 CisKKwlyZWdzLmVieCA9IChmYW4gJiAweGZmKSB8IChzcGVlZCA8PCA4KTsKKwlyZXR1cm4gaThr X3NtbSgmcmVncykgPyA6IChyZWdzLmVheCAmIDB4ZmZmZikgKiBpOGtfZmFuX211bHQ7Cit9CisK Ky8qCisgKiBTZXQgdGhlIGZhbiBzcGVlZCAob2ZmLCBsb3csIGhpZ2gpLiBSZXR1cm5zIHRoZSBu ZXcgZmFuIHN0YXR1cy4KKyAqLworc3RhdGljIGludCBpOGtfc2V0X2ZhbihpbnQgZmFuLCBpbnQg c3BlZWQpCit7CisJc3RydWN0IHNtbV9yZWdzIHJlZ3MgPSB7IC5lYXggPSBJOEtfU01NX1NFVF9G QU4sIH07CisKKwlzcGVlZCA9IChzcGVlZCA8IDApID8gMCA6ICgoc3BlZWQgPiBpOGtfZmFuX21h eCkgPyBpOGtfZmFuX21heCA6IHNwZWVkKTsKKwlyZWdzLmVieCA9IChmYW4gJiAweGZmKSB8IChz cGVlZCA8PCA4KTsKKworCXJldHVybiBpOGtfc21tKCZyZWdzKSA/IDogaThrX2dldF9mYW5fc3Rh dHVzKGZhbik7Cit9CisKK3N0YXRpYyBpbnQgaThrX2dldF90ZW1wX3R5cGUoaW50IHNlbnNvcikK K3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fR0VUX1RFTVBfVFlQ RSwgfTsKKworCXJlZ3MuZWJ4ID0gc2Vuc29yICYgMHhmZjsKKwlyZXR1cm4gaThrX3NtbSgmcmVn cykgPyA6IHJlZ3MuZWF4ICYgMHhmZjsKK30KKworLyoKKyAqIFJlYWQgdGhlIGNwdSB0ZW1wZXJh dHVyZS4KKyAqLworc3RhdGljIGludCBfaThrX2dldF90ZW1wKGludCBzZW5zb3IpCit7CisJc3Ry dWN0IHNtbV9yZWdzIHJlZ3MgPSB7CisJCS5lYXggPSBJOEtfU01NX0dFVF9URU1QLAorCQkuZWJ4 ID0gc2Vuc29yICYgMHhmZiwKKwl9OworCisJcmV0dXJuIGk4a19zbW0oJnJlZ3MpID8gOiByZWdz LmVheCAmIDB4ZmY7Cit9CisKK3N0YXRpYyBpbnQgaThrX2dldF90ZW1wKGludCBzZW5zb3IpCit7 CisJaW50IHRlbXAgPSBfaThrX2dldF90ZW1wKHNlbnNvcik7CisKKwkvKgorCSAqIFNvbWV0aW1l cyB0aGUgdGVtcGVyYXR1cmUgc2Vuc29yIHJldHVybnMgMHg5OSwgd2hpY2ggaXMgb3V0IG9mIHJh bmdlLgorCSAqIEluIHRoaXMgY2FzZSB3ZSByZXRyeSAob25jZSkgYmVmb3JlIHJldHVybmluZyBh biBlcnJvci4KKwkgIyAxMDAzNjU1MTM3IDAwMDAwMDU4IDAwMDA1YTRiCisJICMgMTAwMzY1NTEz OCAwMDAwMDA5OSAwMDAwM2E4MCA8LS0tIDB4OTkgPSAxNTMgZGVncmVlcworCSAjIDEwMDM2NTUx MzkgMDAwMDAwNTQgMDAwMDVjNTIKKwkgKi8KKwlpZiAodGVtcCA9PSAweDk5KSB7CisJCW1zbGVl cCgxMDApOworCQl0ZW1wID0gX2k4a19nZXRfdGVtcChzZW5zb3IpOworCX0KKwkvKgorCSAqIFJl dHVybiAtRU5PREFUQSBmb3IgYWxsIGludmFsaWQgdGVtcGVyYXR1cmVzLgorCSAqCisJICogS25v d24gaW5zdGFuY2VzIGFyZSB0aGUgMHg5OSB2YWx1ZSBhcyBzZWVuIGFib3ZlIGFzIHdlbGwgYXMK KwkgKiAweGMxICgxOTMpLCB3aGljaCBtYXkgYmUgcmV0dXJuZWQgd2hlbiB0cnlpbmcgdG8gcmVh ZCB0aGUgR1BVCisJICogdGVtcGVyYXR1cmUgaWYgdGhlIHN5c3RlbSBzdXBwb3J0cyBhIEdQVSBh bmQgaXQgaXMgY3VycmVudGx5CisJICogdHVybmVkIG9mZi4KKwkgKi8KKwlpZiAodGVtcCA+IEk4 S19NQVhfVEVNUCkKKwkJcmV0dXJuIC1FTk9EQVRBOworCisJcmV0dXJuIHRlbXA7Cit9CisKK3N0 YXRpYyBpbnQgaThrX2dldF9kZWxsX3NpZ25hdHVyZShpbnQgcmVxX2ZuKQoreworCXN0cnVjdCBz bW1fcmVncyByZWdzID0geyAuZWF4ID0gcmVxX2ZuLCB9OworCWludCByYzsKKworCXJjID0gaThr X3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJcmV0dXJuIHJjOworCisJcmV0dXJuIHJlZ3Mu ZWF4ID09IDExNDU2NTE1MjcgJiYgcmVncy5lZHggPT0gMTE0NTM5MjIwNCA/IDAgOiAtMTsKK30K Kworc3RhdGljIGludAoraThrX2lvY3RsX3VubG9ja2VkKHN0cnVjdCBmaWxlICpmcCwgdW5zaWdu ZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJaW50IHZhbCA9IDA7CisJaW50IHNw ZWVkOworCXVuc2lnbmVkIGNoYXIgYnVmZlsxNl07CisJaW50IF9fdXNlciAqYXJncCA9IChpbnQg X191c2VyICopYXJnOworCisJaWYgKCFhcmdwKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXN3aXRj aCAoY21kKSB7CisJY2FzZSBJOEtfQklPU19WRVJTSU9OOgorCQl2YWwgPSAoYmlvc192ZXJzaW9u WzBdIDw8IDE2KSB8CisJCQkJKGJpb3NfdmVyc2lvblsxXSA8PCA4KSB8IGJpb3NfdmVyc2lvblsy XTsKKwkJYnJlYWs7CisKKwljYXNlIEk4S19NQUNISU5FX0lEOgorCQltZW1zZXQoYnVmZiwgMCwg MTYpOworCQlzdHJsY3B5KGJ1ZmYsIGk4a19nZXRfZG1pX2RhdGEoRE1JX1BST0RVQ1RfU0VSSUFM KSwKKwkJCXNpemVvZihidWZmKSk7CisJCWJyZWFrOworCisJY2FzZSBJOEtfRk5fU1RBVFVTOgor CQl2YWwgPSBpOGtfZ2V0X2ZuX3N0YXR1cygpOworCQlicmVhazsKKworCWNhc2UgSThLX1BPV0VS X1NUQVRVUzoKKwkJdmFsID0gaThrX2dldF9wb3dlcl9zdGF0dXMoKTsKKwkJYnJlYWs7CisKKwlj YXNlIEk4S19HRVRfVEVNUDoKKwkJdmFsID0gaThrX2dldF90ZW1wKDApOworCQlicmVhazsKKwor CWNhc2UgSThLX0dFVF9TUEVFRDoKKwkJaWYgKGNvcHlfZnJvbV91c2VyKCZ2YWwsIGFyZ3AsIHNp emVvZihpbnQpKSkKKwkJCXJldHVybiAtRUZBVUxUOworCisJCXZhbCA9IGk4a19nZXRfZmFuX3Nw ZWVkKHZhbCk7CisJCWJyZWFrOworCisJY2FzZSBJOEtfR0VUX0ZBTjoKKwkJaWYgKGNvcHlfZnJv bV91c2VyKCZ2YWwsIGFyZ3AsIHNpemVvZihpbnQpKSkKKwkJCXJldHVybiAtRUZBVUxUOworCisJ CXZhbCA9IGk4a19nZXRfZmFuX3N0YXR1cyh2YWwpOworCQlicmVhazsKKworCWNhc2UgSThLX1NF VF9GQU46CisJCWlmIChyZXN0cmljdGVkICYmICFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQorCQkJ cmV0dXJuIC1FUEVSTTsKKworCQlpZiAoY29weV9mcm9tX3VzZXIoJnZhbCwgYXJncCwgc2l6ZW9m KGludCkpKQorCQkJcmV0dXJuIC1FRkFVTFQ7CisKKwkJaWYgKGNvcHlfZnJvbV91c2VyKCZzcGVl ZCwgYXJncCArIDEsIHNpemVvZihpbnQpKSkKKwkJCXJldHVybiAtRUZBVUxUOworCisJCXZhbCA9 IGk4a19zZXRfZmFuKHZhbCwgc3BlZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCXJldHVy biAtRUlOVkFMOworCX0KKworCWlmICh2YWwgPCAwKQorCQlyZXR1cm4gdmFsOworCisJc3dpdGNo IChjbWQpIHsKKwljYXNlIEk4S19CSU9TX1ZFUlNJT046CisJCWlmIChjb3B5X3RvX3VzZXIoYXJn cCwgJnZhbCwgNCkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKworCQlicmVhazsKKwljYXNlIEk4S19N QUNISU5FX0lEOgorCQlpZiAoY29weV90b191c2VyKGFyZ3AsIGJ1ZmYsIDE2KSkKKwkJCXJldHVy biAtRUZBVUxUOworCisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWlmIChjb3B5X3RvX3VzZXIoYXJn cCwgJnZhbCwgc2l6ZW9mKGludCkpKQorCQkJcmV0dXJuIC1FRkFVTFQ7CisKKwkJYnJlYWs7CisJ fQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBsb25nIGk4a19pb2N0bChzdHJ1Y3QgZmlsZSAq ZnAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQoreworCWxvbmcgcmV0Owor CisJbXV0ZXhfbG9jaygmaThrX211dGV4KTsKKwlyZXQgPSBpOGtfaW9jdGxfdW5sb2NrZWQoZnAs IGNtZCwgYXJnKTsKKwltdXRleF91bmxvY2soJmk4a19tdXRleCk7CisKKwlyZXR1cm4gcmV0Owor fQorCisvKgorICogUHJpbnQgdGhlIGluZm9ybWF0aW9uIGZvciAvcHJvYy9pOGsuCisgKi8KK3N0 YXRpYyBpbnQgaThrX3Byb2Nfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqb2Zmc2V0 KQoreworCWludCBmbl9rZXksIGNwdV90ZW1wLCBhY19wb3dlcjsKKwlpbnQgbGVmdF9mYW4sIHJp Z2h0X2ZhbiwgbGVmdF9zcGVlZCwgcmlnaHRfc3BlZWQ7CisKKwljcHVfdGVtcAk9IGk4a19nZXRf dGVtcCgwKTsJCQkvKiAxMTEwMCDCtXMgKi8KKwlsZWZ0X2Zhbgk9IGk4a19nZXRfZmFuX3N0YXR1 cyhJOEtfRkFOX0xFRlQpOwkvKiAgIDU4MCDCtXMgKi8KKwlyaWdodF9mYW4JPSBpOGtfZ2V0X2Zh bl9zdGF0dXMoSThLX0ZBTl9SSUdIVCk7CS8qICAgNTgwIMK1cyAqLworCWxlZnRfc3BlZWQJPSBp OGtfZ2V0X2Zhbl9zcGVlZChJOEtfRkFOX0xFRlQpOwkvKiAgIDU4MCDCtXMgKi8KKwlyaWdodF9z cGVlZAk9IGk4a19nZXRfZmFuX3NwZWVkKEk4S19GQU5fUklHSFQpOwkvKiAgIDU4MCDCtXMgKi8K Kwlmbl9rZXkJCT0gaThrX2dldF9mbl9zdGF0dXMoKTsJCQkvKiAgIDc1MCDCtXMgKi8KKwlpZiAo cG93ZXJfc3RhdHVzKQorCQlhY19wb3dlciA9IGk4a19nZXRfcG93ZXJfc3RhdHVzKCk7CQkvKiAx NDcwMCDCtXMgKi8KKwllbHNlCisJCWFjX3Bvd2VyID0gLTE7CisKKwkvKgorCSAqIEluZm86CisJ ICoKKwkgKiAxKSAgRm9ybWF0IHZlcnNpb24gKHRoaXMgd2lsbCBjaGFuZ2UgaWYgZm9ybWF0IGNo YW5nZXMpCisJICogMikgIEJJT1MgdmVyc2lvbgorCSAqIDMpICBCSU9TIG1hY2hpbmUgSUQKKwkg KiA0KSAgQ3B1IHRlbXBlcmF0dXJlCisJICogNSkgIExlZnQgZmFuIHN0YXR1cworCSAqIDYpICBS aWdodCBmYW4gc3RhdHVzCisJICogNykgIExlZnQgZmFuIHNwZWVkCisJICogOCkgIFJpZ2h0IGZh biBzcGVlZAorCSAqIDkpICBBQyBwb3dlcgorCSAqIDEwKSBGbiBLZXkgc3RhdHVzCisJICovCisJ c2VxX3ByaW50ZihzZXEsICIlcyAlcyAlcyAlZCAlZCAlZCAlZCAlZCAlZCAlZFxuIiwKKwkJICAg SThLX1BST0NfRk1ULAorCQkgICBiaW9zX3ZlcnNpb24sCisJCSAgIGk4a19nZXRfZG1pX2RhdGEo RE1JX1BST0RVQ1RfU0VSSUFMKSwKKwkJICAgY3B1X3RlbXAsCisJCSAgIGxlZnRfZmFuLCByaWdo dF9mYW4sIGxlZnRfc3BlZWQsIHJpZ2h0X3NwZWVkLAorCQkgICBhY19wb3dlciwgZm5fa2V5KTsK KworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGk4a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAq aW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBp OGtfcHJvY19zaG93LCBOVUxMKTsKK30KKworCisvKgorICogSHdtb24gaW50ZXJmYWNlCisgKi8K Kworc3RhdGljIHNzaXplX3QgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbChzdHJ1Y3QgZGV2aWNl ICpkZXYsCisJCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKKwkJCQkJIGNo YXIgKmJ1ZikKK3sKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGxhYmVsc1tdID0geworCQki Q1BVIiwKKwkJIkdQVSIsCisJCSJTT0RJTU0iLAorCQkiT3RoZXIiLAorCQkiQW1iaWVudCIsCisJ CSJPdGhlciIsCisJfTsKKwlpbnQgaW5kZXggPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0cikt PmluZGV4OworCWludCB0eXBlOworCisJdHlwZSA9IGk4a19nZXRfdGVtcF90eXBlKGluZGV4KTsK KwlpZiAodHlwZSA8IDApCisJCXJldHVybiB0eXBlOworCWlmICh0eXBlID49IEFSUkFZX1NJWkUo bGFiZWxzKSkKKwkJdHlwZSA9IEFSUkFZX1NJWkUobGFiZWxzKSAtIDE7CisJcmV0dXJuIHNwcmlu dGYoYnVmLCAiJXNcbiIsIGxhYmVsc1t0eXBlXSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGk4a19o d21vbl9zaG93X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCSAgIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICpkZXZhdHRyLAorCQkJCSAgIGNoYXIgKmJ1ZikKK3sKKwlpbnQgaW5kZXggPSB0 b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0ciktPmluZGV4OworCWludCB0ZW1wOworCisJdGVtcCA9 IGk4a19nZXRfdGVtcChpbmRleCk7CisJaWYgKHRlbXAgPCAwKQorCQlyZXR1cm4gdGVtcDsKKwly ZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgdGVtcCAqIDEwMDApOworfQorCitzdGF0aWMgc3Np emVfdCBpOGtfaHdtb25fc2hvd19mYW5fbGFiZWwoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCQlz dHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKKwkJCQkJY2hhciAqYnVmKQoreworCXN0 YXRpYyBjb25zdCBjaGFyICogY29uc3QgbGFiZWxzW10gPSB7CisJCSJQcm9jZXNzb3IgRmFuIiwK KwkJIk1vdGhlcmJvYXJkIEZhbiIsCisJCSJWaWRlbyBGYW4iLAorCQkiUG93ZXIgU3VwcGx5IEZh biIsCisJCSJDaGlwc2V0IEZhbiIsCisJCSJPdGhlciBGYW4iLAorCX07CisJaW50IGluZGV4ID0g dG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKKwlib29sIGRvY2sgPSBmYWxzZTsK KwlpbnQgdHlwZTsKKworCXR5cGUgPSBpOGtfZ2V0X2Zhbl90eXBlKGluZGV4KTsKKwlpZiAodHlw ZSA8IDApCisJCXJldHVybiB0eXBlOworCisJaWYgKHR5cGUgJiAweDEwKSB7CisJCWRvY2sgPSB0 cnVlOworCQl0eXBlICY9IDB4MEY7CisJfQorCisJaWYgKHR5cGUgPj0gQVJSQVlfU0laRShsYWJl bHMpKQorCQl0eXBlID0gKEFSUkFZX1NJWkUobGFiZWxzKSAtIDEpOworCisJcmV0dXJuIHNwcmlu dGYoYnVmLCAiJXMlc1xuIiwgKGRvY2sgPyAiRG9ja2luZyAiIDogIiIpLCBsYWJlbHNbdHlwZV0p OworfQorCitzdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2hvd19mYW4oc3RydWN0IGRldmljZSAq ZGV2LAorCQkJCSAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCisJCQkJICBjaGFy ICpidWYpCit7CisJaW50IGluZGV4ID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRl eDsKKwlpbnQgZmFuX3NwZWVkOworCisJZmFuX3NwZWVkID0gaThrX2dldF9mYW5fc3BlZWQoaW5k ZXgpOworCWlmIChmYW5fc3BlZWQgPCAwKQorCQlyZXR1cm4gZmFuX3NwZWVkOworCXJldHVybiBz cHJpbnRmKGJ1ZiwgIiVkXG4iLCBmYW5fc3BlZWQpOworfQorCitzdGF0aWMgc3NpemVfdCBpOGtf aHdtb25fc2hvd19wd20oc3RydWN0IGRldmljZSAqZGV2LAorCQkJCSAgc3RydWN0IGRldmljZV9h dHRyaWJ1dGUgKmRldmF0dHIsCisJCQkJICBjaGFyICpidWYpCit7CisJaW50IGluZGV4ID0gdG9f c2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKKwlpbnQgc3RhdHVzOworCisJc3RhdHVz ID0gaThrX2dldF9mYW5fc3RhdHVzKGluZGV4KTsKKwlpZiAoc3RhdHVzIDwgMCkKKwkJcmV0dXJu IC1FSU87CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIGNsYW1wX3ZhbChzdGF0dXMgKiBp OGtfcHdtX211bHQsIDAsIDI1NSkpOworfQorCitzdGF0aWMgc3NpemVfdCBpOGtfaHdtb25fc2V0 X3B3bShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICph dHRyLAorCQkJCSBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwlpbnQgaW5kZXgg PSB0b19zZW5zb3JfZGV2X2F0dHIoYXR0ciktPmluZGV4OworCXVuc2lnbmVkIGxvbmcgdmFsOwor CWludCBlcnI7CisKKwllcnIgPSBrc3RydG91bChidWYsIDEwLCAmdmFsKTsKKwlpZiAoZXJyKQor CQlyZXR1cm4gZXJyOworCXZhbCA9IGNsYW1wX3ZhbChESVZfUk9VTkRfQ0xPU0VTVCh2YWwsIGk4 a19wd21fbXVsdCksIDAsIGk4a19mYW5fbWF4KTsKKworCW11dGV4X2xvY2soJmk4a19tdXRleCk7 CisJZXJyID0gaThrX3NldF9mYW4oaW5kZXgsIHZhbCk7CisJbXV0ZXhfdW5sb2NrKCZpOGtfbXV0 ZXgpOworCisJcmV0dXJuIGVyciA8IDAgPyAtRUlPIDogY291bnQ7Cit9CisKK3N0YXRpYyBTRU5T T1JfREVWSUNFX0FUVFIodGVtcDFfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3RlbXAs IE5VTEwsIDApOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9sYWJlbCwgU19JUlVH TywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbCwgTlVMTCwKKwkJCSAgMCk7CitzdGF0aWMgU0VO U09SX0RFVklDRV9BVFRSKHRlbXAyX2lucHV0LCBTX0lSVUdPLCBpOGtfaHdtb25fc2hvd190ZW1w LCBOVUxMLCAxKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDJfbGFiZWwsIFNfSVJV R08sIGk4a19od21vbl9zaG93X3RlbXBfbGFiZWwsIE5VTEwsCisJCQkgIDEpOworc3RhdGljIFNF TlNPUl9ERVZJQ0VfQVRUUih0ZW1wM19pbnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfdGVt cCwgTlVMTCwgMik7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAzX2xhYmVsLCBTX0lS VUdPLCBpOGtfaHdtb25fc2hvd190ZW1wX2xhYmVsLCBOVUxMLAorCQkJICAyKTsKK3N0YXRpYyBT RU5TT1JfREVWSUNFX0FUVFIodGVtcDRfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X3Rl bXAsIE5VTEwsIDMpOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wNF9sYWJlbCwgU19J UlVHTywgaThrX2h3bW9uX3Nob3dfdGVtcF9sYWJlbCwgTlVMTCwKKwkJCSAgMyk7CitzdGF0aWMg U0VOU09SX0RFVklDRV9BVFRSKGZhbjFfaW5wdXQsIFNfSVJVR08sIGk4a19od21vbl9zaG93X2Zh biwgTlVMTCwgMCk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGZhbjFfbGFiZWwsIFNfSVJV R08sIGk4a19od21vbl9zaG93X2Zhbl9sYWJlbCwgTlVMTCwKKwkJCSAgMCk7CitzdGF0aWMgU0VO U09SX0RFVklDRV9BVFRSKHB3bTEsIFNfSVJVR08gfCBTX0lXVVNSLCBpOGtfaHdtb25fc2hvd19w d20sCisJCQkgIGk4a19od21vbl9zZXRfcHdtLCAwKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FU VFIoZmFuMl9pbnB1dCwgU19JUlVHTywgaThrX2h3bW9uX3Nob3dfZmFuLCBOVUxMLAorCQkJICAx KTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFuMl9sYWJlbCwgU19JUlVHTywgaThrX2h3 bW9uX3Nob3dfZmFuX2xhYmVsLCBOVUxMLAorCQkJICAxKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNF X0FUVFIocHdtMiwgU19JUlVHTyB8IFNfSVdVU1IsIGk4a19od21vbl9zaG93X3B3bSwKKwkJCSAg aThrX2h3bW9uX3NldF9wd20sIDEpOworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqaThrX2F0 dHJzW10gPSB7CisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9pbnB1dC5kZXZfYXR0ci5hdHRyLAkv KiAwICovCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiAx ICovCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMl9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiAyICov CisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMl9sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiAzICovCisJ JnNlbnNvcl9kZXZfYXR0cl90ZW1wM19pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiA0ICovCisJJnNl bnNvcl9kZXZfYXR0cl90ZW1wM19sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiA1ICovCisJJnNlbnNv cl9kZXZfYXR0cl90ZW1wNF9pbnB1dC5kZXZfYXR0ci5hdHRyLAkvKiA2ICovCisJJnNlbnNvcl9k ZXZfYXR0cl90ZW1wNF9sYWJlbC5kZXZfYXR0ci5hdHRyLAkvKiA3ICovCisJJnNlbnNvcl9kZXZf YXR0cl9mYW4xX2lucHV0LmRldl9hdHRyLmF0dHIsCS8qIDggKi8KKwkmc2Vuc29yX2Rldl9hdHRy X2ZhbjFfbGFiZWwuZGV2X2F0dHIuYXR0ciwJLyogOSAqLworCSZzZW5zb3JfZGV2X2F0dHJfcHdt MS5kZXZfYXR0ci5hdHRyLAkJLyogMTAgKi8KKwkmc2Vuc29yX2Rldl9hdHRyX2ZhbjJfaW5wdXQu ZGV2X2F0dHIuYXR0ciwJLyogMTEgKi8KKwkmc2Vuc29yX2Rldl9hdHRyX2ZhbjJfbGFiZWwuZGV2 X2F0dHIuYXR0ciwJLyogMTIgKi8KKwkmc2Vuc29yX2Rldl9hdHRyX3B3bTIuZGV2X2F0dHIuYXR0 ciwJCS8qIDEzICovCisJTlVMTAorfTsKKworc3RhdGljIHVtb2RlX3QgaThrX2lzX3Zpc2libGUo c3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBhdHRyaWJ1dGUgKmF0dHIsCisJCQkgICAgICBp bnQgaW5kZXgpCit7CisJaWYgKGluZGV4ID49IDAgJiYgaW5kZXggPD0gMSAmJgorCSAgICAhKGk4 a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVAxKSkKKwkJcmV0dXJuIDA7CisJaWYg KGluZGV4ID49IDIgJiYgaW5kZXggPD0gMyAmJgorCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4 S19IV01PTl9IQVZFX1RFTVAyKSkKKwkJcmV0dXJuIDA7CisJaWYgKGluZGV4ID49IDQgJiYgaW5k ZXggPD0gNSAmJgorCSAgICAhKGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVAz KSkKKwkJcmV0dXJuIDA7CisJaWYgKGluZGV4ID49IDYgJiYgaW5kZXggPD0gNyAmJgorCSAgICAh KGk4a19od21vbl9mbGFncyAmIEk4S19IV01PTl9IQVZFX1RFTVA0KSkKKwkJcmV0dXJuIDA7CisJ aWYgKGluZGV4ID49IDggJiYgaW5kZXggPD0gMTAgJiYKKwkgICAgIShpOGtfaHdtb25fZmxhZ3Mg JiBJOEtfSFdNT05fSEFWRV9GQU4xKSkKKwkJcmV0dXJuIDA7CisJaWYgKGluZGV4ID49IDExICYm IGluZGV4IDw9IDEzICYmCisJICAgICEoaThrX2h3bW9uX2ZsYWdzICYgSThLX0hXTU9OX0hBVkVf RkFOMikpCisJCXJldHVybiAwOworCisJcmV0dXJuIGF0dHItPm1vZGU7Cit9CisKK3N0YXRpYyBj b25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGk4a19ncm91cCA9IHsKKwkuYXR0cnMgPSBpOGtf YXR0cnMsCisJLmlzX3Zpc2libGUgPSBpOGtfaXNfdmlzaWJsZSwKK307CitfX0FUVFJJQlVURV9H Uk9VUFMoaThrKTsKKworc3RhdGljIGludCBfX2luaXQgaThrX2luaXRfaHdtb24odm9pZCkKK3sK KwlpbnQgZXJyOworCisJaThrX2h3bW9uX2ZsYWdzID0gMDsKKworCS8qIENQVSB0ZW1wZXJhdHVy ZSBhdHRyaWJ1dGVzLCBpZiB0ZW1wZXJhdHVyZSB0eXBlIGlzIE9LICovCisJZXJyID0gaThrX2dl dF90ZW1wX3R5cGUoMCk7CisJaWYgKGVyciA+PSAwKQorCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThL X0hXTU9OX0hBVkVfVEVNUDE7CisJLyogY2hlY2sgZm9yIGFkZGl0aW9uYWwgdGVtcGVyYXR1cmUg c2Vuc29ycyAqLworCWVyciA9IGk4a19nZXRfdGVtcF90eXBlKDEpOworCWlmIChlcnIgPj0gMCkK KwkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RFTVAyOworCWVyciA9IGk4a19n ZXRfdGVtcF90eXBlKDIpOworCWlmIChlcnIgPj0gMCkKKwkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4 S19IV01PTl9IQVZFX1RFTVAzOworCWVyciA9IGk4a19nZXRfdGVtcF90eXBlKDMpOworCWlmIChl cnIgPj0gMCkKKwkJaThrX2h3bW9uX2ZsYWdzIHw9IEk4S19IV01PTl9IQVZFX1RFTVA0OworCisJ LyogRmlyc3QgZmFuIGF0dHJpYnV0ZXMsIGlmIGZhbiB0eXBlIGlzIE9LICovCisJZXJyID0gaThr X2dldF9mYW5fdHlwZSgwKTsKKwlpZiAoZXJyID49IDApCisJCWk4a19od21vbl9mbGFncyB8PSBJ OEtfSFdNT05fSEFWRV9GQU4xOworCisJLyogU2Vjb25kIGZhbiBhdHRyaWJ1dGVzLCBpZiBmYW4g dHlwZSBpcyBPSyAqLworCWVyciA9IGk4a19nZXRfZmFuX3R5cGUoMSk7CisJaWYgKGVyciA+PSAw KQorCQlpOGtfaHdtb25fZmxhZ3MgfD0gSThLX0hXTU9OX0hBVkVfRkFOMjsKKworCWk4a19od21v bl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoTlVMTCwgImk4ayIsIE5V TEwsCisJCQkJCQkJICBpOGtfZ3JvdXBzKTsKKwlpZiAoSVNfRVJSKGk4a19od21vbl9kZXYpKSB7 CisJCWVyciA9IFBUUl9FUlIoaThrX2h3bW9uX2Rldik7CisJCWk4a19od21vbl9kZXYgPSBOVUxM OworCQlwcl9lcnIoImh3bW9uIHJlZ2lzdHJhdGlvbiBmYWlsZWQgKCVkKVxuIiwgZXJyKTsKKwkJ cmV0dXJuIGVycjsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0cnVjdCBpOGtfY29uZmlnX2RhdGEg eworCXVpbnQgZmFuX211bHQ7CisJdWludCBmYW5fbWF4OworfTsKKworZW51bSBpOGtfY29uZmln cyB7CisJREVMTF9MQVRJVFVERV9ENTIwLAorCURFTExfUFJFQ0lTSU9OXzQ5MCwKKwlERUxMX1NU VURJTywKKwlERUxMX1hQUywKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaThrX2NvbmZpZ19k YXRhIGk4a19jb25maWdfZGF0YVtdID0geworCVtERUxMX0xBVElUVURFX0Q1MjBdID0geworCQku ZmFuX211bHQgPSAxLAorCQkuZmFuX21heCA9IEk4S19GQU5fVFVSQk8sCisJfSwKKwlbREVMTF9Q UkVDSVNJT05fNDkwXSA9IHsKKwkJLmZhbl9tdWx0ID0gMSwKKwkJLmZhbl9tYXggPSBJOEtfRkFO X1RVUkJPLAorCX0sCisJW0RFTExfU1RVRElPXSA9IHsKKwkJLmZhbl9tdWx0ID0gMSwKKwkJLmZh bl9tYXggPSBJOEtfRkFOX0hJR0gsCisJfSwKKwlbREVMTF9YUFNdID0geworCQkuZmFuX211bHQg PSAxLAorCQkuZmFuX21heCA9IEk4S19GQU5fSElHSCwKKwl9LAorfTsKKworc3RhdGljIHN0cnVj dCBkbWlfc3lzdGVtX2lkIGk4a19kbWlfdGFibGVbXSBfX2luaXRkYXRhID0geworCXsKKwkJLmlk ZW50ID0gIkRlbGwgSW5zcGlyb24iLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlf U1lTX1ZFTkRPUiwgIkRlbGwgQ29tcHV0ZXIiKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9O QU1FLCAiSW5zcGlyb24iKSwKKwkJfSwKKwl9LAorCXsKKwkJLmlkZW50ID0gIkRlbGwgTGF0aXR1 ZGUiLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwg Q29tcHV0ZXIiKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTGF0aXR1ZGUiKSwK KwkJfSwKKwl9LAorCXsKKwkJLmlkZW50ID0gIkRlbGwgSW5zcGlyb24gMiIsCisJCS5tYXRjaGVz ID0geworCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlf TUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkluc3Bpcm9uIiksCisJCX0sCisJfSwKKwl7CisJCS5p ZGVudCA9ICJEZWxsIExhdGl0dWRlIEQ1MjAiLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRD SChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNU X05BTUUsICJMYXRpdHVkZSBENTIwIiksCisJCX0sCisJCS5kcml2ZXJfZGF0YSA9ICh2b2lkICop Jmk4a19jb25maWdfZGF0YVtERUxMX0xBVElUVURFX0Q1MjBdLAorCX0sCisJeworCQkuaWRlbnQg PSAiRGVsbCBMYXRpdHVkZSAyIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZ U19WRU5ET1IsICJEZWxsIEluYy4iKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAi TGF0aXR1ZGUiKSwKKwkJfSwKKwl9LAorCXsJLyogVUsgSW5zcGlyb24gNjQwMCAgKi8KKwkJLmlk ZW50ID0gIkRlbGwgSW5zcGlyb24gMyIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERN SV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFN RSwgIk1NMDYxIiksCisJCX0sCisJfSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIEluc3Bpcm9uIDMi LAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5j LiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJNUDA2MSIpLAorCQl9LAorCX0s CisJeworCQkuaWRlbnQgPSAiRGVsbCBQcmVjaXNpb24gNDkwIiwKKwkJLm1hdGNoZXMgPSB7CisJ CQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwKKwkJCURNSV9NQVRDSChE TUlfUFJPRFVDVF9OQU1FLAorCQkJCSAgIlByZWNpc2lvbiBXb3JrU3RhdGlvbiA0OTAiKSwKKwkJ fSwKKwkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikmaThrX2NvbmZpZ19kYXRhW0RFTExfUFJFQ0lT SU9OXzQ5MF0sCisJfSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIFByZWNpc2lvbiIsCisJCS5tYXRj aGVzID0geworCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlE TUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlByZWNpc2lvbiIpLAorCQl9LAorCX0sCisJewor CQkuaWRlbnQgPSAiRGVsbCBWb3N0cm8iLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChE TUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05B TUUsICJWb3N0cm8iKSwKKwkJfSwKKwl9LAorCXsKKwkJLmlkZW50ID0gIkRlbGwgWFBTNDIxIiwK KwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4i KSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiWFBTIEw0MjFYIiksCisJCX0sCisJ fSwKKwl7CisJCS5pZGVudCA9ICJEZWxsIFN0dWRpbyIsCisJCS5tYXRjaGVzID0geworCQkJRE1J X01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1JX1BS T0RVQ1RfTkFNRSwgIlN0dWRpbyIpLAorCQl9LAorCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZp OGtfY29uZmlnX2RhdGFbREVMTF9TVFVESU9dLAorCX0sCisJeworCQkuaWRlbnQgPSAiRGVsbCBY UFMgMTMiLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRl bGwgSW5jLiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJYUFMxMyIpLAorCQl9 LAorCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAqKSZpOGtfY29uZmlnX2RhdGFbREVMTF9YUFNdLAor CX0sCisJeworCQkuaWRlbnQgPSAiRGVsbCBYUFMgTTE0MCIsCisJCS5tYXRjaGVzID0geworCQkJ RE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiksCisJCQlETUlfTUFUQ0goRE1J X1BST0RVQ1RfTkFNRSwgIk1YQzA1MSIpLAorCQl9LAorCQkuZHJpdmVyX2RhdGEgPSAodm9pZCAq KSZpOGtfY29uZmlnX2RhdGFbREVMTF9YUFNdLAorCX0sCisJeyB9Cit9OworCitNT0RVTEVfREVW SUNFX1RBQkxFKGRtaSwgaThrX2RtaV90YWJsZSk7CisKKy8qCisgKiBQcm9iZSBmb3IgdGhlIHBy ZXNlbmNlIG9mIGEgc3VwcG9ydGVkIGxhcHRvcC4KKyAqLworc3RhdGljIGludCBfX2luaXQgaThr X3Byb2JlKHZvaWQpCit7CisJY29uc3Qgc3RydWN0IGRtaV9zeXN0ZW1faWQgKmlkOworCWludCBm YW4sIHJldDsKKworCS8qCisJICogR2V0IERNSSBpbmZvcm1hdGlvbgorCSAqLworCWlmICghZG1p X2NoZWNrX3N5c3RlbShpOGtfZG1pX3RhYmxlKSkgeworCQlpZiAoIWlnbm9yZV9kbWkgJiYgIWZv cmNlKQorCQkJcmV0dXJuIC1FTk9ERVY7CisKKwkJcHJfaW5mbygibm90IHJ1bm5pbmcgb24gYSBz dXBwb3J0ZWQgRGVsbCBzeXN0ZW0uXG4iKTsKKwkJcHJfaW5mbygidmVuZG9yPSVzLCBtb2RlbD0l cywgdmVyc2lvbj0lc1xuIiwKKwkJCWk4a19nZXRfZG1pX2RhdGEoRE1JX1NZU19WRU5ET1IpLAor CQkJaThrX2dldF9kbWlfZGF0YShETUlfUFJPRFVDVF9OQU1FKSwKKwkJCWk4a19nZXRfZG1pX2Rh dGEoRE1JX0JJT1NfVkVSU0lPTikpOworCX0KKworCXN0cmxjcHkoYmlvc192ZXJzaW9uLCBpOGtf Z2V0X2RtaV9kYXRhKERNSV9CSU9TX1ZFUlNJT04pLAorCQlzaXplb2YoYmlvc192ZXJzaW9uKSk7 CisKKwkvKgorCSAqIEdldCBTTU0gRGVsbCBzaWduYXR1cmUKKwkgKi8KKwlpZiAoaThrX2dldF9k ZWxsX3NpZ25hdHVyZShJOEtfU01NX0dFVF9ERUxMX1NJRzEpICYmCisJICAgIGk4a19nZXRfZGVs bF9zaWduYXR1cmUoSThLX1NNTV9HRVRfREVMTF9TSUcyKSkgeworCQlwcl9lcnIoInVuYWJsZSB0 byBnZXQgU01NIERlbGwgc2lnbmF0dXJlXG4iKTsKKwkJaWYgKCFmb3JjZSkKKwkJCXJldHVybiAt RU5PREVWOworCX0KKworCS8qCisJICogU2V0IGZhbiBtdWx0aXBsaWVyIGFuZCBtYXhpbWFsIGZh biBzcGVlZCBmcm9tIGRtaSBjb25maWcKKwkgKiBWYWx1ZXMgc3BlY2lmaWVkIGluIG1vZHVsZSBw YXJhbWV0ZXJzIG92ZXJyaWRlIHZhbHVlcyBmcm9tIGRtaQorCSAqLworCWlkID0gZG1pX2ZpcnN0 X21hdGNoKGk4a19kbWlfdGFibGUpOworCWlmIChpZCAmJiBpZC0+ZHJpdmVyX2RhdGEpIHsKKwkJ Y29uc3Qgc3RydWN0IGk4a19jb25maWdfZGF0YSAqY29uZiA9IGlkLT5kcml2ZXJfZGF0YTsKKwkJ aWYgKCFmYW5fbXVsdCAmJiBjb25mLT5mYW5fbXVsdCkKKwkJCWZhbl9tdWx0ID0gY29uZi0+ZmFu X211bHQ7CisJCWlmICghZmFuX21heCAmJiBjb25mLT5mYW5fbWF4KQorCQkJZmFuX21heCA9IGNv bmYtPmZhbl9tYXg7CisJfQorCisJaThrX2Zhbl9tYXggPSBmYW5fbWF4ID8gOiBJOEtfRkFOX0hJ R0g7CS8qIE11c3Qgbm90IGJlIDAgKi8KKwlpOGtfcHdtX211bHQgPSBESVZfUk9VTkRfVVAoMjU1 LCBpOGtfZmFuX21heCk7CisKKwlpZiAoIWZhbl9tdWx0KSB7CisJCS8qCisJCSAqIEF1dG9kZXRl Y3QgZmFuIG11bHRpcGxpZXIgYmFzZWQgb24gbm9taW5hbCBycG0KKwkJICogSWYgZmFuIHJlcG9y dHMgcnBtIHZhbHVlIHRvbyBoaWdoIHRoZW4gc2V0IG11bHRpcGxpZXIgdG8gMQorCQkgKi8KKwkJ Zm9yIChmYW4gPSAwOyBmYW4gPCAyOyArK2ZhbikgeworCQkJcmV0ID0gaThrX2dldF9mYW5fbm9t aW5hbF9zcGVlZChmYW4sIGk4a19mYW5fbWF4KTsKKwkJCWlmIChyZXQgPCAwKQorCQkJCWNvbnRp bnVlOworCQkJaWYgKHJldCA+IEk4S19GQU5fTUFYX1JQTSkKKwkJCQlpOGtfZmFuX211bHQgPSAx OworCQkJYnJlYWs7CisJCX0KKwl9IGVsc2UgeworCQkvKiBGYW4gbXVsdGlwbGllciB3YXMgc3Bl Y2lmaWVkIGluIG1vZHVsZSBwYXJhbSBvciBpbiBkbWkgKi8KKwkJaThrX2Zhbl9tdWx0ID0gZmFu X211bHQ7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IGk4a19pbml0 KHZvaWQpCit7CisJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpwcm9jX2k4azsKKwlpbnQgZXJyOwor CisJLyogQXJlIHdlIHJ1bm5pbmcgb24gYW4gc3VwcG9ydGVkIGxhcHRvcD8gKi8KKwlpZiAoaThr X3Byb2JlKCkpCisJCXJldHVybiAtRU5PREVWOworCisJLyogUmVnaXN0ZXIgdGhlIHByb2MgZW50 cnkgKi8KKwlwcm9jX2k4ayA9IHByb2NfY3JlYXRlKCJpOGsiLCAwLCBOVUxMLCAmaThrX2ZvcHMp OworCWlmICghcHJvY19pOGspCisJCXJldHVybiAtRU5PRU5UOworCisJZXJyID0gaThrX2luaXRf aHdtb24oKTsKKwlpZiAoZXJyKQorCQlnb3RvIGV4aXRfcmVtb3ZlX3Byb2M7CisKKwlyZXR1cm4g MDsKKworIGV4aXRfcmVtb3ZlX3Byb2M6CisJcmVtb3ZlX3Byb2NfZW50cnkoImk4ayIsIE5VTEwp OworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBpOGtfZXhpdCh2b2lkKQor eworCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGk4a19od21vbl9kZXYpOworCXJlbW92ZV9wcm9j X2VudHJ5KCJpOGsiLCBOVUxMKTsKK30KKworbW9kdWxlX2luaXQoaThrX2luaXQpOworbW9kdWxl X2V4aXQoaThrX2V4aXQpOwotLSAKMS43LjEwLjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3Jz QGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree @ 2015-04-29 11:41 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-29 11:41 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This commit moves i8k driver to hwmon tree under name dell-smm-hwmon which is better name then abbreviation i8k. For backward compatibility is added macro MODULE_ALIAS("i8k") so modprobe will load driver also old name i8k. CONFIG_I8K compile option was not changed. This commit also adds me as maintainer of this new dell-smm-hwmon driver and remove Guenter Roeck from list who is implicit maintainer all hwmon drivers. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- MAINTAINERS | 4 +- drivers/char/Makefile | 1 - drivers/char/i8k.c | 1007 --------------------------------------- drivers/hwmon/Makefile | 1 + drivers/hwmon/dell-smm-hwmon.c | 1009 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 1012 insertions(+), 1010 deletions(-) delete mode 100644 drivers/char/i8k.c create mode 100644 drivers/hwmon/dell-smm-hwmon.c diff --git a/MAINTAINERS b/MAINTAINERS index 2e5bbc0..014c15f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3077,9 +3077,9 @@ S: Maintained F: drivers/platform/x86/dell-smo8800.c DELL LAPTOP SMM DRIVER -M: Guenter Roeck <linux@roeck-us.net> +M: Pali Rohár <pali.rohar@gmail.com> S: Maintained -F: drivers/char/i8k.c +F: drivers/hwmon/dell-smm-hwmon.c F: include/uapi/linux/i8k.h DELL SYSTEMS MANAGEMENT BASE DRIVER (dcdbas) diff --git a/drivers/char/Makefile b/drivers/char/Makefile index d06cde26..1d9cf00 100644 --- a/drivers/char/Makefile +++ b/drivers/char/Makefile @@ -36,7 +36,6 @@ else obj-$(CONFIG_NVRAM) += nvram.o endif obj-$(CONFIG_TOSHIBA) += toshiba.o -obj-$(CONFIG_I8K) += i8k.o obj-$(CONFIG_DS1620) += ds1620.o obj-$(CONFIG_HW_RANDOM) += hw_random/ obj-$(CONFIG_PPDEV) += ppdev.o diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c deleted file mode 100644 index a43048b..0000000 --- a/drivers/char/i8k.c +++ /dev/null @@ -1,1007 +0,0 @@ -/* - * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops. - * - * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> - * - * Hwmon integration: - * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> - * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> - * Copyright (C) 2014 Pali Rohár <pali.rohar@gmail.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, 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. - */ - -#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt - -#include <linux/delay.h> -#include <linux/module.h> -#include <linux/types.h> -#include <linux/init.h> -#include <linux/proc_fs.h> -#include <linux/seq_file.h> -#include <linux/dmi.h> -#include <linux/capability.h> -#include <linux/mutex.h> -#include <linux/hwmon.h> -#include <linux/hwmon-sysfs.h> -#include <linux/uaccess.h> -#include <linux/io.h> -#include <linux/sched.h> - -#include <linux/i8k.h> - -#define I8K_SMM_FN_STATUS 0x0025 -#define I8K_SMM_POWER_STATUS 0x0069 -#define I8K_SMM_SET_FAN 0x01a3 -#define I8K_SMM_GET_FAN 0x00a3 -#define I8K_SMM_GET_SPEED 0x02a3 -#define I8K_SMM_GET_FAN_TYPE 0x03a3 -#define I8K_SMM_GET_NOM_SPEED 0x04a3 -#define I8K_SMM_GET_TEMP 0x10a3 -#define I8K_SMM_GET_TEMP_TYPE 0x11a3 -#define I8K_SMM_GET_DELL_SIG1 0xfea3 -#define I8K_SMM_GET_DELL_SIG2 0xffa3 - -#define I8K_FAN_MULT 30 -#define I8K_FAN_MAX_RPM 30000 -#define I8K_MAX_TEMP 127 - -#define I8K_FN_NONE 0x00 -#define I8K_FN_UP 0x01 -#define I8K_FN_DOWN 0x02 -#define I8K_FN_MUTE 0x04 -#define I8K_FN_MASK 0x07 -#define I8K_FN_SHIFT 8 - -#define I8K_POWER_AC 0x05 -#define I8K_POWER_BATTERY 0x01 - -static DEFINE_MUTEX(i8k_mutex); -static char bios_version[4]; -static struct device *i8k_hwmon_dev; -static u32 i8k_hwmon_flags; -static uint i8k_fan_mult = I8K_FAN_MULT; -static uint i8k_pwm_mult; -static uint i8k_fan_max = I8K_FAN_HIGH; - -#define I8K_HWMON_HAVE_TEMP1 (1 << 0) -#define I8K_HWMON_HAVE_TEMP2 (1 << 1) -#define I8K_HWMON_HAVE_TEMP3 (1 << 2) -#define I8K_HWMON_HAVE_TEMP4 (1 << 3) -#define I8K_HWMON_HAVE_FAN1 (1 << 4) -#define I8K_HWMON_HAVE_FAN2 (1 << 5) - -MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); -MODULE_LICENSE("GPL"); - -static bool force; -module_param(force, bool, 0); -MODULE_PARM_DESC(force, "Force loading without checking for supported models"); - -static bool ignore_dmi; -module_param(ignore_dmi, bool, 0); -MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); - -static bool restricted; -module_param(restricted, bool, 0); -MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); - -static bool power_status; -module_param(power_status, bool, 0600); -MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); - -static uint fan_mult; -module_param(fan_mult, uint, 0); -MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); - -static uint fan_max; -module_param(fan_max, uint, 0); -MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); - -static int i8k_open_fs(struct inode *inode, struct file *file); -static long i8k_ioctl(struct file *, unsigned int, unsigned long); - -static const struct file_operations i8k_fops = { - .owner = THIS_MODULE, - .open = i8k_open_fs, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, - .unlocked_ioctl = i8k_ioctl, -}; - -struct smm_regs { - unsigned int eax; - unsigned int ebx __packed; - unsigned int ecx __packed; - unsigned int edx __packed; - unsigned int esi __packed; - unsigned int edi __packed; -}; - -static inline const char *i8k_get_dmi_data(int field) -{ - const char *dmi_data = dmi_get_system_info(field); - - return dmi_data && *dmi_data ? dmi_data : "?"; -} - -/* - * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. - */ -static int i8k_smm(struct smm_regs *regs) -{ - int rc; - int eax = regs->eax; - cpumask_var_t old_mask; - - /* SMM requires CPU 0 */ - if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) - return -ENOMEM; - cpumask_copy(old_mask, ¤t->cpus_allowed); - rc = set_cpus_allowed_ptr(current, cpumask_of(0)); - if (rc) - goto out; - if (smp_processor_id() != 0) { - rc = -EBUSY; - goto out; - } - -#if defined(CONFIG_X86_64) - asm volatile("pushq %%rax\n\t" - "movl 0(%%rax),%%edx\n\t" - "pushq %%rdx\n\t" - "movl 4(%%rax),%%ebx\n\t" - "movl 8(%%rax),%%ecx\n\t" - "movl 12(%%rax),%%edx\n\t" - "movl 16(%%rax),%%esi\n\t" - "movl 20(%%rax),%%edi\n\t" - "popq %%rax\n\t" - "out %%al,$0xb2\n\t" - "out %%al,$0x84\n\t" - "xchgq %%rax,(%%rsp)\n\t" - "movl %%ebx,4(%%rax)\n\t" - "movl %%ecx,8(%%rax)\n\t" - "movl %%edx,12(%%rax)\n\t" - "movl %%esi,16(%%rax)\n\t" - "movl %%edi,20(%%rax)\n\t" - "popq %%rdx\n\t" - "movl %%edx,0(%%rax)\n\t" - "pushfq\n\t" - "popq %%rax\n\t" - "andl $1,%%eax\n" - : "=a"(rc) - : "a"(regs) - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); -#else - asm volatile("pushl %%eax\n\t" - "movl 0(%%eax),%%edx\n\t" - "push %%edx\n\t" - "movl 4(%%eax),%%ebx\n\t" - "movl 8(%%eax),%%ecx\n\t" - "movl 12(%%eax),%%edx\n\t" - "movl 16(%%eax),%%esi\n\t" - "movl 20(%%eax),%%edi\n\t" - "popl %%eax\n\t" - "out %%al,$0xb2\n\t" - "out %%al,$0x84\n\t" - "xchgl %%eax,(%%esp)\n\t" - "movl %%ebx,4(%%eax)\n\t" - "movl %%ecx,8(%%eax)\n\t" - "movl %%edx,12(%%eax)\n\t" - "movl %%esi,16(%%eax)\n\t" - "movl %%edi,20(%%eax)\n\t" - "popl %%edx\n\t" - "movl %%edx,0(%%eax)\n\t" - "lahf\n\t" - "shrl $8,%%eax\n\t" - "andl $1,%%eax\n" - : "=a"(rc) - : "a"(regs) - : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); -#endif - if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) - rc = -EINVAL; - -out: - set_cpus_allowed_ptr(current, old_mask); - free_cpumask_var(old_mask); - return rc; -} - -/* - * Read the Fn key status. - */ -static int i8k_get_fn_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { - case I8K_FN_UP: - return I8K_VOL_UP; - case I8K_FN_DOWN: - return I8K_VOL_DOWN; - case I8K_FN_MUTE: - return I8K_VOL_MUTE; - default: - return 0; - } -} - -/* - * Read the power status. - */ -static int i8k_get_power_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; -} - -/* - * Read the fan status. - */ -static int i8k_get_fan_status(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the fan speed in RPM. - */ -static int i8k_get_fan_speed(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; -} - -/* - * Read the fan type. - */ -static int i8k_get_fan_type(int fan) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; - - regs.ebx = fan & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the fan nominal rpm for specific fan speed. - */ -static int i8k_get_fan_nominal_speed(int fan, int speed) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; - - regs.ebx = (fan & 0xff) | (speed << 8); - return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; -} - -/* - * Set the fan speed (off, low, high). Returns the new fan status. - */ -static int i8k_set_fan(int fan, int speed) -{ - struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; - - speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); - regs.ebx = (fan & 0xff) | (speed << 8); - - return i8k_smm(®s) ? : i8k_get_fan_status(fan); -} - -static int i8k_get_temp_type(int sensor) -{ - struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; - - regs.ebx = sensor & 0xff; - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -/* - * Read the cpu temperature. - */ -static int _i8k_get_temp(int sensor) -{ - struct smm_regs regs = { - .eax = I8K_SMM_GET_TEMP, - .ebx = sensor & 0xff, - }; - - return i8k_smm(®s) ? : regs.eax & 0xff; -} - -static int i8k_get_temp(int sensor) -{ - int temp = _i8k_get_temp(sensor); - - /* - * Sometimes the temperature sensor returns 0x99, which is out of range. - * In this case we retry (once) before returning an error. - # 1003655137 00000058 00005a4b - # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees - # 1003655139 00000054 00005c52 - */ - if (temp == 0x99) { - msleep(100); - temp = _i8k_get_temp(sensor); - } - /* - * Return -ENODATA for all invalid temperatures. - * - * Known instances are the 0x99 value as seen above as well as - * 0xc1 (193), which may be returned when trying to read the GPU - * temperature if the system supports a GPU and it is currently - * turned off. - */ - if (temp > I8K_MAX_TEMP) - return -ENODATA; - - return temp; -} - -static int i8k_get_dell_signature(int req_fn) -{ - struct smm_regs regs = { .eax = req_fn, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; -} - -static int -i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) -{ - int val = 0; - int speed; - unsigned char buff[16]; - int __user *argp = (int __user *)arg; - - if (!argp) - return -EINVAL; - - switch (cmd) { - case I8K_BIOS_VERSION: - val = (bios_version[0] << 16) | - (bios_version[1] << 8) | bios_version[2]; - break; - - case I8K_MACHINE_ID: - memset(buff, 0, 16); - strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), - sizeof(buff)); - break; - - case I8K_FN_STATUS: - val = i8k_get_fn_status(); - break; - - case I8K_POWER_STATUS: - val = i8k_get_power_status(); - break; - - case I8K_GET_TEMP: - val = i8k_get_temp(0); - break; - - case I8K_GET_SPEED: - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - val = i8k_get_fan_speed(val); - break; - - case I8K_GET_FAN: - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - val = i8k_get_fan_status(val); - break; - - case I8K_SET_FAN: - if (restricted && !capable(CAP_SYS_ADMIN)) - return -EPERM; - - if (copy_from_user(&val, argp, sizeof(int))) - return -EFAULT; - - if (copy_from_user(&speed, argp + 1, sizeof(int))) - return -EFAULT; - - val = i8k_set_fan(val, speed); - break; - - default: - return -EINVAL; - } - - if (val < 0) - return val; - - switch (cmd) { - case I8K_BIOS_VERSION: - if (copy_to_user(argp, &val, 4)) - return -EFAULT; - - break; - case I8K_MACHINE_ID: - if (copy_to_user(argp, buff, 16)) - return -EFAULT; - - break; - default: - if (copy_to_user(argp, &val, sizeof(int))) - return -EFAULT; - - break; - } - - return 0; -} - -static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) -{ - long ret; - - mutex_lock(&i8k_mutex); - ret = i8k_ioctl_unlocked(fp, cmd, arg); - mutex_unlock(&i8k_mutex); - - return ret; -} - -/* - * Print the information for /proc/i8k. - */ -static int i8k_proc_show(struct seq_file *seq, void *offset) -{ - int fn_key, cpu_temp, ac_power; - int left_fan, right_fan, left_speed, right_speed; - - cpu_temp = i8k_get_temp(0); /* 11100 µs */ - left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ - right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ - left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ - right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ - fn_key = i8k_get_fn_status(); /* 750 µs */ - if (power_status) - ac_power = i8k_get_power_status(); /* 14700 µs */ - else - ac_power = -1; - - /* - * Info: - * - * 1) Format version (this will change if format changes) - * 2) BIOS version - * 3) BIOS machine ID - * 4) Cpu temperature - * 5) Left fan status - * 6) Right fan status - * 7) Left fan speed - * 8) Right fan speed - * 9) AC power - * 10) Fn Key status - */ - seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", - I8K_PROC_FMT, - bios_version, - i8k_get_dmi_data(DMI_PRODUCT_SERIAL), - cpu_temp, - left_fan, right_fan, left_speed, right_speed, - ac_power, fn_key); - - return 0; -} - -static int i8k_open_fs(struct inode *inode, struct file *file) -{ - return single_open(file, i8k_proc_show, NULL); -} - - -/* - * Hwmon interface - */ - -static ssize_t i8k_hwmon_show_temp_label(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - static const char * const labels[] = { - "CPU", - "GPU", - "SODIMM", - "Other", - "Ambient", - "Other", - }; - int index = to_sensor_dev_attr(devattr)->index; - int type; - - type = i8k_get_temp_type(index); - if (type < 0) - return type; - if (type >= ARRAY_SIZE(labels)) - type = ARRAY_SIZE(labels) - 1; - return sprintf(buf, "%s\n", labels[type]); -} - -static ssize_t i8k_hwmon_show_temp(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int temp; - - temp = i8k_get_temp(index); - if (temp < 0) - return temp; - return sprintf(buf, "%d\n", temp * 1000); -} - -static ssize_t i8k_hwmon_show_fan_label(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - static const char * const labels[] = { - "Processor Fan", - "Motherboard Fan", - "Video Fan", - "Power Supply Fan", - "Chipset Fan", - "Other Fan", - }; - int index = to_sensor_dev_attr(devattr)->index; - bool dock = false; - int type; - - type = i8k_get_fan_type(index); - if (type < 0) - return type; - - if (type & 0x10) { - dock = true; - type &= 0x0F; - } - - if (type >= ARRAY_SIZE(labels)) - type = (ARRAY_SIZE(labels) - 1); - - return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); -} - -static ssize_t i8k_hwmon_show_fan(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int fan_speed; - - fan_speed = i8k_get_fan_speed(index); - if (fan_speed < 0) - return fan_speed; - return sprintf(buf, "%d\n", fan_speed); -} - -static ssize_t i8k_hwmon_show_pwm(struct device *dev, - struct device_attribute *devattr, - char *buf) -{ - int index = to_sensor_dev_attr(devattr)->index; - int status; - - status = i8k_get_fan_status(index); - if (status < 0) - return -EIO; - return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); -} - -static ssize_t i8k_hwmon_set_pwm(struct device *dev, - struct device_attribute *attr, - const char *buf, size_t count) -{ - int index = to_sensor_dev_attr(attr)->index; - unsigned long val; - int err; - - err = kstrtoul(buf, 10, &val); - if (err) - return err; - val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); - - mutex_lock(&i8k_mutex); - err = i8k_set_fan(index, val); - mutex_unlock(&i8k_mutex); - - return err < 0 ? -EIO : count; -} - -static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); -static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 0); -static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); -static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 1); -static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); -static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 2); -static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); -static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, - 3); -static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); -static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, - 0); -static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, - i8k_hwmon_set_pwm, 0); -static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, - 1); -static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, - 1); -static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, - i8k_hwmon_set_pwm, 1); - -static struct attribute *i8k_attrs[] = { - &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ - &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ - &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ - &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ - &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ - &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ - &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ - &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ - &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ - &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ - &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ - &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ - &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ - &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ - NULL -}; - -static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, - int index) -{ - if (index >= 0 && index <= 1 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) - return 0; - if (index >= 2 && index <= 3 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) - return 0; - if (index >= 4 && index <= 5 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) - return 0; - if (index >= 6 && index <= 7 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) - return 0; - if (index >= 8 && index <= 10 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) - return 0; - if (index >= 11 && index <= 13 && - !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) - return 0; - - return attr->mode; -} - -static const struct attribute_group i8k_group = { - .attrs = i8k_attrs, - .is_visible = i8k_is_visible, -}; -__ATTRIBUTE_GROUPS(i8k); - -static int __init i8k_init_hwmon(void) -{ - int err; - - i8k_hwmon_flags = 0; - - /* CPU temperature attributes, if temperature type is OK */ - err = i8k_get_temp_type(0); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; - /* check for additional temperature sensors */ - err = i8k_get_temp_type(1); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; - err = i8k_get_temp_type(2); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; - err = i8k_get_temp_type(3); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; - - /* First fan attributes, if fan type is OK */ - err = i8k_get_fan_type(0); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; - - /* Second fan attributes, if fan type is OK */ - err = i8k_get_fan_type(1); - if (err >= 0) - i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; - - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, - i8k_groups); - if (IS_ERR(i8k_hwmon_dev)) { - err = PTR_ERR(i8k_hwmon_dev); - i8k_hwmon_dev = NULL; - pr_err("hwmon registration failed (%d)\n", err); - return err; - } - return 0; -} - -struct i8k_config_data { - uint fan_mult; - uint fan_max; -}; - -enum i8k_configs { - DELL_LATITUDE_D520, - DELL_PRECISION_490, - DELL_STUDIO, - DELL_XPS, -}; - -static const struct i8k_config_data i8k_config_data[] = { - [DELL_LATITUDE_D520] = { - .fan_mult = 1, - .fan_max = I8K_FAN_TURBO, - }, - [DELL_PRECISION_490] = { - .fan_mult = 1, - .fan_max = I8K_FAN_TURBO, - }, - [DELL_STUDIO] = { - .fan_mult = 1, - .fan_max = I8K_FAN_HIGH, - }, - [DELL_XPS] = { - .fan_mult = 1, - .fan_max = I8K_FAN_HIGH, - }, -}; - -static struct dmi_system_id i8k_dmi_table[] __initdata = { - { - .ident = "Dell Inspiron", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), - }, - }, - { - .ident = "Dell Latitude", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), - }, - }, - { - .ident = "Dell Inspiron 2", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), - }, - }, - { - .ident = "Dell Latitude D520", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), - }, - .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], - }, - { - .ident = "Dell Latitude 2", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), - }, - }, - { /* UK Inspiron 6400 */ - .ident = "Dell Inspiron 3", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), - }, - }, - { - .ident = "Dell Inspiron 3", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), - }, - }, - { - .ident = "Dell Precision 490", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, - "Precision WorkStation 490"), - }, - .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], - }, - { - .ident = "Dell Precision", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), - }, - }, - { - .ident = "Dell Vostro", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), - }, - }, - { - .ident = "Dell XPS421", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), - }, - }, - { - .ident = "Dell Studio", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), - }, - .driver_data = (void *)&i8k_config_data[DELL_STUDIO], - }, - { - .ident = "Dell XPS 13", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), - }, - .driver_data = (void *)&i8k_config_data[DELL_XPS], - }, - { - .ident = "Dell XPS M140", - .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), - DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), - }, - .driver_data = (void *)&i8k_config_data[DELL_XPS], - }, - { } -}; - -MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); - -/* - * Probe for the presence of a supported laptop. - */ -static int __init i8k_probe(void) -{ - const struct dmi_system_id *id; - int fan, ret; - - /* - * Get DMI information - */ - if (!dmi_check_system(i8k_dmi_table)) { - if (!ignore_dmi && !force) - return -ENODEV; - - pr_info("not running on a supported Dell system.\n"); - pr_info("vendor=%s, model=%s, version=%s\n", - i8k_get_dmi_data(DMI_SYS_VENDOR), - i8k_get_dmi_data(DMI_PRODUCT_NAME), - i8k_get_dmi_data(DMI_BIOS_VERSION)); - } - - strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), - sizeof(bios_version)); - - /* - * Get SMM Dell signature - */ - if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && - i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { - pr_err("unable to get SMM Dell signature\n"); - if (!force) - return -ENODEV; - } - - /* - * Set fan multiplier and maximal fan speed from dmi config - * Values specified in module parameters override values from dmi - */ - id = dmi_first_match(i8k_dmi_table); - if (id && id->driver_data) { - const struct i8k_config_data *conf = id->driver_data; - if (!fan_mult && conf->fan_mult) - fan_mult = conf->fan_mult; - if (!fan_max && conf->fan_max) - fan_max = conf->fan_max; - } - - i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ - i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); - - if (!fan_mult) { - /* - * Autodetect fan multiplier based on nominal rpm - * If fan reports rpm value too high then set multiplier to 1 - */ - for (fan = 0; fan < 2; ++fan) { - ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); - if (ret < 0) - continue; - if (ret > I8K_FAN_MAX_RPM) - i8k_fan_mult = 1; - break; - } - } else { - /* Fan multiplier was specified in module param or in dmi */ - i8k_fan_mult = fan_mult; - } - - return 0; -} - -static int __init i8k_init(void) -{ - struct proc_dir_entry *proc_i8k; - int err; - - /* Are we running on an supported laptop? */ - if (i8k_probe()) - return -ENODEV; - - /* Register the proc entry */ - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); - if (!proc_i8k) - return -ENOENT; - - err = i8k_init_hwmon(); - if (err) - goto exit_remove_proc; - - return 0; - - exit_remove_proc: - remove_proc_entry("i8k", NULL); - return err; -} - -static void __exit i8k_exit(void) -{ - hwmon_device_unregister(i8k_hwmon_dev); - remove_proc_entry("i8k", NULL); -} - -module_init(i8k_init); -module_exit(i8k_exit); diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index b4a40f1..51533ac 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -156,6 +156,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o +obj-$(CONFIG_I8K) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c new file mode 100644 index 0000000..65d314b --- /dev/null +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -0,0 +1,1009 @@ +/* + * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops. + * + * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> + * + * Hwmon integration: + * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> + * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> + * Copyright (C) 2014, 2015 Pali Rohár <pali.rohar@gmail.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, 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. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/delay.h> +#include <linux/module.h> +#include <linux/types.h> +#include <linux/init.h> +#include <linux/proc_fs.h> +#include <linux/seq_file.h> +#include <linux/dmi.h> +#include <linux/capability.h> +#include <linux/mutex.h> +#include <linux/hwmon.h> +#include <linux/hwmon-sysfs.h> +#include <linux/uaccess.h> +#include <linux/io.h> +#include <linux/sched.h> + +#include <linux/i8k.h> + +#define I8K_SMM_FN_STATUS 0x0025 +#define I8K_SMM_POWER_STATUS 0x0069 +#define I8K_SMM_SET_FAN 0x01a3 +#define I8K_SMM_GET_FAN 0x00a3 +#define I8K_SMM_GET_SPEED 0x02a3 +#define I8K_SMM_GET_FAN_TYPE 0x03a3 +#define I8K_SMM_GET_NOM_SPEED 0x04a3 +#define I8K_SMM_GET_TEMP 0x10a3 +#define I8K_SMM_GET_TEMP_TYPE 0x11a3 +#define I8K_SMM_GET_DELL_SIG1 0xfea3 +#define I8K_SMM_GET_DELL_SIG2 0xffa3 + +#define I8K_FAN_MULT 30 +#define I8K_FAN_MAX_RPM 30000 +#define I8K_MAX_TEMP 127 + +#define I8K_FN_NONE 0x00 +#define I8K_FN_UP 0x01 +#define I8K_FN_DOWN 0x02 +#define I8K_FN_MUTE 0x04 +#define I8K_FN_MASK 0x07 +#define I8K_FN_SHIFT 8 + +#define I8K_POWER_AC 0x05 +#define I8K_POWER_BATTERY 0x01 + +static DEFINE_MUTEX(i8k_mutex); +static char bios_version[4]; +static struct device *i8k_hwmon_dev; +static u32 i8k_hwmon_flags; +static uint i8k_fan_mult = I8K_FAN_MULT; +static uint i8k_pwm_mult; +static uint i8k_fan_max = I8K_FAN_HIGH; + +#define I8K_HWMON_HAVE_TEMP1 (1 << 0) +#define I8K_HWMON_HAVE_TEMP2 (1 << 1) +#define I8K_HWMON_HAVE_TEMP3 (1 << 2) +#define I8K_HWMON_HAVE_TEMP4 (1 << 3) +#define I8K_HWMON_HAVE_FAN1 (1 << 4) +#define I8K_HWMON_HAVE_FAN2 (1 << 5) + +MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); +MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); +MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("i8k"); + +static bool force; +module_param(force, bool, 0); +MODULE_PARM_DESC(force, "Force loading without checking for supported models"); + +static bool ignore_dmi; +module_param(ignore_dmi, bool, 0); +MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); + +static bool restricted; +module_param(restricted, bool, 0); +MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); + +static bool power_status; +module_param(power_status, bool, 0600); +MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); + +static uint fan_mult; +module_param(fan_mult, uint, 0); +MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); + +static uint fan_max; +module_param(fan_max, uint, 0); +MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); + +static int i8k_open_fs(struct inode *inode, struct file *file); +static long i8k_ioctl(struct file *, unsigned int, unsigned long); + +static const struct file_operations i8k_fops = { + .owner = THIS_MODULE, + .open = i8k_open_fs, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .unlocked_ioctl = i8k_ioctl, +}; + +struct smm_regs { + unsigned int eax; + unsigned int ebx __packed; + unsigned int ecx __packed; + unsigned int edx __packed; + unsigned int esi __packed; + unsigned int edi __packed; +}; + +static inline const char *i8k_get_dmi_data(int field) +{ + const char *dmi_data = dmi_get_system_info(field); + + return dmi_data && *dmi_data ? dmi_data : "?"; +} + +/* + * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. + */ +static int i8k_smm(struct smm_regs *regs) +{ + int rc; + int eax = regs->eax; + cpumask_var_t old_mask; + + /* SMM requires CPU 0 */ + if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) + return -ENOMEM; + cpumask_copy(old_mask, ¤t->cpus_allowed); + rc = set_cpus_allowed_ptr(current, cpumask_of(0)); + if (rc) + goto out; + if (smp_processor_id() != 0) { + rc = -EBUSY; + goto out; + } + +#if defined(CONFIG_X86_64) + asm volatile("pushq %%rax\n\t" + "movl 0(%%rax),%%edx\n\t" + "pushq %%rdx\n\t" + "movl 4(%%rax),%%ebx\n\t" + "movl 8(%%rax),%%ecx\n\t" + "movl 12(%%rax),%%edx\n\t" + "movl 16(%%rax),%%esi\n\t" + "movl 20(%%rax),%%edi\n\t" + "popq %%rax\n\t" + "out %%al,$0xb2\n\t" + "out %%al,$0x84\n\t" + "xchgq %%rax,(%%rsp)\n\t" + "movl %%ebx,4(%%rax)\n\t" + "movl %%ecx,8(%%rax)\n\t" + "movl %%edx,12(%%rax)\n\t" + "movl %%esi,16(%%rax)\n\t" + "movl %%edi,20(%%rax)\n\t" + "popq %%rdx\n\t" + "movl %%edx,0(%%rax)\n\t" + "pushfq\n\t" + "popq %%rax\n\t" + "andl $1,%%eax\n" + : "=a"(rc) + : "a"(regs) + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); +#else + asm volatile("pushl %%eax\n\t" + "movl 0(%%eax),%%edx\n\t" + "push %%edx\n\t" + "movl 4(%%eax),%%ebx\n\t" + "movl 8(%%eax),%%ecx\n\t" + "movl 12(%%eax),%%edx\n\t" + "movl 16(%%eax),%%esi\n\t" + "movl 20(%%eax),%%edi\n\t" + "popl %%eax\n\t" + "out %%al,$0xb2\n\t" + "out %%al,$0x84\n\t" + "xchgl %%eax,(%%esp)\n\t" + "movl %%ebx,4(%%eax)\n\t" + "movl %%ecx,8(%%eax)\n\t" + "movl %%edx,12(%%eax)\n\t" + "movl %%esi,16(%%eax)\n\t" + "movl %%edi,20(%%eax)\n\t" + "popl %%edx\n\t" + "movl %%edx,0(%%eax)\n\t" + "lahf\n\t" + "shrl $8,%%eax\n\t" + "andl $1,%%eax\n" + : "=a"(rc) + : "a"(regs) + : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); +#endif + if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) + rc = -EINVAL; + +out: + set_cpus_allowed_ptr(current, old_mask); + free_cpumask_var(old_mask); + return rc; +} + +/* + * Read the Fn key status. + */ +static int i8k_get_fn_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { + case I8K_FN_UP: + return I8K_VOL_UP; + case I8K_FN_DOWN: + return I8K_VOL_DOWN; + case I8K_FN_MUTE: + return I8K_VOL_MUTE; + default: + return 0; + } +} + +/* + * Read the power status. + */ +static int i8k_get_power_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; +} + +/* + * Read the fan status. + */ +static int i8k_get_fan_status(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the fan speed in RPM. + */ +static int i8k_get_fan_speed(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; +} + +/* + * Read the fan type. + */ +static int i8k_get_fan_type(int fan) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; + + regs.ebx = fan & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the fan nominal rpm for specific fan speed. + */ +static int i8k_get_fan_nominal_speed(int fan, int speed) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; + + regs.ebx = (fan & 0xff) | (speed << 8); + return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; +} + +/* + * Set the fan speed (off, low, high). Returns the new fan status. + */ +static int i8k_set_fan(int fan, int speed) +{ + struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; + + speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); + regs.ebx = (fan & 0xff) | (speed << 8); + + return i8k_smm(®s) ? : i8k_get_fan_status(fan); +} + +static int i8k_get_temp_type(int sensor) +{ + struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; + + regs.ebx = sensor & 0xff; + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +/* + * Read the cpu temperature. + */ +static int _i8k_get_temp(int sensor) +{ + struct smm_regs regs = { + .eax = I8K_SMM_GET_TEMP, + .ebx = sensor & 0xff, + }; + + return i8k_smm(®s) ? : regs.eax & 0xff; +} + +static int i8k_get_temp(int sensor) +{ + int temp = _i8k_get_temp(sensor); + + /* + * Sometimes the temperature sensor returns 0x99, which is out of range. + * In this case we retry (once) before returning an error. + # 1003655137 00000058 00005a4b + # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees + # 1003655139 00000054 00005c52 + */ + if (temp == 0x99) { + msleep(100); + temp = _i8k_get_temp(sensor); + } + /* + * Return -ENODATA for all invalid temperatures. + * + * Known instances are the 0x99 value as seen above as well as + * 0xc1 (193), which may be returned when trying to read the GPU + * temperature if the system supports a GPU and it is currently + * turned off. + */ + if (temp > I8K_MAX_TEMP) + return -ENODATA; + + return temp; +} + +static int i8k_get_dell_signature(int req_fn) +{ + struct smm_regs regs = { .eax = req_fn, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; +} + +static int +i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) +{ + int val = 0; + int speed; + unsigned char buff[16]; + int __user *argp = (int __user *)arg; + + if (!argp) + return -EINVAL; + + switch (cmd) { + case I8K_BIOS_VERSION: + val = (bios_version[0] << 16) | + (bios_version[1] << 8) | bios_version[2]; + break; + + case I8K_MACHINE_ID: + memset(buff, 0, 16); + strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + sizeof(buff)); + break; + + case I8K_FN_STATUS: + val = i8k_get_fn_status(); + break; + + case I8K_POWER_STATUS: + val = i8k_get_power_status(); + break; + + case I8K_GET_TEMP: + val = i8k_get_temp(0); + break; + + case I8K_GET_SPEED: + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + val = i8k_get_fan_speed(val); + break; + + case I8K_GET_FAN: + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + val = i8k_get_fan_status(val); + break; + + case I8K_SET_FAN: + if (restricted && !capable(CAP_SYS_ADMIN)) + return -EPERM; + + if (copy_from_user(&val, argp, sizeof(int))) + return -EFAULT; + + if (copy_from_user(&speed, argp + 1, sizeof(int))) + return -EFAULT; + + val = i8k_set_fan(val, speed); + break; + + default: + return -EINVAL; + } + + if (val < 0) + return val; + + switch (cmd) { + case I8K_BIOS_VERSION: + if (copy_to_user(argp, &val, 4)) + return -EFAULT; + + break; + case I8K_MACHINE_ID: + if (copy_to_user(argp, buff, 16)) + return -EFAULT; + + break; + default: + if (copy_to_user(argp, &val, sizeof(int))) + return -EFAULT; + + break; + } + + return 0; +} + +static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) +{ + long ret; + + mutex_lock(&i8k_mutex); + ret = i8k_ioctl_unlocked(fp, cmd, arg); + mutex_unlock(&i8k_mutex); + + return ret; +} + +/* + * Print the information for /proc/i8k. + */ +static int i8k_proc_show(struct seq_file *seq, void *offset) +{ + int fn_key, cpu_temp, ac_power; + int left_fan, right_fan, left_speed, right_speed; + + cpu_temp = i8k_get_temp(0); /* 11100 µs */ + left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ + right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ + left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ + right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ + fn_key = i8k_get_fn_status(); /* 750 µs */ + if (power_status) + ac_power = i8k_get_power_status(); /* 14700 µs */ + else + ac_power = -1; + + /* + * Info: + * + * 1) Format version (this will change if format changes) + * 2) BIOS version + * 3) BIOS machine ID + * 4) Cpu temperature + * 5) Left fan status + * 6) Right fan status + * 7) Left fan speed + * 8) Right fan speed + * 9) AC power + * 10) Fn Key status + */ + seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", + I8K_PROC_FMT, + bios_version, + i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + cpu_temp, + left_fan, right_fan, left_speed, right_speed, + ac_power, fn_key); + + return 0; +} + +static int i8k_open_fs(struct inode *inode, struct file *file) +{ + return single_open(file, i8k_proc_show, NULL); +} + + +/* + * Hwmon interface + */ + +static ssize_t i8k_hwmon_show_temp_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + static const char * const labels[] = { + "CPU", + "GPU", + "SODIMM", + "Other", + "Ambient", + "Other", + }; + int index = to_sensor_dev_attr(devattr)->index; + int type; + + type = i8k_get_temp_type(index); + if (type < 0) + return type; + if (type >= ARRAY_SIZE(labels)) + type = ARRAY_SIZE(labels) - 1; + return sprintf(buf, "%s\n", labels[type]); +} + +static ssize_t i8k_hwmon_show_temp(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int temp; + + temp = i8k_get_temp(index); + if (temp < 0) + return temp; + return sprintf(buf, "%d\n", temp * 1000); +} + +static ssize_t i8k_hwmon_show_fan_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + static const char * const labels[] = { + "Processor Fan", + "Motherboard Fan", + "Video Fan", + "Power Supply Fan", + "Chipset Fan", + "Other Fan", + }; + int index = to_sensor_dev_attr(devattr)->index; + bool dock = false; + int type; + + type = i8k_get_fan_type(index); + if (type < 0) + return type; + + if (type & 0x10) { + dock = true; + type &= 0x0F; + } + + if (type >= ARRAY_SIZE(labels)) + type = (ARRAY_SIZE(labels) - 1); + + return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); +} + +static ssize_t i8k_hwmon_show_fan(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int fan_speed; + + fan_speed = i8k_get_fan_speed(index); + if (fan_speed < 0) + return fan_speed; + return sprintf(buf, "%d\n", fan_speed); +} + +static ssize_t i8k_hwmon_show_pwm(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + int index = to_sensor_dev_attr(devattr)->index; + int status; + + status = i8k_get_fan_status(index); + if (status < 0) + return -EIO; + return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); +} + +static ssize_t i8k_hwmon_set_pwm(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int index = to_sensor_dev_attr(attr)->index; + unsigned long val; + int err; + + err = kstrtoul(buf, 10, &val); + if (err) + return err; + val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); + + mutex_lock(&i8k_mutex); + err = i8k_set_fan(index, val); + mutex_unlock(&i8k_mutex); + + return err < 0 ? -EIO : count; +} + +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 0); +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); +static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 1); +static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); +static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 2); +static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); +static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, + 3); +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); +static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, + 0); +static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, + i8k_hwmon_set_pwm, 0); +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, + 1); +static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, + 1); +static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, + i8k_hwmon_set_pwm, 1); + +static struct attribute *i8k_attrs[] = { + &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ + &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ + &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ + &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ + &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ + &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ + &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ + &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ + &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ + &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ + &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ + &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ + &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ + &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ + NULL +}; + +static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, + int index) +{ + if (index >= 0 && index <= 1 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) + return 0; + if (index >= 2 && index <= 3 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) + return 0; + if (index >= 4 && index <= 5 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) + return 0; + if (index >= 6 && index <= 7 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) + return 0; + if (index >= 8 && index <= 10 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) + return 0; + if (index >= 11 && index <= 13 && + !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) + return 0; + + return attr->mode; +} + +static const struct attribute_group i8k_group = { + .attrs = i8k_attrs, + .is_visible = i8k_is_visible, +}; +__ATTRIBUTE_GROUPS(i8k); + +static int __init i8k_init_hwmon(void) +{ + int err; + + i8k_hwmon_flags = 0; + + /* CPU temperature attributes, if temperature type is OK */ + err = i8k_get_temp_type(0); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; + /* check for additional temperature sensors */ + err = i8k_get_temp_type(1); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; + err = i8k_get_temp_type(2); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; + err = i8k_get_temp_type(3); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; + + /* First fan attributes, if fan type is OK */ + err = i8k_get_fan_type(0); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; + + /* Second fan attributes, if fan type is OK */ + err = i8k_get_fan_type(1); + if (err >= 0) + i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; + + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, + i8k_groups); + if (IS_ERR(i8k_hwmon_dev)) { + err = PTR_ERR(i8k_hwmon_dev); + i8k_hwmon_dev = NULL; + pr_err("hwmon registration failed (%d)\n", err); + return err; + } + return 0; +} + +struct i8k_config_data { + uint fan_mult; + uint fan_max; +}; + +enum i8k_configs { + DELL_LATITUDE_D520, + DELL_PRECISION_490, + DELL_STUDIO, + DELL_XPS, +}; + +static const struct i8k_config_data i8k_config_data[] = { + [DELL_LATITUDE_D520] = { + .fan_mult = 1, + .fan_max = I8K_FAN_TURBO, + }, + [DELL_PRECISION_490] = { + .fan_mult = 1, + .fan_max = I8K_FAN_TURBO, + }, + [DELL_STUDIO] = { + .fan_mult = 1, + .fan_max = I8K_FAN_HIGH, + }, + [DELL_XPS] = { + .fan_mult = 1, + .fan_max = I8K_FAN_HIGH, + }, +}; + +static struct dmi_system_id i8k_dmi_table[] __initdata = { + { + .ident = "Dell Inspiron", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), + }, + }, + { + .ident = "Dell Latitude", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), + }, + }, + { + .ident = "Dell Inspiron 2", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), + }, + }, + { + .ident = "Dell Latitude D520", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), + }, + .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], + }, + { + .ident = "Dell Latitude 2", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), + }, + }, + { /* UK Inspiron 6400 */ + .ident = "Dell Inspiron 3", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), + }, + }, + { + .ident = "Dell Inspiron 3", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), + }, + }, + { + .ident = "Dell Precision 490", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, + "Precision WorkStation 490"), + }, + .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], + }, + { + .ident = "Dell Precision", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), + }, + }, + { + .ident = "Dell Vostro", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), + }, + }, + { + .ident = "Dell XPS421", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), + }, + }, + { + .ident = "Dell Studio", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), + }, + .driver_data = (void *)&i8k_config_data[DELL_STUDIO], + }, + { + .ident = "Dell XPS 13", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), + }, + .driver_data = (void *)&i8k_config_data[DELL_XPS], + }, + { + .ident = "Dell XPS M140", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), + }, + .driver_data = (void *)&i8k_config_data[DELL_XPS], + }, + { } +}; + +MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); + +/* + * Probe for the presence of a supported laptop. + */ +static int __init i8k_probe(void) +{ + const struct dmi_system_id *id; + int fan, ret; + + /* + * Get DMI information + */ + if (!dmi_check_system(i8k_dmi_table)) { + if (!ignore_dmi && !force) + return -ENODEV; + + pr_info("not running on a supported Dell system.\n"); + pr_info("vendor=%s, model=%s, version=%s\n", + i8k_get_dmi_data(DMI_SYS_VENDOR), + i8k_get_dmi_data(DMI_PRODUCT_NAME), + i8k_get_dmi_data(DMI_BIOS_VERSION)); + } + + strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), + sizeof(bios_version)); + + /* + * Get SMM Dell signature + */ + if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && + i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { + pr_err("unable to get SMM Dell signature\n"); + if (!force) + return -ENODEV; + } + + /* + * Set fan multiplier and maximal fan speed from dmi config + * Values specified in module parameters override values from dmi + */ + id = dmi_first_match(i8k_dmi_table); + if (id && id->driver_data) { + const struct i8k_config_data *conf = id->driver_data; + if (!fan_mult && conf->fan_mult) + fan_mult = conf->fan_mult; + if (!fan_max && conf->fan_max) + fan_max = conf->fan_max; + } + + i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ + i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); + + if (!fan_mult) { + /* + * Autodetect fan multiplier based on nominal rpm + * If fan reports rpm value too high then set multiplier to 1 + */ + for (fan = 0; fan < 2; ++fan) { + ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); + if (ret < 0) + continue; + if (ret > I8K_FAN_MAX_RPM) + i8k_fan_mult = 1; + break; + } + } else { + /* Fan multiplier was specified in module param or in dmi */ + i8k_fan_mult = fan_mult; + } + + return 0; +} + +static int __init i8k_init(void) +{ + struct proc_dir_entry *proc_i8k; + int err; + + /* Are we running on an supported laptop? */ + if (i8k_probe()) + return -ENODEV; + + /* Register the proc entry */ + proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); + if (!proc_i8k) + return -ENOENT; + + err = i8k_init_hwmon(); + if (err) + goto exit_remove_proc; + + return 0; + + exit_remove_proc: + remove_proc_entry("i8k", NULL); + return err; +} + +static void __exit i8k_exit(void) +{ + hwmon_device_unregister(i8k_hwmon_dev); + remove_proc_entry("i8k", NULL); +} + +module_init(i8k_init); +module_exit(i8k_exit); -- 1.7.10.4 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-04-29 11:41 ` Pali Rohár @ 2015-04-29 11:41 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-29 11:41 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár VGhpcyBwYXRjaCBzcGxpdHMgQ09ORklHX0k4SyBjb21waWxlIG9wdGlvbiB0byBTRU5TT1JTX0RF TExfU01NIGFuZCBDT05GSUdfSThLLgpPcHRpb24gU0VOU09SU19ERUxMX1NNTSBpcyBub3cgdXNl ZCB0byBlbmFibGUgY29tcGlsYXRpb24gb2YgZGVsbC1zbW0taHdtb24KZHJpdmVyIGFuZCBvbGQg Q09ORklHX0k4SyBvcHRpb24gdG8gZW5hYmxlIC9wcm9jL2k4ayBpbnRlcmZhY2UgaW4gZHJpdmVy LgoKU28gdGhpcyBjaGFuZ2UgYWxsb3dzIHRvIGNvbXBpbGUgZGVsbC1zbW0taHdtb24gZHJpdmVy IHdpdGhvdXQgbGVnYWN5IC9wcm9jL2k4awppbnRlcmZhY2Ugd2hpY2ggaXMgbmVlZGVkIG9ubHkg Zm9yIG9sZCBEZWxsIEluc3BpcmlvbiBtb2RlbHMgb3IgZm9yIHVzZXJzcGFjZQppOGt1dGlscyBw YWNrYWdlLgoKRm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2hlbiBDT05GSUdfSThLIGlzIGVu YWJsZWQgdGhlbiBhbHNvIFNFTlNPUlNfREVMTF9TTU0KaXMgZW5hYmxlZCBhbmQgc28gZHJpdmVy IGRlbGwtc21tLWh3bW9uICh3aXRoIC9wcm9jL2k4aykgaXMgY29tcGlsZWQuCgpTaWduZWQtb2Zm LWJ5OiBQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Ci0tLQogYXJjaC94ODYvS2Nv bmZpZyAgICAgICAgICAgICAgIHwgICAyNSArKystLS0tCiBkcml2ZXJzL2h3bW9uL0tjb25maWcg ICAgICAgICAgfCAgIDExICsrKwogZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgIHwgICAg MiArLQogZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIHwgIDE1MCArKysrKysrKysrKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tCiA0IGZpbGVzIGNoYW5nZWQsIDEwNiBpbnNlcnRp b25zKCspLCA4MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9LY29uZmlnIGIv YXJjaC94ODYvS2NvbmZpZwppbmRleCAyMjZkNTY5Li43Yjc1NmIzIDEwMDY0NAotLS0gYS9hcmNo L3g4Ni9LY29uZmlnCisrKyBiL2FyY2gveDg2L0tjb25maWcKQEAgLTEwNTUsMjQgKzEwNTUsMTkg QEAgY29uZmlnIFRPU0hJQkEKIAkgIFNheSBOIG90aGVyd2lzZS4KIAogY29uZmlnIEk4SwotCXRy aXN0YXRlICJEZWxsIGxhcHRvcCBzdXBwb3J0IgorCXRyaXN0YXRlICJEZWxsIGk4ayBsZWdhY3kg bGFwdG9wIHN1cHBvcnQiCiAJc2VsZWN0IEhXTU9OCisJc2VsZWN0IFNFTlNPUlNfREVMTF9TTU0K IAktLS1oZWxwLS0tCi0JICBUaGlzIGFkZHMgYSBkcml2ZXIgdG8gc2FmZWx5IGFjY2VzcyB0aGUg U3lzdGVtIE1hbmFnZW1lbnQgTW9kZQotCSAgb2YgdGhlIENQVSBvbiB0aGUgRGVsbCBJbnNwaXJv biA4MDAwLiBUaGUgU3lzdGVtIE1hbmFnZW1lbnQgTW9kZQotCSAgaXMgdXNlZCB0byByZWFkIGNw dSB0ZW1wZXJhdHVyZSBhbmQgY29vbGluZyBmYW4gc3RhdHVzIGFuZCB0bwotCSAgY29udHJvbCB0 aGUgZmFucyBvbiB0aGUgSThLIHBvcnRhYmxlcy4KKwkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgbGVn YWN5IC9wcm9jL2k4ayB1c2Vyc3BhY2UgaW50ZXJmYWNlIGluIGh3bW9uCisJICBkZWxsLXNtbS1o d21vbiBkcml2ZXIuIENoYXJhY3RlciBmaWxlIC9wcm9jL2k4ayByZXBvcnRzIGJpb3MgdmVyc2lv biwKKwkgIHRlbXBlcmF0dXJlIGFuZCBhbGxvd3MgY29udHJvbGxpbmcgZmFuIHNwZWVkcyBvZiBE ZWxsIGxhcHRvcHMgdmlhCisJICBTeXN0ZW0gTWFuYWdlbWVudCBNb2RlLiBGb3Igb2xkIERlbGwg bGFwdG9wcyAobGlrZSBEZWxsIEluc3Bpcm9uIDgwMDApCisJICBpdCByZXBvcnRzIGFsc28gcG93 ZXIgYW5kIGhvdGtleSBzdGF0dXMuIEZvciBmYW4gc3BlZWQgY29udHJvbCBpcworCSAgbmVlZGVk IHVzZXJzcGFjZSBwYWNrYWdlIGk4a3V0aWxzLgogCi0JICBUaGlzIGRyaXZlciBoYXMgYmVlbiB0 ZXN0ZWQgb25seSBvbiB0aGUgSW5zcGlyb24gODAwMCBidXQgaXQgbWF5Ci0JICBhbHNvIHdvcmsg d2l0aCBvdGhlciBEZWxsIGxhcHRvcHMuIFlvdSBjYW4gZm9yY2UgbG9hZGluZyBvbiBvdGhlcgot CSAgbW9kZWxzIGJ5IHBhc3NpbmcgdGhlIHBhcmFtZXRlciBgZm9yY2U9MScgdG8gdGhlIG1vZHVs ZS4gVXNlIGF0Ci0JICB5b3VyIG93biByaXNrLgotCi0JICBGb3IgaW5mb3JtYXRpb24gb24gdXRp bGl0aWVzIHRvIG1ha2UgdXNlIG9mIHRoaXMgZHJpdmVyIHNlZSB0aGUKLQkgIEk4SyBMaW51eCB1 dGlsaXRpZXMgd2ViIHNpdGUgYXQ6Ci0JICA8aHR0cDovL3Blb3BsZS5kZWJpYW4ub3JnL35kei9p OGsvPgotCi0JICBTYXkgWSBpZiB5b3UgaW50ZW5kIHRvIHJ1biB0aGlzIGtlcm5lbCBvbiBhIERl bGwgSW5zcGlyb24gODAwMC4KKwkgIFNheSBZIGlmIHlvdSBpbnRlbmQgdG8gcnVuIHRoaXMga2Vy bmVsIG9uIG9sZCBEZWxsIGxhcHRvcHMgb3Igd2FudCB0bworCSAgdXNlIHVzZXJzcGFjZSBwYWNr YWdlIGk4a3V0aWxzLgogCSAgU2F5IE4gb3RoZXJ3aXNlLgogCiBjb25maWcgWDg2X1JFQk9PVEZJ WFVQUwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21vbi9L Y29uZmlnCmluZGV4IDI1ZDllNzIuLjcxNGY5MmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24v S2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTM3MSw2ICszNzEsMTcgQEAg Y29uZmlnIFNFTlNPUlNfRFMxNjIxCiAJICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBh cyBhIG1vZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCiAJICB3aWxsIGJlIGNhbGxlZCBkczE2MjEu CiAKK2NvbmZpZyBTRU5TT1JTX0RFTExfU01NCisJdHJpc3RhdGUgIkRlbGwgbGFwdG9wIFNNTSBC SU9TIGh3bW9uIGRyaXZlciIKKwlkZXBlbmRzIG9uIFg4NiAmJiBETUkKKwloZWxwCisJICBUaGlz IGh3bW9uIGRyaXZlciBhZGRzIHN1cHBvcnQgZm9yIHJlcG9ydGluZyB0ZW1wZXJhdHVyZSBvZiBk aWZmZXJlbnQKKwkgIHNlbnNvcnMgYW5kIGNvbnRyb2xzIHRoZSBmYW5zIG9uIERlbGwgbGFwdG9w cyB2aWEgU3lzdGVtIE1hbmFnZW1lbnQKKwkgIE1vZGUgcHJvdmlkZWQgYnkgRGVsbCBCSU9TLgor CisJICBXaGVuIG9wdGlvbiBJOEsgaXMgYWxzbyBlbmFibGVkIHRoaXMgZHJpdmVyIHByb3ZpZGVz IGxlZ2FjeSAvcHJvYy9pOGsKKwkgIHVzZXJzcGFjZSBpbnRlcmZhY2UgZm9yIGk4a3V0aWxzIHBh Y2thZ2UuCisKIGNvbmZpZyBTRU5TT1JTX0RBOTA1Ml9BREMKIAl0cmlzdGF0ZSAiRGlhbG9nIERB OTA1Mi9EQTkwNTMgQURDIgogCWRlcGVuZHMgb24gUE1JQ19EQTkwNTIKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCmluZGV4IDUxNTMz YWMuLjZjYWNkMGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKKysrIGIvZHJp dmVycy9od21vbi9NYWtlZmlsZQpAQCAtNDksNiArNDksNyBAQCBvYmotJChDT05GSUdfU0VOU09S U19BVFhQMSkJKz0gYXR4cDEubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfQ09SRVRFTVApCSs9IGNv cmV0ZW1wLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0RBOTA1Ml9BREMpKz0gZGE5MDUyLWh3bW9u Lm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0RBOTA1NSkrPSBkYTkwNTUtaHdtb24ubworb2JqLSQo Q09ORklHX1NFTlNPUlNfREVMTF9TTU0pCSs9IGRlbGwtc21tLWh3bW9uLm8KIG9iai0kKENPTkZJ R19TRU5TT1JTX0RNRTE3MzcpCSs9IGRtZTE3Mzcubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfRFM2 MjApCSs9IGRzNjIwLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0RTMTYyMSkJKz0gZHMxNjIxLm8K QEAgLTE1Niw3ICsxNTcsNiBAQCBvYmotJChDT05GSUdfU0VOU09SU19XODNMNzg1VFMpCSs9IHc4 M2w3ODV0cy5vCiBvYmotJChDT05GSUdfU0VOU09SU19XODNMNzg2TkcpCSs9IHc4M2w3ODZuZy5v CiBvYmotJChDT05GSUdfU0VOU09SU19XTTgzMVgpCSs9IHdtODMxeC1od21vbi5vCiBvYmotJChD T05GSUdfU0VOU09SU19XTTgzNTApCSs9IHdtODM1MC1od21vbi5vCi1vYmotJChDT05GSUdfSThL KQkJKz0gZGVsbC1zbW0taHdtb24ubwogCiBvYmotJChDT05GSUdfUE1CVVMpCQkrPSBwbWJ1cy8K IApkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIGIvZHJpdmVycy9o d21vbi9kZWxsLXNtbS1od21vbi5jCmluZGV4IDY1ZDMxNGIuLjJhODA4ODIgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYworKysgYi9kcml2ZXJzL2h3bW9uL2RlbGwt c21tLWh3bW9uLmMKQEAgLTgxLDcgKzgxLDcgQEAgc3RhdGljIHVpbnQgaThrX2Zhbl9tYXggPSBJ OEtfRkFOX0hJR0g7CiAKIE1PRFVMRV9BVVRIT1IoIk1hc3NpbW8gRGFsIFpvdHRvIChkekBkZWJp YW4ub3JnKSIpOwogTU9EVUxFX0FVVEhPUigiUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwu Y29tPiIpOwotTU9EVUxFX0RFU0NSSVBUSU9OKCJEcml2ZXIgZm9yIGFjY2Vzc2luZyBTTU0gQklP UyBvbiBEZWxsIGxhcHRvcHMiKTsKK01PRFVMRV9ERVNDUklQVElPTigiRGVsbCBsYXB0b3AgU01N IEJJT1MgaHdtb24gZHJpdmVyIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfQUxJ QVMoImk4ayIpOwogCkBAIC05Myw2ICs5Myw3IEBAIHN0YXRpYyBib29sIGlnbm9yZV9kbWk7CiBt b2R1bGVfcGFyYW0oaWdub3JlX2RtaSwgYm9vbCwgMCk7CiBNT0RVTEVfUEFSTV9ERVNDKGlnbm9y ZV9kbWksICJDb250aW51ZSBwcm9iaW5nIGhhcmR3YXJlIGV2ZW4gaWYgRE1JIGRhdGEgZG9lcyBu b3QgbWF0Y2giKTsKIAorI2lmIElTX0VOQUJMRUQoQ09ORklHX0k4SykKIHN0YXRpYyBib29sIHJl c3RyaWN0ZWQ7CiBtb2R1bGVfcGFyYW0ocmVzdHJpY3RlZCwgYm9vbCwgMCk7CiBNT0RVTEVfUEFS TV9ERVNDKHJlc3RyaWN0ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJp bGl0eSBzZXQiKTsKQEAgLTEwMCw2ICsxMDEsNyBAQCBNT0RVTEVfUEFSTV9ERVNDKHJlc3RyaWN0 ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJpbGl0eSBzZXQiKTsKIHN0 YXRpYyBib29sIHBvd2VyX3N0YXR1czsKIG1vZHVsZV9wYXJhbShwb3dlcl9zdGF0dXMsIGJvb2ws IDA2MDApOwogTU9EVUxFX1BBUk1fREVTQyhwb3dlcl9zdGF0dXMsICJSZXBvcnQgcG93ZXIgc3Rh dHVzIGluIC9wcm9jL2k4ayIpOworI2VuZGlmCiAKIHN0YXRpYyB1aW50IGZhbl9tdWx0OwogbW9k dWxlX3BhcmFtKGZhbl9tdWx0LCB1aW50LCAwKTsKQEAgLTEwOSwxOCArMTExLDYgQEAgc3RhdGlj IHVpbnQgZmFuX21heDsKIG1vZHVsZV9wYXJhbShmYW5fbWF4LCB1aW50LCAwKTsKIE1PRFVMRV9Q QVJNX0RFU0MoZmFuX21heCwgIk1heGltdW0gY29uZmlndXJhYmxlIGZhbiBzcGVlZCAoZGVmYXVs dDogYXV0b2RldGVjdCkiKTsKIAotc3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5vZGUg Kmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSk7Ci1zdGF0aWMgbG9uZyBpOGtfaW9jdGwoc3RydWN0 IGZpbGUgKiwgdW5zaWduZWQgaW50LCB1bnNpZ25lZCBsb25nKTsKLQotc3RhdGljIGNvbnN0IHN0 cnVjdCBmaWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7Ci0JLm93bmVyCQk9IFRISVNfTU9EVUxF LAotCS5vcGVuCQk9IGk4a19vcGVuX2ZzLAotCS5yZWFkCQk9IHNlcV9yZWFkLAotCS5sbHNlZWsJ CT0gc2VxX2xzZWVrLAotCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVhc2UsCi0JLnVubG9ja2VkX2lv Y3RsCT0gaThrX2lvY3RsLAotfTsKLQogc3RydWN0IHNtbV9yZWdzIHsKIAl1bnNpZ25lZCBpbnQg ZWF4OwogCXVuc2lnbmVkIGludCBlYnggX19wYWNrZWQ7CkBAIC0yMjEsNDUgKzIxMSw2IEBAIG91 dDoKIH0KIAogLyoKLSAqIFJlYWQgdGhlIEZuIGtleSBzdGF0dXMuCi0gKi8KLXN0YXRpYyBpbnQg aThrX2dldF9mbl9zdGF0dXModm9pZCkKLXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVh eCA9IEk4S19TTU1fRk5fU1RBVFVTLCB9OwotCWludCByYzsKLQotCXJjID0gaThrX3NtbSgmcmVn cyk7Ci0JaWYgKHJjIDwgMCkKLQkJcmV0dXJuIHJjOwotCi0Jc3dpdGNoICgocmVncy5lYXggPj4g SThLX0ZOX1NISUZUKSAmIEk4S19GTl9NQVNLKSB7Ci0JY2FzZSBJOEtfRk5fVVA6Ci0JCXJldHVy biBJOEtfVk9MX1VQOwotCWNhc2UgSThLX0ZOX0RPV046Ci0JCXJldHVybiBJOEtfVk9MX0RPV047 Ci0JY2FzZSBJOEtfRk5fTVVURToKLQkJcmV0dXJuIEk4S19WT0xfTVVURTsKLQlkZWZhdWx0Ogot CQlyZXR1cm4gMDsKLQl9Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBwb3dlciBzdGF0dXMuCi0gKi8K LXN0YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9pZCkKLXsKLQlzdHJ1Y3Qgc21tX3Jl Z3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fUE9XRVJfU1RBVFVTLCB9OwotCWludCByYzsKLQot CXJjID0gaThrX3NtbSgmcmVncyk7Ci0JaWYgKHJjIDwgMCkKLQkJcmV0dXJuIHJjOwotCi0JcmV0 dXJuIChyZWdzLmVheCAmIDB4ZmYpID09IEk4S19QT1dFUl9BQyA/IEk4S19BQyA6IEk4S19CQVRU RVJZOwotfQotCi0vKgogICogUmVhZCB0aGUgZmFuIHN0YXR1cy4KICAqLwogc3RhdGljIGludCBp OGtfZ2V0X2Zhbl9zdGF0dXMoaW50IGZhbikKQEAgLTM3OCw2ICszMjksNTEgQEAgc3RhdGljIGlu dCBpOGtfZ2V0X2RlbGxfc2lnbmF0dXJlKGludCByZXFfZm4pCiAJcmV0dXJuIHJlZ3MuZWF4ID09 IDExNDU2NTE1MjcgJiYgcmVncy5lZHggPT0gMTE0NTM5MjIwNCA/IDAgOiAtMTsKIH0KIAorI2lm IElTX0VOQUJMRUQoQ09ORklHX0k4SykKKworLyoKKyAqIFJlYWQgdGhlIEZuIGtleSBzdGF0dXMu CisgKi8KK3N0YXRpYyBpbnQgaThrX2dldF9mbl9zdGF0dXModm9pZCkKK3sKKwlzdHJ1Y3Qgc21t X3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fRk5fU1RBVFVTLCB9OworCWludCByYzsKKwor CXJjID0gaThrX3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJcmV0dXJuIHJjOworCisJc3dp dGNoICgocmVncy5lYXggPj4gSThLX0ZOX1NISUZUKSAmIEk4S19GTl9NQVNLKSB7CisJY2FzZSBJ OEtfRk5fVVA6CisJCXJldHVybiBJOEtfVk9MX1VQOworCWNhc2UgSThLX0ZOX0RPV046CisJCXJl dHVybiBJOEtfVk9MX0RPV047CisJY2FzZSBJOEtfRk5fTVVURToKKwkJcmV0dXJuIEk4S19WT0xf TVVURTsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9Cit9CisKKy8qCisgKiBSZWFkIHRoZSBw b3dlciBzdGF0dXMuCisgKi8KK3N0YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9pZCkK K3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fUE9XRVJfU1RBVFVT LCB9OworCWludCByYzsKKworCXJjID0gaThrX3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJ cmV0dXJuIHJjOworCisJcmV0dXJuIChyZWdzLmVheCAmIDB4ZmYpID09IEk4S19QT1dFUl9BQyA/ IEk4S19BQyA6IEk4S19CQVRURVJZOworfQorCisvKgorICogUHJvY2ZzIGludGVyZmFjZQorICov CisKIHN0YXRpYyBpbnQKIGk4a19pb2N0bF91bmxvY2tlZChzdHJ1Y3QgZmlsZSAqZnAsIHVuc2ln bmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQogewpAQCAtNTI4LDYgKzUyNCwzNyBAQCBz dGF0aWMgaW50IGk4a19vcGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpm aWxlKQogCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBpOGtfcHJvY19zaG93LCBOVUxMKTsKIH0K IAorc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7CisJLm93 bmVyCQk9IFRISVNfTU9EVUxFLAorCS5vcGVuCQk9IGk4a19vcGVuX2ZzLAorCS5yZWFkCQk9IHNl cV9yZWFkLAorCS5sbHNlZWsJCT0gc2VxX2xzZWVrLAorCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVh c2UsCisJLnVubG9ja2VkX2lvY3RsCT0gaThrX2lvY3RsLAorfTsKKworc3RhdGljIHZvaWQgX19p bml0IGk4a19pbml0X3Byb2Nmcyh2b2lkKQoreworCS8qIFJlZ2lzdGVyIHRoZSBwcm9jIGVudHJ5 ICovCisJcHJvY19jcmVhdGUoImk4ayIsIDAsIE5VTEwsICZpOGtfZm9wcyk7Cit9CisKK3N0YXRp YyB2b2lkIF9fZXhpdCBpOGtfZXhpdF9wcm9jZnModm9pZCkKK3sKKwlyZW1vdmVfcHJvY19lbnRy eSgiaThrIiwgTlVMTCk7Cit9CisKKyNlbHNlCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2luaXQg aThrX2luaXRfcHJvY2ZzKHZvaWQpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2V4aXQg aThrX2V4aXRfcHJvY2ZzKHZvaWQpCit7Cit9CisKKyNlbmRpZgogCiAvKgogICogSHdtb24gaW50 ZXJmYWNlCkBAIC03NTAsOCArNzc3LDggQEAgc3RhdGljIGludCBfX2luaXQgaThrX2luaXRfaHdt b24odm9pZCkKIAlpZiAoZXJyID49IDApCiAJCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05f SEFWRV9GQU4yOwogCi0JaThrX2h3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRo X2dyb3VwcyhOVUxMLCAiaThrIiwgTlVMTCwKLQkJCQkJCQkgIGk4a19ncm91cHMpOworCWk4a19o d21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoTlVMTCwgImRlbGwt c21tIiwKKwkJCQkJCQkgIE5VTEwsIGk4a19ncm91cHMpOwogCWlmIChJU19FUlIoaThrX2h3bW9u X2RldikpIHsKIAkJZXJyID0gUFRSX0VSUihpOGtfaHdtb25fZGV2KTsKIAkJaThrX2h3bW9uX2Rl diA9IE5VTEw7CkBAIC05NzYsMzMgKzEwMDMsMjQgQEAgc3RhdGljIGludCBfX2luaXQgaThrX3By b2JlKHZvaWQpCiAKIHN0YXRpYyBpbnQgX19pbml0IGk4a19pbml0KHZvaWQpCiB7Ci0Jc3RydWN0 IHByb2NfZGlyX2VudHJ5ICpwcm9jX2k4azsKIAlpbnQgZXJyOwogCiAJLyogQXJlIHdlIHJ1bm5p bmcgb24gYW4gc3VwcG9ydGVkIGxhcHRvcD8gKi8KIAlpZiAoaThrX3Byb2JlKCkpCiAJCXJldHVy biAtRU5PREVWOwogCi0JLyogUmVnaXN0ZXIgdGhlIHByb2MgZW50cnkgKi8KLQlwcm9jX2k4ayA9 IHByb2NfY3JlYXRlKCJpOGsiLCAwLCBOVUxMLCAmaThrX2ZvcHMpOwotCWlmICghcHJvY19pOGsp Ci0JCXJldHVybiAtRU5PRU5UOwotCiAJZXJyID0gaThrX2luaXRfaHdtb24oKTsKIAlpZiAoZXJy KQotCQlnb3RvIGV4aXRfcmVtb3ZlX3Byb2M7CisJCXJldHVybiBlcnI7CiAKKwlpOGtfaW5pdF9w cm9jZnMoKTsKIAlyZXR1cm4gMDsKLQotIGV4aXRfcmVtb3ZlX3Byb2M6Ci0JcmVtb3ZlX3Byb2Nf ZW50cnkoImk4ayIsIE5VTEwpOwotCXJldHVybiBlcnI7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhp dCBpOGtfZXhpdCh2b2lkKQogewogCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGk4a19od21vbl9k ZXYpOwotCXJlbW92ZV9wcm9jX2VudHJ5KCJpOGsiLCBOVUxMKTsKKwlpOGtfZXhpdF9wcm9jZnMo KTsKIH0KIAogbW9kdWxlX2luaXQoaThrX2luaXQpOwotLSAKMS43LjEwLjQKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcg bGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-04-29 11:41 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-29 11:41 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors, Pali Rohár This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k interface which is needed only for old Dell Inspirion models or for userspace i8kutils package. For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- arch/x86/Kconfig | 25 +++---- drivers/hwmon/Kconfig | 11 +++ drivers/hwmon/Makefile | 2 +- drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ 4 files changed, 106 insertions(+), 82 deletions(-) diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 226d569..7b756b3 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -1055,24 +1055,19 @@ config TOSHIBA Say N otherwise. config I8K - tristate "Dell laptop support" + tristate "Dell i8k legacy laptop support" select HWMON + select SENSORS_DELL_SMM ---help--- - This adds a driver to safely access the System Management Mode - of the CPU on the Dell Inspiron 8000. The System Management Mode - is used to read cpu temperature and cooling fan status and to - control the fans on the I8K portables. + This option enables legacy /proc/i8k userspace interface in hwmon + dell-smm-hwmon driver. Character file /proc/i8k reports bios version, + temperature and allows controlling fan speeds of Dell laptops via + System Management Mode. For old Dell laptops (like Dell Inspiron 8000) + it reports also power and hotkey status. For fan speed control is + needed userspace package i8kutils. - This driver has been tested only on the Inspiron 8000 but it may - also work with other Dell laptops. You can force loading on other - models by passing the parameter `force=1' to the module. Use at - your own risk. - - For information on utilities to make use of this driver see the - I8K Linux utilities web site at: - <http://people.debian.org/~dz/i8k/> - - Say Y if you intend to run this kernel on a Dell Inspiron 8000. + Say Y if you intend to run this kernel on old Dell laptops or want to + use userspace package i8kutils. Say N otherwise. config X86_REBOOTFIXUPS diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 25d9e72..714f92a 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -371,6 +371,17 @@ config SENSORS_DS1621 This driver can also be built as a module. If so, the module will be called ds1621. +config SENSORS_DELL_SMM + tristate "Dell laptop SMM BIOS hwmon driver" + depends on X86 && DMI + help + This hwmon driver adds support for reporting temperature of different + sensors and controls the fans on Dell laptops via System Management + Mode provided by Dell BIOS. + + When option I8K is also enabled this driver provides legacy /proc/i8k + userspace interface for i8kutils package. + config SENSORS_DA9052_ADC tristate "Dialog DA9052/DA9053 ADC" depends on PMIC_DA9052 diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 51533ac..6cacd0f 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -49,6 +49,7 @@ obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o obj-$(CONFIG_SENSORS_CORETEMP) += coretemp.o obj-$(CONFIG_SENSORS_DA9052_ADC)+= da9052-hwmon.o obj-$(CONFIG_SENSORS_DA9055)+= da9055-hwmon.o +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o obj-$(CONFIG_SENSORS_DME1737) += dme1737.o obj-$(CONFIG_SENSORS_DS620) += ds620.o obj-$(CONFIG_SENSORS_DS1621) += ds1621.o @@ -156,7 +157,6 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o -obj-$(CONFIG_I8K) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c index 65d314b..2a80882 100644 --- a/drivers/hwmon/dell-smm-hwmon.c +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -81,7 +81,7 @@ static uint i8k_fan_max = I8K_FAN_HIGH; MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); +MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS("i8k"); @@ -93,6 +93,7 @@ static bool ignore_dmi; module_param(ignore_dmi, bool, 0); MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); +#if IS_ENABLED(CONFIG_I8K) static bool restricted; module_param(restricted, bool, 0); MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); @@ -100,6 +101,7 @@ MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); static bool power_status; module_param(power_status, bool, 0600); MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); +#endif static uint fan_mult; module_param(fan_mult, uint, 0); @@ -109,18 +111,6 @@ static uint fan_max; module_param(fan_max, uint, 0); MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); -static int i8k_open_fs(struct inode *inode, struct file *file); -static long i8k_ioctl(struct file *, unsigned int, unsigned long); - -static const struct file_operations i8k_fops = { - .owner = THIS_MODULE, - .open = i8k_open_fs, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, - .unlocked_ioctl = i8k_ioctl, -}; - struct smm_regs { unsigned int eax; unsigned int ebx __packed; @@ -221,45 +211,6 @@ out: } /* - * Read the Fn key status. - */ -static int i8k_get_fn_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { - case I8K_FN_UP: - return I8K_VOL_UP; - case I8K_FN_DOWN: - return I8K_VOL_DOWN; - case I8K_FN_MUTE: - return I8K_VOL_MUTE; - default: - return 0; - } -} - -/* - * Read the power status. - */ -static int i8k_get_power_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; -} - -/* * Read the fan status. */ static int i8k_get_fan_status(int fan) @@ -378,6 +329,51 @@ static int i8k_get_dell_signature(int req_fn) return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; } +#if IS_ENABLED(CONFIG_I8K) + +/* + * Read the Fn key status. + */ +static int i8k_get_fn_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { + case I8K_FN_UP: + return I8K_VOL_UP; + case I8K_FN_DOWN: + return I8K_VOL_DOWN; + case I8K_FN_MUTE: + return I8K_VOL_MUTE; + default: + return 0; + } +} + +/* + * Read the power status. + */ +static int i8k_get_power_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; +} + +/* + * Procfs interface + */ + static int i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) { @@ -528,6 +524,37 @@ static int i8k_open_fs(struct inode *inode, struct file *file) return single_open(file, i8k_proc_show, NULL); } +static const struct file_operations i8k_fops = { + .owner = THIS_MODULE, + .open = i8k_open_fs, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .unlocked_ioctl = i8k_ioctl, +}; + +static void __init i8k_init_procfs(void) +{ + /* Register the proc entry */ + proc_create("i8k", 0, NULL, &i8k_fops); +} + +static void __exit i8k_exit_procfs(void) +{ + remove_proc_entry("i8k", NULL); +} + +#else + +static inline void __init i8k_init_procfs(void) +{ +} + +static inline void __exit i8k_exit_procfs(void) +{ +} + +#endif /* * Hwmon interface @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) if (err >= 0) i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, - i8k_groups); + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "dell-smm", + NULL, i8k_groups); if (IS_ERR(i8k_hwmon_dev)) { err = PTR_ERR(i8k_hwmon_dev); i8k_hwmon_dev = NULL; @@ -976,33 +1003,24 @@ static int __init i8k_probe(void) static int __init i8k_init(void) { - struct proc_dir_entry *proc_i8k; int err; /* Are we running on an supported laptop? */ if (i8k_probe()) return -ENODEV; - /* Register the proc entry */ - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); - if (!proc_i8k) - return -ENOENT; - err = i8k_init_hwmon(); if (err) - goto exit_remove_proc; + return err; + i8k_init_procfs(); return 0; - - exit_remove_proc: - remove_proc_entry("i8k", NULL); - return err; } static void __exit i8k_exit(void) { hwmon_device_unregister(i8k_hwmon_dev); - remove_proc_entry("i8k", NULL); + i8k_exit_procfs(); } module_init(i8k_init); -- 1.7.10.4 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-04-29 11:41 ` Pali Rohár @ 2015-06-27 11:34 ` Gabriele Mazzotta -1 siblings, 0 replies; 86+ messages in thread From: Gabriele Mazzotta @ 2015-06-27 11:34 UTC (permalink / raw) To: Pali Rohár Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors Hi Pali, I've just noticed an issue with this patch. See the comment here below. Gabriele On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. > Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon > driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. > > So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k > interface which is needed only for old Dell Inspirion models or for userspace > i8kutils package. > > For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM > is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > arch/x86/Kconfig | 25 +++---- > drivers/hwmon/Kconfig | 11 +++ > drivers/hwmon/Makefile | 2 +- > drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ > 4 files changed, 106 insertions(+), 82 deletions(-) > > diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig > index 226d569..7b756b3 100644 > --- a/arch/x86/Kconfig > +++ b/arch/x86/Kconfig > @@ -1055,24 +1055,19 @@ config TOSHIBA > Say N otherwise. > > config I8K > - tristate "Dell laptop support" > + tristate "Dell i8k legacy laptop support" > select HWMON > + select SENSORS_DELL_SMM > ---help--- > - This adds a driver to safely access the System Management Mode > - of the CPU on the Dell Inspiron 8000. The System Management Mode > - is used to read cpu temperature and cooling fan status and to > - control the fans on the I8K portables. > + This option enables legacy /proc/i8k userspace interface in hwmon > + dell-smm-hwmon driver. Character file /proc/i8k reports bios version, > + temperature and allows controlling fan speeds of Dell laptops via > + System Management Mode. For old Dell laptops (like Dell Inspiron 8000) > + it reports also power and hotkey status. For fan speed control is > + needed userspace package i8kutils. > > - This driver has been tested only on the Inspiron 8000 but it may > - also work with other Dell laptops. You can force loading on other > - models by passing the parameter `force=1' to the module. Use at > - your own risk. > - > - For information on utilities to make use of this driver see the > - I8K Linux utilities web site at: > - <http://people.debian.org/~dz/i8k/> > - > - Say Y if you intend to run this kernel on a Dell Inspiron 8000. > + Say Y if you intend to run this kernel on old Dell laptops or want to > + use userspace package i8kutils. > Say N otherwise. > > config X86_REBOOTFIXUPS > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > index 25d9e72..714f92a 100644 > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -371,6 +371,17 @@ config SENSORS_DS1621 > This driver can also be built as a module. If so, the module > will be called ds1621. > > +config SENSORS_DELL_SMM > + tristate "Dell laptop SMM BIOS hwmon driver" > + depends on X86 && DMI > + help > + This hwmon driver adds support for reporting temperature of different > + sensors and controls the fans on Dell laptops via System Management > + Mode provided by Dell BIOS. > + > + When option I8K is also enabled this driver provides legacy /proc/i8k > + userspace interface for i8kutils package. > + > config SENSORS_DA9052_ADC > tristate "Dialog DA9052/DA9053 ADC" > depends on PMIC_DA9052 > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > index 51533ac..6cacd0f 100644 > --- a/drivers/hwmon/Makefile > +++ b/drivers/hwmon/Makefile > @@ -49,6 +49,7 @@ obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o > obj-$(CONFIG_SENSORS_CORETEMP) += coretemp.o > obj-$(CONFIG_SENSORS_DA9052_ADC)+= da9052-hwmon.o > obj-$(CONFIG_SENSORS_DA9055)+= da9055-hwmon.o > +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o > obj-$(CONFIG_SENSORS_DME1737) += dme1737.o > obj-$(CONFIG_SENSORS_DS620) += ds620.o > obj-$(CONFIG_SENSORS_DS1621) += ds1621.o > @@ -156,7 +157,6 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o > obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o > obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o > obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o > -obj-$(CONFIG_I8K) += dell-smm-hwmon.o > > obj-$(CONFIG_PMBUS) += pmbus/ > > diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c > index 65d314b..2a80882 100644 > --- a/drivers/hwmon/dell-smm-hwmon.c > +++ b/drivers/hwmon/dell-smm-hwmon.c > @@ -81,7 +81,7 @@ static uint i8k_fan_max = I8K_FAN_HIGH; > > MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); > MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); > -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); > +MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); > MODULE_LICENSE("GPL"); > MODULE_ALIAS("i8k"); > > @@ -93,6 +93,7 @@ static bool ignore_dmi; > module_param(ignore_dmi, bool, 0); > MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); > > +#if IS_ENABLED(CONFIG_I8K) > static bool restricted; > module_param(restricted, bool, 0); > MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > @@ -100,6 +101,7 @@ MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > static bool power_status; > module_param(power_status, bool, 0600); > MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); > +#endif > > static uint fan_mult; > module_param(fan_mult, uint, 0); > @@ -109,18 +111,6 @@ static uint fan_max; > module_param(fan_max, uint, 0); > MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); > > -static int i8k_open_fs(struct inode *inode, struct file *file); > -static long i8k_ioctl(struct file *, unsigned int, unsigned long); > - > -static const struct file_operations i8k_fops = { > - .owner = THIS_MODULE, > - .open = i8k_open_fs, > - .read = seq_read, > - .llseek = seq_lseek, > - .release = single_release, > - .unlocked_ioctl = i8k_ioctl, > -}; > - > struct smm_regs { > unsigned int eax; > unsigned int ebx __packed; > @@ -221,45 +211,6 @@ out: > } > > /* > - * Read the Fn key status. > - */ > -static int i8k_get_fn_status(void) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; > - int rc; > - > - rc = i8k_smm(®s); > - if (rc < 0) > - return rc; > - > - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { > - case I8K_FN_UP: > - return I8K_VOL_UP; > - case I8K_FN_DOWN: > - return I8K_VOL_DOWN; > - case I8K_FN_MUTE: > - return I8K_VOL_MUTE; > - default: > - return 0; > - } > -} > - > -/* > - * Read the power status. > - */ > -static int i8k_get_power_status(void) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; > - int rc; > - > - rc = i8k_smm(®s); > - if (rc < 0) > - return rc; > - > - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; > -} > - > -/* > * Read the fan status. > */ > static int i8k_get_fan_status(int fan) > @@ -378,6 +329,51 @@ static int i8k_get_dell_signature(int req_fn) > return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; > } > > +#if IS_ENABLED(CONFIG_I8K) > + > +/* > + * Read the Fn key status. > + */ > +static int i8k_get_fn_status(void) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; > + int rc; > + > + rc = i8k_smm(®s); > + if (rc < 0) > + return rc; > + > + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { > + case I8K_FN_UP: > + return I8K_VOL_UP; > + case I8K_FN_DOWN: > + return I8K_VOL_DOWN; > + case I8K_FN_MUTE: > + return I8K_VOL_MUTE; > + default: > + return 0; > + } > +} > + > +/* > + * Read the power status. > + */ > +static int i8k_get_power_status(void) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; > + int rc; > + > + rc = i8k_smm(®s); > + if (rc < 0) > + return rc; > + > + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; > +} > + > +/* > + * Procfs interface > + */ > + > static int > i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) > { > @@ -528,6 +524,37 @@ static int i8k_open_fs(struct inode *inode, struct file *file) > return single_open(file, i8k_proc_show, NULL); > } > > +static const struct file_operations i8k_fops = { > + .owner = THIS_MODULE, > + .open = i8k_open_fs, > + .read = seq_read, > + .llseek = seq_lseek, > + .release = single_release, > + .unlocked_ioctl = i8k_ioctl, > +}; > + > +static void __init i8k_init_procfs(void) > +{ > + /* Register the proc entry */ > + proc_create("i8k", 0, NULL, &i8k_fops); > +} > + > +static void __exit i8k_exit_procfs(void) > +{ > + remove_proc_entry("i8k", NULL); > +} > + > +#else > + > +static inline void __init i8k_init_procfs(void) > +{ > +} > + > +static inline void __exit i8k_exit_procfs(void) > +{ > +} > + > +#endif > > /* > * Hwmon interface > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > if (err >= 0) > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, > - i8k_groups); > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "dell-smm", > + NULL, i8k_groups); dell-smm is not a valid name, see hwmon_device_register_with_groups() for more info (dash not allowed). Because of this, the driver can't be loaded. > if (IS_ERR(i8k_hwmon_dev)) { > err = PTR_ERR(i8k_hwmon_dev); > i8k_hwmon_dev = NULL; > @@ -976,33 +1003,24 @@ static int __init i8k_probe(void) > > static int __init i8k_init(void) > { > - struct proc_dir_entry *proc_i8k; > int err; > > /* Are we running on an supported laptop? */ > if (i8k_probe()) > return -ENODEV; > > - /* Register the proc entry */ > - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); > - if (!proc_i8k) > - return -ENOENT; > - > err = i8k_init_hwmon(); > if (err) > - goto exit_remove_proc; > + return err; > > + i8k_init_procfs(); > return 0; > - > - exit_remove_proc: > - remove_proc_entry("i8k", NULL); > - return err; > } > > static void __exit i8k_exit(void) > { > hwmon_device_unregister(i8k_hwmon_dev); > - remove_proc_entry("i8k", NULL); > + i8k_exit_procfs(); > } > > module_init(i8k_init); > _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-06-27 11:34 ` Gabriele Mazzotta 0 siblings, 0 replies; 86+ messages in thread From: Gabriele Mazzotta @ 2015-06-27 11:34 UTC (permalink / raw) To: Pali Rohár Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors Hi Pali, I've just noticed an issue with this patch. See the comment here below. Gabriele On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. > Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon > driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. > > So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k > interface which is needed only for old Dell Inspirion models or for userspace > i8kutils package. > > For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM > is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > arch/x86/Kconfig | 25 +++---- > drivers/hwmon/Kconfig | 11 +++ > drivers/hwmon/Makefile | 2 +- > drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ > 4 files changed, 106 insertions(+), 82 deletions(-) > > diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig > index 226d569..7b756b3 100644 > --- a/arch/x86/Kconfig > +++ b/arch/x86/Kconfig > @@ -1055,24 +1055,19 @@ config TOSHIBA > Say N otherwise. > > config I8K > - tristate "Dell laptop support" > + tristate "Dell i8k legacy laptop support" > select HWMON > + select SENSORS_DELL_SMM > ---help--- > - This adds a driver to safely access the System Management Mode > - of the CPU on the Dell Inspiron 8000. The System Management Mode > - is used to read cpu temperature and cooling fan status and to > - control the fans on the I8K portables. > + This option enables legacy /proc/i8k userspace interface in hwmon > + dell-smm-hwmon driver. Character file /proc/i8k reports bios version, > + temperature and allows controlling fan speeds of Dell laptops via > + System Management Mode. For old Dell laptops (like Dell Inspiron 8000) > + it reports also power and hotkey status. For fan speed control is > + needed userspace package i8kutils. > > - This driver has been tested only on the Inspiron 8000 but it may > - also work with other Dell laptops. You can force loading on other > - models by passing the parameter `force=1' to the module. Use at > - your own risk. > - > - For information on utilities to make use of this driver see the > - I8K Linux utilities web site at: > - <http://people.debian.org/~dz/i8k/> > - > - Say Y if you intend to run this kernel on a Dell Inspiron 8000. > + Say Y if you intend to run this kernel on old Dell laptops or want to > + use userspace package i8kutils. > Say N otherwise. > > config X86_REBOOTFIXUPS > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > index 25d9e72..714f92a 100644 > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -371,6 +371,17 @@ config SENSORS_DS1621 > This driver can also be built as a module. If so, the module > will be called ds1621. > > +config SENSORS_DELL_SMM > + tristate "Dell laptop SMM BIOS hwmon driver" > + depends on X86 && DMI > + help > + This hwmon driver adds support for reporting temperature of different > + sensors and controls the fans on Dell laptops via System Management > + Mode provided by Dell BIOS. > + > + When option I8K is also enabled this driver provides legacy /proc/i8k > + userspace interface for i8kutils package. > + > config SENSORS_DA9052_ADC > tristate "Dialog DA9052/DA9053 ADC" > depends on PMIC_DA9052 > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile > index 51533ac..6cacd0f 100644 > --- a/drivers/hwmon/Makefile > +++ b/drivers/hwmon/Makefile > @@ -49,6 +49,7 @@ obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o > obj-$(CONFIG_SENSORS_CORETEMP) += coretemp.o > obj-$(CONFIG_SENSORS_DA9052_ADC)+= da9052-hwmon.o > obj-$(CONFIG_SENSORS_DA9055)+= da9055-hwmon.o > +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o > obj-$(CONFIG_SENSORS_DME1737) += dme1737.o > obj-$(CONFIG_SENSORS_DS620) += ds620.o > obj-$(CONFIG_SENSORS_DS1621) += ds1621.o > @@ -156,7 +157,6 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o > obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o > obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o > obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o > -obj-$(CONFIG_I8K) += dell-smm-hwmon.o > > obj-$(CONFIG_PMBUS) += pmbus/ > > diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c > index 65d314b..2a80882 100644 > --- a/drivers/hwmon/dell-smm-hwmon.c > +++ b/drivers/hwmon/dell-smm-hwmon.c > @@ -81,7 +81,7 @@ static uint i8k_fan_max = I8K_FAN_HIGH; > > MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); > MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); > -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); > +MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); > MODULE_LICENSE("GPL"); > MODULE_ALIAS("i8k"); > > @@ -93,6 +93,7 @@ static bool ignore_dmi; > module_param(ignore_dmi, bool, 0); > MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); > > +#if IS_ENABLED(CONFIG_I8K) > static bool restricted; > module_param(restricted, bool, 0); > MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > @@ -100,6 +101,7 @@ MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); > static bool power_status; > module_param(power_status, bool, 0600); > MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); > +#endif > > static uint fan_mult; > module_param(fan_mult, uint, 0); > @@ -109,18 +111,6 @@ static uint fan_max; > module_param(fan_max, uint, 0); > MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); > > -static int i8k_open_fs(struct inode *inode, struct file *file); > -static long i8k_ioctl(struct file *, unsigned int, unsigned long); > - > -static const struct file_operations i8k_fops = { > - .owner = THIS_MODULE, > - .open = i8k_open_fs, > - .read = seq_read, > - .llseek = seq_lseek, > - .release = single_release, > - .unlocked_ioctl = i8k_ioctl, > -}; > - > struct smm_regs { > unsigned int eax; > unsigned int ebx __packed; > @@ -221,45 +211,6 @@ out: > } > > /* > - * Read the Fn key status. > - */ > -static int i8k_get_fn_status(void) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; > - int rc; > - > - rc = i8k_smm(®s); > - if (rc < 0) > - return rc; > - > - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { > - case I8K_FN_UP: > - return I8K_VOL_UP; > - case I8K_FN_DOWN: > - return I8K_VOL_DOWN; > - case I8K_FN_MUTE: > - return I8K_VOL_MUTE; > - default: > - return 0; > - } > -} > - > -/* > - * Read the power status. > - */ > -static int i8k_get_power_status(void) > -{ > - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; > - int rc; > - > - rc = i8k_smm(®s); > - if (rc < 0) > - return rc; > - > - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; > -} > - > -/* > * Read the fan status. > */ > static int i8k_get_fan_status(int fan) > @@ -378,6 +329,51 @@ static int i8k_get_dell_signature(int req_fn) > return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; > } > > +#if IS_ENABLED(CONFIG_I8K) > + > +/* > + * Read the Fn key status. > + */ > +static int i8k_get_fn_status(void) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; > + int rc; > + > + rc = i8k_smm(®s); > + if (rc < 0) > + return rc; > + > + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { > + case I8K_FN_UP: > + return I8K_VOL_UP; > + case I8K_FN_DOWN: > + return I8K_VOL_DOWN; > + case I8K_FN_MUTE: > + return I8K_VOL_MUTE; > + default: > + return 0; > + } > +} > + > +/* > + * Read the power status. > + */ > +static int i8k_get_power_status(void) > +{ > + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; > + int rc; > + > + rc = i8k_smm(®s); > + if (rc < 0) > + return rc; > + > + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; > +} > + > +/* > + * Procfs interface > + */ > + > static int > i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) > { > @@ -528,6 +524,37 @@ static int i8k_open_fs(struct inode *inode, struct file *file) > return single_open(file, i8k_proc_show, NULL); > } > > +static const struct file_operations i8k_fops = { > + .owner = THIS_MODULE, > + .open = i8k_open_fs, > + .read = seq_read, > + .llseek = seq_lseek, > + .release = single_release, > + .unlocked_ioctl = i8k_ioctl, > +}; > + > +static void __init i8k_init_procfs(void) > +{ > + /* Register the proc entry */ > + proc_create("i8k", 0, NULL, &i8k_fops); > +} > + > +static void __exit i8k_exit_procfs(void) > +{ > + remove_proc_entry("i8k", NULL); > +} > + > +#else > + > +static inline void __init i8k_init_procfs(void) > +{ > +} > + > +static inline void __exit i8k_exit_procfs(void) > +{ > +} > + > +#endif > > /* > * Hwmon interface > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > if (err >= 0) > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, > - i8k_groups); > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "dell-smm", > + NULL, i8k_groups); dell-smm is not a valid name, see hwmon_device_register_with_groups() for more info (dash not allowed). Because of this, the driver can't be loaded. > if (IS_ERR(i8k_hwmon_dev)) { > err = PTR_ERR(i8k_hwmon_dev); > i8k_hwmon_dev = NULL; > @@ -976,33 +1003,24 @@ static int __init i8k_probe(void) > > static int __init i8k_init(void) > { > - struct proc_dir_entry *proc_i8k; > int err; > > /* Are we running on an supported laptop? */ > if (i8k_probe()) > return -ENODEV; > > - /* Register the proc entry */ > - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); > - if (!proc_i8k) > - return -ENOENT; > - > err = i8k_init_hwmon(); > if (err) > - goto exit_remove_proc; > + return err; > > + i8k_init_procfs(); > return 0; > - > - exit_remove_proc: > - remove_proc_entry("i8k", NULL); > - return err; > } > > static void __exit i8k_exit(void) > { > hwmon_device_unregister(i8k_hwmon_dev); > - remove_proc_entry("i8k", NULL); > + i8k_exit_procfs(); > } > > module_init(i8k_init); > ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-06-27 11:34 ` Gabriele Mazzotta @ 2015-06-27 12:47 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-06-27 12:47 UTC (permalink / raw) To: Gabriele Mazzotta Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors [-- Attachment #1.1: Type: Text/Plain, Size: 1084 bytes --] On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > Hi Pali, > > I've just noticed an issue with this patch. See the comment here > below. > > Gabriele > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > if (err >= 0) > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", > > NULL, - i8k_groups); > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > "dell-smm", + NULL, i8k_groups); > > dell-smm is not a valid name, see hwmon_device_register_with_groups() > for more info (dash not allowed). Because of this, the driver can't > be loaded. > How it is possible? It worked fine on my tested dell machine... And now I see, I probably tested this change with older kernel version (ubuntu/3.13) which did not have that check for invalid characters... Renaming dell-smm to dell_smm should fix this problem, right? -- Pali Rohár pali.rohar@gmail.com [-- Attachment #1.2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] [-- Attachment #2: Type: text/plain, Size: 153 bytes --] _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-06-27 12:47 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-06-27 12:47 UTC (permalink / raw) To: Gabriele Mazzotta Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors [-- Attachment #1: Type: Text/Plain, Size: 1084 bytes --] On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > Hi Pali, > > I've just noticed an issue with this patch. See the comment here > below. > > Gabriele > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > if (err >= 0) > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", > > NULL, - i8k_groups); > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > "dell-smm", + NULL, i8k_groups); > > dell-smm is not a valid name, see hwmon_device_register_with_groups() > for more info (dash not allowed). Because of this, the driver can't > be loaded. > How it is possible? It worked fine on my tested dell machine... And now I see, I probably tested this change with older kernel version (ubuntu/3.13) which did not have that check for invalid characters... Renaming dell-smm to dell_smm should fix this problem, right? -- Pali Rohár pali.rohar@gmail.com [-- Attachment #2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-06-27 12:47 ` Pali Rohár @ 2015-06-27 12:55 ` Gabriele Mazzotta -1 siblings, 0 replies; 86+ messages in thread From: Gabriele Mazzotta @ 2015-06-27 12:55 UTC (permalink / raw) To: Pali Rohár Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors On Saturday 27 June 2015 14:47:16 Pali Rohár wrote: > On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > > Hi Pali, > > > > I've just noticed an issue with this patch. See the comment here > > below. > > > > Gabriele > > > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > > > if (err >= 0) > > > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", > > > NULL, - i8k_groups); > > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > "dell-smm", + NULL, i8k_groups); > > > > dell-smm is not a valid name, see hwmon_device_register_with_groups() > > for more info (dash not allowed). Because of this, the driver can't > > be loaded. > > > > How it is possible? It worked fine on my tested dell machine... > > And now I see, I probably tested this change with older kernel version > (ubuntu/3.13) which did not have that check for invalid characters... > > Renaming dell-smm to dell_smm should fix this problem, right? Yes, everything works just fine with the underscore. _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-06-27 12:55 ` Gabriele Mazzotta 0 siblings, 0 replies; 86+ messages in thread From: Gabriele Mazzotta @ 2015-06-27 12:55 UTC (permalink / raw) To: Pali Rohár Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors On Saturday 27 June 2015 14:47:16 Pali Rohár wrote: > On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > > Hi Pali, > > > > I've just noticed an issue with this patch. See the comment here > > below. > > > > Gabriele > > > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > > > if (err >= 0) > > > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", > > > NULL, - i8k_groups); > > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > "dell-smm", + NULL, i8k_groups); > > > > dell-smm is not a valid name, see hwmon_device_register_with_groups() > > for more info (dash not allowed). Because of this, the driver can't > > be loaded. > > > > How it is possible? It worked fine on my tested dell machine... > > And now I see, I probably tested this change with older kernel version > (ubuntu/3.13) which did not have that check for invalid characters... > > Renaming dell-smm to dell_smm should fix this problem, right? Yes, everything works just fine with the underscore. ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-06-27 12:55 ` Gabriele Mazzotta @ 2015-06-27 13:01 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-06-27 13:01 UTC (permalink / raw) To: Gabriele Mazzotta Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors [-- Attachment #1.1: Type: Text/Plain, Size: 1427 bytes --] On Saturday 27 June 2015 14:55:40 Gabriele Mazzotta wrote: > On Saturday 27 June 2015 14:47:16 Pali Rohár wrote: > > On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > > > Hi Pali, > > > > > > I've just noticed an issue with this patch. See the comment here > > > below. > > > > > > Gabriele > > > > > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > > > > > if (err >= 0) > > > > > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > "i8k", NULL, - i8k_groups); > > > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > "dell-smm", + NULL, i8k_groups); > > > > > > dell-smm is not a valid name, see > > > hwmon_device_register_with_groups() for more info (dash not > > > allowed). Because of this, the driver can't be loaded. > > > > How it is possible? It worked fine on my tested dell machine... > > > > And now I see, I probably tested this change with older kernel > > version (ubuntu/3.13) which did not have that check for invalid > > characters... > > > > Renaming dell-smm to dell_smm should fix this problem, right? > > Yes, everything works just fine with the underscore. Ok, will you send patch for this small fix? -- Pali Rohár pali.rohar@gmail.com [-- Attachment #1.2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] [-- Attachment #2: Type: text/plain, Size: 153 bytes --] _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-06-27 13:01 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-06-27 13:01 UTC (permalink / raw) To: Gabriele Mazzotta Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors [-- Attachment #1: Type: Text/Plain, Size: 1427 bytes --] On Saturday 27 June 2015 14:55:40 Gabriele Mazzotta wrote: > On Saturday 27 June 2015 14:47:16 Pali Rohár wrote: > > On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > > > Hi Pali, > > > > > > I've just noticed an issue with this patch. See the comment here > > > below. > > > > > > Gabriele > > > > > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > > > > > if (err >= 0) > > > > > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > "i8k", NULL, - i8k_groups); > > > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > "dell-smm", + NULL, i8k_groups); > > > > > > dell-smm is not a valid name, see > > > hwmon_device_register_with_groups() for more info (dash not > > > allowed). Because of this, the driver can't be loaded. > > > > How it is possible? It worked fine on my tested dell machine... > > > > And now I see, I probably tested this change with older kernel > > version (ubuntu/3.13) which did not have that check for invalid > > characters... > > > > Renaming dell-smm to dell_smm should fix this problem, right? > > Yes, everything works just fine with the underscore. Ok, will you send patch for this small fix? -- Pali Rohár pali.rohar@gmail.com [-- Attachment #2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-06-27 13:01 ` Pali Rohár @ 2015-06-27 13:21 ` Gabriele Mazzotta -1 siblings, 0 replies; 86+ messages in thread From: Gabriele Mazzotta @ 2015-06-27 13:21 UTC (permalink / raw) To: Pali Rohár Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors On Saturday 27 June 2015 15:01:34 Pali Rohár wrote: > On Saturday 27 June 2015 14:55:40 Gabriele Mazzotta wrote: > > On Saturday 27 June 2015 14:47:16 Pali Rohár wrote: > > > On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > > > > Hi Pali, > > > > > > > > I've just noticed an issue with this patch. See the comment here > > > > below. > > > > > > > > Gabriele > > > > > > > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > > > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > > > > > > > if (err >= 0) > > > > > > > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > > > > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > > "i8k", NULL, - i8k_groups); > > > > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > > "dell-smm", + NULL, i8k_groups); > > > > > > > > dell-smm is not a valid name, see > > > > hwmon_device_register_with_groups() for more info (dash not > > > > allowed). Because of this, the driver can't be loaded. > > > > > > How it is possible? It worked fine on my tested dell machine... > > > > > > And now I see, I probably tested this change with older kernel > > > version (ubuntu/3.13) which did not have that check for invalid > > > characters... > > > > > > Renaming dell-smm to dell_smm should fix this problem, right? > > > > Yes, everything works just fine with the underscore. > > Ok, will you send patch for this small fix? OK, I'll do it shortly. _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-06-27 13:21 ` Gabriele Mazzotta 0 siblings, 0 replies; 86+ messages in thread From: Gabriele Mazzotta @ 2015-06-27 13:21 UTC (permalink / raw) To: Pali Rohár Cc: Greg Kroah-Hartman, Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, linux-kernel, lm-sensors On Saturday 27 June 2015 15:01:34 Pali Rohár wrote: > On Saturday 27 June 2015 14:55:40 Gabriele Mazzotta wrote: > > On Saturday 27 June 2015 14:47:16 Pali Rohár wrote: > > > On Saturday 27 June 2015 13:34:30 Gabriele Mazzotta wrote: > > > > Hi Pali, > > > > > > > > I've just noticed an issue with this patch. See the comment here > > > > below. > > > > > > > > Gabriele > > > > > > > > On Wednesday 29 April 2015 13:41:26 Pali Rohár wrote: > > > > > @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) > > > > > > > > > > if (err >= 0) > > > > > > > > > > i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; > > > > > > > > > > - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > > "i8k", NULL, - i8k_groups); > > > > > + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, > > > > > "dell-smm", + NULL, i8k_groups); > > > > > > > > dell-smm is not a valid name, see > > > > hwmon_device_register_with_groups() for more info (dash not > > > > allowed). Because of this, the driver can't be loaded. > > > > > > How it is possible? It worked fine on my tested dell machine... > > > > > > And now I see, I probably tested this change with older kernel > > > version (ubuntu/3.13) which did not have that check for invalid > > > characters... > > > > > > Renaming dell-smm to dell_smm should fix this problem, right? > > > > Yes, everything works just fine with the underscore. > > Ok, will you send patch for this small fix? OK, I'll do it shortly. ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree 2015-04-29 11:41 ` Pali Rohár @ 2015-04-29 12:07 ` Greg Kroah-Hartman -1 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-29 12:07 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Wed, Apr 29, 2015 at 01:41:25PM +0200, Pali Rohár wrote: > This commit moves i8k driver to hwmon tree under name dell-smm-hwmon which is > better name then abbreviation i8k. For backward compatibility is added macro > MODULE_ALIAS("i8k") so modprobe will load driver also old name i8k. CONFIG_I8K > compile option was not changed. > > This commit also adds me as maintainer of this new dell-smm-hwmon driver and > remove Guenter Roeck from list who is implicit maintainer all hwmon drivers. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > MAINTAINERS | 4 +- > drivers/char/Makefile | 1 - > drivers/char/i8k.c | 1007 --------------------------------------- > drivers/hwmon/Makefile | 1 + > drivers/hwmon/dell-smm-hwmon.c | 1009 ++++++++++++++++++++++++++++++++++++++++ > 5 files changed, 1012 insertions(+), 1010 deletions(-) > delete mode 100644 drivers/char/i8k.c > create mode 100644 drivers/hwmon/dell-smm-hwmon.c In the future, please create patches with -M to show the file is moved, which makes it much easier to review. thanks, greg k-h _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree @ 2015-04-29 12:07 ` Greg Kroah-Hartman 0 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-29 12:07 UTC (permalink / raw) To: Pali Rohár Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Wed, Apr 29, 2015 at 01:41:25PM +0200, Pali Rohár wrote: > This commit moves i8k driver to hwmon tree under name dell-smm-hwmon which is > better name then abbreviation i8k. For backward compatibility is added macro > MODULE_ALIAS("i8k") so modprobe will load driver also old name i8k. CONFIG_I8K > compile option was not changed. > > This commit also adds me as maintainer of this new dell-smm-hwmon driver and > remove Guenter Roeck from list who is implicit maintainer all hwmon drivers. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > MAINTAINERS | 4 +- > drivers/char/Makefile | 1 - > drivers/char/i8k.c | 1007 --------------------------------------- > drivers/hwmon/Makefile | 1 + > drivers/hwmon/dell-smm-hwmon.c | 1009 ++++++++++++++++++++++++++++++++++++++++ > 5 files changed, 1012 insertions(+), 1010 deletions(-) > delete mode 100644 drivers/char/i8k.c > create mode 100644 drivers/hwmon/dell-smm-hwmon.c In the future, please create patches with -M to show the file is moved, which makes it much easier to review. thanks, greg k-h ^ permalink raw reply [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree @ 2015-05-14 11:16 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-05-14 11:16 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck Cc: linux-kernel, lm-sensors, Pali Rohár VGhpcyBjb21taXQgbW92ZXMgaThrIGRyaXZlciB0byBod21vbiB0cmVlIHVuZGVyIG5hbWUgZGVs bC1zbW0taHdtb24gd2hpY2ggaXMKYmV0dGVyIG5hbWUgdGhlbiBhYmJyZXZpYXRpb24gaThrLiBG b3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSBpcyBhZGRlZCBtYWNybwpNT0RVTEVfQUxJQVMoImk4 ayIpIHNvIG1vZHByb2JlIHdpbGwgbG9hZCBkcml2ZXIgYWxzbyBvbGQgbmFtZSBpOGsuIENPTkZJ R19JOEsKY29tcGlsZSBvcHRpb24gd2FzIG5vdCBjaGFuZ2VkLgoKVGhpcyBjb21taXQgYWxzbyBh ZGRzIG1lIGFzIG1haW50YWluZXIgb2YgdGhpcyBuZXcgZGVsbC1zbW0taHdtb24gZHJpdmVyIGFu ZApyZW1vdmUgR3VlbnRlciBSb2VjayBmcm9tIGxpc3Qgd2hvIGlzIGltcGxpY2l0IG1haW50YWlu ZXIgYWxsIGh3bW9uIGRyaXZlcnMuCgpTaWduZWQtb2ZmLWJ5OiBQYWxpIFJvaMOhciA8cGFsaS5y b2hhckBnbWFpbC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB8ICAgIDQgKystLQogZHJpdmVycy9jaGFyL01ha2VmaWxlICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgIDEgLQogZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgIDEgKwogZHJpdmVycy97Y2hhci9pOGsuYyA9PiBod21vbi9kZWxs LXNtbS1od21vbi5jfSB8ICAgIDYgKysrKy0tCiA0IGZpbGVzIGNoYW5nZWQsIDcgaW5zZXJ0aW9u cygrKSwgNSBkZWxldGlvbnMoLSkKIHJlbmFtZSBkcml2ZXJzL3tjaGFyL2k4ay5jID0+IGh3bW9u L2RlbGwtc21tLWh3bW9uLmN9ICg5OSUpCgpkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlO VEFJTkVSUwppbmRleCAyZTViYmMwLi4wMTRjMTVmIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUwor KysgYi9NQUlOVEFJTkVSUwpAQCAtMzA3Nyw5ICszMDc3LDkgQEAgUzoJTWFpbnRhaW5lZAogRjoJ ZHJpdmVycy9wbGF0Zm9ybS94ODYvZGVsbC1zbW84ODAwLmMKIAogREVMTCBMQVBUT1AgU01NIERS SVZFUgotTToJR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0PgorTToJUGFsaSBSb2jD oXIgPHBhbGkucm9oYXJAZ21haWwuY29tPgogUzoJTWFpbnRhaW5lZAotRjoJZHJpdmVycy9jaGFy L2k4ay5jCitGOglkcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMKIEY6CWluY2x1ZGUvdWFw aS9saW51eC9pOGsuaAogCiBERUxMIFNZU1RFTVMgTUFOQUdFTUVOVCBCQVNFIERSSVZFUiAoZGNk YmFzKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL01ha2VmaWxlIGIvZHJpdmVycy9jaGFyL01h a2VmaWxlCmluZGV4IGQwNmNkZTI2Li4xZDljZjAwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIv TWFrZWZpbGUKKysrIGIvZHJpdmVycy9jaGFyL01ha2VmaWxlCkBAIC0zNiw3ICszNiw2IEBAIGVs c2UKICAgb2JqLSQoQ09ORklHX05WUkFNKQkrPSBudnJhbS5vCiBlbmRpZgogb2JqLSQoQ09ORklH X1RPU0hJQkEpCQkrPSB0b3NoaWJhLm8KLW9iai0kKENPTkZJR19JOEspCQkrPSBpOGsubwogb2Jq LSQoQ09ORklHX0RTMTYyMCkJCSs9IGRzMTYyMC5vCiBvYmotJChDT05GSUdfSFdfUkFORE9NKQkJ Kz0gaHdfcmFuZG9tLwogb2JqLSQoQ09ORklHX1BQREVWKQkJKz0gcHBkZXYubwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9od21vbi9NYWtlZmlsZSBiL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKaW5kZXgg YjRhNDBmMS4uNTE1MzNhYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9NYWtlZmlsZQorKysg Yi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCkBAIC0xNTYsNiArMTU2LDcgQEAgb2JqLSQoQ09ORklH X1NFTlNPUlNfVzgzTDc4NVRTKQkrPSB3ODNsNzg1dHMubwogb2JqLSQoQ09ORklHX1NFTlNPUlNf VzgzTDc4Nk5HKQkrPSB3ODNsNzg2bmcubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzFYKQkr PSB3bTgzMXgtaHdtb24ubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfV004MzUwKQkrPSB3bTgzNTAt aHdtb24ubworb2JqLSQoQ09ORklHX0k4SykJCSs9IGRlbGwtc21tLWh3bW9uLm8KIAogb2JqLSQo Q09ORklHX1BNQlVTKQkJKz0gcG1idXMvCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9pOGsu YyBiL2RyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwpzaW1pbGFyaXR5IGluZGV4IDk5JQpy ZW5hbWUgZnJvbSBkcml2ZXJzL2NoYXIvaThrLmMKcmVuYW1lIHRvIGRyaXZlcnMvaHdtb24vZGVs bC1zbW0taHdtb24uYwppbmRleCBhNDMwNDhiLi42NWQzMTRiIDEwMDY0NAotLS0gYS9kcml2ZXJz L2NoYXIvaThrLmMKKysrIGIvZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jCkBAIC0xLDEy ICsxLDEyIEBACiAvKgotICogaThrLmMgLS0gTGludXggZHJpdmVyIGZvciBhY2Nlc3NpbmcgdGhl IFNNTSBCSU9TIG9uIERlbGwgbGFwdG9wcy4KKyAqIGRlbGwtc21tLWh3bW9uLmMgLS0gTGludXgg ZHJpdmVyIGZvciBhY2Nlc3NpbmcgdGhlIFNNTSBCSU9TIG9uIERlbGwgbGFwdG9wcy4KICAqCiAg KiBDb3B5cmlnaHQgKEMpIDIwMDEgIE1hc3NpbW8gRGFsIFpvdHRvIDxkekBkZWJpYW4ub3JnPgog ICoKICAqIEh3bW9uIGludGVncmF0aW9uOgogICogQ29weXJpZ2h0IChDKSAyMDExICBKZWFuIERl bHZhcmUgPGpkZWx2YXJlQHN1c2UuZGU+CiAgKiBDb3B5cmlnaHQgKEMpIDIwMTMsIDIwMTQgIEd1 ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVzLm5ldD4KLSAqIENvcHlyaWdodCAoQykgMjAxNCAg UGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDE0 LCAyMDE1ICBQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+CiAgKgogICogVGhpcyBw cm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBt b2RpZnkgaXQKICAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZQpAQCAtODAsOCArODAsMTAgQEAgc3RhdGljIHVpbnQg aThrX2Zhbl9tYXggPSBJOEtfRkFOX0hJR0g7CiAjZGVmaW5lIEk4S19IV01PTl9IQVZFX0ZBTjIJ KDEgPDwgNSkKIAogTU9EVUxFX0FVVEhPUigiTWFzc2ltbyBEYWwgWm90dG8gKGR6QGRlYmlhbi5v cmcpIik7CitNT0RVTEVfQVVUSE9SKCJQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+ Iik7CiBNT0RVTEVfREVTQ1JJUFRJT04oIkRyaXZlciBmb3IgYWNjZXNzaW5nIFNNTSBCSU9TIG9u IERlbGwgbGFwdG9wcyIpOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFTKCJp OGsiKTsKIAogc3RhdGljIGJvb2wgZm9yY2U7CiBtb2R1bGVfcGFyYW0oZm9yY2UsIGJvb2wsIDAp OwotLSAKMS43LjEwLjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3Jn Cmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree @ 2015-05-14 11:16 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-05-14 11:16 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck Cc: linux-kernel, lm-sensors, Pali Rohár This commit moves i8k driver to hwmon tree under name dell-smm-hwmon which is better name then abbreviation i8k. For backward compatibility is added macro MODULE_ALIAS("i8k") so modprobe will load driver also old name i8k. CONFIG_I8K compile option was not changed. This commit also adds me as maintainer of this new dell-smm-hwmon driver and remove Guenter Roeck from list who is implicit maintainer all hwmon drivers. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- MAINTAINERS | 4 ++-- drivers/char/Makefile | 1 - drivers/hwmon/Makefile | 1 + drivers/{char/i8k.c => hwmon/dell-smm-hwmon.c} | 6 ++++-- 4 files changed, 7 insertions(+), 5 deletions(-) rename drivers/{char/i8k.c => hwmon/dell-smm-hwmon.c} (99%) diff --git a/MAINTAINERS b/MAINTAINERS index 2e5bbc0..014c15f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3077,9 +3077,9 @@ S: Maintained F: drivers/platform/x86/dell-smo8800.c DELL LAPTOP SMM DRIVER -M: Guenter Roeck <linux@roeck-us.net> +M: Pali Rohár <pali.rohar@gmail.com> S: Maintained -F: drivers/char/i8k.c +F: drivers/hwmon/dell-smm-hwmon.c F: include/uapi/linux/i8k.h DELL SYSTEMS MANAGEMENT BASE DRIVER (dcdbas) diff --git a/drivers/char/Makefile b/drivers/char/Makefile index d06cde26..1d9cf00 100644 --- a/drivers/char/Makefile +++ b/drivers/char/Makefile @@ -36,7 +36,6 @@ else obj-$(CONFIG_NVRAM) += nvram.o endif obj-$(CONFIG_TOSHIBA) += toshiba.o -obj-$(CONFIG_I8K) += i8k.o obj-$(CONFIG_DS1620) += ds1620.o obj-$(CONFIG_HW_RANDOM) += hw_random/ obj-$(CONFIG_PPDEV) += ppdev.o diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index b4a40f1..51533ac 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -156,6 +156,7 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o +obj-$(CONFIG_I8K) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/char/i8k.c b/drivers/hwmon/dell-smm-hwmon.c similarity index 99% rename from drivers/char/i8k.c rename to drivers/hwmon/dell-smm-hwmon.c index a43048b..65d314b 100644 --- a/drivers/char/i8k.c +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -1,12 +1,12 @@ /* - * i8k.c -- Linux driver for accessing the SMM BIOS on Dell laptops. + * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops. * * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> * * Hwmon integration: * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> - * Copyright (C) 2014 Pali Rohár <pali.rohar@gmail.com> + * Copyright (C) 2014, 2015 Pali Rohár <pali.rohar@gmail.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 @@ -80,8 +80,10 @@ static uint i8k_fan_max = I8K_FAN_HIGH; #define I8K_HWMON_HAVE_FAN2 (1 << 5) MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); +MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); MODULE_LICENSE("GPL"); +MODULE_ALIAS("i8k"); static bool force; module_param(force, bool, 0); -- 1.7.10.4 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-05-14 11:16 ` Pali Rohár @ 2015-05-14 11:16 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-05-14 11:16 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck Cc: linux-kernel, lm-sensors, Pali Rohár VGhpcyBwYXRjaCBzcGxpdHMgQ09ORklHX0k4SyBjb21waWxlIG9wdGlvbiB0byBTRU5TT1JTX0RF TExfU01NIGFuZCBDT05GSUdfSThLLgpPcHRpb24gU0VOU09SU19ERUxMX1NNTSBpcyBub3cgdXNl ZCB0byBlbmFibGUgY29tcGlsYXRpb24gb2YgZGVsbC1zbW0taHdtb24KZHJpdmVyIGFuZCBvbGQg Q09ORklHX0k4SyBvcHRpb24gdG8gZW5hYmxlIC9wcm9jL2k4ayBpbnRlcmZhY2UgaW4gZHJpdmVy LgoKU28gdGhpcyBjaGFuZ2UgYWxsb3dzIHRvIGNvbXBpbGUgZGVsbC1zbW0taHdtb24gZHJpdmVy IHdpdGhvdXQgbGVnYWN5IC9wcm9jL2k4awppbnRlcmZhY2Ugd2hpY2ggaXMgbmVlZGVkIG9ubHkg Zm9yIG9sZCBEZWxsIEluc3BpcmlvbiBtb2RlbHMgb3IgZm9yIHVzZXJzcGFjZQppOGt1dGlscyBw YWNrYWdlLgoKRm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2hlbiBDT05GSUdfSThLIGlzIGVu YWJsZWQgdGhlbiBhbHNvIFNFTlNPUlNfREVMTF9TTU0KaXMgZW5hYmxlZCBhbmQgc28gZHJpdmVy IGRlbGwtc21tLWh3bW9uICh3aXRoIC9wcm9jL2k4aykgaXMgY29tcGlsZWQuCgpTaWduZWQtb2Zm LWJ5OiBQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Ci0tLQpjaGFuZ2VzIHNpbmNl IHYyOgogLSByZW1vdmVkIGRlcGVuZHMgb24gRE1JCi0tLQogYXJjaC94ODYvS2NvbmZpZyAgICAg ICAgICAgICAgIHwgICAyNSArKystLS0tCiBkcml2ZXJzL2h3bW9uL0tjb25maWcgICAgICAgICAg fCAgIDExICsrKwogZHJpdmVycy9od21vbi9NYWtlZmlsZSAgICAgICAgIHwgICAgMiArLQogZHJp dmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIHwgIDE1MCArKysrKysrKysrKysrKysrKysrKysr LS0tLS0tLS0tLS0tLS0tLS0tCiA0IGZpbGVzIGNoYW5nZWQsIDEwNiBpbnNlcnRpb25zKCspLCA4 MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9LY29uZmlnIGIvYXJjaC94ODYv S2NvbmZpZwppbmRleCAyMjZkNTY5Li43Yjc1NmIzIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9LY29u ZmlnCisrKyBiL2FyY2gveDg2L0tjb25maWcKQEAgLTEwNTUsMjQgKzEwNTUsMTkgQEAgY29uZmln IFRPU0hJQkEKIAkgIFNheSBOIG90aGVyd2lzZS4KIAogY29uZmlnIEk4SwotCXRyaXN0YXRlICJE ZWxsIGxhcHRvcCBzdXBwb3J0IgorCXRyaXN0YXRlICJEZWxsIGk4ayBsZWdhY3kgbGFwdG9wIHN1 cHBvcnQiCiAJc2VsZWN0IEhXTU9OCisJc2VsZWN0IFNFTlNPUlNfREVMTF9TTU0KIAktLS1oZWxw LS0tCi0JICBUaGlzIGFkZHMgYSBkcml2ZXIgdG8gc2FmZWx5IGFjY2VzcyB0aGUgU3lzdGVtIE1h bmFnZW1lbnQgTW9kZQotCSAgb2YgdGhlIENQVSBvbiB0aGUgRGVsbCBJbnNwaXJvbiA4MDAwLiBU aGUgU3lzdGVtIE1hbmFnZW1lbnQgTW9kZQotCSAgaXMgdXNlZCB0byByZWFkIGNwdSB0ZW1wZXJh dHVyZSBhbmQgY29vbGluZyBmYW4gc3RhdHVzIGFuZCB0bwotCSAgY29udHJvbCB0aGUgZmFucyBv biB0aGUgSThLIHBvcnRhYmxlcy4KKwkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgbGVnYWN5IC9wcm9j L2k4ayB1c2Vyc3BhY2UgaW50ZXJmYWNlIGluIGh3bW9uCisJICBkZWxsLXNtbS1od21vbiBkcml2 ZXIuIENoYXJhY3RlciBmaWxlIC9wcm9jL2k4ayByZXBvcnRzIGJpb3MgdmVyc2lvbiwKKwkgIHRl bXBlcmF0dXJlIGFuZCBhbGxvd3MgY29udHJvbGxpbmcgZmFuIHNwZWVkcyBvZiBEZWxsIGxhcHRv cHMgdmlhCisJICBTeXN0ZW0gTWFuYWdlbWVudCBNb2RlLiBGb3Igb2xkIERlbGwgbGFwdG9wcyAo bGlrZSBEZWxsIEluc3Bpcm9uIDgwMDApCisJICBpdCByZXBvcnRzIGFsc28gcG93ZXIgYW5kIGhv dGtleSBzdGF0dXMuIEZvciBmYW4gc3BlZWQgY29udHJvbCBpcworCSAgbmVlZGVkIHVzZXJzcGFj ZSBwYWNrYWdlIGk4a3V0aWxzLgogCi0JICBUaGlzIGRyaXZlciBoYXMgYmVlbiB0ZXN0ZWQgb25s eSBvbiB0aGUgSW5zcGlyb24gODAwMCBidXQgaXQgbWF5Ci0JICBhbHNvIHdvcmsgd2l0aCBvdGhl ciBEZWxsIGxhcHRvcHMuIFlvdSBjYW4gZm9yY2UgbG9hZGluZyBvbiBvdGhlcgotCSAgbW9kZWxz IGJ5IHBhc3NpbmcgdGhlIHBhcmFtZXRlciBgZm9yY2U9MScgdG8gdGhlIG1vZHVsZS4gVXNlIGF0 Ci0JICB5b3VyIG93biByaXNrLgotCi0JICBGb3IgaW5mb3JtYXRpb24gb24gdXRpbGl0aWVzIHRv IG1ha2UgdXNlIG9mIHRoaXMgZHJpdmVyIHNlZSB0aGUKLQkgIEk4SyBMaW51eCB1dGlsaXRpZXMg d2ViIHNpdGUgYXQ6Ci0JICA8aHR0cDovL3Blb3BsZS5kZWJpYW4ub3JnL35kei9pOGsvPgotCi0J ICBTYXkgWSBpZiB5b3UgaW50ZW5kIHRvIHJ1biB0aGlzIGtlcm5lbCBvbiBhIERlbGwgSW5zcGly b24gODAwMC4KKwkgIFNheSBZIGlmIHlvdSBpbnRlbmQgdG8gcnVuIHRoaXMga2VybmVsIG9uIG9s ZCBEZWxsIGxhcHRvcHMgb3Igd2FudCB0bworCSAgdXNlIHVzZXJzcGFjZSBwYWNrYWdlIGk4a3V0 aWxzLgogCSAgU2F5IE4gb3RoZXJ3aXNlLgogCiBjb25maWcgWDg2X1JFQk9PVEZJWFVQUwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21vbi9LY29uZmlnCmlu ZGV4IDI1ZDllNzIuLmJjOWQ5MGIxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL0tjb25maWcK KysrIGIvZHJpdmVycy9od21vbi9LY29uZmlnCkBAIC0zNzEsNiArMzcxLDE3IEBAIGNvbmZpZyBT RU5TT1JTX0RTMTYyMQogCSAgVGhpcyBkcml2ZXIgY2FuIGFsc28gYmUgYnVpbHQgYXMgYSBtb2R1 bGUuICBJZiBzbywgdGhlIG1vZHVsZQogCSAgd2lsbCBiZSBjYWxsZWQgZHMxNjIxLgogCitjb25m aWcgU0VOU09SU19ERUxMX1NNTQorCXRyaXN0YXRlICJEZWxsIGxhcHRvcCBTTU0gQklPUyBod21v biBkcml2ZXIiCisJZGVwZW5kcyBvbiBYODYKKwloZWxwCisJICBUaGlzIGh3bW9uIGRyaXZlciBh ZGRzIHN1cHBvcnQgZm9yIHJlcG9ydGluZyB0ZW1wZXJhdHVyZSBvZiBkaWZmZXJlbnQKKwkgIHNl bnNvcnMgYW5kIGNvbnRyb2xzIHRoZSBmYW5zIG9uIERlbGwgbGFwdG9wcyB2aWEgU3lzdGVtIE1h bmFnZW1lbnQKKwkgIE1vZGUgcHJvdmlkZWQgYnkgRGVsbCBCSU9TLgorCisJICBXaGVuIG9wdGlv biBJOEsgaXMgYWxzbyBlbmFibGVkIHRoaXMgZHJpdmVyIHByb3ZpZGVzIGxlZ2FjeSAvcHJvYy9p OGsKKwkgIHVzZXJzcGFjZSBpbnRlcmZhY2UgZm9yIGk4a3V0aWxzIHBhY2thZ2UuCisKIGNvbmZp ZyBTRU5TT1JTX0RBOTA1Ml9BREMKIAl0cmlzdGF0ZSAiRGlhbG9nIERBOTA1Mi9EQTkwNTMgQURD IgogCWRlcGVuZHMgb24gUE1JQ19EQTkwNTIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFr ZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCmluZGV4IDUxNTMzYWMuLjZjYWNkMGYgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9od21vbi9NYWtl ZmlsZQpAQCAtNDksNiArNDksNyBAQCBvYmotJChDT05GSUdfU0VOU09SU19BVFhQMSkJKz0gYXR4 cDEubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfQ09SRVRFTVApCSs9IGNvcmV0ZW1wLm8KIG9iai0k KENPTkZJR19TRU5TT1JTX0RBOTA1Ml9BREMpKz0gZGE5MDUyLWh3bW9uLm8KIG9iai0kKENPTkZJ R19TRU5TT1JTX0RBOTA1NSkrPSBkYTkwNTUtaHdtb24ubworb2JqLSQoQ09ORklHX1NFTlNPUlNf REVMTF9TTU0pCSs9IGRlbGwtc21tLWh3bW9uLm8KIG9iai0kKENPTkZJR19TRU5TT1JTX0RNRTE3 MzcpCSs9IGRtZTE3Mzcubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfRFM2MjApCSs9IGRzNjIwLm8K IG9iai0kKENPTkZJR19TRU5TT1JTX0RTMTYyMSkJKz0gZHMxNjIxLm8KQEAgLTE1Niw3ICsxNTcs NiBAQCBvYmotJChDT05GSUdfU0VOU09SU19XODNMNzg1VFMpCSs9IHc4M2w3ODV0cy5vCiBvYmot JChDT05GSUdfU0VOU09SU19XODNMNzg2TkcpCSs9IHc4M2w3ODZuZy5vCiBvYmotJChDT05GSUdf U0VOU09SU19XTTgzMVgpCSs9IHdtODMxeC1od21vbi5vCiBvYmotJChDT05GSUdfU0VOU09SU19X TTgzNTApCSs9IHdtODM1MC1od21vbi5vCi1vYmotJChDT05GSUdfSThLKQkJKz0gZGVsbC1zbW0t aHdtb24ubwogCiBvYmotJChDT05GSUdfUE1CVVMpCQkrPSBwbWJ1cy8KIApkaWZmIC0tZ2l0IGEv ZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIGIvZHJpdmVycy9od21vbi9kZWxsLXNtbS1o d21vbi5jCmluZGV4IDY1ZDMxNGIuLjJhODA4ODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24v ZGVsbC1zbW0taHdtb24uYworKysgYi9kcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMKQEAg LTgxLDcgKzgxLDcgQEAgc3RhdGljIHVpbnQgaThrX2Zhbl9tYXggPSBJOEtfRkFOX0hJR0g7CiAK IE1PRFVMRV9BVVRIT1IoIk1hc3NpbW8gRGFsIFpvdHRvIChkekBkZWJpYW4ub3JnKSIpOwogTU9E VUxFX0FVVEhPUigiUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPiIpOwotTU9EVUxF X0RFU0NSSVBUSU9OKCJEcml2ZXIgZm9yIGFjY2Vzc2luZyBTTU0gQklPUyBvbiBEZWxsIGxhcHRv cHMiKTsKK01PRFVMRV9ERVNDUklQVElPTigiRGVsbCBsYXB0b3AgU01NIEJJT1MgaHdtb24gZHJp dmVyIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfQUxJQVMoImk4ayIpOwogCkBA IC05Myw2ICs5Myw3IEBAIHN0YXRpYyBib29sIGlnbm9yZV9kbWk7CiBtb2R1bGVfcGFyYW0oaWdu b3JlX2RtaSwgYm9vbCwgMCk7CiBNT0RVTEVfUEFSTV9ERVNDKGlnbm9yZV9kbWksICJDb250aW51 ZSBwcm9iaW5nIGhhcmR3YXJlIGV2ZW4gaWYgRE1JIGRhdGEgZG9lcyBub3QgbWF0Y2giKTsKIAor I2lmIElTX0VOQUJMRUQoQ09ORklHX0k4SykKIHN0YXRpYyBib29sIHJlc3RyaWN0ZWQ7CiBtb2R1 bGVfcGFyYW0ocmVzdHJpY3RlZCwgYm9vbCwgMCk7CiBNT0RVTEVfUEFSTV9ERVNDKHJlc3RyaWN0 ZWQsICJBbGxvdyBmYW4gY29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJpbGl0eSBzZXQiKTsKQEAg LTEwMCw2ICsxMDEsNyBAQCBNT0RVTEVfUEFSTV9ERVNDKHJlc3RyaWN0ZWQsICJBbGxvdyBmYW4g Y29udHJvbCBpZiBTWVNfQURNSU4gY2FwYWJpbGl0eSBzZXQiKTsKIHN0YXRpYyBib29sIHBvd2Vy X3N0YXR1czsKIG1vZHVsZV9wYXJhbShwb3dlcl9zdGF0dXMsIGJvb2wsIDA2MDApOwogTU9EVUxF X1BBUk1fREVTQyhwb3dlcl9zdGF0dXMsICJSZXBvcnQgcG93ZXIgc3RhdHVzIGluIC9wcm9jL2k4 ayIpOworI2VuZGlmCiAKIHN0YXRpYyB1aW50IGZhbl9tdWx0OwogbW9kdWxlX3BhcmFtKGZhbl9t dWx0LCB1aW50LCAwKTsKQEAgLTEwOSwxOCArMTExLDYgQEAgc3RhdGljIHVpbnQgZmFuX21heDsK IG1vZHVsZV9wYXJhbShmYW5fbWF4LCB1aW50LCAwKTsKIE1PRFVMRV9QQVJNX0RFU0MoZmFuX21h eCwgIk1heGltdW0gY29uZmlndXJhYmxlIGZhbiBzcGVlZCAoZGVmYXVsdDogYXV0b2RldGVjdCki KTsKIAotc3RhdGljIGludCBpOGtfb3Blbl9mcyhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3Qg ZmlsZSAqZmlsZSk7Ci1zdGF0aWMgbG9uZyBpOGtfaW9jdGwoc3RydWN0IGZpbGUgKiwgdW5zaWdu ZWQgaW50LCB1bnNpZ25lZCBsb25nKTsKLQotc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJh dGlvbnMgaThrX2ZvcHMgPSB7Ci0JLm93bmVyCQk9IFRISVNfTU9EVUxFLAotCS5vcGVuCQk9IGk4 a19vcGVuX2ZzLAotCS5yZWFkCQk9IHNlcV9yZWFkLAotCS5sbHNlZWsJCT0gc2VxX2xzZWVrLAot CS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVhc2UsCi0JLnVubG9ja2VkX2lvY3RsCT0gaThrX2lvY3Rs LAotfTsKLQogc3RydWN0IHNtbV9yZWdzIHsKIAl1bnNpZ25lZCBpbnQgZWF4OwogCXVuc2lnbmVk IGludCBlYnggX19wYWNrZWQ7CkBAIC0yMjEsNDUgKzIxMSw2IEBAIG91dDoKIH0KIAogLyoKLSAq IFJlYWQgdGhlIEZuIGtleSBzdGF0dXMuCi0gKi8KLXN0YXRpYyBpbnQgaThrX2dldF9mbl9zdGF0 dXModm9pZCkKLXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fRk5f U1RBVFVTLCB9OwotCWludCByYzsKLQotCXJjID0gaThrX3NtbSgmcmVncyk7Ci0JaWYgKHJjIDwg MCkKLQkJcmV0dXJuIHJjOwotCi0Jc3dpdGNoICgocmVncy5lYXggPj4gSThLX0ZOX1NISUZUKSAm IEk4S19GTl9NQVNLKSB7Ci0JY2FzZSBJOEtfRk5fVVA6Ci0JCXJldHVybiBJOEtfVk9MX1VQOwot CWNhc2UgSThLX0ZOX0RPV046Ci0JCXJldHVybiBJOEtfVk9MX0RPV047Ci0JY2FzZSBJOEtfRk5f TVVURToKLQkJcmV0dXJuIEk4S19WT0xfTVVURTsKLQlkZWZhdWx0OgotCQlyZXR1cm4gMDsKLQl9 Ci19Ci0KLS8qCi0gKiBSZWFkIHRoZSBwb3dlciBzdGF0dXMuCi0gKi8KLXN0YXRpYyBpbnQgaThr X2dldF9wb3dlcl9zdGF0dXModm9pZCkKLXsKLQlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsgLmVh eCA9IEk4S19TTU1fUE9XRVJfU1RBVFVTLCB9OwotCWludCByYzsKLQotCXJjID0gaThrX3NtbSgm cmVncyk7Ci0JaWYgKHJjIDwgMCkKLQkJcmV0dXJuIHJjOwotCi0JcmV0dXJuIChyZWdzLmVheCAm IDB4ZmYpID09IEk4S19QT1dFUl9BQyA/IEk4S19BQyA6IEk4S19CQVRURVJZOwotfQotCi0vKgog ICogUmVhZCB0aGUgZmFuIHN0YXR1cy4KICAqLwogc3RhdGljIGludCBpOGtfZ2V0X2Zhbl9zdGF0 dXMoaW50IGZhbikKQEAgLTM3OCw2ICszMjksNTEgQEAgc3RhdGljIGludCBpOGtfZ2V0X2RlbGxf c2lnbmF0dXJlKGludCByZXFfZm4pCiAJcmV0dXJuIHJlZ3MuZWF4ID09IDExNDU2NTE1MjcgJiYg cmVncy5lZHggPT0gMTE0NTM5MjIwNCA/IDAgOiAtMTsKIH0KIAorI2lmIElTX0VOQUJMRUQoQ09O RklHX0k4SykKKworLyoKKyAqIFJlYWQgdGhlIEZuIGtleSBzdGF0dXMuCisgKi8KK3N0YXRpYyBp bnQgaThrX2dldF9mbl9zdGF0dXModm9pZCkKK3sKKwlzdHJ1Y3Qgc21tX3JlZ3MgcmVncyA9IHsg LmVheCA9IEk4S19TTU1fRk5fU1RBVFVTLCB9OworCWludCByYzsKKworCXJjID0gaThrX3NtbSgm cmVncyk7CisJaWYgKHJjIDwgMCkKKwkJcmV0dXJuIHJjOworCisJc3dpdGNoICgocmVncy5lYXgg Pj4gSThLX0ZOX1NISUZUKSAmIEk4S19GTl9NQVNLKSB7CisJY2FzZSBJOEtfRk5fVVA6CisJCXJl dHVybiBJOEtfVk9MX1VQOworCWNhc2UgSThLX0ZOX0RPV046CisJCXJldHVybiBJOEtfVk9MX0RP V047CisJY2FzZSBJOEtfRk5fTVVURToKKwkJcmV0dXJuIEk4S19WT0xfTVVURTsKKwlkZWZhdWx0 OgorCQlyZXR1cm4gMDsKKwl9Cit9CisKKy8qCisgKiBSZWFkIHRoZSBwb3dlciBzdGF0dXMuCisg Ki8KK3N0YXRpYyBpbnQgaThrX2dldF9wb3dlcl9zdGF0dXModm9pZCkKK3sKKwlzdHJ1Y3Qgc21t X3JlZ3MgcmVncyA9IHsgLmVheCA9IEk4S19TTU1fUE9XRVJfU1RBVFVTLCB9OworCWludCByYzsK KworCXJjID0gaThrX3NtbSgmcmVncyk7CisJaWYgKHJjIDwgMCkKKwkJcmV0dXJuIHJjOworCisJ cmV0dXJuIChyZWdzLmVheCAmIDB4ZmYpID09IEk4S19QT1dFUl9BQyA/IEk4S19BQyA6IEk4S19C QVRURVJZOworfQorCisvKgorICogUHJvY2ZzIGludGVyZmFjZQorICovCisKIHN0YXRpYyBpbnQK IGk4a19pb2N0bF91bmxvY2tlZChzdHJ1Y3QgZmlsZSAqZnAsIHVuc2lnbmVkIGludCBjbWQsIHVu c2lnbmVkIGxvbmcgYXJnKQogewpAQCAtNTI4LDYgKzUyNCwzNyBAQCBzdGF0aWMgaW50IGk4a19v cGVuX2ZzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQogCXJldHVybiBz aW5nbGVfb3BlbihmaWxlLCBpOGtfcHJvY19zaG93LCBOVUxMKTsKIH0KIAorc3RhdGljIGNvbnN0 IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgaThrX2ZvcHMgPSB7CisJLm93bmVyCQk9IFRISVNfTU9E VUxFLAorCS5vcGVuCQk9IGk4a19vcGVuX2ZzLAorCS5yZWFkCQk9IHNlcV9yZWFkLAorCS5sbHNl ZWsJCT0gc2VxX2xzZWVrLAorCS5yZWxlYXNlCT0gc2luZ2xlX3JlbGVhc2UsCisJLnVubG9ja2Vk X2lvY3RsCT0gaThrX2lvY3RsLAorfTsKKworc3RhdGljIHZvaWQgX19pbml0IGk4a19pbml0X3By b2Nmcyh2b2lkKQoreworCS8qIFJlZ2lzdGVyIHRoZSBwcm9jIGVudHJ5ICovCisJcHJvY19jcmVh dGUoImk4ayIsIDAsIE5VTEwsICZpOGtfZm9wcyk7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBp OGtfZXhpdF9wcm9jZnModm9pZCkKK3sKKwlyZW1vdmVfcHJvY19lbnRyeSgiaThrIiwgTlVMTCk7 Cit9CisKKyNlbHNlCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2luaXQgaThrX2luaXRfcHJvY2Zz KHZvaWQpCit7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2V4aXQgaThrX2V4aXRfcHJvY2Zz KHZvaWQpCit7Cit9CisKKyNlbmRpZgogCiAvKgogICogSHdtb24gaW50ZXJmYWNlCkBAIC03NTAs OCArNzc3LDggQEAgc3RhdGljIGludCBfX2luaXQgaThrX2luaXRfaHdtb24odm9pZCkKIAlpZiAo ZXJyID49IDApCiAJCWk4a19od21vbl9mbGFncyB8PSBJOEtfSFdNT05fSEFWRV9GQU4yOwogCi0J aThrX2h3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3Rlcl93aXRoX2dyb3VwcyhOVUxMLCAi aThrIiwgTlVMTCwKLQkJCQkJCQkgIGk4a19ncm91cHMpOworCWk4a19od21vbl9kZXYgPSBod21v bl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoTlVMTCwgImRlbGwtc21tIiwKKwkJCQkJCQkg IE5VTEwsIGk4a19ncm91cHMpOwogCWlmIChJU19FUlIoaThrX2h3bW9uX2RldikpIHsKIAkJZXJy ID0gUFRSX0VSUihpOGtfaHdtb25fZGV2KTsKIAkJaThrX2h3bW9uX2RldiA9IE5VTEw7CkBAIC05 NzYsMzMgKzEwMDMsMjQgQEAgc3RhdGljIGludCBfX2luaXQgaThrX3Byb2JlKHZvaWQpCiAKIHN0 YXRpYyBpbnQgX19pbml0IGk4a19pbml0KHZvaWQpCiB7Ci0Jc3RydWN0IHByb2NfZGlyX2VudHJ5 ICpwcm9jX2k4azsKIAlpbnQgZXJyOwogCiAJLyogQXJlIHdlIHJ1bm5pbmcgb24gYW4gc3VwcG9y dGVkIGxhcHRvcD8gKi8KIAlpZiAoaThrX3Byb2JlKCkpCiAJCXJldHVybiAtRU5PREVWOwogCi0J LyogUmVnaXN0ZXIgdGhlIHByb2MgZW50cnkgKi8KLQlwcm9jX2k4ayA9IHByb2NfY3JlYXRlKCJp OGsiLCAwLCBOVUxMLCAmaThrX2ZvcHMpOwotCWlmICghcHJvY19pOGspCi0JCXJldHVybiAtRU5P RU5UOwotCiAJZXJyID0gaThrX2luaXRfaHdtb24oKTsKIAlpZiAoZXJyKQotCQlnb3RvIGV4aXRf cmVtb3ZlX3Byb2M7CisJCXJldHVybiBlcnI7CiAKKwlpOGtfaW5pdF9wcm9jZnMoKTsKIAlyZXR1 cm4gMDsKLQotIGV4aXRfcmVtb3ZlX3Byb2M6Ci0JcmVtb3ZlX3Byb2NfZW50cnkoImk4ayIsIE5V TEwpOwotCXJldHVybiBlcnI7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhpdCBpOGtfZXhpdCh2b2lk KQogewogCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGk4a19od21vbl9kZXYpOwotCXJlbW92ZV9w cm9jX2VudHJ5KCJpOGsiLCBOVUxMKTsKKwlpOGtfZXhpdF9wcm9jZnMoKTsKIH0KIAogbW9kdWxl X2luaXQoaThrX2luaXQpOwotLSAKMS43LjEwLjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5zb3Jz QGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-05-14 11:16 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-05-14 11:16 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck Cc: linux-kernel, lm-sensors, Pali Rohár This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k interface which is needed only for old Dell Inspirion models or for userspace i8kutils package. For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. Signed-off-by: Pali Rohár <pali.rohar@gmail.com> --- changes since v2: - removed depends on DMI --- arch/x86/Kconfig | 25 +++---- drivers/hwmon/Kconfig | 11 +++ drivers/hwmon/Makefile | 2 +- drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ 4 files changed, 106 insertions(+), 82 deletions(-) diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 226d569..7b756b3 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -1055,24 +1055,19 @@ config TOSHIBA Say N otherwise. config I8K - tristate "Dell laptop support" + tristate "Dell i8k legacy laptop support" select HWMON + select SENSORS_DELL_SMM ---help--- - This adds a driver to safely access the System Management Mode - of the CPU on the Dell Inspiron 8000. The System Management Mode - is used to read cpu temperature and cooling fan status and to - control the fans on the I8K portables. + This option enables legacy /proc/i8k userspace interface in hwmon + dell-smm-hwmon driver. Character file /proc/i8k reports bios version, + temperature and allows controlling fan speeds of Dell laptops via + System Management Mode. For old Dell laptops (like Dell Inspiron 8000) + it reports also power and hotkey status. For fan speed control is + needed userspace package i8kutils. - This driver has been tested only on the Inspiron 8000 but it may - also work with other Dell laptops. You can force loading on other - models by passing the parameter `force=1' to the module. Use at - your own risk. - - For information on utilities to make use of this driver see the - I8K Linux utilities web site at: - <http://people.debian.org/~dz/i8k/> - - Say Y if you intend to run this kernel on a Dell Inspiron 8000. + Say Y if you intend to run this kernel on old Dell laptops or want to + use userspace package i8kutils. Say N otherwise. config X86_REBOOTFIXUPS diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 25d9e72..bc9d90b1 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -371,6 +371,17 @@ config SENSORS_DS1621 This driver can also be built as a module. If so, the module will be called ds1621. +config SENSORS_DELL_SMM + tristate "Dell laptop SMM BIOS hwmon driver" + depends on X86 + help + This hwmon driver adds support for reporting temperature of different + sensors and controls the fans on Dell laptops via System Management + Mode provided by Dell BIOS. + + When option I8K is also enabled this driver provides legacy /proc/i8k + userspace interface for i8kutils package. + config SENSORS_DA9052_ADC tristate "Dialog DA9052/DA9053 ADC" depends on PMIC_DA9052 diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 51533ac..6cacd0f 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -49,6 +49,7 @@ obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o obj-$(CONFIG_SENSORS_CORETEMP) += coretemp.o obj-$(CONFIG_SENSORS_DA9052_ADC)+= da9052-hwmon.o obj-$(CONFIG_SENSORS_DA9055)+= da9055-hwmon.o +obj-$(CONFIG_SENSORS_DELL_SMM) += dell-smm-hwmon.o obj-$(CONFIG_SENSORS_DME1737) += dme1737.o obj-$(CONFIG_SENSORS_DS620) += ds620.o obj-$(CONFIG_SENSORS_DS1621) += ds1621.o @@ -156,7 +157,6 @@ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o -obj-$(CONFIG_I8K) += dell-smm-hwmon.o obj-$(CONFIG_PMBUS) += pmbus/ diff --git a/drivers/hwmon/dell-smm-hwmon.c b/drivers/hwmon/dell-smm-hwmon.c index 65d314b..2a80882 100644 --- a/drivers/hwmon/dell-smm-hwmon.c +++ b/drivers/hwmon/dell-smm-hwmon.c @@ -81,7 +81,7 @@ static uint i8k_fan_max = I8K_FAN_HIGH; MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); -MODULE_DESCRIPTION("Driver for accessing SMM BIOS on Dell laptops"); +MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS("i8k"); @@ -93,6 +93,7 @@ static bool ignore_dmi; module_param(ignore_dmi, bool, 0); MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); +#if IS_ENABLED(CONFIG_I8K) static bool restricted; module_param(restricted, bool, 0); MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); @@ -100,6 +101,7 @@ MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability set"); static bool power_status; module_param(power_status, bool, 0600); MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); +#endif static uint fan_mult; module_param(fan_mult, uint, 0); @@ -109,18 +111,6 @@ static uint fan_max; module_param(fan_max, uint, 0); MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); -static int i8k_open_fs(struct inode *inode, struct file *file); -static long i8k_ioctl(struct file *, unsigned int, unsigned long); - -static const struct file_operations i8k_fops = { - .owner = THIS_MODULE, - .open = i8k_open_fs, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, - .unlocked_ioctl = i8k_ioctl, -}; - struct smm_regs { unsigned int eax; unsigned int ebx __packed; @@ -221,45 +211,6 @@ out: } /* - * Read the Fn key status. - */ -static int i8k_get_fn_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { - case I8K_FN_UP: - return I8K_VOL_UP; - case I8K_FN_DOWN: - return I8K_VOL_DOWN; - case I8K_FN_MUTE: - return I8K_VOL_MUTE; - default: - return 0; - } -} - -/* - * Read the power status. - */ -static int i8k_get_power_status(void) -{ - struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; - int rc; - - rc = i8k_smm(®s); - if (rc < 0) - return rc; - - return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; -} - -/* * Read the fan status. */ static int i8k_get_fan_status(int fan) @@ -378,6 +329,51 @@ static int i8k_get_dell_signature(int req_fn) return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; } +#if IS_ENABLED(CONFIG_I8K) + +/* + * Read the Fn key status. + */ +static int i8k_get_fn_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { + case I8K_FN_UP: + return I8K_VOL_UP; + case I8K_FN_DOWN: + return I8K_VOL_DOWN; + case I8K_FN_MUTE: + return I8K_VOL_MUTE; + default: + return 0; + } +} + +/* + * Read the power status. + */ +static int i8k_get_power_status(void) +{ + struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; + int rc; + + rc = i8k_smm(®s); + if (rc < 0) + return rc; + + return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; +} + +/* + * Procfs interface + */ + static int i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) { @@ -528,6 +524,37 @@ static int i8k_open_fs(struct inode *inode, struct file *file) return single_open(file, i8k_proc_show, NULL); } +static const struct file_operations i8k_fops = { + .owner = THIS_MODULE, + .open = i8k_open_fs, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .unlocked_ioctl = i8k_ioctl, +}; + +static void __init i8k_init_procfs(void) +{ + /* Register the proc entry */ + proc_create("i8k", 0, NULL, &i8k_fops); +} + +static void __exit i8k_exit_procfs(void) +{ + remove_proc_entry("i8k", NULL); +} + +#else + +static inline void __init i8k_init_procfs(void) +{ +} + +static inline void __exit i8k_exit_procfs(void) +{ +} + +#endif /* * Hwmon interface @@ -750,8 +777,8 @@ static int __init i8k_init_hwmon(void) if (err >= 0) i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; - i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "i8k", NULL, - i8k_groups); + i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "dell-smm", + NULL, i8k_groups); if (IS_ERR(i8k_hwmon_dev)) { err = PTR_ERR(i8k_hwmon_dev); i8k_hwmon_dev = NULL; @@ -976,33 +1003,24 @@ static int __init i8k_probe(void) static int __init i8k_init(void) { - struct proc_dir_entry *proc_i8k; int err; /* Are we running on an supported laptop? */ if (i8k_probe()) return -ENODEV; - /* Register the proc entry */ - proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops); - if (!proc_i8k) - return -ENOENT; - err = i8k_init_hwmon(); if (err) - goto exit_remove_proc; + return err; + i8k_init_procfs(); return 0; - - exit_remove_proc: - remove_proc_entry("i8k", NULL); - return err; } static void __exit i8k_exit(void) { hwmon_device_unregister(i8k_hwmon_dev); - remove_proc_entry("i8k", NULL); + i8k_exit_procfs(); } module_init(i8k_init); -- 1.7.10.4 ^ permalink raw reply related [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k 2015-05-14 11:16 ` Pali Rohár @ 2015-05-21 11:42 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-05-21 11:42 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck; +Cc: linux-kernel, lm-sensors T24gVGh1cnNkYXkgMTQgTWF5IDIwMTUgMTM6MTY6MzcgUGFsaSBSb2jDoXIgd3JvdGU6Cj4gVGhp cyBwYXRjaCBzcGxpdHMgQ09ORklHX0k4SyBjb21waWxlIG9wdGlvbiB0byBTRU5TT1JTX0RFTExf U01NIGFuZCBDT05GSUdfSThLLgo+IE9wdGlvbiBTRU5TT1JTX0RFTExfU01NIGlzIG5vdyB1c2Vk IHRvIGVuYWJsZSBjb21waWxhdGlvbiBvZiBkZWxsLXNtbS1od21vbgo+IGRyaXZlciBhbmQgb2xk IENPTkZJR19JOEsgb3B0aW9uIHRvIGVuYWJsZSAvcHJvYy9pOGsgaW50ZXJmYWNlIGluIGRyaXZl ci4KPiAKPiBTbyB0aGlzIGNoYW5nZSBhbGxvd3MgdG8gY29tcGlsZSBkZWxsLXNtbS1od21vbiBk cml2ZXIgd2l0aG91dCBsZWdhY3kgL3Byb2MvaThrCj4gaW50ZXJmYWNlIHdoaWNoIGlzIG5lZWRl ZCBvbmx5IGZvciBvbGQgRGVsbCBJbnNwaXJpb24gbW9kZWxzIG9yIGZvciB1c2Vyc3BhY2UKPiBp OGt1dGlscyBwYWNrYWdlLgo+IAo+IEZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IHdoZW4gQ09O RklHX0k4SyBpcyBlbmFibGVkIHRoZW4gYWxzbyBTRU5TT1JTX0RFTExfU01NCj4gaXMgZW5hYmxl ZCBhbmQgc28gZHJpdmVyIGRlbGwtc21tLWh3bW9uICh3aXRoIC9wcm9jL2k4aykgaXMgY29tcGls ZWQuCj4gCj4gU2lnbmVkLW9mZi1ieTogUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29t Pgo+IC0tLQo+IGNoYW5nZXMgc2luY2UgdjI6Cj4gIC0gcmVtb3ZlZCBkZXBlbmRzIG9uIERNSQo+ IC0tLQo+ICBhcmNoL3g4Ni9LY29uZmlnICAgICAgICAgICAgICAgfCAgIDI1ICsrKy0tLS0KPiAg ZHJpdmVycy9od21vbi9LY29uZmlnICAgICAgICAgIHwgICAxMSArKysKPiAgZHJpdmVycy9od21v bi9NYWtlZmlsZSAgICAgICAgIHwgICAgMiArLQo+ICBkcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3 bW9uLmMgfCAgMTUwICsrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0KPiAg NCBmaWxlcyBjaGFuZ2VkLCAxMDYgaW5zZXJ0aW9ucygrKSwgODIgZGVsZXRpb25zKC0pCj4gCgpH cmVnLCBjYW4geW91IGZpbmFsbHkgYXBwbHkgdGhpcyBwYXRjaCBzZXJpZXM/CgotLSAKUGFsaSBS b2jDoXIKcGFsaS5yb2hhckBnbWFpbC5jb20KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0CmxtLXNlbnNvcnNAbG0t c2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxtYW4vbGlzdGluZm8v bG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k @ 2015-05-21 11:42 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-05-21 11:42 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck; +Cc: linux-kernel, lm-sensors On Thursday 14 May 2015 13:16:37 Pali Rohár wrote: > This patch splits CONFIG_I8K compile option to SENSORS_DELL_SMM and CONFIG_I8K. > Option SENSORS_DELL_SMM is now used to enable compilation of dell-smm-hwmon > driver and old CONFIG_I8K option to enable /proc/i8k interface in driver. > > So this change allows to compile dell-smm-hwmon driver without legacy /proc/i8k > interface which is needed only for old Dell Inspirion models or for userspace > i8kutils package. > > For backward compatibility when CONFIG_I8K is enabled then also SENSORS_DELL_SMM > is enabled and so driver dell-smm-hwmon (with /proc/i8k) is compiled. > > Signed-off-by: Pali Rohár <pali.rohar@gmail.com> > --- > changes since v2: > - removed depends on DMI > --- > arch/x86/Kconfig | 25 +++---- > drivers/hwmon/Kconfig | 11 +++ > drivers/hwmon/Makefile | 2 +- > drivers/hwmon/dell-smm-hwmon.c | 150 ++++++++++++++++++++++------------------ > 4 files changed, 106 insertions(+), 82 deletions(-) > Greg, can you finally apply this patch series? -- Pali Rohár pali.rohar@gmail.com ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-03-29 12:57 ` Pali Rohár @ 2015-03-31 3:32 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-31 3:32 UTC (permalink / raw) To: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMDMvMjkvMjAxNSAwNTo1NyBBTSwgUGFsaSBSb2jDoXIgd3JvdGU6Cj4gVGhpcyBwYXRjaCBz ZXJpZXMgbW92ZXMgZHJpdmVycy9jaGFyL2k4ay5jIHRvIGRyaXZlcnMvaHdtb24vZGVsbC1zbW0t aHdtb24uYwo+IGFuZCBhbGxvd3MgdG8gY29tcGlsZSBod21vbiBkcml2ZXIgd2l0aG91dCAvcHJv Yy9pOGsgZmlsZS4KPgo+IFBhbGkgUm9ow6FyICgyKToKPiAgICBod21vbjogUmVuYW1lIGk4ayBk cml2ZXIgdG8gZGVsbC1zbW0taHdtb24gYW5kIG1vdmUgaXQgdG8gaHdtb24gdHJlZQo+ICAgIGh3 bW9uOiBBbGxvdyB0byBjb21waWxlIGRlbGwtc21tLWh3bW9uIGRyaXZlciB3aXRob3V0IC9wcm9j L2k4awo+Cj4gICBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgfCAgICA0ICstCj4gICBh cmNoL3g4Ni9LY29uZmlnICAgICAgICAgICAgICAgfCAgIDI1ICstCj4gICBkcml2ZXJzL2NoYXIv TWFrZWZpbGUgICAgICAgICAgfCAgICAxIC0KPiAgIGRyaXZlcnMvY2hhci9pOGsuYyAgICAgICAg ICAgICB8IDEwMDUgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gICBk cml2ZXJzL2h3bW9uL0tjb25maWcgICAgICAgICAgfCAgIDExICsKPiAgIGRyaXZlcnMvaHdtb24v TWFrZWZpbGUgICAgICAgICB8ICAgIDEgKwo+ICAgZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21v bi5jIHwgMTAyNSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gICA3 IGZpbGVzIGNoYW5nZWQsIDEwNDkgaW5zZXJ0aW9ucygrKSwgMTAyMyBkZWxldGlvbnMoLSkKPiAg IGRlbGV0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2NoYXIvaThrLmMKPiAgIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMKPgpJIGFtIG9rIHdpdGggdGhlIHNl cmllcyBhbmQgd291bGQgdGFrZSBpdCBmb3IgNC4xIGlmIEdyZWcgYWdyZWVzLgoKR3JlZywgYW55 IGNvbW1lbnRzID8KClRoYW5rcywKR3VlbnRlcgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0CmxtLXNlbnNvcnNA bG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxtYW4vbGlzdGlu Zm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-03-31 3:32 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-03-31 3:32 UTC (permalink / raw) To: Pali Rohár, Arnd Bergmann, Greg Kroah-Hartman, Jean Delvare Cc: Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 03/29/2015 05:57 AM, Pali Rohár wrote: > This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > and allows to compile hwmon driver without /proc/i8k file. > > Pali Rohár (2): > hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > MAINTAINERS | 4 +- > arch/x86/Kconfig | 25 +- > drivers/char/Makefile | 1 - > drivers/char/i8k.c | 1005 --------------------------------------- > drivers/hwmon/Kconfig | 11 + > drivers/hwmon/Makefile | 1 + > drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > 7 files changed, 1049 insertions(+), 1023 deletions(-) > delete mode 100644 drivers/char/i8k.c > create mode 100644 drivers/hwmon/dell-smm-hwmon.c > I am ok with the series and would take it for 4.1 if Greg agrees. Greg, any comments ? Thanks, Guenter ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-03-31 3:32 ` Guenter Roeck @ 2015-03-31 13:56 ` Greg Kroah-Hartman -1 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-03-31 13:56 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > On 03/29/2015 05:57 AM, Pali Rohár wrote: > >This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > >and allows to compile hwmon driver without /proc/i8k file. > > > >Pali Rohár (2): > > hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > > > MAINTAINERS | 4 +- > > arch/x86/Kconfig | 25 +- > > drivers/char/Makefile | 1 - > > drivers/char/i8k.c | 1005 --------------------------------------- > > drivers/hwmon/Kconfig | 11 + > > drivers/hwmon/Makefile | 1 + > > drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > 7 files changed, 1049 insertions(+), 1023 deletions(-) > > delete mode 100644 drivers/char/i8k.c > > create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > I am ok with the series and would take it for 4.1 if Greg agrees. > > Greg, any comments ? Let me review it, it's in my queue... _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-03-31 13:56 ` Greg Kroah-Hartman 0 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-03-31 13:56 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > On 03/29/2015 05:57 AM, Pali Rohár wrote: > >This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > >and allows to compile hwmon driver without /proc/i8k file. > > > >Pali Rohár (2): > > hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > > > MAINTAINERS | 4 +- > > arch/x86/Kconfig | 25 +- > > drivers/char/Makefile | 1 - > > drivers/char/i8k.c | 1005 --------------------------------------- > > drivers/hwmon/Kconfig | 11 + > > drivers/hwmon/Makefile | 1 + > > drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > 7 files changed, 1049 insertions(+), 1023 deletions(-) > > delete mode 100644 drivers/char/i8k.c > > create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > I am ok with the series and would take it for 4.1 if Greg agrees. > > Greg, any comments ? Let me review it, it's in my queue... ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-03-31 13:56 ` Greg Kroah-Hartman @ 2015-04-09 14:02 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-09 14:02 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gVHVlc2RheSAzMSBNYXJjaCAyMDE1IDE1OjU2OjAxIEdyZWcgS3JvYWgtSGFydG1hbiB3cm90 ZToKPiBPbiBNb24sIE1hciAzMCwgMjAxNSBhdCAwODozMjozNlBNIC0wNzAwLCBHdWVudGVyIFJv ZWNrIHdyb3RlOgo+ID4gT24gMDMvMjkvMjAxNSAwNTo1NyBBTSwgUGFsaSBSb2jDoXIgd3JvdGU6 Cj4gPiA+VGhpcyBwYXRjaCBzZXJpZXMgbW92ZXMgZHJpdmVycy9jaGFyL2k4ay5jIHRvIGRyaXZl cnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwo+ID4gPmFuZCBhbGxvd3MgdG8gY29tcGlsZSBod21v biBkcml2ZXIgd2l0aG91dCAvcHJvYy9pOGsgZmlsZS4KPiA+ID4KPiA+ID5QYWxpIFJvaMOhciAo Mik6Cj4gPiA+ICAgaHdtb246IFJlbmFtZSBpOGsgZHJpdmVyIHRvIGRlbGwtc21tLWh3bW9uIGFu ZCBtb3ZlIGl0IHRvIGh3bW9uIHRyZWUKPiA+ID4gICBod21vbjogQWxsb3cgdG8gY29tcGlsZSBk ZWxsLXNtbS1od21vbiBkcml2ZXIgd2l0aG91dCAvcHJvYy9pOGsKPiA+ID4KPiA+ID4gIE1BSU5U QUlORVJTICAgICAgICAgICAgICAgICAgICB8ICAgIDQgKy0KPiA+ID4gIGFyY2gveDg2L0tjb25m aWcgICAgICAgICAgICAgICB8ICAgMjUgKy0KPiA+ID4gIGRyaXZlcnMvY2hhci9NYWtlZmlsZSAg ICAgICAgICB8ICAgIDEgLQo+ID4gPiAgZHJpdmVycy9jaGFyL2k4ay5jICAgICAgICAgICAgIHwg MTAwNSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ID4gIGRyaXZl cnMvaHdtb24vS2NvbmZpZyAgICAgICAgICB8ICAgMTEgKwo+ID4gPiAgZHJpdmVycy9od21vbi9N YWtlZmlsZSAgICAgICAgIHwgICAgMSArCj4gPiA+ICBkcml2ZXJzL2h3bW9uL2RlbGwtc21tLWh3 bW9uLmMgfCAxMDI1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiA+ ID4gIDcgZmlsZXMgY2hhbmdlZCwgMTA0OSBpbnNlcnRpb25zKCspLCAxMDIzIGRlbGV0aW9ucygt KQo+ID4gPiAgZGVsZXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY2hhci9pOGsuYwo+ID4gPiAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwo+ID4gPgo+ID4g SSBhbSBvayB3aXRoIHRoZSBzZXJpZXMgYW5kIHdvdWxkIHRha2UgaXQgZm9yIDQuMSBpZiBHcmVn IGFncmVlcy4KPiA+IAo+ID4gR3JlZywgYW55IGNvbW1lbnRzID8KPiAKPiBMZXQgbWUgcmV2aWV3 IGl0LCBpdCdzIGluIG15IHF1ZXVlLi4uCgpIaSBHcmVnISBIYXZlIHlvdSBsb29rZWQgYXQgaXQ/ CgotLSAKUGFsaSBSb2jDoXIKcGFsaS5yb2hhckBnbWFpbC5jb20KCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0Cmxt LXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxt YW4vbGlzdGluZm8vbG0tc2Vuc29ycw= ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-04-09 14:02 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-09 14:02 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > > On 03/29/2015 05:57 AM, Pali Rohár wrote: > > >This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > > >and allows to compile hwmon driver without /proc/i8k file. > > > > > >Pali Rohár (2): > > > hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > > hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > > > > > MAINTAINERS | 4 +- > > > arch/x86/Kconfig | 25 +- > > > drivers/char/Makefile | 1 - > > > drivers/char/i8k.c | 1005 --------------------------------------- > > > drivers/hwmon/Kconfig | 11 + > > > drivers/hwmon/Makefile | 1 + > > > drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > > 7 files changed, 1049 insertions(+), 1023 deletions(-) > > > delete mode 100644 drivers/char/i8k.c > > > create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > > > I am ok with the series and would take it for 4.1 if Greg agrees. > > > > Greg, any comments ? > > Let me review it, it's in my queue... Hi Greg! Have you looked at it? -- Pali Rohár pali.rohar@gmail.com ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-04-09 14:02 ` Pali Rohár @ 2015-04-21 13:30 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-21 13:30 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck Cc: Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gVGh1cnNkYXkgMDkgQXByaWwgMjAxNSAxNjowMjoyNCBQYWxpIFJvaMOhciB3cm90ZToKPiBP biBUdWVzZGF5IDMxIE1hcmNoIDIwMTUgMTU6NTY6MDEgR3JlZyBLcm9haC1IYXJ0bWFuIHdyb3Rl Ogo+ID4gT24gTW9uLCBNYXIgMzAsIDIwMTUgYXQgMDg6MzI6MzZQTSAtMDcwMCwgR3VlbnRlciBS b2VjayB3cm90ZToKPiA+ID4gT24gMDMvMjkvMjAxNSAwNTo1NyBBTSwgUGFsaSBSb2jDoXIgd3Jv dGU6Cj4gPiA+ID5UaGlzIHBhdGNoIHNlcmllcyBtb3ZlcyBkcml2ZXJzL2NoYXIvaThrLmMgdG8g ZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jCj4gPiA+ID5hbmQgYWxsb3dzIHRvIGNvbXBp bGUgaHdtb24gZHJpdmVyIHdpdGhvdXQgL3Byb2MvaThrIGZpbGUuCj4gPiA+ID4KPiA+ID4gPlBh bGkgUm9ow6FyICgyKToKPiA+ID4gPiAgIGh3bW9uOiBSZW5hbWUgaThrIGRyaXZlciB0byBkZWxs LXNtbS1od21vbiBhbmQgbW92ZSBpdCB0byBod21vbiB0cmVlCj4gPiA+ID4gICBod21vbjogQWxs b3cgdG8gY29tcGlsZSBkZWxsLXNtbS1od21vbiBkcml2ZXIgd2l0aG91dCAvcHJvYy9pOGsKPiA+ ID4gPgo+ID4gPiA+ICBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgfCAgICA0ICstCj4g PiA+ID4gIGFyY2gveDg2L0tjb25maWcgICAgICAgICAgICAgICB8ICAgMjUgKy0KPiA+ID4gPiAg ZHJpdmVycy9jaGFyL01ha2VmaWxlICAgICAgICAgIHwgICAgMSAtCj4gPiA+ID4gIGRyaXZlcnMv Y2hhci9pOGsuYyAgICAgICAgICAgICB8IDEwMDUgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tCj4gPiA+ID4gIGRyaXZlcnMvaHdtb24vS2NvbmZpZyAgICAgICAgICB8ICAg MTEgKwo+ID4gPiA+ICBkcml2ZXJzL2h3bW9uL01ha2VmaWxlICAgICAgICAgfCAgICAxICsKPiA+ ID4gPiAgZHJpdmVycy9od21vbi9kZWxsLXNtbS1od21vbi5jIHwgMTAyNSArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gPiA+ID4gIDcgZmlsZXMgY2hhbmdlZCwgMTA0 OSBpbnNlcnRpb25zKCspLCAxMDIzIGRlbGV0aW9ucygtKQo+ID4gPiA+ICBkZWxldGUgbW9kZSAx MDA2NDQgZHJpdmVycy9jaGFyL2k4ay5jCj4gPiA+ID4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2h3bW9uL2RlbGwtc21tLWh3bW9uLmMKPiA+ID4gPgo+ID4gPiBJIGFtIG9rIHdpdGggdGhl IHNlcmllcyBhbmQgd291bGQgdGFrZSBpdCBmb3IgNC4xIGlmIEdyZWcgYWdyZWVzLgo+ID4gPiAK PiA+ID4gR3JlZywgYW55IGNvbW1lbnRzID8KPiA+IAo+ID4gTGV0IG1lIHJldmlldyBpdCwgaXQn cyBpbiBteSBxdWV1ZS4uLgo+IAo+IEhpIEdyZWchIEhhdmUgeW91IGxvb2tlZCBhdCBpdD8KPiAK CkdyZWcgJiBHdWVudGVyOiBwaW5nLiBXaWxsIHlvdSBpbmNsdWRlIGl0IGludG8gNC4xPwoKLS0g ClBhbGkgUm9ow6FyCnBhbGkucm9oYXJAZ21haWwuY29tCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxpbmcgbGlzdApsbS1zZW5z b3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3JzLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-04-21 13:30 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-21 13:30 UTC (permalink / raw) To: Greg Kroah-Hartman, Guenter Roeck Cc: Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > > On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > > > On 03/29/2015 05:57 AM, Pali Rohár wrote: > > > >This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > > > >and allows to compile hwmon driver without /proc/i8k file. > > > > > > > >Pali Rohár (2): > > > > hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > > > hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > > > > > > > MAINTAINERS | 4 +- > > > > arch/x86/Kconfig | 25 +- > > > > drivers/char/Makefile | 1 - > > > > drivers/char/i8k.c | 1005 --------------------------------------- > > > > drivers/hwmon/Kconfig | 11 + > > > > drivers/hwmon/Makefile | 1 + > > > > drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > > > 7 files changed, 1049 insertions(+), 1023 deletions(-) > > > > delete mode 100644 drivers/char/i8k.c > > > > create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > > > > > I am ok with the series and would take it for 4.1 if Greg agrees. > > > > > > Greg, any comments ? > > > > Let me review it, it's in my queue... > > Hi Greg! Have you looked at it? > Greg & Guenter: ping. Will you include it into 4.1? -- Pali Rohár pali.rohar@gmail.com ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-04-21 13:30 ` Pali Rohár @ 2015-04-21 13:40 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-04-21 13:40 UTC (permalink / raw) To: Pali Rohár, Greg Kroah-Hartman Cc: Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors T24gMDQvMjEvMjAxNSAwNjozMCBBTSwgUGFsaSBSb2jDoXIgd3JvdGU6Cj4gT24gVGh1cnNkYXkg MDkgQXByaWwgMjAxNSAxNjowMjoyNCBQYWxpIFJvaMOhciB3cm90ZToKPj4gT24gVHVlc2RheSAz MSBNYXJjaCAyMDE1IDE1OjU2OjAxIEdyZWcgS3JvYWgtSGFydG1hbiB3cm90ZToKPj4+IE9uIE1v biwgTWFyIDMwLCAyMDE1IGF0IDA4OjMyOjM2UE0gLTA3MDAsIEd1ZW50ZXIgUm9lY2sgd3JvdGU6 Cj4+Pj4gT24gMDMvMjkvMjAxNSAwNTo1NyBBTSwgUGFsaSBSb2jDoXIgd3JvdGU6Cj4+Pj4+IFRo aXMgcGF0Y2ggc2VyaWVzIG1vdmVzIGRyaXZlcnMvY2hhci9pOGsuYyB0byBkcml2ZXJzL2h3bW9u L2RlbGwtc21tLWh3bW9uLmMKPj4+Pj4gYW5kIGFsbG93cyB0byBjb21waWxlIGh3bW9uIGRyaXZl ciB3aXRob3V0IC9wcm9jL2k4ayBmaWxlLgo+Pj4+Pgo+Pj4+PiBQYWxpIFJvaMOhciAoMik6Cj4+ Pj4+ICAgIGh3bW9uOiBSZW5hbWUgaThrIGRyaXZlciB0byBkZWxsLXNtbS1od21vbiBhbmQgbW92 ZSBpdCB0byBod21vbiB0cmVlCj4+Pj4+ICAgIGh3bW9uOiBBbGxvdyB0byBjb21waWxlIGRlbGwt c21tLWh3bW9uIGRyaXZlciB3aXRob3V0IC9wcm9jL2k4awo+Pj4+Pgo+Pj4+PiAgIE1BSU5UQUlO RVJTICAgICAgICAgICAgICAgICAgICB8ICAgIDQgKy0KPj4+Pj4gICBhcmNoL3g4Ni9LY29uZmln ICAgICAgICAgICAgICAgfCAgIDI1ICstCj4+Pj4+ICAgZHJpdmVycy9jaGFyL01ha2VmaWxlICAg ICAgICAgIHwgICAgMSAtCj4+Pj4+ICAgZHJpdmVycy9jaGFyL2k4ay5jICAgICAgICAgICAgIHwg MTAwNSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPj4+Pj4gICBkcml2 ZXJzL2h3bW9uL0tjb25maWcgICAgICAgICAgfCAgIDExICsKPj4+Pj4gICBkcml2ZXJzL2h3bW9u L01ha2VmaWxlICAgICAgICAgfCAgICAxICsKPj4+Pj4gICBkcml2ZXJzL2h3bW9uL2RlbGwtc21t LWh3bW9uLmMgfCAxMDI1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK Pj4+Pj4gICA3IGZpbGVzIGNoYW5nZWQsIDEwNDkgaW5zZXJ0aW9ucygrKSwgMTAyMyBkZWxldGlv bnMoLSkKPj4+Pj4gICBkZWxldGUgbW9kZSAxMDA2NDQgZHJpdmVycy9jaGFyL2k4ay5jCj4+Pj4+ ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vZGVsbC1zbW0taHdtb24uYwo+Pj4+ Pgo+Pj4+IEkgYW0gb2sgd2l0aCB0aGUgc2VyaWVzIGFuZCB3b3VsZCB0YWtlIGl0IGZvciA0LjEg aWYgR3JlZyBhZ3JlZXMuCj4+Pj4KPj4+PiBHcmVnLCBhbnkgY29tbWVudHMgPwo+Pj4KPj4+IExl dCBtZSByZXZpZXcgaXQsIGl0J3MgaW4gbXkgcXVldWUuLi4KPj4KPj4gSGkgR3JlZyEgSGF2ZSB5 b3UgbG9va2VkIGF0IGl0Pwo+Pgo+Cj4gR3JlZyAmIEd1ZW50ZXI6IHBpbmcuIFdpbGwgeW91IGlu Y2x1ZGUgaXQgaW50byA0LjE/Cj4KSSBkb24ndCBzZWUgaXQgaW4gR3JlZydzIHB1bGwgcmVxdWVz dCwgc28gcHJlc3VtYWJseSBubyAodW5sZXNzIEkgbWlzc2VkIGl0KS4KCkd1ZW50ZXIKCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1h aWxpbmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5z b3JzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-04-21 13:40 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-04-21 13:40 UTC (permalink / raw) To: Pali Rohár, Greg Kroah-Hartman Cc: Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On 04/21/2015 06:30 AM, Pali Rohár wrote: > On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: >> On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: >>> On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: >>>> On 03/29/2015 05:57 AM, Pali Rohár wrote: >>>>> This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c >>>>> and allows to compile hwmon driver without /proc/i8k file. >>>>> >>>>> Pali Rohár (2): >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree >>>>> hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k >>>>> >>>>> MAINTAINERS | 4 +- >>>>> arch/x86/Kconfig | 25 +- >>>>> drivers/char/Makefile | 1 - >>>>> drivers/char/i8k.c | 1005 --------------------------------------- >>>>> drivers/hwmon/Kconfig | 11 + >>>>> drivers/hwmon/Makefile | 1 + >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ >>>>> 7 files changed, 1049 insertions(+), 1023 deletions(-) >>>>> delete mode 100644 drivers/char/i8k.c >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c >>>>> >>>> I am ok with the series and would take it for 4.1 if Greg agrees. >>>> >>>> Greg, any comments ? >>> >>> Let me review it, it's in my queue... >> >> Hi Greg! Have you looked at it? >> > > Greg & Guenter: ping. Will you include it into 4.1? > I don't see it in Greg's pull request, so presumably no (unless I missed it). Guenter ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-04-21 13:40 ` Guenter Roeck @ 2015-04-21 13:52 ` Greg Kroah-Hartman -1 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-21 13:52 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck wrote: > On 04/21/2015 06:30 AM, Pali Rohár wrote: > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > >>>>>This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > >>>>>and allows to compile hwmon driver without /proc/i8k file. > >>>>> > >>>>>Pali Rohár (2): > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > >>>>> hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > >>>>> > >>>>> MAINTAINERS | 4 +- > >>>>> arch/x86/Kconfig | 25 +- > >>>>> drivers/char/Makefile | 1 - > >>>>> drivers/char/i8k.c | 1005 --------------------------------------- > >>>>> drivers/hwmon/Kconfig | 11 + > >>>>> drivers/hwmon/Makefile | 1 + > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > >>>>> 7 files changed, 1049 insertions(+), 1023 deletions(-) > >>>>> delete mode 100644 drivers/char/i8k.c > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > >>>>> > >>>>I am ok with the series and would take it for 4.1 if Greg agrees. > >>>> > >>>>Greg, any comments ? > >>> > >>>Let me review it, it's in my queue... > >> > >>Hi Greg! Have you looked at it? > >> > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > I don't see it in Greg's pull request, so presumably no (unless I missed it). No, I missed it for this rc cycle, sorry. If you want to include it in yours, by all means please do so. thanks, greg k-h _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-04-21 13:52 ` Greg Kroah-Hartman 0 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-21 13:52 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck wrote: > On 04/21/2015 06:30 AM, Pali Rohár wrote: > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > >>>>>This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > >>>>>and allows to compile hwmon driver without /proc/i8k file. > >>>>> > >>>>>Pali Rohár (2): > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > >>>>> hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > >>>>> > >>>>> MAINTAINERS | 4 +- > >>>>> arch/x86/Kconfig | 25 +- > >>>>> drivers/char/Makefile | 1 - > >>>>> drivers/char/i8k.c | 1005 --------------------------------------- > >>>>> drivers/hwmon/Kconfig | 11 + > >>>>> drivers/hwmon/Makefile | 1 + > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > >>>>> 7 files changed, 1049 insertions(+), 1023 deletions(-) > >>>>> delete mode 100644 drivers/char/i8k.c > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > >>>>> > >>>>I am ok with the series and would take it for 4.1 if Greg agrees. > >>>> > >>>>Greg, any comments ? > >>> > >>>Let me review it, it's in my queue... > >> > >>Hi Greg! Have you looked at it? > >> > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > I don't see it in Greg's pull request, so presumably no (unless I missed it). No, I missed it for this rc cycle, sorry. If you want to include it in yours, by all means please do so. thanks, greg k-h ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-04-21 13:52 ` Greg Kroah-Hartman @ 2015-04-21 15:24 ` Guenter Roeck -1 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-04-21 15:24 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Tue, Apr 21, 2015 at 03:52:06PM +0200, Greg Kroah-Hartman wrote: > On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck wrote: > > On 04/21/2015 06:30 AM, Pali Rohár wrote: > > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > > >>>>>This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > > >>>>>and allows to compile hwmon driver without /proc/i8k file. > > >>>>> > > >>>>>Pali Rohár (2): > > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > >>>>> hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > >>>>> > > >>>>> MAINTAINERS | 4 +- > > >>>>> arch/x86/Kconfig | 25 +- > > >>>>> drivers/char/Makefile | 1 - > > >>>>> drivers/char/i8k.c | 1005 --------------------------------------- > > >>>>> drivers/hwmon/Kconfig | 11 + > > >>>>> drivers/hwmon/Makefile | 1 + > > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > >>>>> 7 files changed, 1049 insertions(+), 1023 deletions(-) > > >>>>> delete mode 100644 drivers/char/i8k.c > > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > >>>>> > > >>>>I am ok with the series and would take it for 4.1 if Greg agrees. > > >>>> > > >>>>Greg, any comments ? > > >>> > > >>>Let me review it, it's in my queue... > > >> > > >>Hi Greg! Have you looked at it? > > >> > > > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > > > I don't see it in Greg's pull request, so presumably no (unless I missed it). > > No, I missed it for this rc cycle, sorry. If you want to include it in > yours, by all means please do so. > Too late; I sent my pull request early last week. Also, since I don't have the patch in my queue, it would not follow my own process, and I really dislike doing that. Guenter _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-04-21 15:24 ` Guenter Roeck 0 siblings, 0 replies; 86+ messages in thread From: Guenter Roeck @ 2015-04-21 15:24 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Tue, Apr 21, 2015 at 03:52:06PM +0200, Greg Kroah-Hartman wrote: > On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck wrote: > > On 04/21/2015 06:30 AM, Pali Rohár wrote: > > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > > >>>>>This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > > >>>>>and allows to compile hwmon driver without /proc/i8k file. > > >>>>> > > >>>>>Pali Rohár (2): > > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > >>>>> hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > >>>>> > > >>>>> MAINTAINERS | 4 +- > > >>>>> arch/x86/Kconfig | 25 +- > > >>>>> drivers/char/Makefile | 1 - > > >>>>> drivers/char/i8k.c | 1005 --------------------------------------- > > >>>>> drivers/hwmon/Kconfig | 11 + > > >>>>> drivers/hwmon/Makefile | 1 + > > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > >>>>> 7 files changed, 1049 insertions(+), 1023 deletions(-) > > >>>>> delete mode 100644 drivers/char/i8k.c > > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > >>>>> > > >>>>I am ok with the series and would take it for 4.1 if Greg agrees. > > >>>> > > >>>>Greg, any comments ? > > >>> > > >>>Let me review it, it's in my queue... > > >> > > >>Hi Greg! Have you looked at it? > > >> > > > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > > > I don't see it in Greg's pull request, so presumably no (unless I missed it). > > No, I missed it for this rc cycle, sorry. If you want to include it in > yours, by all means please do so. > Too late; I sent my pull request early last week. Also, since I don't have the patch in my queue, it would not follow my own process, and I really dislike doing that. Guenter ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-04-21 15:24 ` Guenter Roeck @ 2015-04-21 15:30 ` Greg Kroah-Hartman -1 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-21 15:30 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Tue, Apr 21, 2015 at 08:24:00AM -0700, Guenter Roeck wrote: > On Tue, Apr 21, 2015 at 03:52:06PM +0200, Greg Kroah-Hartman wrote: > > On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck wrote: > > > On 04/21/2015 06:30 AM, Pali Rohár wrote: > > > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > > > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > > > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > > > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > > > >>>>>This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > > > >>>>>and allows to compile hwmon driver without /proc/i8k file. > > > >>>>> > > > >>>>>Pali Rohár (2): > > > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > > >>>>> hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > > >>>>> > > > >>>>> MAINTAINERS | 4 +- > > > >>>>> arch/x86/Kconfig | 25 +- > > > >>>>> drivers/char/Makefile | 1 - > > > >>>>> drivers/char/i8k.c | 1005 --------------------------------------- > > > >>>>> drivers/hwmon/Kconfig | 11 + > > > >>>>> drivers/hwmon/Makefile | 1 + > > > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > > >>>>> 7 files changed, 1049 insertions(+), 1023 deletions(-) > > > >>>>> delete mode 100644 drivers/char/i8k.c > > > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > >>>>> > > > >>>>I am ok with the series and would take it for 4.1 if Greg agrees. > > > >>>> > > > >>>>Greg, any comments ? > > > >>> > > > >>>Let me review it, it's in my queue... > > > >> > > > >>Hi Greg! Have you looked at it? > > > >> > > > > > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > > > > > I don't see it in Greg's pull request, so presumably no (unless I missed it). > > > > No, I missed it for this rc cycle, sorry. If you want to include it in > > yours, by all means please do so. > > > Too late; I sent my pull request early last week. Also, since I don't have > the patch in my queue, it would not follow my own process, and I really > dislike doing that. Ok, as this is "just" a rename, I'll see about doing it for -rc2, that way we avoid the merge issues. thanks, greg k-h _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-04-21 15:30 ` Greg Kroah-Hartman 0 siblings, 0 replies; 86+ messages in thread From: Greg Kroah-Hartman @ 2015-04-21 15:30 UTC (permalink / raw) To: Guenter Roeck Cc: Pali Rohár, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors On Tue, Apr 21, 2015 at 08:24:00AM -0700, Guenter Roeck wrote: > On Tue, Apr 21, 2015 at 03:52:06PM +0200, Greg Kroah-Hartman wrote: > > On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck wrote: > > > On 04/21/2015 06:30 AM, Pali Rohár wrote: > > > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > > > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman wrote: > > > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter Roeck wrote: > > > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > > > >>>>>This patch series moves drivers/char/i8k.c to drivers/hwmon/dell-smm-hwmon.c > > > >>>>>and allows to compile hwmon driver without /proc/i8k file. > > > >>>>> > > > >>>>>Pali Rohár (2): > > > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree > > > >>>>> hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k > > > >>>>> > > > >>>>> MAINTAINERS | 4 +- > > > >>>>> arch/x86/Kconfig | 25 +- > > > >>>>> drivers/char/Makefile | 1 - > > > >>>>> drivers/char/i8k.c | 1005 --------------------------------------- > > > >>>>> drivers/hwmon/Kconfig | 11 + > > > >>>>> drivers/hwmon/Makefile | 1 + > > > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 ++++++++++++++++++++++++++++++++++++++++ > > > >>>>> 7 files changed, 1049 insertions(+), 1023 deletions(-) > > > >>>>> delete mode 100644 drivers/char/i8k.c > > > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > >>>>> > > > >>>>I am ok with the series and would take it for 4.1 if Greg agrees. > > > >>>> > > > >>>>Greg, any comments ? > > > >>> > > > >>>Let me review it, it's in my queue... > > > >> > > > >>Hi Greg! Have you looked at it? > > > >> > > > > > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > > > > > I don't see it in Greg's pull request, so presumably no (unless I missed it). > > > > No, I missed it for this rc cycle, sorry. If you want to include it in > > yours, by all means please do so. > > > Too late; I sent my pull request early last week. Also, since I don't have > the patch in my queue, it would not follow my own process, and I really > dislike doing that. Ok, as this is "just" a rename, I'll see about doing it for -rc2, that way we avoid the merge issues. thanks, greg k-h ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c 2015-04-21 15:30 ` Greg Kroah-Hartman @ 2015-04-27 18:39 ` Pali Rohár -1 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-27 18:39 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1.1: Type: Text/Plain, Size: 2778 bytes --] On Tuesday 21 April 2015 17:30:16 Greg Kroah-Hartman wrote: > On Tue, Apr 21, 2015 at 08:24:00AM -0700, Guenter Roeck wrote: > > On Tue, Apr 21, 2015 at 03:52:06PM +0200, Greg Kroah-Hartman > > wrote: > > > On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck > > > wrote: > > > > On 04/21/2015 06:30 AM, Pali Rohár wrote: > > > > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > > > > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman > > > > >>wrote: > > > > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter > > > > >>>Roeck wrote: > > > > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > > > > >>>>>This patch series moves drivers/char/i8k.c to > > > > >>>>>drivers/hwmon/dell-smm-hwmon.c and allows to > > > > >>>>>compile hwmon driver without /proc/i8k file. > > > > >>>>> > > > > >>>>>Pali Rohár (2): > > > > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and > > > > >>>>> move it to hwmon tree hwmon: Allow to compile > > > > >>>>> dell-smm-hwmon driver without /proc/i8k > > > > >>>>> > > > > >>>>> MAINTAINERS | 4 +- > > > > >>>>> arch/x86/Kconfig | 25 +- > > > > >>>>> drivers/char/Makefile | 1 - > > > > >>>>> drivers/char/i8k.c | 1005 > > > > >>>>> --------------------------------------- > > > > >>>>> drivers/hwmon/Kconfig | 11 + > > > > >>>>> drivers/hwmon/Makefile | 1 + > > > > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 > > > > >>>>> ++++++++++++++++++++++++++++++++++++++++ 7 files > > > > >>>>> changed, 1049 insertions(+), 1023 deletions(-) > > > > >>>>> delete mode 100644 drivers/char/i8k.c > > > > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > > >>>> > > > > >>>>I am ok with the series and would take it for 4.1 if > > > > >>>>Greg agrees. > > > > >>>> > > > > >>>>Greg, any comments ? > > > > >>> > > > > >>>Let me review it, it's in my queue... > > > > >> > > > > >>Hi Greg! Have you looked at it? > > > > > > > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > > > > > > I don't see it in Greg's pull request, so presumably no > > > > (unless I missed it). > > > > > > No, I missed it for this rc cycle, sorry. If you want to > > > include it in yours, by all means please do so. > > > > Too late; I sent my pull request early last week. Also, > > since I don't have the patch in my queue, it would not > > follow my own process, and I really dislike doing that. > > Ok, as this is "just" a rename, I'll see about doing it for > -rc2, that way we avoid the merge issues. > > thanks, > > greg k-h Hi Greg, -rc1 was released. Do not forget to include it for -rc2 pull request. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #1.2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] [-- Attachment #2: Type: text/plain, Size: 153 bytes --] _______________________________________________ lm-sensors mailing list lm-sensors@lm-sensors.org http://lists.lm-sensors.org/mailman/listinfo/lm-sensors ^ permalink raw reply [flat|nested] 86+ messages in thread
* Re: [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c @ 2015-04-27 18:39 ` Pali Rohár 0 siblings, 0 replies; 86+ messages in thread From: Pali Rohár @ 2015-04-27 18:39 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: Guenter Roeck, Arnd Bergmann, Jean Delvare, Steven Honeyman, Valdis.Kletnieks, Jochen Eisinger, Gabriele Mazzotta, linux-kernel, lm-sensors [-- Attachment #1: Type: Text/Plain, Size: 2778 bytes --] On Tuesday 21 April 2015 17:30:16 Greg Kroah-Hartman wrote: > On Tue, Apr 21, 2015 at 08:24:00AM -0700, Guenter Roeck wrote: > > On Tue, Apr 21, 2015 at 03:52:06PM +0200, Greg Kroah-Hartman > > wrote: > > > On Tue, Apr 21, 2015 at 06:40:57AM -0700, Guenter Roeck > > > wrote: > > > > On 04/21/2015 06:30 AM, Pali Rohár wrote: > > > > >On Thursday 09 April 2015 16:02:24 Pali Rohár wrote: > > > > >>On Tuesday 31 March 2015 15:56:01 Greg Kroah-Hartman > > > > >>wrote: > > > > >>>On Mon, Mar 30, 2015 at 08:32:36PM -0700, Guenter > > > > >>>Roeck wrote: > > > > >>>>On 03/29/2015 05:57 AM, Pali Rohár wrote: > > > > >>>>>This patch series moves drivers/char/i8k.c to > > > > >>>>>drivers/hwmon/dell-smm-hwmon.c and allows to > > > > >>>>>compile hwmon driver without /proc/i8k file. > > > > >>>>> > > > > >>>>>Pali Rohár (2): > > > > >>>>> hwmon: Rename i8k driver to dell-smm-hwmon and > > > > >>>>> move it to hwmon tree hwmon: Allow to compile > > > > >>>>> dell-smm-hwmon driver without /proc/i8k > > > > >>>>> > > > > >>>>> MAINTAINERS | 4 +- > > > > >>>>> arch/x86/Kconfig | 25 +- > > > > >>>>> drivers/char/Makefile | 1 - > > > > >>>>> drivers/char/i8k.c | 1005 > > > > >>>>> --------------------------------------- > > > > >>>>> drivers/hwmon/Kconfig | 11 + > > > > >>>>> drivers/hwmon/Makefile | 1 + > > > > >>>>> drivers/hwmon/dell-smm-hwmon.c | 1025 > > > > >>>>> ++++++++++++++++++++++++++++++++++++++++ 7 files > > > > >>>>> changed, 1049 insertions(+), 1023 deletions(-) > > > > >>>>> delete mode 100644 drivers/char/i8k.c > > > > >>>>> create mode 100644 drivers/hwmon/dell-smm-hwmon.c > > > > >>>> > > > > >>>>I am ok with the series and would take it for 4.1 if > > > > >>>>Greg agrees. > > > > >>>> > > > > >>>>Greg, any comments ? > > > > >>> > > > > >>>Let me review it, it's in my queue... > > > > >> > > > > >>Hi Greg! Have you looked at it? > > > > > > > > > >Greg & Guenter: ping. Will you include it into 4.1? > > > > > > > > I don't see it in Greg's pull request, so presumably no > > > > (unless I missed it). > > > > > > No, I missed it for this rc cycle, sorry. If you want to > > > include it in yours, by all means please do so. > > > > Too late; I sent my pull request early last week. Also, > > since I don't have the patch in my queue, it would not > > follow my own process, and I really dislike doing that. > > Ok, as this is "just" a rename, I'll see about doing it for > -rc2, that way we avoid the merge issues. > > thanks, > > greg k-h Hi Greg, -rc1 was released. Do not forget to include it for -rc2 pull request. -- Pali Rohár pali.rohar@gmail.com [-- Attachment #2: This is a digitally signed message part. --] [-- Type: application/pgp-signature, Size: 198 bytes --] ^ permalink raw reply [flat|nested] 86+ messages in thread
end of thread, other threads:[~2015-06-27 13:22 UTC | newest] Thread overview: 86+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2015-03-28 10:24 [lm-sensors] [PATCH 0/2] i8k.c => dell-smm-hwmon.c Pali Rohár 2015-03-28 10:24 ` Pali Rohár 2015-03-28 10:24 ` [lm-sensors] [PATCH 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree Pali Rohár 2015-03-28 10:24 ` Pali Rohár 2015-03-28 14:31 ` [lm-sensors] " Guenter Roeck 2015-03-28 14:31 ` Guenter Roeck 2015-03-28 10:24 ` [lm-sensors] [PATCH 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k Pali Rohár 2015-03-28 10:24 ` Pali Rohár 2015-03-28 11:04 ` [lm-sensors] " Paul Bolle 2015-03-28 11:04 ` Paul Bolle 2015-03-28 12:54 ` [lm-sensors] " Steven Honeyman 2015-03-28 12:54 ` Steven Honeyman 2015-03-28 14:13 ` [lm-sensors] " Guenter Roeck 2015-03-28 14:13 ` Guenter Roeck 2015-03-28 22:00 ` [lm-sensors] " Pali Rohár 2015-03-28 22:00 ` Pali Rohár 2015-03-28 22:20 ` [lm-sensors] " Guenter Roeck 2015-03-28 22:20 ` Guenter Roeck 2015-03-28 22:44 ` [lm-sensors] " Paul Bolle 2015-03-28 22:44 ` Paul Bolle 2015-03-29 0:55 ` [lm-sensors] " Guenter Roeck 2015-03-29 0:55 ` Guenter Roeck 2015-03-30 8:01 ` [lm-sensors] " Paul Bolle 2015-03-30 8:01 ` Paul Bolle 2015-03-28 21:55 ` [lm-sensors] " Pali Rohár 2015-03-28 21:55 ` Pali Rohár 2015-03-28 22:06 ` [lm-sensors] " Paul Bolle 2015-03-28 22:06 ` Paul Bolle 2015-03-28 22:19 ` [lm-sensors] " Steven Honeyman 2015-03-28 22:19 ` Steven Honeyman 2015-03-28 22:33 ` [lm-sensors] " Pali Rohár 2015-03-28 22:33 ` Pali Rohár 2015-03-30 7:44 ` [lm-sensors] " Jean Delvare 2015-03-30 7:44 ` Jean Delvare 2015-03-28 14:23 ` [lm-sensors] " Guenter Roeck 2015-03-28 14:23 ` Guenter Roeck 2015-03-28 22:04 ` [lm-sensors] " Pali Rohár 2015-03-28 22:04 ` Pali Rohár 2015-03-29 12:57 ` [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c Pali Rohár 2015-03-29 12:57 ` Pali Rohár 2015-03-29 12:57 ` [lm-sensors] [PATCH v2 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree Pali Rohár 2015-03-29 12:57 ` Pali Rohár 2015-03-29 12:57 ` [lm-sensors] [PATCH v2 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k Pali Rohár 2015-03-29 12:57 ` Pali Rohár 2015-04-28 12:38 ` [lm-sensors] " Greg Kroah-Hartman 2015-04-28 12:38 ` Greg Kroah-Hartman 2015-04-29 11:41 ` [lm-sensors] [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree Pali Rohár 2015-04-29 11:41 ` Pali Rohár 2015-04-29 11:41 ` [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k Pali Rohár 2015-04-29 11:41 ` Pali Rohár 2015-06-27 11:34 ` [lm-sensors] " Gabriele Mazzotta 2015-06-27 11:34 ` Gabriele Mazzotta 2015-06-27 12:47 ` [lm-sensors] " Pali Rohár 2015-06-27 12:47 ` Pali Rohár 2015-06-27 12:55 ` [lm-sensors] " Gabriele Mazzotta 2015-06-27 12:55 ` Gabriele Mazzotta 2015-06-27 13:01 ` [lm-sensors] " Pali Rohár 2015-06-27 13:01 ` Pali Rohár 2015-06-27 13:21 ` [lm-sensors] " Gabriele Mazzotta 2015-06-27 13:21 ` Gabriele Mazzotta 2015-04-29 12:07 ` [lm-sensors] [PATCH v3 1/2] hwmon: Rename i8k driver to dell-smm-hwmon and move it to hwmon tree Greg Kroah-Hartman 2015-04-29 12:07 ` Greg Kroah-Hartman 2015-05-14 11:16 ` [lm-sensors] " Pali Rohár 2015-05-14 11:16 ` Pali Rohár 2015-05-14 11:16 ` [lm-sensors] [PATCH v3 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k Pali Rohár 2015-05-14 11:16 ` Pali Rohár 2015-05-21 11:42 ` [lm-sensors] " Pali Rohár 2015-05-21 11:42 ` Pali Rohár 2015-03-31 3:32 ` [lm-sensors] [PATCH v2 0/2] i8k.c => dell-smm-hwmon.c Guenter Roeck 2015-03-31 3:32 ` Guenter Roeck 2015-03-31 13:56 ` [lm-sensors] " Greg Kroah-Hartman 2015-03-31 13:56 ` Greg Kroah-Hartman 2015-04-09 14:02 ` [lm-sensors] " Pali Rohár 2015-04-09 14:02 ` Pali Rohár 2015-04-21 13:30 ` [lm-sensors] " Pali Rohár 2015-04-21 13:30 ` Pali Rohár 2015-04-21 13:40 ` [lm-sensors] " Guenter Roeck 2015-04-21 13:40 ` Guenter Roeck 2015-04-21 13:52 ` [lm-sensors] " Greg Kroah-Hartman 2015-04-21 13:52 ` Greg Kroah-Hartman 2015-04-21 15:24 ` [lm-sensors] " Guenter Roeck 2015-04-21 15:24 ` Guenter Roeck 2015-04-21 15:30 ` [lm-sensors] " Greg Kroah-Hartman 2015-04-21 15:30 ` Greg Kroah-Hartman 2015-04-27 18:39 ` [lm-sensors] " Pali Rohár 2015-04-27 18:39 ` Pali Rohár
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.