acerhdf.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * acerhdf - A driver which monitors the temperature
  4. * of the aspire one netbook, turns on/off the fan
  5. * as soon as the upper/lower threshold is reached.
  6. *
  7. * (C) 2009 - Peter Kaestle peter (a) piie.net
  8. * https://piie.net
  9. * 2009 Borislav Petkov bp (a) alien8.de
  10. *
  11. * Inspired by and many thanks to:
  12. * o acerfand - Rachel Greenham
  13. * o acer_ec.pl - Michael Kurz michi.kurz (at) googlemail.com
  14. * - Petr Tomasek tomasek (#) etf,cuni,cz
  15. * - Carlos Corbacho cathectic (at) gmail.com
  16. * o lkml - Matthew Garrett
  17. * - Borislav Petkov
  18. * - Andreas Mohr
  19. */
  20. #define pr_fmt(fmt) "acerhdf: " fmt
  21. #include <linux/kernel.h>
  22. #include <linux/module.h>
  23. #include <linux/dmi.h>
  24. #include <linux/acpi.h>
  25. #include <linux/thermal.h>
  26. #include <linux/platform_device.h>
  27. /*
  28. * The driver is started with "kernel mode off" by default. That means, the BIOS
  29. * is still in control of the fan. In this mode the driver allows to read the
  30. * temperature of the cpu and a userspace tool may take over control of the fan.
  31. * If the driver is switched to "kernel mode" (e.g. via module parameter) the
  32. * driver is in full control of the fan. If you want the module to be started in
  33. * kernel mode by default, define the following:
  34. */
  35. #undef START_IN_KERNEL_MODE
  36. #define DRV_VER "0.7.0"
  37. /*
  38. * According to the Atom N270 datasheet,
  39. * (http://download.intel.com/design/processor/datashts/320032.pdf) the
  40. * CPU's optimal operating limits denoted in junction temperature as
  41. * measured by the on-die thermal monitor are within 0 <= Tj <= 90. So,
  42. * assume 89°C is critical temperature.
  43. */
  44. #define ACERHDF_TEMP_CRIT 89000
  45. #define ACERHDF_FAN_OFF 0
  46. #define ACERHDF_FAN_AUTO 1
  47. /*
  48. * No matter what value the user puts into the fanon variable, turn on the fan
  49. * at 80 degree Celsius to prevent hardware damage
  50. */
  51. #define ACERHDF_MAX_FANON 80000
  52. /*
  53. * Maximum interval between two temperature checks is 15 seconds, as the die
  54. * can get hot really fast under heavy load (plus we shouldn't forget about
  55. * possible impact of _external_ aggressive sources such as heaters, sun etc.)
  56. */
  57. #define ACERHDF_MAX_INTERVAL 15
  58. #ifdef START_IN_KERNEL_MODE
  59. static int kernelmode = 1;
  60. #else
  61. static int kernelmode;
  62. #endif
  63. static unsigned int interval = 10;
  64. static unsigned int fanon = 60000;
  65. static unsigned int fanoff = 53000;
  66. static unsigned int verbose;
  67. static unsigned int list_supported;
  68. static unsigned int fanstate = ACERHDF_FAN_AUTO;
  69. static char force_bios[16];
  70. static char force_product[16];
  71. static unsigned int prev_interval;
  72. static struct thermal_zone_device *thz_dev;
  73. static struct thermal_cooling_device *cl_dev;
  74. static struct platform_device *acerhdf_dev;
  75. module_param(kernelmode, uint, 0);
  76. MODULE_PARM_DESC(kernelmode, "Kernel mode fan control on / off");
  77. module_param(interval, uint, 0600);
  78. MODULE_PARM_DESC(interval, "Polling interval of temperature check");
  79. module_param(fanon, uint, 0600);
  80. MODULE_PARM_DESC(fanon, "Turn the fan on above this temperature");
  81. module_param(fanoff, uint, 0600);
  82. MODULE_PARM_DESC(fanoff, "Turn the fan off below this temperature");
  83. module_param(verbose, uint, 0600);
  84. MODULE_PARM_DESC(verbose, "Enable verbose dmesg output");
  85. module_param(list_supported, uint, 0600);
  86. MODULE_PARM_DESC(list_supported, "List supported models and BIOS versions");
  87. module_param_string(force_bios, force_bios, 16, 0);
  88. MODULE_PARM_DESC(force_bios, "Pretend system has this known supported BIOS version");
  89. module_param_string(force_product, force_product, 16, 0);
  90. MODULE_PARM_DESC(force_product, "Pretend system is this known supported model");
  91. /*
  92. * cmd_off: to switch the fan completely off and check if the fan is off
  93. * cmd_auto: to set the BIOS in control of the fan. The BIOS regulates then
  94. * the fan speed depending on the temperature
  95. */
  96. struct fancmd {
  97. u8 cmd_off;
  98. u8 cmd_auto;
  99. };
  100. struct manualcmd {
  101. u8 mreg;
  102. u8 moff;
  103. };
  104. /* default register and command to disable fan in manual mode */
  105. static const struct manualcmd mcmd = {
  106. .mreg = 0x94,
  107. .moff = 0xff,
  108. };
  109. /* BIOS settings - only used during probe */
  110. struct bios_settings {
  111. const char *vendor;
  112. const char *product;
  113. const char *version;
  114. u8 fanreg;
  115. u8 tempreg;
  116. struct fancmd cmd;
  117. int mcmd_enable;
  118. };
  119. /* This could be a daughter struct in the above, but not worth the redirect */
  120. struct ctrl_settings {
  121. u8 fanreg;
  122. u8 tempreg;
  123. struct fancmd cmd;
  124. int mcmd_enable;
  125. };
  126. static struct ctrl_settings ctrl_cfg __read_mostly;
  127. /* Register addresses and values for different BIOS versions */
  128. static const struct bios_settings bios_tbl[] __initconst = {
  129. /* AOA110 */
  130. {"Acer", "AOA110", "v0.3109", 0x55, 0x58, {0x1f, 0x00}, 0},
  131. {"Acer", "AOA110", "v0.3114", 0x55, 0x58, {0x1f, 0x00}, 0},
  132. {"Acer", "AOA110", "v0.3301", 0x55, 0x58, {0xaf, 0x00}, 0},
  133. {"Acer", "AOA110", "v0.3304", 0x55, 0x58, {0xaf, 0x00}, 0},
  134. {"Acer", "AOA110", "v0.3305", 0x55, 0x58, {0xaf, 0x00}, 0},
  135. {"Acer", "AOA110", "v0.3307", 0x55, 0x58, {0xaf, 0x00}, 0},
  136. {"Acer", "AOA110", "v0.3308", 0x55, 0x58, {0x21, 0x00}, 0},
  137. {"Acer", "AOA110", "v0.3309", 0x55, 0x58, {0x21, 0x00}, 0},
  138. {"Acer", "AOA110", "v0.3310", 0x55, 0x58, {0x21, 0x00}, 0},
  139. /* AOA150 */
  140. {"Acer", "AOA150", "v0.3114", 0x55, 0x58, {0x1f, 0x00}, 0},
  141. {"Acer", "AOA150", "v0.3301", 0x55, 0x58, {0x20, 0x00}, 0},
  142. {"Acer", "AOA150", "v0.3304", 0x55, 0x58, {0x20, 0x00}, 0},
  143. {"Acer", "AOA150", "v0.3305", 0x55, 0x58, {0x20, 0x00}, 0},
  144. {"Acer", "AOA150", "v0.3307", 0x55, 0x58, {0x20, 0x00}, 0},
  145. {"Acer", "AOA150", "v0.3308", 0x55, 0x58, {0x20, 0x00}, 0},
  146. {"Acer", "AOA150", "v0.3309", 0x55, 0x58, {0x20, 0x00}, 0},
  147. {"Acer", "AOA150", "v0.3310", 0x55, 0x58, {0x20, 0x00}, 0},
  148. /* LT1005u */
  149. {"Acer", "LT-10Q", "v0.3310", 0x55, 0x58, {0x20, 0x00}, 0},
  150. /* Acer 1410 */
  151. {"Acer", "Aspire 1410", "v0.3108", 0x55, 0x58, {0x9e, 0x00}, 0},
  152. {"Acer", "Aspire 1410", "v0.3113", 0x55, 0x58, {0x9e, 0x00}, 0},
  153. {"Acer", "Aspire 1410", "v0.3115", 0x55, 0x58, {0x9e, 0x00}, 0},
  154. {"Acer", "Aspire 1410", "v0.3117", 0x55, 0x58, {0x9e, 0x00}, 0},
  155. {"Acer", "Aspire 1410", "v0.3119", 0x55, 0x58, {0x9e, 0x00}, 0},
  156. {"Acer", "Aspire 1410", "v0.3120", 0x55, 0x58, {0x9e, 0x00}, 0},
  157. {"Acer", "Aspire 1410", "v1.3204", 0x55, 0x58, {0x9e, 0x00}, 0},
  158. {"Acer", "Aspire 1410", "v1.3303", 0x55, 0x58, {0x9e, 0x00}, 0},
  159. {"Acer", "Aspire 1410", "v1.3308", 0x55, 0x58, {0x9e, 0x00}, 0},
  160. {"Acer", "Aspire 1410", "v1.3310", 0x55, 0x58, {0x9e, 0x00}, 0},
  161. {"Acer", "Aspire 1410", "v1.3314", 0x55, 0x58, {0x9e, 0x00}, 0},
  162. /* Acer 1810xx */
  163. {"Acer", "Aspire 1810TZ", "v0.3108", 0x55, 0x58, {0x9e, 0x00}, 0},
  164. {"Acer", "Aspire 1810T", "v0.3108", 0x55, 0x58, {0x9e, 0x00}, 0},
  165. {"Acer", "Aspire 1810TZ", "v0.3113", 0x55, 0x58, {0x9e, 0x00}, 0},
  166. {"Acer", "Aspire 1810T", "v0.3113", 0x55, 0x58, {0x9e, 0x00}, 0},
  167. {"Acer", "Aspire 1810TZ", "v0.3115", 0x55, 0x58, {0x9e, 0x00}, 0},
  168. {"Acer", "Aspire 1810T", "v0.3115", 0x55, 0x58, {0x9e, 0x00}, 0},
  169. {"Acer", "Aspire 1810TZ", "v0.3117", 0x55, 0x58, {0x9e, 0x00}, 0},
  170. {"Acer", "Aspire 1810T", "v0.3117", 0x55, 0x58, {0x9e, 0x00}, 0},
  171. {"Acer", "Aspire 1810TZ", "v0.3119", 0x55, 0x58, {0x9e, 0x00}, 0},
  172. {"Acer", "Aspire 1810T", "v0.3119", 0x55, 0x58, {0x9e, 0x00}, 0},
  173. {"Acer", "Aspire 1810TZ", "v0.3120", 0x55, 0x58, {0x9e, 0x00}, 0},
  174. {"Acer", "Aspire 1810T", "v0.3120", 0x55, 0x58, {0x9e, 0x00}, 0},
  175. {"Acer", "Aspire 1810TZ", "v1.3204", 0x55, 0x58, {0x9e, 0x00}, 0},
  176. {"Acer", "Aspire 1810T", "v1.3204", 0x55, 0x58, {0x9e, 0x00}, 0},
  177. {"Acer", "Aspire 1810TZ", "v1.3303", 0x55, 0x58, {0x9e, 0x00}, 0},
  178. {"Acer", "Aspire 1810T", "v1.3303", 0x55, 0x58, {0x9e, 0x00}, 0},
  179. {"Acer", "Aspire 1810TZ", "v1.3308", 0x55, 0x58, {0x9e, 0x00}, 0},
  180. {"Acer", "Aspire 1810T", "v1.3308", 0x55, 0x58, {0x9e, 0x00}, 0},
  181. {"Acer", "Aspire 1810TZ", "v1.3310", 0x55, 0x58, {0x9e, 0x00}, 0},
  182. {"Acer", "Aspire 1810T", "v1.3310", 0x55, 0x58, {0x9e, 0x00}, 0},
  183. {"Acer", "Aspire 1810TZ", "v1.3314", 0x55, 0x58, {0x9e, 0x00}, 0},
  184. {"Acer", "Aspire 1810T", "v1.3314", 0x55, 0x58, {0x9e, 0x00}, 0},
  185. /* Acer 5755G */
  186. {"Acer", "Aspire 5755G", "V1.20", 0xab, 0xb4, {0x00, 0x08}, 0},
  187. {"Acer", "Aspire 5755G", "V1.21", 0xab, 0xb3, {0x00, 0x08}, 0},
  188. /* Acer 521 */
  189. {"Acer", "AO521", "V1.11", 0x55, 0x58, {0x1f, 0x00}, 0},
  190. /* Acer 531 */
  191. {"Acer", "AO531h", "v0.3104", 0x55, 0x58, {0x20, 0x00}, 0},
  192. {"Acer", "AO531h", "v0.3201", 0x55, 0x58, {0x20, 0x00}, 0},
  193. {"Acer", "AO531h", "v0.3304", 0x55, 0x58, {0x20, 0x00}, 0},
  194. /* Acer 751 */
  195. {"Acer", "AO751h", "V0.3206", 0x55, 0x58, {0x21, 0x00}, 0},
  196. {"Acer", "AO751h", "V0.3212", 0x55, 0x58, {0x21, 0x00}, 0},
  197. /* Acer 753 */
  198. {"Acer", "Aspire One 753", "V1.24", 0x93, 0xac, {0x14, 0x04}, 1},
  199. /* Acer 1825 */
  200. {"Acer", "Aspire 1825PTZ", "V1.3118", 0x55, 0x58, {0x9e, 0x00}, 0},
  201. {"Acer", "Aspire 1825PTZ", "V1.3127", 0x55, 0x58, {0x9e, 0x00}, 0},
  202. /* Acer Extensa 5420 */
  203. {"Acer", "Extensa 5420", "V1.17", 0x93, 0xac, {0x14, 0x04}, 1},
  204. /* Acer Aspire 5315 */
  205. {"Acer", "Aspire 5315", "V1.19", 0x93, 0xac, {0x14, 0x04}, 1},
  206. /* Acer Aspire 5739 */
  207. {"Acer", "Aspire 5739G", "V1.3311", 0x55, 0x58, {0x20, 0x00}, 0},
  208. /* Acer TravelMate 7730 */
  209. {"Acer", "TravelMate 7730G", "v0.3509", 0x55, 0x58, {0xaf, 0x00}, 0},
  210. /* Acer Aspire 7551 */
  211. {"Acer", "Aspire 7551", "V1.18", 0x93, 0xa8, {0x14, 0x04}, 1},
  212. /* Acer TravelMate TM8573T */
  213. {"Acer", "TM8573T", "V1.13", 0x93, 0xa8, {0x14, 0x04}, 1},
  214. /* Gateway */
  215. {"Gateway", "AOA110", "v0.3103", 0x55, 0x58, {0x21, 0x00}, 0},
  216. {"Gateway", "AOA150", "v0.3103", 0x55, 0x58, {0x20, 0x00}, 0},
  217. {"Gateway", "LT31", "v1.3103", 0x55, 0x58, {0x9e, 0x00}, 0},
  218. {"Gateway", "LT31", "v1.3201", 0x55, 0x58, {0x9e, 0x00}, 0},
  219. {"Gateway", "LT31", "v1.3302", 0x55, 0x58, {0x9e, 0x00}, 0},
  220. {"Gateway", "LT31", "v1.3303t", 0x55, 0x58, {0x9e, 0x00}, 0},
  221. {"Gateway", "LT31", "v1.3307", 0x55, 0x58, {0x9e, 0x00}, 0},
  222. /* Packard Bell */
  223. {"Packard Bell", "DOA150", "v0.3104", 0x55, 0x58, {0x21, 0x00}, 0},
  224. {"Packard Bell", "DOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00}, 0},
  225. {"Packard Bell", "AOA110", "v0.3105", 0x55, 0x58, {0x21, 0x00}, 0},
  226. {"Packard Bell", "AOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00}, 0},
  227. {"Packard Bell", "ENBFT", "V1.3118", 0x55, 0x58, {0x9e, 0x00}, 0},
  228. {"Packard Bell", "ENBFT", "V1.3127", 0x55, 0x58, {0x9e, 0x00}, 0},
  229. {"Packard Bell", "DOTMU", "v1.3303", 0x55, 0x58, {0x9e, 0x00}, 0},
  230. {"Packard Bell", "DOTMU", "v0.3120", 0x55, 0x58, {0x9e, 0x00}, 0},
  231. {"Packard Bell", "DOTMU", "v0.3108", 0x55, 0x58, {0x9e, 0x00}, 0},
  232. {"Packard Bell", "DOTMU", "v0.3113", 0x55, 0x58, {0x9e, 0x00}, 0},
  233. {"Packard Bell", "DOTMU", "v0.3115", 0x55, 0x58, {0x9e, 0x00}, 0},
  234. {"Packard Bell", "DOTMU", "v0.3117", 0x55, 0x58, {0x9e, 0x00}, 0},
  235. {"Packard Bell", "DOTMU", "v0.3119", 0x55, 0x58, {0x9e, 0x00}, 0},
  236. {"Packard Bell", "DOTMU", "v1.3204", 0x55, 0x58, {0x9e, 0x00}, 0},
  237. {"Packard Bell", "DOTMA", "v1.3201", 0x55, 0x58, {0x9e, 0x00}, 0},
  238. {"Packard Bell", "DOTMA", "v1.3302", 0x55, 0x58, {0x9e, 0x00}, 0},
  239. {"Packard Bell", "DOTMA", "v1.3303t", 0x55, 0x58, {0x9e, 0x00}, 0},
  240. {"Packard Bell", "DOTVR46", "v1.3308", 0x55, 0x58, {0x9e, 0x00}, 0},
  241. /* pewpew-terminator */
  242. {"", "", "", 0, 0, {0, 0}, 0}
  243. };
  244. /*
  245. * this struct is used to instruct thermal layer to use bang_bang instead of
  246. * default governor for acerhdf
  247. */
  248. static struct thermal_zone_params acerhdf_zone_params = {
  249. .governor_name = "bang_bang",
  250. };
  251. static int acerhdf_get_temp(int *temp)
  252. {
  253. u8 read_temp;
  254. if (ec_read(ctrl_cfg.tempreg, &read_temp))
  255. return -EINVAL;
  256. *temp = read_temp * 1000;
  257. return 0;
  258. }
  259. static int acerhdf_get_fanstate(int *state)
  260. {
  261. u8 fan;
  262. if (ec_read(ctrl_cfg.fanreg, &fan))
  263. return -EINVAL;
  264. if (fan != ctrl_cfg.cmd.cmd_off)
  265. *state = ACERHDF_FAN_AUTO;
  266. else
  267. *state = ACERHDF_FAN_OFF;
  268. return 0;
  269. }
  270. static void acerhdf_change_fanstate(int state)
  271. {
  272. unsigned char cmd;
  273. if (verbose)
  274. pr_notice("fan %s\n", state == ACERHDF_FAN_OFF ? "OFF" : "ON");
  275. if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
  276. pr_err("invalid fan state %d requested, setting to auto!\n",
  277. state);
  278. state = ACERHDF_FAN_AUTO;
  279. }
  280. cmd = (state == ACERHDF_FAN_OFF) ? ctrl_cfg.cmd.cmd_off
  281. : ctrl_cfg.cmd.cmd_auto;
  282. fanstate = state;
  283. ec_write(ctrl_cfg.fanreg, cmd);
  284. if (ctrl_cfg.mcmd_enable && state == ACERHDF_FAN_OFF) {
  285. if (verbose)
  286. pr_notice("turning off fan manually\n");
  287. ec_write(mcmd.mreg, mcmd.moff);
  288. }
  289. }
  290. static void acerhdf_check_param(struct thermal_zone_device *thermal)
  291. {
  292. if (fanon > ACERHDF_MAX_FANON) {
  293. pr_err("fanon temperature too high, set to %d\n",
  294. ACERHDF_MAX_FANON);
  295. fanon = ACERHDF_MAX_FANON;
  296. }
  297. if (kernelmode && prev_interval != interval) {
  298. if (interval > ACERHDF_MAX_INTERVAL) {
  299. pr_err("interval too high, set to %d\n",
  300. ACERHDF_MAX_INTERVAL);
  301. interval = ACERHDF_MAX_INTERVAL;
  302. }
  303. if (verbose)
  304. pr_notice("interval changed to: %d\n", interval);
  305. thermal->polling_delay = interval*1000;
  306. prev_interval = interval;
  307. }
  308. }
  309. /*
  310. * This is the thermal zone callback which does the delayed polling of the fan
  311. * state. We do check /sysfs-originating settings here in acerhdf_check_param()
  312. * as late as the polling interval is since we can't do that in the respective
  313. * accessors of the module parameters.
  314. */
  315. static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal, int *t)
  316. {
  317. int temp, err = 0;
  318. acerhdf_check_param(thermal);
  319. err = acerhdf_get_temp(&temp);
  320. if (err)
  321. return err;
  322. if (verbose)
  323. pr_notice("temp %d\n", temp);
  324. *t = temp;
  325. return 0;
  326. }
  327. static int acerhdf_bind(struct thermal_zone_device *thermal,
  328. struct thermal_cooling_device *cdev)
  329. {
  330. /* if the cooling device is the one from acerhdf bind it */
  331. if (cdev != cl_dev)
  332. return 0;
  333. if (thermal_zone_bind_cooling_device(thermal, 0, cdev,
  334. THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
  335. THERMAL_WEIGHT_DEFAULT)) {
  336. pr_err("error binding cooling dev\n");
  337. return -EINVAL;
  338. }
  339. return 0;
  340. }
  341. static int acerhdf_unbind(struct thermal_zone_device *thermal,
  342. struct thermal_cooling_device *cdev)
  343. {
  344. if (cdev != cl_dev)
  345. return 0;
  346. if (thermal_zone_unbind_cooling_device(thermal, 0, cdev)) {
  347. pr_err("error unbinding cooling dev\n");
  348. return -EINVAL;
  349. }
  350. return 0;
  351. }
  352. static inline void acerhdf_revert_to_bios_mode(void)
  353. {
  354. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  355. kernelmode = 0;
  356. pr_notice("kernel mode fan control OFF\n");
  357. }
  358. static inline void acerhdf_enable_kernelmode(void)
  359. {
  360. kernelmode = 1;
  361. pr_notice("kernel mode fan control ON\n");
  362. }
  363. /*
  364. * set operation mode;
  365. * enabled: the thermal layer of the kernel takes care about
  366. * the temperature and the fan.
  367. * disabled: the BIOS takes control of the fan.
  368. */
  369. static int acerhdf_change_mode(struct thermal_zone_device *thermal,
  370. enum thermal_device_mode mode)
  371. {
  372. if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
  373. acerhdf_revert_to_bios_mode();
  374. else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
  375. acerhdf_enable_kernelmode();
  376. return 0;
  377. }
  378. static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
  379. enum thermal_trip_type *type)
  380. {
  381. if (trip == 0)
  382. *type = THERMAL_TRIP_ACTIVE;
  383. else if (trip == 1)
  384. *type = THERMAL_TRIP_CRITICAL;
  385. else
  386. return -EINVAL;
  387. return 0;
  388. }
  389. static int acerhdf_get_trip_hyst(struct thermal_zone_device *thermal, int trip,
  390. int *temp)
  391. {
  392. if (trip != 0)
  393. return -EINVAL;
  394. *temp = fanon - fanoff;
  395. return 0;
  396. }
  397. static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
  398. int *temp)
  399. {
  400. if (trip == 0)
  401. *temp = fanon;
  402. else if (trip == 1)
  403. *temp = ACERHDF_TEMP_CRIT;
  404. else
  405. return -EINVAL;
  406. return 0;
  407. }
  408. static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
  409. int *temperature)
  410. {
  411. *temperature = ACERHDF_TEMP_CRIT;
  412. return 0;
  413. }
  414. /* bind callback functions to thermalzone */
  415. static struct thermal_zone_device_ops acerhdf_dev_ops = {
  416. .bind = acerhdf_bind,
  417. .unbind = acerhdf_unbind,
  418. .get_temp = acerhdf_get_ec_temp,
  419. .change_mode = acerhdf_change_mode,
  420. .get_trip_type = acerhdf_get_trip_type,
  421. .get_trip_hyst = acerhdf_get_trip_hyst,
  422. .get_trip_temp = acerhdf_get_trip_temp,
  423. .get_crit_temp = acerhdf_get_crit_temp,
  424. };
  425. /*
  426. * cooling device callback functions
  427. * get maximal fan cooling state
  428. */
  429. static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
  430. unsigned long *state)
  431. {
  432. *state = 1;
  433. return 0;
  434. }
  435. static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
  436. unsigned long *state)
  437. {
  438. int err = 0, tmp;
  439. err = acerhdf_get_fanstate(&tmp);
  440. if (err)
  441. return err;
  442. *state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
  443. return 0;
  444. }
  445. /* change current fan state - is overwritten when running in kernel mode */
  446. static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
  447. unsigned long state)
  448. {
  449. int cur_temp, cur_state, err = 0;
  450. if (!kernelmode)
  451. return 0;
  452. err = acerhdf_get_temp(&cur_temp);
  453. if (err) {
  454. pr_err("error reading temperature, hand off control to BIOS\n");
  455. goto err_out;
  456. }
  457. err = acerhdf_get_fanstate(&cur_state);
  458. if (err) {
  459. pr_err("error reading fan state, hand off control to BIOS\n");
  460. goto err_out;
  461. }
  462. if (state == 0) {
  463. if (cur_state == ACERHDF_FAN_AUTO)
  464. acerhdf_change_fanstate(ACERHDF_FAN_OFF);
  465. } else {
  466. if (cur_state == ACERHDF_FAN_OFF)
  467. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  468. }
  469. return 0;
  470. err_out:
  471. acerhdf_revert_to_bios_mode();
  472. return -EINVAL;
  473. }
  474. /* bind fan callbacks to fan device */
  475. static const struct thermal_cooling_device_ops acerhdf_cooling_ops = {
  476. .get_max_state = acerhdf_get_max_state,
  477. .get_cur_state = acerhdf_get_cur_state,
  478. .set_cur_state = acerhdf_set_cur_state,
  479. };
  480. /* suspend / resume functionality */
  481. static int acerhdf_suspend(struct device *dev)
  482. {
  483. if (kernelmode)
  484. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  485. if (verbose)
  486. pr_notice("going suspend\n");
  487. return 0;
  488. }
  489. static int acerhdf_probe(struct platform_device *device)
  490. {
  491. return 0;
  492. }
  493. static int acerhdf_remove(struct platform_device *device)
  494. {
  495. return 0;
  496. }
  497. static const struct dev_pm_ops acerhdf_pm_ops = {
  498. .suspend = acerhdf_suspend,
  499. .freeze = acerhdf_suspend,
  500. };
  501. static struct platform_driver acerhdf_driver = {
  502. .driver = {
  503. .name = "acerhdf",
  504. .pm = &acerhdf_pm_ops,
  505. },
  506. .probe = acerhdf_probe,
  507. .remove = acerhdf_remove,
  508. };
  509. /* checks if str begins with start */
  510. static int str_starts_with(const char *str, const char *start)
  511. {
  512. unsigned long str_len = 0, start_len = 0;
  513. str_len = strlen(str);
  514. start_len = strlen(start);
  515. if (str_len >= start_len &&
  516. !strncmp(str, start, start_len))
  517. return 1;
  518. return 0;
  519. }
  520. /* check hardware */
  521. static int __init acerhdf_check_hardware(void)
  522. {
  523. char const *vendor, *version, *product;
  524. const struct bios_settings *bt = NULL;
  525. int found = 0;
  526. /* get BIOS data */
  527. vendor = dmi_get_system_info(DMI_SYS_VENDOR);
  528. version = dmi_get_system_info(DMI_BIOS_VERSION);
  529. product = dmi_get_system_info(DMI_PRODUCT_NAME);
  530. if (!vendor || !version || !product) {
  531. pr_err("error getting hardware information\n");
  532. return -EINVAL;
  533. }
  534. pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
  535. if (list_supported) {
  536. pr_info("List of supported Manufacturer/Model/BIOS:\n");
  537. pr_info("---------------------------------------------------\n");
  538. for (bt = bios_tbl; bt->vendor[0]; bt++) {
  539. pr_info("%-13s | %-17s | %-10s\n", bt->vendor,
  540. bt->product, bt->version);
  541. }
  542. pr_info("---------------------------------------------------\n");
  543. return -ECANCELED;
  544. }
  545. if (force_bios[0]) {
  546. version = force_bios;
  547. pr_info("forcing BIOS version: %s\n", version);
  548. kernelmode = 0;
  549. }
  550. if (force_product[0]) {
  551. product = force_product;
  552. pr_info("forcing BIOS product: %s\n", product);
  553. kernelmode = 0;
  554. }
  555. if (verbose)
  556. pr_info("BIOS info: %s %s, product: %s\n",
  557. vendor, version, product);
  558. /* search BIOS version and vendor in BIOS settings table */
  559. for (bt = bios_tbl; bt->vendor[0]; bt++) {
  560. /*
  561. * check if actual hardware BIOS vendor, product and version
  562. * IDs start with the strings of BIOS table entry
  563. */
  564. if (str_starts_with(vendor, bt->vendor) &&
  565. str_starts_with(product, bt->product) &&
  566. str_starts_with(version, bt->version)) {
  567. found = 1;
  568. break;
  569. }
  570. }
  571. if (!found) {
  572. pr_err("unknown (unsupported) BIOS version %s/%s/%s, please report, aborting!\n",
  573. vendor, product, version);
  574. return -EINVAL;
  575. }
  576. /* Copy control settings from BIOS table before we free it. */
  577. ctrl_cfg.fanreg = bt->fanreg;
  578. ctrl_cfg.tempreg = bt->tempreg;
  579. memcpy(&ctrl_cfg.cmd, &bt->cmd, sizeof(struct fancmd));
  580. ctrl_cfg.mcmd_enable = bt->mcmd_enable;
  581. /*
  582. * if started with kernel mode off, prevent the kernel from switching
  583. * off the fan
  584. */
  585. if (!kernelmode) {
  586. pr_notice("Fan control off, to enable do:\n");
  587. pr_notice("echo -n \"enabled\" > /sys/class/thermal/thermal_zoneN/mode # N=0,1,2...\n");
  588. }
  589. return 0;
  590. }
  591. static int __init acerhdf_register_platform(void)
  592. {
  593. int err = 0;
  594. err = platform_driver_register(&acerhdf_driver);
  595. if (err)
  596. return err;
  597. acerhdf_dev = platform_device_alloc("acerhdf", -1);
  598. if (!acerhdf_dev) {
  599. err = -ENOMEM;
  600. goto err_device_alloc;
  601. }
  602. err = platform_device_add(acerhdf_dev);
  603. if (err)
  604. goto err_device_add;
  605. return 0;
  606. err_device_add:
  607. platform_device_put(acerhdf_dev);
  608. err_device_alloc:
  609. platform_driver_unregister(&acerhdf_driver);
  610. return err;
  611. }
  612. static void acerhdf_unregister_platform(void)
  613. {
  614. platform_device_unregister(acerhdf_dev);
  615. platform_driver_unregister(&acerhdf_driver);
  616. }
  617. static int __init acerhdf_register_thermal(void)
  618. {
  619. int ret;
  620. cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
  621. &acerhdf_cooling_ops);
  622. if (IS_ERR(cl_dev))
  623. return -EINVAL;
  624. thz_dev = thermal_zone_device_register("acerhdf", 2, 0, NULL,
  625. &acerhdf_dev_ops,
  626. &acerhdf_zone_params, 0,
  627. (kernelmode) ? interval*1000 : 0);
  628. if (IS_ERR(thz_dev))
  629. return -EINVAL;
  630. if (kernelmode)
  631. ret = thermal_zone_device_enable(thz_dev);
  632. else
  633. ret = thermal_zone_device_disable(thz_dev);
  634. if (ret)
  635. return ret;
  636. if (strcmp(thz_dev->governor->name,
  637. acerhdf_zone_params.governor_name)) {
  638. pr_err("Didn't get thermal governor %s, perhaps not compiled into thermal subsystem.\n",
  639. acerhdf_zone_params.governor_name);
  640. return -EINVAL;
  641. }
  642. return 0;
  643. }
  644. static void acerhdf_unregister_thermal(void)
  645. {
  646. if (cl_dev) {
  647. thermal_cooling_device_unregister(cl_dev);
  648. cl_dev = NULL;
  649. }
  650. if (thz_dev) {
  651. thermal_zone_device_unregister(thz_dev);
  652. thz_dev = NULL;
  653. }
  654. }
  655. static int __init acerhdf_init(void)
  656. {
  657. int err = 0;
  658. err = acerhdf_check_hardware();
  659. if (err)
  660. goto out_err;
  661. err = acerhdf_register_platform();
  662. if (err)
  663. goto out_err;
  664. err = acerhdf_register_thermal();
  665. if (err)
  666. goto err_unreg;
  667. return 0;
  668. err_unreg:
  669. acerhdf_unregister_thermal();
  670. acerhdf_unregister_platform();
  671. out_err:
  672. return err;
  673. }
  674. static void __exit acerhdf_exit(void)
  675. {
  676. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  677. acerhdf_unregister_thermal();
  678. acerhdf_unregister_platform();
  679. }
  680. MODULE_LICENSE("GPL");
  681. MODULE_AUTHOR("Peter Kaestle");
  682. MODULE_DESCRIPTION("Aspire One temperature and fan driver");
  683. MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
  684. MODULE_ALIAS("dmi:*:*Acer*:pnAO751h*:");
  685. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1410*:");
  686. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1810*:");
  687. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5755G:");
  688. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1825PTZ:");
  689. MODULE_ALIAS("dmi:*:*Acer*:pnAO521*:");
  690. MODULE_ALIAS("dmi:*:*Acer*:pnAO531*:");
  691. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5739G:");
  692. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*One*753:");
  693. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5315:");
  694. MODULE_ALIAS("dmi:*:*Acer*:TravelMate*7730G:");
  695. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*7551:");
  696. MODULE_ALIAS("dmi:*:*Acer*:TM8573T:");
  697. MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
  698. MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
  699. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnAOA*:");
  700. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOA*:");
  701. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMU*:");
  702. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnENBFT*:");
  703. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMA*:");
  704. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTVR46*:");
  705. MODULE_ALIAS("dmi:*:*Acer*:pnExtensa*5420*:");
  706. module_init(acerhdf_init);
  707. module_exit(acerhdf_exit);