/drivers/platform/x86/acerhdf.c

http://github.com/mirrors/linux · C · 833 lines · 604 code · 119 blank · 110 comment · 88 complexity · ff03eb06f9a71354e16c56e91ed75984 MD5 · raw file

  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. * http://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. if (thz_dev)
  357. thz_dev->polling_delay = 0;
  358. pr_notice("kernel mode fan control OFF\n");
  359. }
  360. static inline void acerhdf_enable_kernelmode(void)
  361. {
  362. kernelmode = 1;
  363. thz_dev->polling_delay = interval*1000;
  364. thermal_zone_device_update(thz_dev, THERMAL_EVENT_UNSPECIFIED);
  365. pr_notice("kernel mode fan control ON\n");
  366. }
  367. static int acerhdf_get_mode(struct thermal_zone_device *thermal,
  368. enum thermal_device_mode *mode)
  369. {
  370. if (verbose)
  371. pr_notice("kernel mode fan control %d\n", kernelmode);
  372. *mode = (kernelmode) ? THERMAL_DEVICE_ENABLED
  373. : THERMAL_DEVICE_DISABLED;
  374. return 0;
  375. }
  376. /*
  377. * set operation mode;
  378. * enabled: the thermal layer of the kernel takes care about
  379. * the temperature and the fan.
  380. * disabled: the BIOS takes control of the fan.
  381. */
  382. static int acerhdf_set_mode(struct thermal_zone_device *thermal,
  383. enum thermal_device_mode mode)
  384. {
  385. if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
  386. acerhdf_revert_to_bios_mode();
  387. else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
  388. acerhdf_enable_kernelmode();
  389. return 0;
  390. }
  391. static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
  392. enum thermal_trip_type *type)
  393. {
  394. if (trip == 0)
  395. *type = THERMAL_TRIP_ACTIVE;
  396. else if (trip == 1)
  397. *type = THERMAL_TRIP_CRITICAL;
  398. else
  399. return -EINVAL;
  400. return 0;
  401. }
  402. static int acerhdf_get_trip_hyst(struct thermal_zone_device *thermal, int trip,
  403. int *temp)
  404. {
  405. if (trip != 0)
  406. return -EINVAL;
  407. *temp = fanon - fanoff;
  408. return 0;
  409. }
  410. static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
  411. int *temp)
  412. {
  413. if (trip == 0)
  414. *temp = fanon;
  415. else if (trip == 1)
  416. *temp = ACERHDF_TEMP_CRIT;
  417. else
  418. return -EINVAL;
  419. return 0;
  420. }
  421. static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
  422. int *temperature)
  423. {
  424. *temperature = ACERHDF_TEMP_CRIT;
  425. return 0;
  426. }
  427. /* bind callback functions to thermalzone */
  428. static struct thermal_zone_device_ops acerhdf_dev_ops = {
  429. .bind = acerhdf_bind,
  430. .unbind = acerhdf_unbind,
  431. .get_temp = acerhdf_get_ec_temp,
  432. .get_mode = acerhdf_get_mode,
  433. .set_mode = acerhdf_set_mode,
  434. .get_trip_type = acerhdf_get_trip_type,
  435. .get_trip_hyst = acerhdf_get_trip_hyst,
  436. .get_trip_temp = acerhdf_get_trip_temp,
  437. .get_crit_temp = acerhdf_get_crit_temp,
  438. };
  439. /*
  440. * cooling device callback functions
  441. * get maximal fan cooling state
  442. */
  443. static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
  444. unsigned long *state)
  445. {
  446. *state = 1;
  447. return 0;
  448. }
  449. static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
  450. unsigned long *state)
  451. {
  452. int err = 0, tmp;
  453. err = acerhdf_get_fanstate(&tmp);
  454. if (err)
  455. return err;
  456. *state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
  457. return 0;
  458. }
  459. /* change current fan state - is overwritten when running in kernel mode */
  460. static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
  461. unsigned long state)
  462. {
  463. int cur_temp, cur_state, err = 0;
  464. if (!kernelmode)
  465. return 0;
  466. err = acerhdf_get_temp(&cur_temp);
  467. if (err) {
  468. pr_err("error reading temperature, hand off control to BIOS\n");
  469. goto err_out;
  470. }
  471. err = acerhdf_get_fanstate(&cur_state);
  472. if (err) {
  473. pr_err("error reading fan state, hand off control to BIOS\n");
  474. goto err_out;
  475. }
  476. if (state == 0) {
  477. if (cur_state == ACERHDF_FAN_AUTO)
  478. acerhdf_change_fanstate(ACERHDF_FAN_OFF);
  479. } else {
  480. if (cur_state == ACERHDF_FAN_OFF)
  481. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  482. }
  483. return 0;
  484. err_out:
  485. acerhdf_revert_to_bios_mode();
  486. return -EINVAL;
  487. }
  488. /* bind fan callbacks to fan device */
  489. static const struct thermal_cooling_device_ops acerhdf_cooling_ops = {
  490. .get_max_state = acerhdf_get_max_state,
  491. .get_cur_state = acerhdf_get_cur_state,
  492. .set_cur_state = acerhdf_set_cur_state,
  493. };
  494. /* suspend / resume functionality */
  495. static int acerhdf_suspend(struct device *dev)
  496. {
  497. if (kernelmode)
  498. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  499. if (verbose)
  500. pr_notice("going suspend\n");
  501. return 0;
  502. }
  503. static int acerhdf_probe(struct platform_device *device)
  504. {
  505. return 0;
  506. }
  507. static int acerhdf_remove(struct platform_device *device)
  508. {
  509. return 0;
  510. }
  511. static const struct dev_pm_ops acerhdf_pm_ops = {
  512. .suspend = acerhdf_suspend,
  513. .freeze = acerhdf_suspend,
  514. };
  515. static struct platform_driver acerhdf_driver = {
  516. .driver = {
  517. .name = "acerhdf",
  518. .pm = &acerhdf_pm_ops,
  519. },
  520. .probe = acerhdf_probe,
  521. .remove = acerhdf_remove,
  522. };
  523. /* checks if str begins with start */
  524. static int str_starts_with(const char *str, const char *start)
  525. {
  526. unsigned long str_len = 0, start_len = 0;
  527. str_len = strlen(str);
  528. start_len = strlen(start);
  529. if (str_len >= start_len &&
  530. !strncmp(str, start, start_len))
  531. return 1;
  532. return 0;
  533. }
  534. /* check hardware */
  535. static int __init acerhdf_check_hardware(void)
  536. {
  537. char const *vendor, *version, *product;
  538. const struct bios_settings *bt = NULL;
  539. int found = 0;
  540. /* get BIOS data */
  541. vendor = dmi_get_system_info(DMI_SYS_VENDOR);
  542. version = dmi_get_system_info(DMI_BIOS_VERSION);
  543. product = dmi_get_system_info(DMI_PRODUCT_NAME);
  544. if (!vendor || !version || !product) {
  545. pr_err("error getting hardware information\n");
  546. return -EINVAL;
  547. }
  548. pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
  549. if (list_supported) {
  550. pr_info("List of supported Manufacturer/Model/BIOS:\n");
  551. pr_info("---------------------------------------------------\n");
  552. for (bt = bios_tbl; bt->vendor[0]; bt++) {
  553. pr_info("%-13s | %-17s | %-10s\n", bt->vendor,
  554. bt->product, bt->version);
  555. }
  556. pr_info("---------------------------------------------------\n");
  557. return -ECANCELED;
  558. }
  559. if (force_bios[0]) {
  560. version = force_bios;
  561. pr_info("forcing BIOS version: %s\n", version);
  562. kernelmode = 0;
  563. }
  564. if (force_product[0]) {
  565. product = force_product;
  566. pr_info("forcing BIOS product: %s\n", product);
  567. kernelmode = 0;
  568. }
  569. if (verbose)
  570. pr_info("BIOS info: %s %s, product: %s\n",
  571. vendor, version, product);
  572. /* search BIOS version and vendor in BIOS settings table */
  573. for (bt = bios_tbl; bt->vendor[0]; bt++) {
  574. /*
  575. * check if actual hardware BIOS vendor, product and version
  576. * IDs start with the strings of BIOS table entry
  577. */
  578. if (str_starts_with(vendor, bt->vendor) &&
  579. str_starts_with(product, bt->product) &&
  580. str_starts_with(version, bt->version)) {
  581. found = 1;
  582. break;
  583. }
  584. }
  585. if (!found) {
  586. pr_err("unknown (unsupported) BIOS version %s/%s/%s, please report, aborting!\n",
  587. vendor, product, version);
  588. return -EINVAL;
  589. }
  590. /* Copy control settings from BIOS table before we free it. */
  591. ctrl_cfg.fanreg = bt->fanreg;
  592. ctrl_cfg.tempreg = bt->tempreg;
  593. memcpy(&ctrl_cfg.cmd, &bt->cmd, sizeof(struct fancmd));
  594. ctrl_cfg.mcmd_enable = bt->mcmd_enable;
  595. /*
  596. * if started with kernel mode off, prevent the kernel from switching
  597. * off the fan
  598. */
  599. if (!kernelmode) {
  600. pr_notice("Fan control off, to enable do:\n");
  601. pr_notice("echo -n \"enabled\" > /sys/class/thermal/thermal_zoneN/mode # N=0,1,2...\n");
  602. }
  603. return 0;
  604. }
  605. static int __init acerhdf_register_platform(void)
  606. {
  607. int err = 0;
  608. err = platform_driver_register(&acerhdf_driver);
  609. if (err)
  610. return err;
  611. acerhdf_dev = platform_device_alloc("acerhdf", -1);
  612. if (!acerhdf_dev) {
  613. err = -ENOMEM;
  614. goto err_device_alloc;
  615. }
  616. err = platform_device_add(acerhdf_dev);
  617. if (err)
  618. goto err_device_add;
  619. return 0;
  620. err_device_add:
  621. platform_device_put(acerhdf_dev);
  622. err_device_alloc:
  623. platform_driver_unregister(&acerhdf_driver);
  624. return err;
  625. }
  626. static void acerhdf_unregister_platform(void)
  627. {
  628. platform_device_unregister(acerhdf_dev);
  629. platform_driver_unregister(&acerhdf_driver);
  630. }
  631. static int __init acerhdf_register_thermal(void)
  632. {
  633. cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
  634. &acerhdf_cooling_ops);
  635. if (IS_ERR(cl_dev))
  636. return -EINVAL;
  637. thz_dev = thermal_zone_device_register("acerhdf", 2, 0, NULL,
  638. &acerhdf_dev_ops,
  639. &acerhdf_zone_params, 0,
  640. (kernelmode) ? interval*1000 : 0);
  641. if (IS_ERR(thz_dev))
  642. return -EINVAL;
  643. if (strcmp(thz_dev->governor->name,
  644. acerhdf_zone_params.governor_name)) {
  645. pr_err("Didn't get thermal governor %s, perhaps not compiled into thermal subsystem.\n",
  646. acerhdf_zone_params.governor_name);
  647. return -EINVAL;
  648. }
  649. return 0;
  650. }
  651. static void acerhdf_unregister_thermal(void)
  652. {
  653. if (cl_dev) {
  654. thermal_cooling_device_unregister(cl_dev);
  655. cl_dev = NULL;
  656. }
  657. if (thz_dev) {
  658. thermal_zone_device_unregister(thz_dev);
  659. thz_dev = NULL;
  660. }
  661. }
  662. static int __init acerhdf_init(void)
  663. {
  664. int err = 0;
  665. err = acerhdf_check_hardware();
  666. if (err)
  667. goto out_err;
  668. err = acerhdf_register_platform();
  669. if (err)
  670. goto out_err;
  671. err = acerhdf_register_thermal();
  672. if (err)
  673. goto err_unreg;
  674. return 0;
  675. err_unreg:
  676. acerhdf_unregister_thermal();
  677. acerhdf_unregister_platform();
  678. out_err:
  679. return err;
  680. }
  681. static void __exit acerhdf_exit(void)
  682. {
  683. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  684. acerhdf_unregister_thermal();
  685. acerhdf_unregister_platform();
  686. }
  687. MODULE_LICENSE("GPL");
  688. MODULE_AUTHOR("Peter Kaestle");
  689. MODULE_DESCRIPTION("Aspire One temperature and fan driver");
  690. MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
  691. MODULE_ALIAS("dmi:*:*Acer*:pnAO751h*:");
  692. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1410*:");
  693. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1810*:");
  694. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5755G:");
  695. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1825PTZ:");
  696. MODULE_ALIAS("dmi:*:*Acer*:pnAO521*:");
  697. MODULE_ALIAS("dmi:*:*Acer*:pnAO531*:");
  698. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5739G:");
  699. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*One*753:");
  700. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5315:");
  701. MODULE_ALIAS("dmi:*:*Acer*:TravelMate*7730G:");
  702. MODULE_ALIAS("dmi:*:*Acer*:pnAspire*7551:");
  703. MODULE_ALIAS("dmi:*:*Acer*:TM8573T:");
  704. MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
  705. MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
  706. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnAOA*:");
  707. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOA*:");
  708. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMU*:");
  709. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnENBFT*:");
  710. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMA*:");
  711. MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTVR46*:");
  712. MODULE_ALIAS("dmi:*:*Acer*:pnExtensa 5420*:");
  713. module_init(acerhdf_init);
  714. module_exit(acerhdf_exit);