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 *                              https://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(fanon, uint, 0600);
 88MODULE_PARM_DESC(fanon, "Turn the fan on above this temperature");
 89module_param(fanoff, uint, 0600);
 90MODULE_PARM_DESC(fanoff, "Turn the fan off below this temperature");
 91module_param(verbose, uint, 0600);
 92MODULE_PARM_DESC(verbose, "Enable verbose dmesg output");
 93module_param(list_supported, uint, 0600);
 94MODULE_PARM_DESC(list_supported, "List supported models and BIOS versions");
 95module_param_string(force_bios, force_bios, 16, 0);
 96MODULE_PARM_DESC(force_bios, "Pretend system has this known supported BIOS version");
 97module_param_string(force_product, force_product, 16, 0);
 98MODULE_PARM_DESC(force_product, "Pretend system is this known supported model");
 99
100/*
101 * cmd_off: to switch the fan completely off and check if the fan is off
102 *	cmd_auto: to set the BIOS in control of the fan. The BIOS regulates then
103 *		the fan speed depending on the temperature
104 */
105struct fancmd {
106	u8 cmd_off;
107	u8 cmd_auto;
108};
109
110struct manualcmd {
111	u8 mreg;
112	u8 moff;
113};
114
115/* default register and command to disable fan in manual mode */
116static const struct manualcmd mcmd = {
117	.mreg = 0x94,
118	.moff = 0xff,
119};
120
121/* BIOS settings - only used during probe */
122struct bios_settings {
123	const char *vendor;
124	const char *product;
125	const char *version;
126	u8 fanreg;
127	u8 tempreg;
128	struct fancmd cmd;
129	int mcmd_enable;
130};
131
132/* This could be a daughter struct in the above, but not worth the redirect */
133struct ctrl_settings {
134	u8 fanreg;
135	u8 tempreg;
136	struct fancmd cmd;
137	int mcmd_enable;
138};
139
140static struct ctrl_settings ctrl_cfg __read_mostly;
141
142/* Register addresses and values for different BIOS versions */
143static const struct bios_settings bios_tbl[] __initconst = {
144	/* AOA110 */
145	{"Acer", "AOA110", "v0.3109", 0x55, 0x58, {0x1f, 0x00}, 0},
146	{"Acer", "AOA110", "v0.3114", 0x55, 0x58, {0x1f, 0x00}, 0},
147	{"Acer", "AOA110", "v0.3301", 0x55, 0x58, {0xaf, 0x00}, 0},
148	{"Acer", "AOA110", "v0.3304", 0x55, 0x58, {0xaf, 0x00}, 0},
149	{"Acer", "AOA110", "v0.3305", 0x55, 0x58, {0xaf, 0x00}, 0},
150	{"Acer", "AOA110", "v0.3307", 0x55, 0x58, {0xaf, 0x00}, 0},
151	{"Acer", "AOA110", "v0.3308", 0x55, 0x58, {0x21, 0x00}, 0},
152	{"Acer", "AOA110", "v0.3309", 0x55, 0x58, {0x21, 0x00}, 0},
153	{"Acer", "AOA110", "v0.3310", 0x55, 0x58, {0x21, 0x00}, 0},
154	/* AOA150 */
155	{"Acer", "AOA150", "v0.3114", 0x55, 0x58, {0x1f, 0x00}, 0},
156	{"Acer", "AOA150", "v0.3301", 0x55, 0x58, {0x20, 0x00}, 0},
157	{"Acer", "AOA150", "v0.3304", 0x55, 0x58, {0x20, 0x00}, 0},
158	{"Acer", "AOA150", "v0.3305", 0x55, 0x58, {0x20, 0x00}, 0},
159	{"Acer", "AOA150", "v0.3307", 0x55, 0x58, {0x20, 0x00}, 0},
160	{"Acer", "AOA150", "v0.3308", 0x55, 0x58, {0x20, 0x00}, 0},
161	{"Acer", "AOA150", "v0.3309", 0x55, 0x58, {0x20, 0x00}, 0},
162	{"Acer", "AOA150", "v0.3310", 0x55, 0x58, {0x20, 0x00}, 0},
163	/* LT1005u */
164	{"Acer", "LT-10Q", "v0.3310", 0x55, 0x58, {0x20, 0x00}, 0},
165	/* Acer 1410 */
166	{"Acer", "Aspire 1410", "v0.3108", 0x55, 0x58, {0x9e, 0x00}, 0},
167	{"Acer", "Aspire 1410", "v0.3113", 0x55, 0x58, {0x9e, 0x00}, 0},
168	{"Acer", "Aspire 1410", "v0.3115", 0x55, 0x58, {0x9e, 0x00}, 0},
169	{"Acer", "Aspire 1410", "v0.3117", 0x55, 0x58, {0x9e, 0x00}, 0},
170	{"Acer", "Aspire 1410", "v0.3119", 0x55, 0x58, {0x9e, 0x00}, 0},
171	{"Acer", "Aspire 1410", "v0.3120", 0x55, 0x58, {0x9e, 0x00}, 0},
172	{"Acer", "Aspire 1410", "v1.3204", 0x55, 0x58, {0x9e, 0x00}, 0},
173	{"Acer", "Aspire 1410", "v1.3303", 0x55, 0x58, {0x9e, 0x00}, 0},
174	{"Acer", "Aspire 1410", "v1.3308", 0x55, 0x58, {0x9e, 0x00}, 0},
175	{"Acer", "Aspire 1410", "v1.3310", 0x55, 0x58, {0x9e, 0x00}, 0},
176	{"Acer", "Aspire 1410", "v1.3314", 0x55, 0x58, {0x9e, 0x00}, 0},
177	/* Acer 1810xx */
178	{"Acer", "Aspire 1810TZ", "v0.3108", 0x55, 0x58, {0x9e, 0x00}, 0},
179	{"Acer", "Aspire 1810T",  "v0.3108", 0x55, 0x58, {0x9e, 0x00}, 0},
180	{"Acer", "Aspire 1810TZ", "v0.3113", 0x55, 0x58, {0x9e, 0x00}, 0},
181	{"Acer", "Aspire 1810T",  "v0.3113", 0x55, 0x58, {0x9e, 0x00}, 0},
182	{"Acer", "Aspire 1810TZ", "v0.3115", 0x55, 0x58, {0x9e, 0x00}, 0},
183	{"Acer", "Aspire 1810T",  "v0.3115", 0x55, 0x58, {0x9e, 0x00}, 0},
184	{"Acer", "Aspire 1810TZ", "v0.3117", 0x55, 0x58, {0x9e, 0x00}, 0},
185	{"Acer", "Aspire 1810T",  "v0.3117", 0x55, 0x58, {0x9e, 0x00}, 0},
186	{"Acer", "Aspire 1810TZ", "v0.3119", 0x55, 0x58, {0x9e, 0x00}, 0},
187	{"Acer", "Aspire 1810T",  "v0.3119", 0x55, 0x58, {0x9e, 0x00}, 0},
188	{"Acer", "Aspire 1810TZ", "v0.3120", 0x55, 0x58, {0x9e, 0x00}, 0},
189	{"Acer", "Aspire 1810T",  "v0.3120", 0x55, 0x58, {0x9e, 0x00}, 0},
190	{"Acer", "Aspire 1810TZ", "v1.3204", 0x55, 0x58, {0x9e, 0x00}, 0},
191	{"Acer", "Aspire 1810T",  "v1.3204", 0x55, 0x58, {0x9e, 0x00}, 0},
192	{"Acer", "Aspire 1810TZ", "v1.3303", 0x55, 0x58, {0x9e, 0x00}, 0},
193	{"Acer", "Aspire 1810T",  "v1.3303", 0x55, 0x58, {0x9e, 0x00}, 0},
194	{"Acer", "Aspire 1810TZ", "v1.3308", 0x55, 0x58, {0x9e, 0x00}, 0},
195	{"Acer", "Aspire 1810T",  "v1.3308", 0x55, 0x58, {0x9e, 0x00}, 0},
196	{"Acer", "Aspire 1810TZ", "v1.3310", 0x55, 0x58, {0x9e, 0x00}, 0},
197	{"Acer", "Aspire 1810T",  "v1.3310", 0x55, 0x58, {0x9e, 0x00}, 0},
198	{"Acer", "Aspire 1810TZ", "v1.3314", 0x55, 0x58, {0x9e, 0x00}, 0},
199	{"Acer", "Aspire 1810T",  "v1.3314", 0x55, 0x58, {0x9e, 0x00}, 0},
200	/* Acer 5755G */
201	{"Acer", "Aspire 5755G",  "V1.20",   0xab, 0xb4, {0x00, 0x08}, 0},
202	{"Acer", "Aspire 5755G",  "V1.21",   0xab, 0xb3, {0x00, 0x08}, 0},
203	/* Acer 521 */
204	{"Acer", "AO521", "V1.11", 0x55, 0x58, {0x1f, 0x00}, 0},
205	/* Acer 531 */
206	{"Acer", "AO531h", "v0.3104", 0x55, 0x58, {0x20, 0x00}, 0},
207	{"Acer", "AO531h", "v0.3201", 0x55, 0x58, {0x20, 0x00}, 0},
208	{"Acer", "AO531h", "v0.3304", 0x55, 0x58, {0x20, 0x00}, 0},
209	/* Acer 751 */
210	{"Acer", "AO751h", "V0.3206", 0x55, 0x58, {0x21, 0x00}, 0},
211	{"Acer", "AO751h", "V0.3212", 0x55, 0x58, {0x21, 0x00}, 0},
212	/* Acer 753 */
213	{"Acer", "Aspire One 753", "V1.24", 0x93, 0xac, {0x14, 0x04}, 1},
214	/* Acer 1825 */
215	{"Acer", "Aspire 1825PTZ", "V1.3118", 0x55, 0x58, {0x9e, 0x00}, 0},
216	{"Acer", "Aspire 1825PTZ", "V1.3127", 0x55, 0x58, {0x9e, 0x00}, 0},
217	/* Acer Extensa 5420 */
218	{"Acer", "Extensa 5420", "V1.17", 0x93, 0xac, {0x14, 0x04}, 1},
219	/* Acer Aspire 5315 */
220	{"Acer", "Aspire 5315", "V1.19", 0x93, 0xac, {0x14, 0x04}, 1},
221	/* Acer Aspire 5739 */
222	{"Acer", "Aspire 5739G", "V1.3311", 0x55, 0x58, {0x20, 0x00}, 0},
223	/* Acer TravelMate 7730 */
224	{"Acer", "TravelMate 7730G", "v0.3509", 0x55, 0x58, {0xaf, 0x00}, 0},
225	/* Acer Aspire 7551 */
226	{"Acer", "Aspire 7551", "V1.18", 0x93, 0xa8, {0x14, 0x04}, 1},
227	/* Acer TravelMate TM8573T */
228	{"Acer", "TM8573T", "V1.13", 0x93, 0xa8, {0x14, 0x04}, 1},
229	/* Gateway */
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},
236	{"Gateway", "LT31",   "v1.3307",  0x55, 0x58, {0x9e, 0x00}, 0},
237	/* Packard Bell */
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},
256	/* pewpew-terminator */
257	{"", "", "", 0, 0, {0, 0}, 0}
258};
259
260/*
261 * this struct is used to instruct thermal layer to use bang_bang instead of
262 * default governor for acerhdf
263 */
264static struct thermal_zone_params acerhdf_zone_params = {
265	.governor_name = "bang_bang",
266};
267
268static int acerhdf_get_temp(int *temp)
269{
270	u8 read_temp;
271
272	if (ec_read(ctrl_cfg.tempreg, &read_temp))
273		return -EINVAL;
274
275	*temp = read_temp * 1000;
276
277	return 0;
278}
279
280static int acerhdf_get_fanstate(int *state)
281{
282	u8 fan;
283
284	if (ec_read(ctrl_cfg.fanreg, &fan))
285		return -EINVAL;
286
287	if (fan != ctrl_cfg.cmd.cmd_off)
288		*state = ACERHDF_FAN_AUTO;
289	else
290		*state = ACERHDF_FAN_OFF;
291
292	return 0;
293}
294
295static void acerhdf_change_fanstate(int state)
296{
297	unsigned char cmd;
298
299	if (verbose)
300		pr_notice("fan %s\n", state == ACERHDF_FAN_OFF ? "OFF" : "ON");
301
302	if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
303		pr_err("invalid fan state %d requested, setting to auto!\n",
304		       state);
305		state = ACERHDF_FAN_AUTO;
306	}
307
308	cmd = (state == ACERHDF_FAN_OFF) ? ctrl_cfg.cmd.cmd_off
309					 : ctrl_cfg.cmd.cmd_auto;
310	fanstate = state;
311
312	ec_write(ctrl_cfg.fanreg, cmd);
313
314	if (ctrl_cfg.mcmd_enable && state == ACERHDF_FAN_OFF) {
315		if (verbose)
316			pr_notice("turning off fan manually\n");
317		ec_write(mcmd.mreg, mcmd.moff);
318	}
319}
320
321static 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",
325		       ACERHDF_MAX_FANON);
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",
332			       ACERHDF_MAX_INTERVAL);
333			interval = ACERHDF_MAX_INTERVAL;
334		}
335		if (verbose)
336			pr_notice("interval changed to: %d\n", interval);
337
338		if (thermal)
339			thermal->polling_delay_jiffies =
340				round_jiffies(msecs_to_jiffies(interval * 1000));
341
342		prev_interval = interval;
343	}
344}
345
346/*
347 * This is the thermal zone callback which does the delayed polling of the fan
348 * state. We do check /sysfs-originating settings here in acerhdf_check_param()
349 * as late as the polling interval is since we can't do that in the respective
350 * accessors of the module parameters.
351 */
352static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal, int *t)
353{
354	int temp, err = 0;
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
401	pr_notice("kernel mode fan control OFF\n");
402}
403static inline void acerhdf_enable_kernelmode(void)
404{
405	kernelmode = 1;
406
407	pr_notice("kernel mode fan control ON\n");
408}
409
410/*
411 * set operation mode;
412 * enabled: the thermal layer of the kernel takes care about
413 *          the temperature and the fan.
414 * disabled: the BIOS takes control of the fan.
415 */
416static int acerhdf_change_mode(struct thermal_zone_device *thermal,
417			       enum thermal_device_mode mode)
418{
419	if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
420		acerhdf_revert_to_bios_mode();
421	else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
422		acerhdf_enable_kernelmode();
423
424	return 0;
425}
426
427static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
428				 enum thermal_trip_type *type)
429{
430	if (trip == 0)
431		*type = THERMAL_TRIP_ACTIVE;
432	else if (trip == 1)
433		*type = THERMAL_TRIP_CRITICAL;
434	else
435		return -EINVAL;
436
437	return 0;
438}
439
440static int acerhdf_get_trip_hyst(struct thermal_zone_device *thermal, int trip,
441				 int *temp)
442{
443	if (trip != 0)
444		return -EINVAL;
445
446	*temp = fanon - fanoff;
447
448	return 0;
449}
450
451static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
452				 int *temp)
453{
454	if (trip == 0)
455		*temp = fanon;
456	else if (trip == 1)
457		*temp = ACERHDF_TEMP_CRIT;
458	else
459		return -EINVAL;
460
461	return 0;
462}
463
464static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
465				 int *temperature)
466{
467	*temperature = ACERHDF_TEMP_CRIT;
468	return 0;
469}
470
471/* bind callback functions to thermalzone */
472static struct thermal_zone_device_ops acerhdf_dev_ops = {
473	.bind = acerhdf_bind,
474	.unbind = acerhdf_unbind,
475	.get_temp = acerhdf_get_ec_temp,
476	.change_mode = acerhdf_change_mode,
477	.get_trip_type = acerhdf_get_trip_type,
478	.get_trip_hyst = acerhdf_get_trip_hyst,
479	.get_trip_temp = acerhdf_get_trip_temp,
480	.get_crit_temp = acerhdf_get_crit_temp,
481};
482
483
484/*
485 * cooling device callback functions
486 * get maximal fan cooling state
487 */
488static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
489				 unsigned long *state)
490{
491	*state = 1;
492
493	return 0;
494}
495
496static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
497				 unsigned long *state)
498{
499	int err = 0, tmp;
500
501	err = acerhdf_get_fanstate(&tmp);
502	if (err)
503		return err;
504
505	*state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
506	return 0;
507}
508
509/* change current fan state - is overwritten when running in kernel mode */
510static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
511				 unsigned long state)
512{
513	int cur_temp, cur_state, err = 0;
514
515	if (!kernelmode)
516		return 0;
517
518	err = acerhdf_get_temp(&cur_temp);
519	if (err) {
520		pr_err("error reading temperature, hand off control to BIOS\n");
521		goto err_out;
522	}
523
524	err = acerhdf_get_fanstate(&cur_state);
525	if (err) {
526		pr_err("error reading fan state, hand off control to BIOS\n");
527		goto err_out;
528	}
529
530	if (state == 0) {
531		if (cur_state == ACERHDF_FAN_AUTO)
532			acerhdf_change_fanstate(ACERHDF_FAN_OFF);
533	} else {
534		if (cur_state == ACERHDF_FAN_OFF)
535			acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
536	}
537	return 0;
538
539err_out:
540	acerhdf_revert_to_bios_mode();
541	return -EINVAL;
542}
543
544/* bind fan callbacks to fan device */
545static const struct thermal_cooling_device_ops acerhdf_cooling_ops = {
546	.get_max_state = acerhdf_get_max_state,
547	.get_cur_state = acerhdf_get_cur_state,
548	.set_cur_state = acerhdf_set_cur_state,
549};
550
551/* suspend / resume functionality */
552static int acerhdf_suspend(struct device *dev)
553{
554	if (kernelmode)
555		acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
556
557	if (verbose)
558		pr_notice("going suspend\n");
559
560	return 0;
561}
562
563static int acerhdf_probe(struct platform_device *device)
564{
565	return 0;
566}
567
568static int acerhdf_remove(struct platform_device *device)
569{
570	return 0;
571}
572
573static const struct dev_pm_ops acerhdf_pm_ops = {
574	.suspend = acerhdf_suspend,
575	.freeze  = acerhdf_suspend,
576};
577
578static struct platform_driver acerhdf_driver = {
579	.driver = {
580		.name  = "acerhdf",
581		.pm    = &acerhdf_pm_ops,
582	},
583	.probe = acerhdf_probe,
584	.remove = acerhdf_remove,
585};
586
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
587/* check hardware */
588static int __init acerhdf_check_hardware(void)
589{
590	char const *vendor, *version, *product;
591	const struct bios_settings *bt = NULL;
592	int found = 0;
593
594	/* get BIOS data */
595	vendor  = dmi_get_system_info(DMI_SYS_VENDOR);
596	version = dmi_get_system_info(DMI_BIOS_VERSION);
597	product = dmi_get_system_info(DMI_PRODUCT_NAME);
598
599	if (!vendor || !version || !product) {
600		pr_err("error getting hardware information\n");
601		return -EINVAL;
602	}
603
604	pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
605
606	if (list_supported) {
607		pr_info("List of supported Manufacturer/Model/BIOS:\n");
608		pr_info("---------------------------------------------------\n");
609		for (bt = bios_tbl; bt->vendor[0]; bt++) {
610			pr_info("%-13s | %-17s | %-10s\n", bt->vendor,
611				bt->product, bt->version);
612		}
613		pr_info("---------------------------------------------------\n");
614		return -ECANCELED;
615	}
616
617	if (force_bios[0]) {
618		version = force_bios;
619		pr_info("forcing BIOS version: %s\n", version);
620		kernelmode = 0;
621	}
622
623	if (force_product[0]) {
624		product = force_product;
625		pr_info("forcing BIOS product: %s\n", product);
626		kernelmode = 0;
627	}
628
629	if (verbose)
630		pr_info("BIOS info: %s %s, product: %s\n",
631			vendor, version, product);
632
633	/* search BIOS version and vendor in BIOS settings table */
634	for (bt = bios_tbl; bt->vendor[0]; bt++) {
635		/*
636		 * check if actual hardware BIOS vendor, product and version
637		 * IDs start with the strings of BIOS table entry
638		 */
639		if (strstarts(vendor, bt->vendor) &&
640		    strstarts(product, bt->product) &&
641		    strstarts(version, bt->version)) {
642			found = 1;
643			break;
644		}
645	}
646
647	if (!found) {
648		pr_err("unknown (unsupported) BIOS version %s/%s/%s, please report, aborting!\n",
649		       vendor, product, version);
650		return -EINVAL;
651	}
652
653	/* Copy control settings from BIOS table before we free it. */
654	ctrl_cfg.fanreg = bt->fanreg;
655	ctrl_cfg.tempreg = bt->tempreg;
656	memcpy(&ctrl_cfg.cmd, &bt->cmd, sizeof(struct fancmd));
657	ctrl_cfg.mcmd_enable = bt->mcmd_enable;
658
659	/*
660	 * if started with kernel mode off, prevent the kernel from switching
661	 * off the fan
662	 */
663	if (!kernelmode) {
664		pr_notice("Fan control off, to enable do:\n");
665		pr_notice("echo -n \"enabled\" > /sys/class/thermal/thermal_zoneN/mode # N=0,1,2...\n");
666	}
667
668	return 0;
669}
670
671static int __init acerhdf_register_platform(void)
672{
673	int err = 0;
674
675	err = platform_driver_register(&acerhdf_driver);
676	if (err)
677		return err;
678
679	acerhdf_dev = platform_device_alloc("acerhdf", PLATFORM_DEVID_NONE);
680	if (!acerhdf_dev) {
681		err = -ENOMEM;
682		goto err_device_alloc;
683	}
684	err = platform_device_add(acerhdf_dev);
685	if (err)
686		goto err_device_add;
687
688	return 0;
689
690err_device_add:
691	platform_device_put(acerhdf_dev);
692err_device_alloc:
693	platform_driver_unregister(&acerhdf_driver);
694	return err;
695}
696
697static void acerhdf_unregister_platform(void)
698{
699	platform_device_unregister(acerhdf_dev);
700	platform_driver_unregister(&acerhdf_driver);
701}
702
703static int __init acerhdf_register_thermal(void)
704{
705	int ret;
706
707	cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
708						 &acerhdf_cooling_ops);
709
710	if (IS_ERR(cl_dev))
711		return -EINVAL;
712
713	thz_dev = thermal_zone_device_register("acerhdf", 2, 0, NULL,
714					      &acerhdf_dev_ops,
715					      &acerhdf_zone_params, 0,
716					      (kernelmode) ? interval*1000 : 0);
717	if (IS_ERR(thz_dev))
718		return -EINVAL;
719
720	if (kernelmode)
721		ret = thermal_zone_device_enable(thz_dev);
722	else
723		ret = thermal_zone_device_disable(thz_dev);
724	if (ret)
725		return ret;
726
727	if (strcmp(thz_dev->governor->name,
728				acerhdf_zone_params.governor_name)) {
729		pr_err("Didn't get thermal governor %s, perhaps not compiled into thermal subsystem.\n",
730				acerhdf_zone_params.governor_name);
731		return -EINVAL;
732	}
733
734	return 0;
735}
736
737static void acerhdf_unregister_thermal(void)
738{
739	if (cl_dev) {
740		thermal_cooling_device_unregister(cl_dev);
741		cl_dev = NULL;
742	}
743
744	if (thz_dev) {
745		thermal_zone_device_unregister(thz_dev);
746		thz_dev = NULL;
747	}
748}
749
750static int __init acerhdf_init(void)
751{
752	int err = 0;
753
754	err = acerhdf_check_hardware();
755	if (err)
756		goto out_err;
757
758	err = acerhdf_register_platform();
759	if (err)
760		goto out_err;
761
762	err = acerhdf_register_thermal();
763	if (err)
764		goto err_unreg;
765
766	return 0;
767
768err_unreg:
769	acerhdf_unregister_thermal();
770	acerhdf_unregister_platform();
771
772out_err:
773	return err;
774}
775
776static void __exit acerhdf_exit(void)
777{
778	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
779	acerhdf_unregister_thermal();
780	acerhdf_unregister_platform();
781}
782
783MODULE_LICENSE("GPL");
784MODULE_AUTHOR("Peter Kaestle");
785MODULE_DESCRIPTION("Aspire One temperature and fan driver");
786MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
787MODULE_ALIAS("dmi:*:*Acer*:pnAO751h*:");
788MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1410*:");
789MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1810*:");
790MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5755G:");
791MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1825PTZ:");
792MODULE_ALIAS("dmi:*:*Acer*:pnAO521*:");
793MODULE_ALIAS("dmi:*:*Acer*:pnAO531*:");
794MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5739G:");
795MODULE_ALIAS("dmi:*:*Acer*:pnAspire*One*753:");
796MODULE_ALIAS("dmi:*:*Acer*:pnAspire*5315:");
797MODULE_ALIAS("dmi:*:*Acer*:TravelMate*7730G:");
798MODULE_ALIAS("dmi:*:*Acer*:pnAspire*7551:");
799MODULE_ALIAS("dmi:*:*Acer*:TM8573T:");
800MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
801MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
802MODULE_ALIAS("dmi:*:*Packard*Bell*:pnAOA*:");
803MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOA*:");
804MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMU*:");
805MODULE_ALIAS("dmi:*:*Packard*Bell*:pnENBFT*:");
806MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMA*:");
807MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTVR46*:");
808MODULE_ALIAS("dmi:*:*Acer*:pnExtensa*5420*:");
809
810module_init(acerhdf_init);
811module_exit(acerhdf_exit);
812
813static int interval_set_uint(const char *val, const struct kernel_param *kp)
814{
815	int ret;
816
817	ret = param_set_uint(val, kp);
818	if (ret)
819		return ret;
820
821	acerhdf_check_param(thz_dev);
822
823	return 0;
824}
825
826static const struct kernel_param_ops interval_ops = {
827	.set = interval_set_uint,
828	.get = param_get_uint,
829};
830
831module_param_cb(interval, &interval_ops, &interval, 0600);
832MODULE_PARM_DESC(interval, "Polling interval of temperature check");