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