From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Pali=20Roh=C3=A1r?= Date: Sun, 29 Mar 2015 12:57:39 +0000 Subject: [lm-sensors] [PATCH v2 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k Message-Id: <1427633859-18596-3-git-send-email-pali.rohar@gmail.com> List-Id: References: <1427538255-10860-1-git-send-email-pali.rohar@gmail.com> <1427633859-18596-1-git-send-email-pali.rohar@gmail.com> In-Reply-To: <1427633859-18596-1-git-send-email-pali.rohar@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: Guenter Roeck , Arnd Bergmann , Greg Kroah-Hartman , Jean Delvare Cc: Steven Honeyman , Valdis.Kletnieks@vt.edu, Jochen Eisinger , Gabriele Mazzotta , linux-kernel@vger.kernel.org, lm-sensors@lm-sensors.org, =?UTF-8?q?Pali=20Roh=C3=A1r?= 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= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752853AbbC2M6R (ORCPT ); Sun, 29 Mar 2015 08:58:17 -0400 Received: from mail-wi0-f171.google.com ([209.85.212.171]:38542 "EHLO mail-wi0-f171.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752709AbbC2M6F (ORCPT ); Sun, 29 Mar 2015 08:58:05 -0400 From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Guenter Roeck , Arnd Bergmann , "Greg Kroah-Hartman" , Jean Delvare Cc: Steven Honeyman , Valdis.Kletnieks@vt.edu, Jochen Eisinger , Gabriele Mazzotta , linux-kernel@vger.kernel.org, lm-sensors@lm-sensors.org, =?UTF-8?q?Pali=20Roh=C3=A1r?= Subject: [PATCH v2 2/2] hwmon: Allow to compile dell-smm-hwmon driver without /proc/i8k Date: Sun, 29 Mar 2015 14:57:39 +0200 Message-Id: <1427633859-18596-3-git-send-email-pali.rohar@gmail.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1427633859-18596-1-git-send-email-pali.rohar@gmail.com> References: <1427538255-10860-1-git-send-email-pali.rohar@gmail.com> <1427633859-18596-1-git-send-email-pali.rohar@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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 --- 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: - - - 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 "); -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