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