PageRenderTime 79ms CodeModel.GetById 9ms app.highlight 63ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/platform/x86/acerhdf.c

http://github.com/mirrors/linux
C | 833 lines | 604 code | 119 blank | 110 comment | 88 complexity | ff03eb06f9a71354e16c56e91ed75984 MD5 | raw file
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * acerhdf - A driver which monitors the temperature
  4 *           of the aspire one netbook, turns on/off the fan
  5 *           as soon as the upper/lower threshold is reached.
  6 *
  7 * (C) 2009 - Peter Kaestle     peter (a) piie.net
  8 *                              http://piie.net
  9 *     2009 Borislav Petkov	bp (a) alien8.de
 10 *
 11 * Inspired by and many thanks to:
 12 *  o acerfand   - Rachel Greenham
 13 *  o acer_ec.pl - Michael Kurz     michi.kurz (at) googlemail.com
 14 *               - Petr Tomasek     tomasek (#) etf,cuni,cz
 15 *               - Carlos Corbacho  cathectic (at) gmail.com
 16 *  o lkml       - Matthew Garrett
 17 *               - Borislav Petkov
 18 *               - Andreas Mohr
 19 */
 20
 21#define pr_fmt(fmt) "acerhdf: " fmt
 22
 23#include <linux/kernel.h>
 24#include <linux/module.h>
 25#include <linux/dmi.h>
 26#include <linux/acpi.h>
 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
 40#define DRV_VER "0.7.0"
 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 */
 49#define ACERHDF_TEMP_CRIT 89000
 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 */
 57#define ACERHDF_MAX_FANON 80000
 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
 67static int kernelmode = 1;
 68#else
 69static int kernelmode;
 70#endif
 71
 72static unsigned int interval = 10;
 73static unsigned int fanon = 60000;
 74static unsigned int fanoff = 53000;
 75static unsigned int verbose;
 76static unsigned int list_supported;
 77static unsigned int fanstate = ACERHDF_FAN_AUTO;
 78static char force_bios[16];
 79static char force_product[16];
 80static unsigned int prev_interval;
 81static struct thermal_zone_device *thz_dev;
 82static struct thermal_cooling_device *cl_dev;
 83static struct platform_device *acerhdf_dev;
 84
 85module_param(kernelmode, uint, 0);
 86MODULE_PARM_DESC(kernelmode, "Kernel mode fan control on / off");
 87module_param(interval, uint, 0600);
 88MODULE_PARM_DESC(interval, "Polling interval of temperature check");
 89module_param(fanon, uint, 0600);
 90MODULE_PARM_DESC(fanon, "Turn the fan on above this temperature");
 91module_param(fanoff, uint, 0600);
 92MODULE_PARM_DESC(fanoff, "Turn the fan off below this temperature");
 93module_param(verbose, uint, 0600);
 94MODULE_PARM_DESC(verbose, "Enable verbose dmesg output");
 95module_param(list_supported, uint, 0600);
 96MODULE_PARM_DESC(list_supported, "List supported models and BIOS versions");
 97module_param_string(force_bios, force_bios, 16, 0);
 98MODULE_PARM_DESC(force_bios, "Pretend system has this known supported BIOS version");
 99module_param_string(force_product, force_product, 16, 0);
100MODULE_PARM_DESC(force_product, "Pretend system is this known supported model");
101
102/*
103 * cmd_off: to switch the fan completely off and check if the fan is off
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 */
107struct fancmd {
108	u8 cmd_off;
109	u8 cmd_auto;
110};
111
112struct manualcmd {
113	u8 mreg;
114	u8 moff;
115};
116
117/* default register and command to disable fan in manual mode */
118static const struct manualcmd mcmd = {
119	.mreg = 0x94,
120	.moff = 0xff,
121};
122
123/* BIOS settings - only used during probe */
124struct bios_settings {
125	const char *vendor;
126	const char *product;
127	const char *version;
128	u8 fanreg;
129	u8 tempreg;
130	struct fancmd cmd;
131	int mcmd_enable;
132};
133
134/* This could be a daughter struct in the above, but not worth the redirect */
135struct ctrl_settings {
136	u8 fanreg;
137	u8 tempreg;
138	struct fancmd cmd;
139	int mcmd_enable;
140};
141
142static struct ctrl_settings ctrl_cfg __read_mostly;
143
144/* Register addresses and values for different BIOS versions */
145static const struct bios_settings bios_tbl[] __initconst = {
146	/* AOA110 */
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},
156	/* AOA150 */
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},
165	/* LT1005u */
166	{"Acer", "LT-10Q", "v0.3310", 0x55, 0x58, {0x20, 0x00}, 0},
167	/* Acer 1410 */
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},
179	/* Acer 1810xx */
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},
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},
207	/* Acer 531 */
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},
211	/* Acer 751 */
212	{"Acer", "AO751h", "V0.3206", 0x55, 0x58, {0x21, 0x00}, 0},
213	{"Acer", "AO751h", "V0.3212", 0x55, 0x58, {0x21, 0x00}, 0},
214	/* Acer 753 */
215	{"Acer", "Aspire One 753", "V1.24", 0x93, 0xac, {0x14, 0x04}, 1},
216	/* Acer 1825 */
217	{"Acer", "Aspire 1825PTZ", "V1.3118", 0x55, 0x58, {0x9e, 0x00}, 0},
218	{"Acer", "Aspire 1825PTZ", "V1.3127", 0x55, 0x58, {0x9e, 0x00}, 0},
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},
225	/* Acer TravelMate 7730 */
226	{"Acer", "TravelMate 7730G", "v0.3509", 0x55, 0x58, {0xaf, 0x00}, 0},
227	/* Acer Aspire 7551 */
228	{"Acer", "Aspire 7551", "V1.18", 0x93, 0xa8, {0x14, 0x04}, 1},
229	/* Acer TravelMate TM8573T */
230	{"Acer", "TM8573T", "V1.13", 0x93, 0xa8, {0x14, 0x04}, 1},
231	/* Gateway */
232	{"Gateway", "AOA110", "v0.3103",  0x55, 0x58, {0x21, 0x00}, 0},
233	{"Gateway", "AOA150", "v0.3103",  0x55, 0x58, {0x20, 0x00}, 0},
234	{"Gateway", "LT31",   "v1.3103",  0x55, 0x58, {0x9e, 0x00}, 0},
235	{"Gateway", "LT31",   "v1.3201",  0x55, 0x58, {0x9e, 0x00}, 0},
236	{"Gateway", "LT31",   "v1.3302",  0x55, 0x58, {0x9e, 0x00}, 0},
237	{"Gateway", "LT31",   "v1.3303t", 0x55, 0x58, {0x9e, 0x00}, 0},
238	{"Gateway", "LT31",   "v1.3307",  0x55, 0x58, {0x9e, 0x00}, 0},
239	/* Packard Bell */
240	{"Packard Bell", "DOA150",  "v0.3104",  0x55, 0x58, {0x21, 0x00}, 0},
241	{"Packard Bell", "DOA150",  "v0.3105",  0x55, 0x58, {0x20, 0x00}, 0},
242	{"Packard Bell", "AOA110",  "v0.3105",  0x55, 0x58, {0x21, 0x00}, 0},
243	{"Packard Bell", "AOA150",  "v0.3105",  0x55, 0x58, {0x20, 0x00}, 0},
244	{"Packard Bell", "ENBFT",   "V1.3118",  0x55, 0x58, {0x9e, 0x00}, 0},
245	{"Packard Bell", "ENBFT",   "V1.3127",  0x55, 0x58, {0x9e, 0x00}, 0},
246	{"Packard Bell", "DOTMU",   "v1.3303",  0x55, 0x58, {0x9e, 0x00}, 0},
247	{"Packard Bell", "DOTMU",   "v0.3120",  0x55, 0x58, {0x9e, 0x00}, 0},
248	{"Packard Bell", "DOTMU",   "v0.3108",  0x55, 0x58, {0x9e, 0x00}, 0},
249	{"Packard Bell", "DOTMU",   "v0.3113",  0x55, 0x58, {0x9e, 0x00}, 0},
250	{"Packard Bell", "DOTMU",   "v0.3115",  0x55, 0x58, {0x9e, 0x00}, 0},
251	{"Packard Bell", "DOTMU",   "v0.3117",  0x55, 0x58, {0x9e, 0x00}, 0},
252	{"Packard Bell", "DOTMU",   "v0.3119",  0x55, 0x58, {0x9e, 0x00}, 0},
253	{"Packard Bell", "DOTMU",   "v1.3204",  0x55, 0x58, {0x9e, 0x00}, 0},
254	{"Packard Bell", "DOTMA",   "v1.3201",  0x55, 0x58, {0x9e, 0x00}, 0},
255	{"Packard Bell", "DOTMA",   "v1.3302",  0x55, 0x58, {0x9e, 0x00}, 0},
256	{"Packard Bell", "DOTMA",   "v1.3303t", 0x55, 0x58, {0x9e, 0x00}, 0},
257	{"Packard Bell", "DOTVR46", "v1.3308",  0x55, 0x58, {0x9e, 0x00}, 0},
258	/* pewpew-terminator */
259	{"", "", "", 0, 0, {0, 0}, 0}
260};
261
262/*
263 * this struct is used to instruct thermal layer to use bang_bang instead of
264 * default governor for acerhdf
265 */
266static struct thermal_zone_params acerhdf_zone_params = {
267	.governor_name = "bang_bang",
268};
269
270static int acerhdf_get_temp(int *temp)
271{
272	u8 read_temp;
273
274	if (ec_read(ctrl_cfg.tempreg, &read_temp))
275		return -EINVAL;
276
277	*temp = read_temp * 1000;
278
279	return 0;
280}
281
282static int acerhdf_get_fanstate(int *state)
283{
284	u8 fan;
285
286	if (ec_read(ctrl_cfg.fanreg, &fan))
287		return -EINVAL;
288
289	if (fan != ctrl_cfg.cmd.cmd_off)
290		*state = ACERHDF_FAN_AUTO;
291	else
292		*state = ACERHDF_FAN_OFF;
293
294	return 0;
295}
296
297static void acerhdf_change_fanstate(int state)
298{
299	unsigned char cmd;
300
301	if (verbose)
302		pr_notice("fan %s\n", state == ACERHDF_FAN_OFF ? "OFF" : "ON");
303
304	if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
305		pr_err("invalid fan state %d requested, setting to auto!\n",
306		       state);
307		state = ACERHDF_FAN_AUTO;
308	}
309
310	cmd = (state == ACERHDF_FAN_OFF) ? ctrl_cfg.cmd.cmd_off
311					 : ctrl_cfg.cmd.cmd_auto;
312	fanstate = state;
313
314	ec_write(ctrl_cfg.fanreg, cmd);
315
316	if (ctrl_cfg.mcmd_enable && state == ACERHDF_FAN_OFF) {
317		if (verbose)
318			pr_notice("turning off fan manually\n");
319		ec_write(mcmd.mreg, mcmd.moff);
320	}
321}
322
323static void acerhdf_check_param(struct thermal_zone_device *thermal)
324{
325	if (fanon > ACERHDF_MAX_FANON) {
326		pr_err("fanon temperature too high, set to %d\n",
327		       ACERHDF_MAX_FANON);
328		fanon = ACERHDF_MAX_FANON;
329	}
330
331	if (kernelmode && prev_interval != interval) {
332		if (interval > ACERHDF_MAX_INTERVAL) {
333			pr_err("interval too high, set to %d\n",
334			       ACERHDF_MAX_INTERVAL);
335			interval = ACERHDF_MAX_INTERVAL;
336		}
337		if (verbose)
338			pr_notice("interval changed to: %d\n", interval);
339		thermal->polling_delay = interval*1000;
340		prev_interval = interval;
341	}
342}
343
344/*
345 * This is the thermal zone callback which does the delayed polling of the fan
346 * state. We do check /sysfs-originating settings here in acerhdf_check_param()
347 * as late as the polling interval is since we can't do that in the respective
348 * accessors of the module parameters.
349 */
350static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal, int *t)
351{
352	int temp, err = 0;
353
354	acerhdf_check_param(thermal);
355
356	err = acerhdf_get_temp(&temp);
357	if (err)
358		return err;
359
360	if (verbose)
361		pr_notice("temp %d\n", temp);
362
363	*t = temp;
364	return 0;
365}
366
367static int acerhdf_bind(struct thermal_zone_device *thermal,
368			struct thermal_cooling_device *cdev)
369{
370	/* if the cooling device is the one from acerhdf bind it */
371	if (cdev != cl_dev)
372		return 0;
373
374	if (thermal_zone_bind_cooling_device(thermal, 0, cdev,
375			THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
376			THERMAL_WEIGHT_DEFAULT)) {
377		pr_err("error binding cooling dev\n");
378		return -EINVAL;
379	}
380	return 0;
381}
382
383static int acerhdf_unbind(struct thermal_zone_device *thermal,
384			  struct thermal_cooling_device *cdev)
385{
386	if (cdev != cl_dev)
387		return 0;
388
389	if (thermal_zone_unbind_cooling_device(thermal, 0, cdev)) {
390		pr_err("error unbinding cooling dev\n");
391		return -EINVAL;
392	}
393	return 0;
394}
395
396static inline void acerhdf_revert_to_bios_mode(void)
397{
398	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
399	kernelmode = 0;
400	if (thz_dev)
401		thz_dev->polling_delay = 0;
402	pr_notice("kernel mode fan control OFF\n");
403}
404static inline void acerhdf_enable_kernelmode(void)
405{
406	kernelmode = 1;
407
408	thz_dev->polling_delay = interval*1000;
409	thermal_zone_device_update(thz_dev, THERMAL_EVENT_UNSPECIFIED);
410	pr_notice("kernel mode fan control ON\n");
411}
412
413static int acerhdf_get_mode(struct thermal_zone_device *thermal,
414			    enum thermal_device_mode *mode)
415{
416	if (verbose)
417		pr_notice("kernel mode fan control %d\n", kernelmode);
418
419	*mode = (kernelmode) ? THERMAL_DEVICE_ENABLED
420			     : THERMAL_DEVICE_DISABLED;
421
422	return 0;
423}
424
425/*
426 * set operation mode;
427 * enabled: the thermal layer of the kernel takes care about
428 *          the temperature and the fan.
429 * disabled: the BIOS takes control of the fan.
430 */
431static int acerhdf_set_mode(struct thermal_zone_device *thermal,
432			    enum thermal_device_mode mode)
433{
434	if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
435		acerhdf_revert_to_bios_mode();
436	else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
437		acerhdf_enable_kernelmode();
438
439	return 0;
440}
441
442static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
443				 enum thermal_trip_type *type)
444{
445	if (trip == 0)
446		*type = THERMAL_TRIP_ACTIVE;
447	else if (trip == 1)
448		*type = THERMAL_TRIP_CRITICAL;
449	else
450		return -EINVAL;
451
452	return 0;
453}
454
455static int acerhdf_get_trip_hyst(struct thermal_zone_device *thermal, int trip,
456				 int *temp)
457{
458	if (trip != 0)
459		return -EINVAL;
460
461	*temp = fanon - fanoff;
462
463	return 0;
464}
465
466static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
467				 int *temp)
468{
469	if (trip == 0)
470		*temp = fanon;
471	else if (trip == 1)
472		*temp = ACERHDF_TEMP_CRIT;
473	else
474		return -EINVAL;
475
476	return 0;
477}
478
479static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
480				 int *temperature)
481{
482	*temperature = ACERHDF_TEMP_CRIT;
483	return 0;
484}
485
486/* bind callback functions to thermalzone */
487static struct thermal_zone_device_ops acerhdf_dev_ops = {
488	.bind = acerhdf_bind,
489	.unbind = acerhdf_unbind,
490	.get_temp = acerhdf_get_ec_temp,
491	.get_mode = acerhdf_get_mode,
492	.set_mode = acerhdf_set_mode,
493	.get_trip_type = acerhdf_get_trip_type,
494	.get_trip_hyst = acerhdf_get_trip_hyst,
495	.get_trip_temp = acerhdf_get_trip_temp,
496	.get_crit_temp = acerhdf_get_crit_temp,
497};
498
499
500/*
501 * cooling device callback functions
502 * get maximal fan cooling state
503 */
504static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
505				 unsigned long *state)
506{
507	*state = 1;
508
509	return 0;
510}
511
512static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
513				 unsigned long *state)
514{
515	int err = 0, tmp;
516
517	err = acerhdf_get_fanstate(&tmp);
518	if (err)
519		return err;
520
521	*state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
522	return 0;
523}
524
525/* change current fan state - is overwritten when running in kernel mode */
526static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
527				 unsigned long state)
528{
529	int cur_temp, cur_state, err = 0;
530
531	if (!kernelmode)
532		return 0;
533
534	err = acerhdf_get_temp(&cur_temp);
535	if (err) {
536		pr_err("error reading temperature, hand off control to BIOS\n");
537		goto err_out;
538	}
539
540	err = acerhdf_get_fanstate(&cur_state);
541	if (err) {
542		pr_err("error reading fan state, hand off control to BIOS\n");
543		goto err_out;
544	}
545
546	if (state == 0) {
547		if (cur_state == ACERHDF_FAN_AUTO)
548			acerhdf_change_fanstate(ACERHDF_FAN_OFF);
549	} else {
550		if (cur_state == ACERHDF_FAN_OFF)
551			acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
552	}
553	return 0;
554
555err_out:
556	acerhdf_revert_to_bios_mode();
557	return -EINVAL;
558}
559
560/* bind fan callbacks to fan device */
561static const struct thermal_cooling_device_ops acerhdf_cooling_ops = {
562	.get_max_state = acerhdf_get_max_state,
563	.get_cur_state = acerhdf_get_cur_state,
564	.set_cur_state = acerhdf_set_cur_state,
565};
566
567/* suspend / resume functionality */
568static int acerhdf_suspend(struct device *dev)
569{
570	if (kernelmode)
571		acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
572
573	if (verbose)
574		pr_notice("going suspend\n");
575
576	return 0;
577}
578
579static int acerhdf_probe(struct platform_device *device)
580{
581	return 0;
582}
583
584static int acerhdf_remove(struct platform_device *device)
585{
586	return 0;
587}
588
589static const struct dev_pm_ops acerhdf_pm_ops = {
590	.suspend = acerhdf_suspend,
591	.freeze  = acerhdf_suspend,
592};
593
594static struct platform_driver acerhdf_driver = {
595	.driver = {
596		.name  = "acerhdf",
597		.pm    = &acerhdf_pm_ops,
598	},
599	.probe = acerhdf_probe,
600	.remove = acerhdf_remove,
601};
602
603/* checks if str begins with start */
604static int str_starts_with(const char *str, const char *start)
605{
606	unsigned long str_len = 0, start_len = 0;
607
608	str_len = strlen(str);
609	start_len = strlen(start);
610
611	if (str_len >= start_len &&
612			!strncmp(str, start, start_len))
613		return 1;
614
615	return 0;
616}
617
618/* check hardware */
619static int __init acerhdf_check_hardware(void)
620{
621	char const *vendor, *version, *product;
622	const struct bios_settings *bt = NULL;
623	int found = 0;
624
625	/* get BIOS data */
626	vendor  = dmi_get_system_info(DMI_SYS_VENDOR);
627	version = dmi_get_system_info(DMI_BIOS_VERSION);
628	product = dmi_get_system_info(DMI_PRODUCT_NAME);
629
630	if (!vendor || !version || !product) {
631		pr_err("error getting hardware information\n");
632		return -EINVAL;
633	}
634
635	pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
636
637	if (list_supported) {
638		pr_info("List of supported Manufacturer/Model/BIOS:\n");
639		pr_info("---------------------------------------------------\n");
640		for (bt = bios_tbl; bt->vendor[0]; bt++) {
641			pr_info("%-13s | %-17s | %-10s\n", bt->vendor,
642				bt->product, bt->version);
643		}
644		pr_info("---------------------------------------------------\n");
645		return -ECANCELED;
646	}
647
648	if (force_bios[0]) {
649		version = force_bios;
650		pr_info("forcing BIOS version: %s\n", version);
651		kernelmode = 0;
652	}
653
654	if (force_product[0]) {
655		product = force_product;
656		pr_info("forcing BIOS product: %s\n", product);
657		kernelmode = 0;
658	}
659
660	if (verbose)
661		pr_info("BIOS info: %s %s, product: %s\n",
662			vendor, version, product);
663
664	/* search BIOS version and vendor in BIOS settings table */
665	for (bt = bios_tbl; bt->vendor[0]; bt++) {
666		/*
667		 * check if actual hardware BIOS vendor, product and version
668		 * IDs start with the strings of BIOS table entry
669		 */
670		if (str_starts_with(vendor, bt->vendor) &&
671				str_starts_with(product, bt->product) &&
672				str_starts_with(version, bt->version)) {
673			found = 1;
674			break;
675		}
676	}
677
678	if (!found) {
679		pr_err("unknown (unsupported) BIOS version %s/%s/%s, please report, aborting!\n",
680		       vendor, product, version);
681		return -EINVAL;
682	}
683
684	/* Copy control settings from BIOS table before we free it. */
685	ctrl_cfg.fanreg = bt->fanreg;
686	ctrl_cfg.tempreg = bt->tempreg;
687	memcpy(&ctrl_cfg.cmd, &bt->cmd, sizeof(struct fancmd));
688	ctrl_cfg.mcmd_enable = bt->mcmd_enable;
689
690	/*
691	 * if started with kernel mode off, prevent the kernel from switching
692	 * off the fan
693	 */
694	if (!kernelmode) {
695		pr_notice("Fan control off, to enable do:\n");
696		pr_notice("echo -n \"enabled\" > /sys/class/thermal/thermal_zoneN/mode # N=0,1,2...\n");
697	}
698
699	return 0;
700}
701
702static int __init acerhdf_register_platform(void)
703{
704	int err = 0;
705
706	err = platform_driver_register(&acerhdf_driver);
707	if (err)
708		return err;
709
710	acerhdf_dev = platform_device_alloc("acerhdf", -1);
711	if (!acerhdf_dev) {
712		err = -ENOMEM;
713		goto err_device_alloc;
714	}
715	err = platform_device_add(acerhdf_dev);
716	if (err)
717		goto err_device_add;
718
719	return 0;
720
721err_device_add:
722	platform_device_put(acerhdf_dev);
723err_device_alloc:
724	platform_driver_unregister(&acerhdf_driver);
725	return err;
726}
727
728static void acerhdf_unregister_platform(void)
729{
730	platform_device_unregister(acerhdf_dev);
731	platform_driver_unregister(&acerhdf_driver);
732}
733
734static int __init acerhdf_register_thermal(void)
735{
736	cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
737						 &acerhdf_cooling_ops);
738
739	if (IS_ERR(cl_dev))
740		return -EINVAL;
741
742	thz_dev = thermal_zone_device_register("acerhdf", 2, 0, NULL,
743					      &acerhdf_dev_ops,
744					      &acerhdf_zone_params, 0,
745					      (kernelmode) ? interval*1000 : 0);
746	if (IS_ERR(thz_dev))
747		return -EINVAL;
748
749	if (strcmp(thz_dev->governor->name,
750				acerhdf_zone_params.governor_name)) {
751		pr_err("Didn't get thermal governor %s, perhaps not compiled into thermal subsystem.\n",
752				acerhdf_zone_params.governor_name);
753		return -EINVAL;
754	}
755
756	return 0;
757}
758
759static void acerhdf_unregister_thermal(void)
760{
761	if (cl_dev) {
762		thermal_cooling_device_unregister(cl_dev);
763		cl_dev = NULL;
764	}
765
766	if (thz_dev) {
767		thermal_zone_device_unregister(thz_dev);
768		thz_dev = NULL;
769	}
770}
771
772static int __init acerhdf_init(void)
773{
774	int err = 0;
775
776	err = acerhdf_check_hardware();
777	if (err)
778		goto out_err;
779
780	err = acerhdf_register_platform();
781	if (err)
782		goto out_err;
783
784	err = acerhdf_register_thermal();
785	if (err)
786		goto err_unreg;
787
788	return 0;
789
790err_unreg:
791	acerhdf_unregister_thermal();
792	acerhdf_unregister_platform();
793
794out_err:
795	return err;
796}
797
798static void __exit acerhdf_exit(void)
799{
800	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
801	acerhdf_unregister_thermal();
802	acerhdf_unregister_platform();
803}
804
805MODULE_LICENSE("GPL");
806MODULE_AUTHOR("Peter Kaestle");
807MODULE_DESCRIPTION("Aspire One temperature and fan driver");
808MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
809MODULE_ALIAS("dmi:*:*Acer*:pnAO751h*:");
810MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1410*:");
811MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1810*:");
812MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5755G:");
813MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1825PTZ:");
814MODULE_ALIAS("dmi:*:*Acer*:pnAO521*:");
815MODULE_ALIAS("dmi:*:*Acer*:pnAO531*:");
816MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5739G:");
817MODULE_ALIAS("dmi:*:*Acer*:pnAspire*One*753:");
818MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5315:");
819MODULE_ALIAS("dmi:*:*Acer*:TravelMate*7730G:");
820MODULE_ALIAS("dmi:*:*Acer*:pnAspire*7551:");
821MODULE_ALIAS("dmi:*:*Acer*:TM8573T:");
822MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
823MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
824MODULE_ALIAS("dmi:*:*Packard*Bell*:pnAOA*:");
825MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOA*:");
826MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMU*:");
827MODULE_ALIAS("dmi:*:*Packard*Bell*:pnENBFT*:");
828MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMA*:");
829MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTVR46*:");
830MODULE_ALIAS("dmi:*:*Acer*:pnExtensa 5420*:");
831
832module_init(acerhdf_init);
833module_exit(acerhdf_exit);