projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
acerhdf: Drop pointless dependency on THERMAL_HWMON
[deliverable/linux.git] / drivers / platform / x86 / acerhdf.c
CommitLineData
e86435eb
PF		 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
24964639 55#define DRV_VER "0.5.24"
e86435eb
PF		 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 */
70052917 64#define ACERHDF_TEMP_CRIT 89000
e86435eb
PF		 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 */
70052917 72#define ACERHDF_MAX_FANON 80000
e86435eb
PF		 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
82static int kernelmode = 1;
83#else
84static int kernelmode;
85#endif
86
87static unsigned int interval = 10;
70052917
PF		 88static unsigned int fanon = 63000;
89static unsigned int fanoff = 58000;
e86435eb
PF		 90static unsigned int verbose;
91static unsigned int fanstate = ACERHDF_FAN_AUTO;
92static char force_bios[16];
ded0cdfc 93static char force_product[16];
e86435eb 94static unsigned int prev_interval;
fedae5ad
AL		 95static struct thermal_zone_device *thz_dev;
96static struct thermal_cooling_device *cl_dev;
97static struct platform_device *acerhdf_dev;
e86435eb
PF		 98
99module_param(kernelmode, uint, 0);
100MODULE_PARM_DESC(kernelmode, "Kernel mode fan control on / off");
101module_param(interval, uint, 0600);
102MODULE_PARM_DESC(interval, "Polling interval of temperature check");
103module_param(fanon, uint, 0600);
104MODULE_PARM_DESC(fanon, "Turn the fan on above this temperature");
105module_param(fanoff, uint, 0600);
106MODULE_PARM_DESC(fanoff, "Turn the fan off below this temperature");
107module_param(verbose, uint, 0600);
108MODULE_PARM_DESC(verbose, "Enable verbose dmesg output");
109module_param_string(force_bios, force_bios, 16, 0);
110MODULE_PARM_DESC(force_bios, "Force BIOS version and omit BIOS check");
ded0cdfc
PF		 111module_param_string(force_product, force_product, 16, 0);
112MODULE_PARM_DESC(force_product, "Force BIOS product and omit BIOS check");
113
114/*
210183d4 115 * cmd_off: to switch the fan completely off and check if the fan is off
ded0cdfc
PF		 116 * cmd_auto: to set the BIOS in control of the fan. The BIOS regulates then
117 * the fan speed depending on the temperature
118 */
119struct fancmd {
120 u8 cmd_off;
121 u8 cmd_auto;
122};
e86435eb
PF		 123
124/* BIOS settings */
125struct bios_settings_t {
126 const char *vendor;
ded0cdfc 127 const char *product;
e86435eb
PF		 128 const char *version;
129 unsigned char fanreg;
130 unsigned char tempreg;
ded0cdfc 131 struct fancmd cmd;
e86435eb
PF		 132};
133
134/* Register addresses and values for different BIOS versions */
135static const struct bios_settings_t bios_tbl[] = {
ded0cdfc 136 /* AOA110 */
210183d4
PF		 137 {"Acer", "AOA110", "v0.3109", 0x55, 0x58, {0x1f, 0x00} },
138 {"Acer", "AOA110", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
139 {"Acer", "AOA110", "v0.3301", 0x55, 0x58, {0xaf, 0x00} },
140 {"Acer", "AOA110", "v0.3304", 0x55, 0x58, {0xaf, 0x00} },
141 {"Acer", "AOA110", "v0.3305", 0x55, 0x58, {0xaf, 0x00} },
142 {"Acer", "AOA110", "v0.3307", 0x55, 0x58, {0xaf, 0x00} },
143 {"Acer", "AOA110", "v0.3308", 0x55, 0x58, {0x21, 0x00} },
144 {"Acer", "AOA110", "v0.3309", 0x55, 0x58, {0x21, 0x00} },
145 {"Acer", "AOA110", "v0.3310", 0x55, 0x58, {0x21, 0x00} },
ded0cdfc 146 /* AOA150 */
210183d4
PF		 147 {"Acer", "AOA150", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
148 {"Acer", "AOA150", "v0.3301", 0x55, 0x58, {0x20, 0x00} },
149 {"Acer", "AOA150", "v0.3304", 0x55, 0x58, {0x20, 0x00} },
150 {"Acer", "AOA150", "v0.3305", 0x55, 0x58, {0x20, 0x00} },
151 {"Acer", "AOA150", "v0.3307", 0x55, 0x58, {0x20, 0x00} },
152 {"Acer", "AOA150", "v0.3308", 0x55, 0x58, {0x20, 0x00} },
153 {"Acer", "AOA150", "v0.3309", 0x55, 0x58, {0x20, 0x00} },
154 {"Acer", "AOA150", "v0.3310", 0x55, 0x58, {0x20, 0x00} },
36065746 155 /* Acer 1410 */
24964639
PF		 156 {"Acer", "Aspire 1410", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
157 {"Acer", "Aspire 1410", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
210183d4 158 {"Acer", "Aspire 1410", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
24964639
PF		 159 {"Acer", "Aspire 1410", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
160 {"Acer", "Aspire 1410", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
210183d4 161 {"Acer", "Aspire 1410", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
24964639 162 {"Acer", "Aspire 1410", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
210183d4 163 {"Acer", "Aspire 1410", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
24964639
PF		 164 {"Acer", "Aspire 1410", "v1.3308", 0x55, 0x58, {0x9e, 0x00} },
165 {"Acer", "Aspire 1410", "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
94219d79 166 /* Acer 1810xx */
24964639
PF		 167 {"Acer", "Aspire 1810TZ", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
168 {"Acer", "Aspire 1810T", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
169 {"Acer", "Aspire 1810TZ", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
170 {"Acer", "Aspire 1810T", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
210183d4
PF		 171 {"Acer", "Aspire 1810TZ", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
172 {"Acer", "Aspire 1810T", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
24964639
PF		 173 {"Acer", "Aspire 1810TZ", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
174 {"Acer", "Aspire 1810T", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
210183d4
PF		 175 {"Acer", "Aspire 1810TZ", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
176 {"Acer", "Aspire 1810T", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
177 {"Acer", "Aspire 1810TZ", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
178 {"Acer", "Aspire 1810T", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
179 {"Acer", "Aspire 1810TZ", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
180 {"Acer", "Aspire 1810T", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
181 {"Acer", "Aspire 1810TZ", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
182 {"Acer", "Aspire 1810T", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
24964639
PF		 183 {"Acer", "Aspire 1810TZ", "v1.3308", 0x55, 0x58, {0x9e, 0x00} },
184 {"Acer", "Aspire 1810T", "v1.3308", 0x55, 0x58, {0x9e, 0x00} },
185 {"Acer", "Aspire 1810TZ", "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
186 {"Acer", "Aspire 1810T", "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
187 /* Acer 531 */
188 {"Acer", "AO531h", "v0.3201", 0x55, 0x58, {0x20, 0x00} },
94219d79 189 /* Gateway */
210183d4
PF		 190 {"Gateway", "AOA110", "v0.3103", 0x55, 0x58, {0x21, 0x00} },
191 {"Gateway", "AOA150", "v0.3103", 0x55, 0x58, {0x20, 0x00} },
192 {"Gateway", "LT31", "v1.3103", 0x55, 0x58, {0x9e, 0x00} },
193 {"Gateway", "LT31", "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
194 {"Gateway", "LT31", "v1.3302", 0x55, 0x58, {0x9e, 0x00} },
94219d79 195 /* Packard Bell */
210183d4
PF		 196 {"Packard Bell", "DOA150", "v0.3104", 0x55, 0x58, {0x21, 0x00} },
197 {"Packard Bell", "DOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
198 {"Packard Bell", "AOA110", "v0.3105", 0x55, 0x58, {0x21, 0x00} },
199 {"Packard Bell", "AOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
200 {"Packard Bell", "DOTMU", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
201 {"Packard Bell", "DOTMU", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
24964639
PF		 202 {"Packard Bell", "DOTMU", "v0.3108", 0x55, 0x58, {0x9e, 0x00} },
203 {"Packard Bell", "DOTMU", "v0.3113", 0x55, 0x58, {0x9e, 0x00} },
204 {"Packard Bell", "DOTMU", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
205 {"Packard Bell", "DOTMU", "v0.3117", 0x55, 0x58, {0x9e, 0x00} },
206 {"Packard Bell", "DOTMU", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
207 {"Packard Bell", "DOTMU", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
210183d4 208 {"Packard Bell", "DOTMA", "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
24964639 209 {"Packard Bell", "DOTMA", "v1.3302", 0x55, 0x58, {0x9e, 0x00} },
ded0cdfc 210 /* pewpew-terminator */
210183d4 211 {"", "", "", 0, 0, {0, 0} }
e86435eb
PF		 212};
213
214static const struct bios_settings_t *bios_cfg __read_mostly;
215
e86435eb
PF		 216static int acerhdf_get_temp(int *temp)
217{
218 u8 read_temp;
219
220 if (ec_read(bios_cfg->tempreg, &read_temp))
221 return -EINVAL;
222
70052917 223 *temp = read_temp * 1000;
e86435eb
PF		 224
225 return 0;
226}
227
228static int acerhdf_get_fanstate(int *state)
229{
230 u8 fan;
e86435eb
PF		 231
232 if (ec_read(bios_cfg->fanreg, &fan))
233 return -EINVAL;
234
210183d4 235 if (fan != bios_cfg->cmd.cmd_off)
ded0cdfc
PF		 236 *state = ACERHDF_FAN_AUTO;
237 else
238 *state = ACERHDF_FAN_OFF;
e86435eb
PF		 239
240 return 0;
241}
242
243static void acerhdf_change_fanstate(int state)
244{
245 unsigned char cmd;
246
247 if (verbose)
248 pr_notice("fan %s\n", (state == ACERHDF_FAN_OFF) ?
249 "OFF" : "ON");
250
251 if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
252 pr_err("invalid fan state %d requested, setting to auto!\n",
253 state);
254 state = ACERHDF_FAN_AUTO;
255 }
256
ded0cdfc
PF		 257 cmd = (state == ACERHDF_FAN_OFF) ? bios_cfg->cmd.cmd_off
258 : bios_cfg->cmd.cmd_auto;
e86435eb
PF		 259 fanstate = state;
260
261 ec_write(bios_cfg->fanreg, cmd);
262}
263
264static void acerhdf_check_param(struct thermal_zone_device *thermal)
265{
266 if (fanon > ACERHDF_MAX_FANON) {
267 pr_err("fanon temperature too high, set to %d\n",
268 ACERHDF_MAX_FANON);
269 fanon = ACERHDF_MAX_FANON;
270 }
271
272 if (kernelmode && prev_interval != interval) {
273 if (interval > ACERHDF_MAX_INTERVAL) {
274 pr_err("interval too high, set to %d\n",
275 ACERHDF_MAX_INTERVAL);
276 interval = ACERHDF_MAX_INTERVAL;
277 }
278 if (verbose)
279 pr_notice("interval changed to: %d\n",
280 interval);
281 thermal->polling_delay = interval*1000;
282 prev_interval = interval;
283 }
284}
285
286/*
287 * This is the thermal zone callback which does the delayed polling of the fan
288 * state. We do check /sysfs-originating settings here in acerhdf_check_param()
289 * as late as the polling interval is since we can't do that in the respective
290 * accessors of the module parameters.
291 */
292static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal,
293 unsigned long *t)
294{
295 int temp, err = 0;
296
297 acerhdf_check_param(thermal);
298
299 err = acerhdf_get_temp(&temp);
300 if (err)
301 return err;
302
303 if (verbose)
304 pr_notice("temp %d\n", temp);
305
306 *t = temp;
307 return 0;
308}
309
310static int acerhdf_bind(struct thermal_zone_device *thermal,
311 struct thermal_cooling_device *cdev)
312{
313 /* if the cooling device is the one from acerhdf bind it */
314 if (cdev != cl_dev)
315 return 0;
316
317 if (thermal_zone_bind_cooling_device(thermal, 0, cdev)) {
318 pr_err("error binding cooling dev\n");
319 return -EINVAL;
320 }
321 return 0;
322}
323
324static int acerhdf_unbind(struct thermal_zone_device *thermal,
325 struct thermal_cooling_device *cdev)
326{
327 if (cdev != cl_dev)
328 return 0;
329
330 if (thermal_zone_unbind_cooling_device(thermal, 0, cdev)) {
331 pr_err("error unbinding cooling dev\n");
332 return -EINVAL;
333 }
334 return 0;
335}
336
337static inline void acerhdf_revert_to_bios_mode(void)
338{
339 acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
340 kernelmode = 0;
341 if (thz_dev)
342 thz_dev->polling_delay = 0;
343 pr_notice("kernel mode fan control OFF\n");
344}
345static inline void acerhdf_enable_kernelmode(void)
346{
347 kernelmode = 1;
348
349 thz_dev->polling_delay = interval*1000;
350 thermal_zone_device_update(thz_dev);
351 pr_notice("kernel mode fan control ON\n");
352}
353
354static int acerhdf_get_mode(struct thermal_zone_device *thermal,
355 enum thermal_device_mode *mode)
356{
357 if (verbose)
358 pr_notice("kernel mode fan control %d\n", kernelmode);
359
360 *mode = (kernelmode) ? THERMAL_DEVICE_ENABLED
361 : THERMAL_DEVICE_DISABLED;
362
363 return 0;
364}
365
366/*
367 * set operation mode;
368 * enabled: the thermal layer of the kernel takes care about
369 * the temperature and the fan.
370 * disabled: the BIOS takes control of the fan.
371 */
372static int acerhdf_set_mode(struct thermal_zone_device *thermal,
373 enum thermal_device_mode mode)
374{
375 if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
376 acerhdf_revert_to_bios_mode();
377 else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
378 acerhdf_enable_kernelmode();
379
380 return 0;
381}
382
383static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
384 enum thermal_trip_type *type)
385{
386 if (trip == 0)
387 *type = THERMAL_TRIP_ACTIVE;
388
389 return 0;
390}
391
392static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
393 unsigned long *temp)
394{
395 if (trip == 0)
396 *temp = fanon;
397
398 return 0;
399}
400
401static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
402 unsigned long *temperature)
403{
404 *temperature = ACERHDF_TEMP_CRIT;
405 return 0;
406}
407
408/* bind callback functions to thermalzone */
fedae5ad 409static struct thermal_zone_device_ops acerhdf_dev_ops = {
e86435eb
PF		 410 .bind = acerhdf_bind,
411 .unbind = acerhdf_unbind,
412 .get_temp = acerhdf_get_ec_temp,
413 .get_mode = acerhdf_get_mode,
414 .set_mode = acerhdf_set_mode,
415 .get_trip_type = acerhdf_get_trip_type,
416 .get_trip_temp = acerhdf_get_trip_temp,
417 .get_crit_temp = acerhdf_get_crit_temp,
418};
419
420
421/*
422 * cooling device callback functions
423 * get maximal fan cooling state
424 */
425static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
426 unsigned long *state)
427{
428 *state = 1;
429
430 return 0;
431}
432
433static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
434 unsigned long *state)
435{
436 int err = 0, tmp;
437
438 err = acerhdf_get_fanstate(&tmp);
439 if (err)
440 return err;
441
442 *state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
443 return 0;
444}
445
446/* change current fan state - is overwritten when running in kernel mode */
447static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
448 unsigned long state)
449{
450 int cur_temp, cur_state, err = 0;
451
452 if (!kernelmode)
453 return 0;
454
455 err = acerhdf_get_temp(&cur_temp);
456 if (err) {
457 pr_err("error reading temperature, hand off control to BIOS\n");
458 goto err_out;
459 }
460
461 err = acerhdf_get_fanstate(&cur_state);
462 if (err) {
463 pr_err("error reading fan state, hand off control to BIOS\n");
464 goto err_out;
465 }
466
467 if (state == 0) {
468 /* turn fan off only if below fanoff temperature */
469 if ((cur_state == ACERHDF_FAN_AUTO) &&
470 (cur_temp < fanoff))
471 acerhdf_change_fanstate(ACERHDF_FAN_OFF);
472 } else {
473 if (cur_state == ACERHDF_FAN_OFF)
474 acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
475 }
476 return 0;
477
478err_out:
479 acerhdf_revert_to_bios_mode();
480 return -EINVAL;
481}
482
483/* bind fan callbacks to fan device */
fedae5ad 484static struct thermal_cooling_device_ops acerhdf_cooling_ops = {
e86435eb
PF		 485 .get_max_state = acerhdf_get_max_state,
486 .get_cur_state = acerhdf_get_cur_state,
487 .set_cur_state = acerhdf_set_cur_state,
488};
489
490/* suspend / resume functionality */
ff27e1f3 491static int acerhdf_suspend(struct device *dev)
e86435eb
PF		 492{
493 if (kernelmode)
494 acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
495
496 if (verbose)
497 pr_notice("going suspend\n");
498
499 return 0;
500}
501
e86435eb
PF		 502static int __devinit acerhdf_probe(struct platform_device *device)
503{
504 return 0;
505}
506
507static int acerhdf_remove(struct platform_device *device)
508{
509 return 0;
510}
511
47145210 512static const struct dev_pm_ops acerhdf_pm_ops = {
ff27e1f3
BP		 513 .suspend = acerhdf_suspend,
514 .freeze = acerhdf_suspend,
515};
516
ded0cdfc 517static struct platform_driver acerhdf_driver = {
e86435eb 518 .driver = {
ff27e1f3 519 .name = "acerhdf",
e86435eb 520 .owner = THIS_MODULE,
ff27e1f3 521 .pm = &acerhdf_pm_ops,
e86435eb
PF		 522 },
523 .probe = acerhdf_probe,
524 .remove = acerhdf_remove,
e86435eb
PF		 525};
526
dcbfb815
PF		 527/* checks if str begins with start */
528static int str_starts_with(const char *str, const char *start)
529{
530 unsigned long str_len = 0, start_len = 0;
531
532 str_len = strlen(str);
533 start_len = strlen(start);
534
535 if (str_len >= start_len &&
536 !strncmp(str, start, start_len))
537 return 1;
538
539 return 0;
540}
e86435eb
PF		 541
542/* check hardware */
543static int acerhdf_check_hardware(void)
544{
545 char const *vendor, *version, *product;
dcbfb815 546 const struct bios_settings_t *bt = NULL;
e86435eb
PF		 547
548 /* get BIOS data */
549 vendor = dmi_get_system_info(DMI_SYS_VENDOR);
550 version = dmi_get_system_info(DMI_BIOS_VERSION);
551 product = dmi_get_system_info(DMI_PRODUCT_NAME);
552
5cf4c07a
RC		 553 if (!vendor || !version || !product) {
554 pr_err("error getting hardware information\n");
555 return -EINVAL;
556 }
ded0cdfc 557
e86435eb
PF		 558 pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
559
ded0cdfc 560 if (force_bios[0]) {
e86435eb 561 version = force_bios;
ded0cdfc 562 pr_info("forcing BIOS version: %s\n", version);
e86435eb
PF		 563 kernelmode = 0;
564 }
565
ded0cdfc
PF		 566 if (force_product[0]) {
567 product = force_product;
568 pr_info("forcing BIOS product: %s\n", product);
569 kernelmode = 0;
570 }
571
e86435eb
PF		 572 if (verbose)
573 pr_info("BIOS info: %s %s, product: %s\n",
574 vendor, version, product);
575
576 /* search BIOS version and vendor in BIOS settings table */
dcbfb815
PF		 577 for (bt = bios_tbl; bt->vendor[0]; bt++) {
578 /*
579 * check if actual hardware BIOS vendor, product and version
580 * IDs start with the strings of BIOS table entry
581 */
582 if (str_starts_with(vendor, bt->vendor) &&
583 str_starts_with(product, bt->product) &&
584 str_starts_with(version, bt->version)) {
585 bios_cfg = bt;
e86435eb
PF		 586 break;
587 }
588 }
589
590 if (!bios_cfg) {
ded0cdfc
PF		 591 pr_err("unknown (unsupported) BIOS version %s/%s/%s, "
592 "please report, aborting!\n", vendor, product, version);
e86435eb
PF		 593 return -EINVAL;
594 }
595
596 /*
597 * if started with kernel mode off, prevent the kernel from switching
598 * off the fan
599 */
600 if (!kernelmode) {
601 pr_notice("Fan control off, to enable do:\n");
602 pr_notice("echo -n \"enabled\" > "
603 "/sys/class/thermal/thermal_zone0/mode\n");
604 }
605
606 return 0;
607}
608
609static int acerhdf_register_platform(void)
610{
611 int err = 0;
612
ded0cdfc 613 err = platform_driver_register(&acerhdf_driver);
e86435eb
PF		 614 if (err)
615 return err;
616
617 acerhdf_dev = platform_device_alloc("acerhdf", -1);
a0dba697
AL		 618 if (!acerhdf_dev) {
619 err = -ENOMEM;
620 goto err_device_alloc;
621 }
622 err = platform_device_add(acerhdf_dev);
623 if (err)
624 goto err_device_add;
e86435eb
PF		 625
626 return 0;
a0dba697
AL		 627
628err_device_add:
629 platform_device_put(acerhdf_dev);
630err_device_alloc:
631 platform_driver_unregister(&acerhdf_driver);
632 return err;
e86435eb
PF		 633}
634
635static void acerhdf_unregister_platform(void)
636{
a0dba697 637 platform_device_unregister(acerhdf_dev);
ded0cdfc 638 platform_driver_unregister(&acerhdf_driver);
e86435eb
PF		 639}
640
641static int acerhdf_register_thermal(void)
642{
643 cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
644 &acerhdf_cooling_ops);
645
646 if (IS_ERR(cl_dev))
647 return -EINVAL;
648
649 thz_dev = thermal_zone_device_register("acerhdf", 1, NULL,
650 &acerhdf_dev_ops, 0, 0, 0,
651 (kernelmode) ? interval*1000 : 0);
652 if (IS_ERR(thz_dev))
653 return -EINVAL;
654
655 return 0;
656}
657
658static void acerhdf_unregister_thermal(void)
659{
660 if (cl_dev) {
661 thermal_cooling_device_unregister(cl_dev);
662 cl_dev = NULL;
663 }
664
665 if (thz_dev) {
666 thermal_zone_device_unregister(thz_dev);
667 thz_dev = NULL;
668 }
669}
670
671static int __init acerhdf_init(void)
672{
673 int err = 0;
674
675 err = acerhdf_check_hardware();
676 if (err)
677 goto out_err;
678
679 err = acerhdf_register_platform();
680 if (err)
a0dba697 681 goto out_err;
e86435eb
PF		 682
683 err = acerhdf_register_thermal();
684 if (err)
685 goto err_unreg;
686
687 return 0;
688
689err_unreg:
690 acerhdf_unregister_thermal();
691 acerhdf_unregister_platform();
692
693out_err:
a0dba697 694 return err;
e86435eb
PF		 695}
696
697static void __exit acerhdf_exit(void)
698{
699 acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
700 acerhdf_unregister_thermal();
701 acerhdf_unregister_platform();
702}
703
704MODULE_LICENSE("GPL");
705MODULE_AUTHOR("Peter Feuerer");
706MODULE_DESCRIPTION("Aspire One temperature and fan driver");
bdc731bc 707MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
94219d79
PF		 708MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1410*:");
709MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1810*:");
24964639 710MODULE_ALIAS("dmi:*:*Acer*:pnAO531*:");
bdc731bc 711MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
94219d79 712MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
bdc731bc
SB		 713MODULE_ALIAS("dmi:*:*Packard Bell*:pnAOA*:");
714MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOA*:");
94219d79 715MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMU*:");
887b7ca9 716MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMA*:");
e86435eb
PF		 717
718module_init(acerhdf_init);
719module_exit(acerhdf_exit);
Linux kernel - Deliverables
This page took 0.211867 seconds and 5 git commands to generate.