/drivers/platform/x86/acerhdf.c

https://bitbucket.org/slukk/jb-tsm-kernel-4.2 · C · 717 lines · 504 code · 108 blank · 105 comment · 73 complexity · 1826486364ae0d839fba80368c8b216b MD5 · raw file

  1. /*
  2. * acerhdf - A driver which monitors the temperature
  3. * of the aspire one netbook, turns on/off the fan
  4. * as soon as the upper/lower threshold is reached.
  5. *
  6. * (C) 2009 - Peter Feuerer peter (a) piie.net
  7. * http://piie.net
  8. * 2009 Borislav Petkov <petkovbb@gmail.com>
  9. *
  10. * Inspired by and many thanks to:
  11. * o acerfand - Rachel Greenham
  12. * o acer_ec.pl - Michael Kurz michi.kurz (at) googlemail.com
  13. * - Petr Tomasek tomasek (#) etf,cuni,cz
  14. * - Carlos Corbacho cathectic (at) gmail.com
  15. * o lkml - Matthew Garrett
  16. * - Borislav Petkov
  17. * - Andreas Mohr
  18. *
  19. * This program is free software; you can redistribute it and/or modify
  20. * it under the terms of the GNU General Public License as published by
  21. * the Free Software Foundation; either version 2 of the License, or
  22. * (at your option) any later version.
  23. *
  24. * This program is distributed in the hope that it will be useful,
  25. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  27. * GNU General Public License for more details.
  28. *
  29. * You should have received a copy of the GNU General Public License
  30. * along with this program; if not, write to the Free Software
  31. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  32. */
  33. #define pr_fmt(fmt) "acerhdf: " fmt
  34. #include <linux/kernel.h>
  35. #include <linux/module.h>
  36. #include <linux/dmi.h>
  37. #include <linux/acpi.h>
  38. #include <linux/thermal.h>
  39. #include <linux/platform_device.h>
  40. /*
  41. * The driver is started with "kernel mode off" by default. That means, the BIOS
  42. * is still in control of the fan. In this mode the driver allows to read the
  43. * temperature of the cpu and a userspace tool may take over control of the fan.
  44. * If the driver is switched to "kernel mode" (e.g. via module parameter) the
  45. * driver is in full control of the fan. If you want the module to be started in
  46. * kernel mode by default, define the following:
  47. */
  48. #undef START_IN_KERNEL_MODE
  49. #define DRV_VER "0.5.24"
  50. /*
  51. * According to the Atom N270 datasheet,
  52. * (http://download.intel.com/design/processor/datashts/320032.pdf) the
  53. * CPU's optimal operating limits denoted in junction temperature as
  54. * measured by the on-die thermal monitor are within 0 <= Tj <= 90. So,
  55. * assume 89°C is critical temperature.
  56. */
  57. #define ACERHDF_TEMP_CRIT 89000
  58. #define ACERHDF_FAN_OFF 0
  59. #define ACERHDF_FAN_AUTO 1
  60. /*
  61. * No matter what value the user puts into the fanon variable, turn on the fan
  62. * at 80 degree Celsius to prevent hardware damage
  63. */
  64. #define ACERHDF_MAX_FANON 80000
  65. /*
  66. * Maximum interval between two temperature checks is 15 seconds, as the die
  67. * can get hot really fast under heavy load (plus we shouldn't forget about
  68. * possible impact of _external_ aggressive sources such as heaters, sun etc.)
  69. */
  70. #define ACERHDF_MAX_INTERVAL 15
  71. #ifdef START_IN_KERNEL_MODE
  72. static int kernelmode = 1;
  73. #else
  74. static int kernelmode;
  75. #endif
  76. static unsigned int interval = 10;
  77. static unsigned int fanon = 63000;
  78. static unsigned int fanoff = 58000;
  79. static unsigned int verbose;
  80. static unsigned int fanstate = ACERHDF_FAN_AUTO;
  81. static char force_bios[16];
  82. static char force_product[16];
  83. static unsigned int prev_interval;
  84. static struct thermal_zone_device *thz_dev;
  85. static struct thermal_cooling_device *cl_dev;
  86. static struct platform_device *acerhdf_dev;
  87. module_param(kernelmode, uint, 0);
  88. MODULE_PARM_DESC(kernelmode, "Kernel mode fan control on / off");
  89. module_param(interval, uint, 0600);
  90. MODULE_PARM_DESC(interval, "Polling interval of temperature check");
  91. module_param(fanon, uint, 0600);
  92. MODULE_PARM_DESC(fanon, "Turn the fan on above this temperature");
  93. module_param(fanoff, uint, 0600);
  94. MODULE_PARM_DESC(fanoff, "Turn the fan off below this temperature");
  95. module_param(verbose, uint, 0600);
  96. MODULE_PARM_DESC(verbose, "Enable verbose dmesg output");
  97. module_param_string(force_bios, force_bios, 16, 0);
  98. MODULE_PARM_DESC(force_bios, "Force BIOS version and omit BIOS check");
  99. module_param_string(force_product, force_product, 16, 0);
  100. MODULE_PARM_DESC(force_product, "Force BIOS product and omit BIOS check");
  101. /*
  102. * cmd_off: to switch the fan completely off and check if the fan is off
  103. * cmd_auto: to set the BIOS in control of the fan. The BIOS regulates then
  104. * the fan speed depending on the temperature
  105. */
  106. struct fancmd {
  107. u8 cmd_off;
  108. u8 cmd_auto;
  109. };
  110. /* BIOS settings */
  111. struct bios_settings_t {
  112. const char *vendor;
  113. const char *product;
  114. const char *version;
  115. unsigned char fanreg;
  116. unsigned char tempreg;
  117. struct fancmd cmd;
  118. };
  119. /* Register addresses and values for different BIOS versions */
  120. static const struct bios_settings_t bios_tbl[] = {
  121. /* AOA110 */
  122. {"Acer", "AOA110", "v0.3109", 0x55, 0x58, {0x1f, 0x00} },
  123. {"Acer", "AOA110", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
  124. {"Acer", "AOA110", "v0.3301", 0x55, 0x58, {0xaf, 0x00} },
  125. {"Acer", "AOA110", "v0.3304", 0x55, 0x58, {0xaf, 0x00} },
  126. {"Acer", "AOA110", "v0.3305", 0x55, 0x58, {0xaf, 0x00} },
  127. {"Acer", "AOA110", "v0.3307", 0x55, 0x58, {0xaf, 0x00} },
  128. {"Acer", "AOA110", "v0.3308", 0x55, 0x58, {0x21, 0x00} },
  129. {"Acer", "AOA110", "v0.3309", 0x55, 0x58, {0x21, 0x00} },
  130. {"Acer", "AOA110", "v0.3310", 0x55, 0x58, {0x21, 0x00} },
  131. /* AOA150 */
  132. {"Acer", "AOA150", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
  133. {"Acer", "AOA150", "v0.3301", 0x55, 0x58, {0x20, 0x00} },
  134. {"Acer", "AOA150", "v0.3304", 0x55, 0x58, {0x20, 0x00} },
  135. {"Acer", "AOA150", "v0.3305", 0x55, 0x58, {0x20, 0x00} },
  136. {"Acer", "AOA150", "v0.3307", 0x55, 0x58, {0x20, 0x00} },
  137. {"Acer", "AOA150", "v0.3308", 0x55, 0x58, {0x20, 0x00} },
  138. {"Acer", "AOA150", "v0.3309", 0x55, 0x58, {0x20, 0x00} },
  139. {"Acer", "AOA150", "v0.3310", 0x55, 0x58, {0x20, 0x00} },
  140. /* Acer 1410 */
  141. {"Acer", "Aspire 1410", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
  142. {"Acer", "Aspire 1410", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
  143. {"Acer", "Aspire 1410", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
  144. {"Acer", "Aspire 1410", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
  145. {"Acer", "Aspire 1410", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
  146. {"Acer", "Aspire 1410", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
  147. {"Acer", "Aspire 1410", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
  148. {"Acer", "Aspire 1410", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
  149. {"Acer", "Aspire 1410", "v1.3308", 0x55, 0x58, {0x9e, 0x00} },
  150. {"Acer", "Aspire 1410", "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
  151. /* Acer 1810xx */
  152. {"Acer", "Aspire 1810TZ", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
  153. {"Acer", "Aspire 1810T", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
  154. {"Acer", "Aspire 1810TZ", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
  155. {"Acer", "Aspire 1810T", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
  156. {"Acer", "Aspire 1810TZ", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
  157. {"Acer", "Aspire 1810T", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
  158. {"Acer", "Aspire 1810TZ", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
  159. {"Acer", "Aspire 1810T", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
  160. {"Acer", "Aspire 1810TZ", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
  161. {"Acer", "Aspire 1810T", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
  162. {"Acer", "Aspire 1810TZ", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
  163. {"Acer", "Aspire 1810T", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
  164. {"Acer", "Aspire 1810TZ", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
  165. {"Acer", "Aspire 1810T", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
  166. {"Acer", "Aspire 1810TZ", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
  167. {"Acer", "Aspire 1810T", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
  168. {"Acer", "Aspire 1810TZ", "v1.3308", 0x55, 0x58, {0x9e, 0x00} },
  169. {"Acer", "Aspire 1810T", "v1.3308", 0x55, 0x58, {0x9e, 0x00} },
  170. {"Acer", "Aspire 1810TZ", "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
  171. {"Acer", "Aspire 1810T", "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
  172. /* Acer 531 */
  173. {"Acer", "AO531h", "v0.3201", 0x55, 0x58, {0x20, 0x00} },
  174. /* Gateway */
  175. {"Gateway", "AOA110", "v0.3103", 0x55, 0x58, {0x21, 0x00} },
  176. {"Gateway", "AOA150", "v0.3103", 0x55, 0x58, {0x20, 0x00} },
  177. {"Gateway", "LT31", "v1.3103", 0x55, 0x58, {0x9e, 0x00} },
  178. {"Gateway", "LT31", "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
  179. {"Gateway", "LT31", "v1.3302", 0x55, 0x58, {0x9e, 0x00} },
  180. /* Packard Bell */
  181. {"Packard Bell", "DOA150", "v0.3104", 0x55, 0x58, {0x21, 0x00} },
  182. {"Packard Bell", "DOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
  183. {"Packard Bell", "AOA110", "v0.3105", 0x55, 0x58, {0x21, 0x00} },
  184. {"Packard Bell", "AOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
  185. {"Packard Bell", "DOTMU", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
  186. {"Packard Bell", "DOTMU", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
  187. {"Packard Bell", "DOTMU", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
  188. {"Packard Bell", "DOTMU", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
  189. {"Packard Bell", "DOTMU", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
  190. {"Packard Bell", "DOTMU", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
  191. {"Packard Bell", "DOTMU", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
  192. {"Packard Bell", "DOTMU", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
  193. {"Packard Bell", "DOTMA", "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
  194. {"Packard Bell", "DOTMA", "v1.3302", 0x55, 0x58, {0x9e, 0x00} },
  195. /* pewpew-terminator */
  196. {"", "", "", 0, 0, {0, 0} }
  197. };
  198. static const struct bios_settings_t *bios_cfg __read_mostly;
  199. static int acerhdf_get_temp(int *temp)
  200. {
  201. u8 read_temp;
  202. if (ec_read(bios_cfg->tempreg, &read_temp))
  203. return -EINVAL;
  204. *temp = read_temp * 1000;
  205. return 0;
  206. }
  207. static int acerhdf_get_fanstate(int *state)
  208. {
  209. u8 fan;
  210. if (ec_read(bios_cfg->fanreg, &fan))
  211. return -EINVAL;
  212. if (fan != bios_cfg->cmd.cmd_off)
  213. *state = ACERHDF_FAN_AUTO;
  214. else
  215. *state = ACERHDF_FAN_OFF;
  216. return 0;
  217. }
  218. static void acerhdf_change_fanstate(int state)
  219. {
  220. unsigned char cmd;
  221. if (verbose)
  222. pr_notice("fan %s\n", (state == ACERHDF_FAN_OFF) ?
  223. "OFF" : "ON");
  224. if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
  225. pr_err("invalid fan state %d requested, setting to auto!\n",
  226. state);
  227. state = ACERHDF_FAN_AUTO;
  228. }
  229. cmd = (state == ACERHDF_FAN_OFF) ? bios_cfg->cmd.cmd_off
  230. : bios_cfg->cmd.cmd_auto;
  231. fanstate = state;
  232. ec_write(bios_cfg->fanreg, cmd);
  233. }
  234. static void acerhdf_check_param(struct thermal_zone_device *thermal)
  235. {
  236. if (fanon > ACERHDF_MAX_FANON) {
  237. pr_err("fanon temperature too high, set to %d\n",
  238. ACERHDF_MAX_FANON);
  239. fanon = ACERHDF_MAX_FANON;
  240. }
  241. if (kernelmode && prev_interval != interval) {
  242. if (interval > ACERHDF_MAX_INTERVAL) {
  243. pr_err("interval too high, set to %d\n",
  244. ACERHDF_MAX_INTERVAL);
  245. interval = ACERHDF_MAX_INTERVAL;
  246. }
  247. if (verbose)
  248. pr_notice("interval changed to: %d\n",
  249. interval);
  250. thermal->polling_delay = interval*1000;
  251. prev_interval = interval;
  252. }
  253. }
  254. /*
  255. * This is the thermal zone callback which does the delayed polling of the fan
  256. * state. We do check /sysfs-originating settings here in acerhdf_check_param()
  257. * as late as the polling interval is since we can't do that in the respective
  258. * accessors of the module parameters.
  259. */
  260. static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal,
  261. unsigned long *t)
  262. {
  263. int temp, err = 0;
  264. acerhdf_check_param(thermal);
  265. err = acerhdf_get_temp(&temp);
  266. if (err)
  267. return err;
  268. if (verbose)
  269. pr_notice("temp %d\n", temp);
  270. *t = temp;
  271. return 0;
  272. }
  273. static int acerhdf_bind(struct thermal_zone_device *thermal,
  274. struct thermal_cooling_device *cdev)
  275. {
  276. /* if the cooling device is the one from acerhdf bind it */
  277. if (cdev != cl_dev)
  278. return 0;
  279. if (thermal_zone_bind_cooling_device(thermal, 0, cdev)) {
  280. pr_err("error binding cooling dev\n");
  281. return -EINVAL;
  282. }
  283. return 0;
  284. }
  285. static int acerhdf_unbind(struct thermal_zone_device *thermal,
  286. struct thermal_cooling_device *cdev)
  287. {
  288. if (cdev != cl_dev)
  289. return 0;
  290. if (thermal_zone_unbind_cooling_device(thermal, 0, cdev)) {
  291. pr_err("error unbinding cooling dev\n");
  292. return -EINVAL;
  293. }
  294. return 0;
  295. }
  296. static inline void acerhdf_revert_to_bios_mode(void)
  297. {
  298. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  299. kernelmode = 0;
  300. if (thz_dev)
  301. thz_dev->polling_delay = 0;
  302. pr_notice("kernel mode fan control OFF\n");
  303. }
  304. static inline void acerhdf_enable_kernelmode(void)
  305. {
  306. kernelmode = 1;
  307. thz_dev->polling_delay = interval*1000;
  308. thermal_zone_device_update(thz_dev);
  309. pr_notice("kernel mode fan control ON\n");
  310. }
  311. static int acerhdf_get_mode(struct thermal_zone_device *thermal,
  312. enum thermal_device_mode *mode)
  313. {
  314. if (verbose)
  315. pr_notice("kernel mode fan control %d\n", kernelmode);
  316. *mode = (kernelmode) ? THERMAL_DEVICE_ENABLED
  317. : THERMAL_DEVICE_DISABLED;
  318. return 0;
  319. }
  320. /*
  321. * set operation mode;
  322. * enabled: the thermal layer of the kernel takes care about
  323. * the temperature and the fan.
  324. * disabled: the BIOS takes control of the fan.
  325. */
  326. static int acerhdf_set_mode(struct thermal_zone_device *thermal,
  327. enum thermal_device_mode mode)
  328. {
  329. if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
  330. acerhdf_revert_to_bios_mode();
  331. else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
  332. acerhdf_enable_kernelmode();
  333. return 0;
  334. }
  335. static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
  336. enum thermal_trip_type *type)
  337. {
  338. if (trip == 0)
  339. *type = THERMAL_TRIP_ACTIVE;
  340. return 0;
  341. }
  342. static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
  343. unsigned long *temp)
  344. {
  345. if (trip == 0)
  346. *temp = fanon;
  347. return 0;
  348. }
  349. static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
  350. unsigned long *temperature)
  351. {
  352. *temperature = ACERHDF_TEMP_CRIT;
  353. return 0;
  354. }
  355. /* bind callback functions to thermalzone */
  356. static struct thermal_zone_device_ops acerhdf_dev_ops = {
  357. .bind = acerhdf_bind,
  358. .unbind = acerhdf_unbind,
  359. .get_temp = acerhdf_get_ec_temp,
  360. .get_mode = acerhdf_get_mode,
  361. .set_mode = acerhdf_set_mode,
  362. .get_trip_type = acerhdf_get_trip_type,
  363. .get_trip_temp = acerhdf_get_trip_temp,
  364. .get_crit_temp = acerhdf_get_crit_temp,
  365. };
  366. /*
  367. * cooling device callback functions
  368. * get maximal fan cooling state
  369. */
  370. static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
  371. unsigned long *state)
  372. {
  373. *state = 1;
  374. return 0;
  375. }
  376. static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
  377. unsigned long *state)
  378. {
  379. int err = 0, tmp;
  380. err = acerhdf_get_fanstate(&tmp);
  381. if (err)
  382. return err;
  383. *state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
  384. return 0;
  385. }
  386. /* change current fan state - is overwritten when running in kernel mode */
  387. static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
  388. unsigned long state)
  389. {
  390. int cur_temp, cur_state, err = 0;
  391. if (!kernelmode)
  392. return 0;
  393. err = acerhdf_get_temp(&cur_temp);
  394. if (err) {
  395. pr_err("error reading temperature, hand off control to BIOS\n");
  396. goto err_out;
  397. }
  398. err = acerhdf_get_fanstate(&cur_state);
  399. if (err) {
  400. pr_err("error reading fan state, hand off control to BIOS\n");
  401. goto err_out;
  402. }
  403. if (state == 0) {
  404. /* turn fan off only if below fanoff temperature */
  405. if ((cur_state == ACERHDF_FAN_AUTO) &&
  406. (cur_temp < fanoff))
  407. acerhdf_change_fanstate(ACERHDF_FAN_OFF);
  408. } else {
  409. if (cur_state == ACERHDF_FAN_OFF)
  410. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  411. }
  412. return 0;
  413. err_out:
  414. acerhdf_revert_to_bios_mode();
  415. return -EINVAL;
  416. }
  417. /* bind fan callbacks to fan device */
  418. static struct thermal_cooling_device_ops acerhdf_cooling_ops = {
  419. .get_max_state = acerhdf_get_max_state,
  420. .get_cur_state = acerhdf_get_cur_state,
  421. .set_cur_state = acerhdf_set_cur_state,
  422. };
  423. /* suspend / resume functionality */
  424. static int acerhdf_suspend(struct device *dev)
  425. {
  426. if (kernelmode)
  427. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  428. if (verbose)
  429. pr_notice("going suspend\n");
  430. return 0;
  431. }
  432. static int __devinit acerhdf_probe(struct platform_device *device)
  433. {
  434. return 0;
  435. }
  436. static int acerhdf_remove(struct platform_device *device)
  437. {
  438. return 0;
  439. }
  440. static const struct dev_pm_ops acerhdf_pm_ops = {
  441. .suspend = acerhdf_suspend,
  442. .freeze = acerhdf_suspend,
  443. };
  444. static struct platform_driver acerhdf_driver = {
  445. .driver = {
  446. .name = "acerhdf",
  447. .owner = THIS_MODULE,
  448. .pm = &acerhdf_pm_ops,
  449. },
  450. .probe = acerhdf_probe,
  451. .remove = acerhdf_remove,
  452. };
  453. /* checks if str begins with start */
  454. static int str_starts_with(const char *str, const char *start)
  455. {
  456. unsigned long str_len = 0, start_len = 0;
  457. str_len = strlen(str);
  458. start_len = strlen(start);
  459. if (str_len >= start_len &&
  460. !strncmp(str, start, start_len))
  461. return 1;
  462. return 0;
  463. }
  464. /* check hardware */
  465. static int acerhdf_check_hardware(void)
  466. {
  467. char const *vendor, *version, *product;
  468. const struct bios_settings_t *bt = NULL;
  469. /* get BIOS data */
  470. vendor = dmi_get_system_info(DMI_SYS_VENDOR);
  471. version = dmi_get_system_info(DMI_BIOS_VERSION);
  472. product = dmi_get_system_info(DMI_PRODUCT_NAME);
  473. if (!vendor || !version || !product) {
  474. pr_err("error getting hardware information\n");
  475. return -EINVAL;
  476. }
  477. pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
  478. if (force_bios[0]) {
  479. version = force_bios;
  480. pr_info("forcing BIOS version: %s\n", version);
  481. kernelmode = 0;
  482. }
  483. if (force_product[0]) {
  484. product = force_product;
  485. pr_info("forcing BIOS product: %s\n", product);
  486. kernelmode = 0;
  487. }
  488. if (verbose)
  489. pr_info("BIOS info: %s %s, product: %s\n",
  490. vendor, version, product);
  491. /* search BIOS version and vendor in BIOS settings table */
  492. for (bt = bios_tbl; bt->vendor[0]; bt++) {
  493. /*
  494. * check if actual hardware BIOS vendor, product and version
  495. * IDs start with the strings of BIOS table entry
  496. */
  497. if (str_starts_with(vendor, bt->vendor) &&
  498. str_starts_with(product, bt->product) &&
  499. str_starts_with(version, bt->version)) {
  500. bios_cfg = bt;
  501. break;
  502. }
  503. }
  504. if (!bios_cfg) {
  505. pr_err("unknown (unsupported) BIOS version %s/%s/%s, "
  506. "please report, aborting!\n", vendor, product, version);
  507. return -EINVAL;
  508. }
  509. /*
  510. * if started with kernel mode off, prevent the kernel from switching
  511. * off the fan
  512. */
  513. if (!kernelmode) {
  514. pr_notice("Fan control off, to enable do:\n");
  515. pr_notice("echo -n \"enabled\" > "
  516. "/sys/class/thermal/thermal_zone0/mode\n");
  517. }
  518. return 0;
  519. }
  520. static int acerhdf_register_platform(void)
  521. {
  522. int err = 0;
  523. err = platform_driver_register(&acerhdf_driver);
  524. if (err)
  525. return err;
  526. acerhdf_dev = platform_device_alloc("acerhdf", -1);
  527. if (!acerhdf_dev) {
  528. err = -ENOMEM;
  529. goto err_device_alloc;
  530. }
  531. err = platform_device_add(acerhdf_dev);
  532. if (err)
  533. goto err_device_add;
  534. return 0;
  535. err_device_add:
  536. platform_device_put(acerhdf_dev);
  537. err_device_alloc:
  538. platform_driver_unregister(&acerhdf_driver);
  539. return err;
  540. }
  541. static void acerhdf_unregister_platform(void)
  542. {
  543. platform_device_unregister(acerhdf_dev);
  544. platform_driver_unregister(&acerhdf_driver);
  545. }
  546. static int acerhdf_register_thermal(void)
  547. {
  548. cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
  549. &acerhdf_cooling_ops);
  550. if (IS_ERR(cl_dev))
  551. return -EINVAL;
  552. thz_dev = thermal_zone_device_register("acerhdf", 1, NULL,
  553. &acerhdf_dev_ops, 0, 0, 0,
  554. (kernelmode) ? interval*1000 : 0);
  555. if (IS_ERR(thz_dev))
  556. return -EINVAL;
  557. return 0;
  558. }
  559. static void acerhdf_unregister_thermal(void)
  560. {
  561. if (cl_dev) {
  562. thermal_cooling_device_unregister(cl_dev);
  563. cl_dev = NULL;
  564. }
  565. if (thz_dev) {
  566. thermal_zone_device_unregister(thz_dev);
  567. thz_dev = NULL;
  568. }
  569. }
  570. static int __init acerhdf_init(void)
  571. {
  572. int err = 0;
  573. err = acerhdf_check_hardware();
  574. if (err)
  575. goto out_err;
  576. err = acerhdf_register_platform();
  577. if (err)
  578. goto out_err;
  579. err = acerhdf_register_thermal();
  580. if (err)
  581. goto err_unreg;
  582. return 0;
  583. err_unreg:
  584. acerhdf_unregister_thermal();
  585. acerhdf_unregister_platform();
  586. out_err:
  587. return err;
  588. }
  589. static void __exit acerhdf_exit(void)
  590. {
  591. acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
  592. acerhdf_unregister_thermal();
  593. acerhdf_unregister_platform();
  594. }
  595. MODULE_LICENSE("GPL");
  596. MODULE_AUTHOR("Peter Feuerer");
  597. MODULE_DESCRIPTION("Aspire One temperature and fan driver");
  598. MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
  599. MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1410*:");
  600. MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1810*:");
  601. MODULE_ALIAS("dmi:*:*Acer*:pnAO531*:");
  602. MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
  603. MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
  604. MODULE_ALIAS("dmi:*:*Packard Bell*:pnAOA*:");
  605. MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOA*:");
  606. MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMU*:");
  607. MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMA*:");
  608. module_init(acerhdf_init);
  609. module_exit(acerhdf_exit);