1 /*
2  *  eeepc-laptop.c - Asus Eee PC extras
3  *
4  *  Based on asus_acpi.c as patched for the Eee PC by Asus:
5  *  ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar
6  *  Based on eee.c from eeepc-linux
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  */
18 
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/types.h>
25 #include <linux/platform_device.h>
26 #include <linux/backlight.h>
27 #include <linux/fb.h>
28 #include <linux/hwmon.h>
29 #include <linux/hwmon-sysfs.h>
30 #include <linux/slab.h>
31 #include <linux/acpi.h>
32 #include <linux/uaccess.h>
33 #include <linux/input.h>
34 #include <linux/input/sparse-keymap.h>
35 #include <linux/rfkill.h>
36 #include <linux/pci.h>
37 #include <linux/pci_hotplug.h>
38 #include <linux/leds.h>
39 #include <linux/dmi.h>
40 #include <acpi/video.h>
41 
42 #define EEEPC_LAPTOP_VERSION	"0.1"
43 #define EEEPC_LAPTOP_NAME	"Eee PC Hotkey Driver"
44 #define EEEPC_LAPTOP_FILE	"eeepc"
45 
46 #define EEEPC_ACPI_CLASS	"hotkey"
47 #define EEEPC_ACPI_DEVICE_NAME	"Hotkey"
48 #define EEEPC_ACPI_HID		"ASUS010"
49 
50 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
51 MODULE_DESCRIPTION(EEEPC_LAPTOP_NAME);
52 MODULE_LICENSE("GPL");
53 
54 static bool hotplug_disabled;
55 
56 module_param(hotplug_disabled, bool, 0444);
57 MODULE_PARM_DESC(hotplug_disabled,
58 		 "Disable hotplug for wireless device. "
59 		 "If your laptop need that, please report to "
60 		 "acpi4asus-user@lists.sourceforge.net.");
61 
62 /*
63  * Definitions for Asus EeePC
64  */
65 #define NOTIFY_BRN_MIN	0x20
66 #define NOTIFY_BRN_MAX	0x2f
67 
68 enum {
69 	DISABLE_ASL_WLAN = 0x0001,
70 	DISABLE_ASL_BLUETOOTH = 0x0002,
71 	DISABLE_ASL_IRDA = 0x0004,
72 	DISABLE_ASL_CAMERA = 0x0008,
73 	DISABLE_ASL_TV = 0x0010,
74 	DISABLE_ASL_GPS = 0x0020,
75 	DISABLE_ASL_DISPLAYSWITCH = 0x0040,
76 	DISABLE_ASL_MODEM = 0x0080,
77 	DISABLE_ASL_CARDREADER = 0x0100,
78 	DISABLE_ASL_3G = 0x0200,
79 	DISABLE_ASL_WIMAX = 0x0400,
80 	DISABLE_ASL_HWCF = 0x0800
81 };
82 
83 enum {
84 	CM_ASL_WLAN = 0,
85 	CM_ASL_BLUETOOTH,
86 	CM_ASL_IRDA,
87 	CM_ASL_1394,
88 	CM_ASL_CAMERA,
89 	CM_ASL_TV,
90 	CM_ASL_GPS,
91 	CM_ASL_DVDROM,
92 	CM_ASL_DISPLAYSWITCH,
93 	CM_ASL_PANELBRIGHT,
94 	CM_ASL_BIOSFLASH,
95 	CM_ASL_ACPIFLASH,
96 	CM_ASL_CPUFV,
97 	CM_ASL_CPUTEMPERATURE,
98 	CM_ASL_FANCPU,
99 	CM_ASL_FANCHASSIS,
100 	CM_ASL_USBPORT1,
101 	CM_ASL_USBPORT2,
102 	CM_ASL_USBPORT3,
103 	CM_ASL_MODEM,
104 	CM_ASL_CARDREADER,
105 	CM_ASL_3G,
106 	CM_ASL_WIMAX,
107 	CM_ASL_HWCF,
108 	CM_ASL_LID,
109 	CM_ASL_TYPE,
110 	CM_ASL_PANELPOWER,	/*P901*/
111 	CM_ASL_TPD
112 };
113 
114 static const char *cm_getv[] = {
115 	"WLDG", "BTHG", NULL, NULL,
116 	"CAMG", NULL, NULL, NULL,
117 	NULL, "PBLG", NULL, NULL,
118 	"CFVG", NULL, NULL, NULL,
119 	"USBG", NULL, NULL, "MODG",
120 	"CRDG", "M3GG", "WIMG", "HWCF",
121 	"LIDG",	"TYPE", "PBPG",	"TPDG"
122 };
123 
124 static const char *cm_setv[] = {
125 	"WLDS", "BTHS", NULL, NULL,
126 	"CAMS", NULL, NULL, NULL,
127 	"SDSP", "PBLS", "HDPS", NULL,
128 	"CFVS", NULL, NULL, NULL,
129 	"USBG", NULL, NULL, "MODS",
130 	"CRDS", "M3GS", "WIMS", NULL,
131 	NULL, NULL, "PBPS", "TPDS"
132 };
133 
134 static const struct key_entry eeepc_keymap[] = {
135 	{ KE_KEY, 0x10, { KEY_WLAN } },
136 	{ KE_KEY, 0x11, { KEY_WLAN } },
137 	{ KE_KEY, 0x12, { KEY_PROG1 } },
138 	{ KE_KEY, 0x13, { KEY_MUTE } },
139 	{ KE_KEY, 0x14, { KEY_VOLUMEDOWN } },
140 	{ KE_KEY, 0x15, { KEY_VOLUMEUP } },
141 	{ KE_KEY, 0x16, { KEY_DISPLAY_OFF } },
142 	{ KE_KEY, 0x1a, { KEY_COFFEE } },
143 	{ KE_KEY, 0x1b, { KEY_ZOOM } },
144 	{ KE_KEY, 0x1c, { KEY_PROG2 } },
145 	{ KE_KEY, 0x1d, { KEY_PROG3 } },
146 	{ KE_KEY, NOTIFY_BRN_MIN, { KEY_BRIGHTNESSDOWN } },
147 	{ KE_KEY, NOTIFY_BRN_MAX, { KEY_BRIGHTNESSUP } },
148 	{ KE_KEY, 0x30, { KEY_SWITCHVIDEOMODE } },
149 	{ KE_KEY, 0x31, { KEY_SWITCHVIDEOMODE } },
150 	{ KE_KEY, 0x32, { KEY_SWITCHVIDEOMODE } },
151 	{ KE_KEY, 0x37, { KEY_F13 } }, /* Disable Touchpad */
152 	{ KE_KEY, 0x38, { KEY_F14 } },
153 	{ KE_IGNORE, 0x50, { KEY_RESERVED } }, /* AC plugged */
154 	{ KE_IGNORE, 0x51, { KEY_RESERVED } }, /* AC unplugged */
155 	{ KE_END, 0 },
156 };
157 
158 /*
159  * This is the main structure, we can use it to store useful information
160  */
161 struct eeepc_laptop {
162 	acpi_handle handle;		/* the handle of the acpi device */
163 	u32 cm_supported;		/* the control methods supported
164 					   by this BIOS */
165 	bool cpufv_disabled;
166 	bool hotplug_disabled;
167 	u16 event_count[128];		/* count for each event */
168 
169 	struct platform_device *platform_device;
170 	struct acpi_device *device;		/* the device we are in */
171 	struct backlight_device *backlight_device;
172 
173 	struct input_dev *inputdev;
174 
175 	struct rfkill *wlan_rfkill;
176 	struct rfkill *bluetooth_rfkill;
177 	struct rfkill *wwan3g_rfkill;
178 	struct rfkill *wimax_rfkill;
179 
180 	struct hotplug_slot *hotplug_slot;
181 	struct mutex hotplug_lock;
182 
183 	struct led_classdev tpd_led;
184 	int tpd_led_wk;
185 	struct workqueue_struct *led_workqueue;
186 	struct work_struct tpd_led_work;
187 };
188 
189 /*
190  * ACPI Helpers
191  */
192 static int write_acpi_int(acpi_handle handle, const char *method, int val)
193 {
194 	acpi_status status;
195 
196 	status = acpi_execute_simple_method(handle, (char *)method, val);
197 
198 	return (status == AE_OK ? 0 : -1);
199 }
200 
201 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
202 {
203 	acpi_status status;
204 	unsigned long long result;
205 
206 	status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
207 	if (ACPI_FAILURE(status)) {
208 		*val = -1;
209 		return -1;
210 	} else {
211 		*val = result;
212 		return 0;
213 	}
214 }
215 
216 static int set_acpi(struct eeepc_laptop *eeepc, int cm, int value)
217 {
218 	const char *method = cm_setv[cm];
219 
220 	if (method == NULL)
221 		return -ENODEV;
222 	if ((eeepc->cm_supported & (0x1 << cm)) == 0)
223 		return -ENODEV;
224 
225 	if (write_acpi_int(eeepc->handle, method, value))
226 		pr_warn("Error writing %s\n", method);
227 	return 0;
228 }
229 
230 static int get_acpi(struct eeepc_laptop *eeepc, int cm)
231 {
232 	const char *method = cm_getv[cm];
233 	int value;
234 
235 	if (method == NULL)
236 		return -ENODEV;
237 	if ((eeepc->cm_supported & (0x1 << cm)) == 0)
238 		return -ENODEV;
239 
240 	if (read_acpi_int(eeepc->handle, method, &value))
241 		pr_warn("Error reading %s\n", method);
242 	return value;
243 }
244 
245 static int acpi_setter_handle(struct eeepc_laptop *eeepc, int cm,
246 			      acpi_handle *handle)
247 {
248 	const char *method = cm_setv[cm];
249 	acpi_status status;
250 
251 	if (method == NULL)
252 		return -ENODEV;
253 	if ((eeepc->cm_supported & (0x1 << cm)) == 0)
254 		return -ENODEV;
255 
256 	status = acpi_get_handle(eeepc->handle, (char *)method,
257 				 handle);
258 	if (status != AE_OK) {
259 		pr_warn("Error finding %s\n", method);
260 		return -ENODEV;
261 	}
262 	return 0;
263 }
264 
265 
266 /*
267  * Sys helpers
268  */
269 static int parse_arg(const char *buf, int *val)
270 {
271 	if (sscanf(buf, "%i", val) != 1)
272 		return -EINVAL;
273 	return 0;
274 }
275 
276 static ssize_t store_sys_acpi(struct device *dev, int cm,
277 			      const char *buf, size_t count)
278 {
279 	struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
280 	int rv, value;
281 
282 	rv = parse_arg(buf, &value);
283 	if (rv < 0)
284 		return rv;
285 	rv = set_acpi(eeepc, cm, value);
286 	if (rv < 0)
287 		return -EIO;
288 	return count;
289 }
290 
291 static ssize_t show_sys_acpi(struct device *dev, int cm, char *buf)
292 {
293 	struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
294 	int value = get_acpi(eeepc, cm);
295 
296 	if (value < 0)
297 		return -EIO;
298 	return sprintf(buf, "%d\n", value);
299 }
300 
301 #define EEEPC_ACPI_SHOW_FUNC(_name, _cm)				\
302 	static ssize_t _name##_show(struct device *dev,			\
303 				    struct device_attribute *attr,	\
304 				    char *buf)				\
305 	{								\
306 		return show_sys_acpi(dev, _cm, buf);			\
307 	}
308 
309 #define EEEPC_ACPI_STORE_FUNC(_name, _cm)				\
310 	static ssize_t _name##_store(struct device *dev,		\
311 				     struct device_attribute *attr,	\
312 				     const char *buf, size_t count)	\
313 	{								\
314 		return store_sys_acpi(dev, _cm, buf, count);		\
315 	}
316 
317 #define EEEPC_CREATE_DEVICE_ATTR_RW(_name, _cm)				\
318 	EEEPC_ACPI_SHOW_FUNC(_name, _cm)				\
319 	EEEPC_ACPI_STORE_FUNC(_name, _cm)				\
320 	static DEVICE_ATTR_RW(_name)
321 
322 #define EEEPC_CREATE_DEVICE_ATTR_WO(_name, _cm)				\
323 	EEEPC_ACPI_STORE_FUNC(_name, _cm)				\
324 	static DEVICE_ATTR_WO(_name)
325 
326 EEEPC_CREATE_DEVICE_ATTR_RW(camera, CM_ASL_CAMERA);
327 EEEPC_CREATE_DEVICE_ATTR_RW(cardr, CM_ASL_CARDREADER);
328 EEEPC_CREATE_DEVICE_ATTR_WO(disp, CM_ASL_DISPLAYSWITCH);
329 
330 struct eeepc_cpufv {
331 	int num;
332 	int cur;
333 };
334 
335 static int get_cpufv(struct eeepc_laptop *eeepc, struct eeepc_cpufv *c)
336 {
337 	c->cur = get_acpi(eeepc, CM_ASL_CPUFV);
338 	if (c->cur < 0)
339 		return -ENODEV;
340 
341 	c->num = (c->cur >> 8) & 0xff;
342 	c->cur &= 0xff;
343 	if (c->num == 0 || c->num > 12)
344 		return -ENODEV;
345 	return 0;
346 }
347 
348 static ssize_t available_cpufv_show(struct device *dev,
349 				    struct device_attribute *attr,
350 				    char *buf)
351 {
352 	struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
353 	struct eeepc_cpufv c;
354 	int i;
355 	ssize_t len = 0;
356 
357 	if (get_cpufv(eeepc, &c))
358 		return -ENODEV;
359 	for (i = 0; i < c.num; i++)
360 		len += sprintf(buf + len, "%d ", i);
361 	len += sprintf(buf + len, "\n");
362 	return len;
363 }
364 
365 static ssize_t cpufv_show(struct device *dev,
366 			  struct device_attribute *attr,
367 			  char *buf)
368 {
369 	struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
370 	struct eeepc_cpufv c;
371 
372 	if (get_cpufv(eeepc, &c))
373 		return -ENODEV;
374 	return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
375 }
376 
377 static ssize_t cpufv_store(struct device *dev,
378 			   struct device_attribute *attr,
379 			   const char *buf, size_t count)
380 {
381 	struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
382 	struct eeepc_cpufv c;
383 	int rv, value;
384 
385 	if (eeepc->cpufv_disabled)
386 		return -EPERM;
387 	if (get_cpufv(eeepc, &c))
388 		return -ENODEV;
389 	rv = parse_arg(buf, &value);
390 	if (rv < 0)
391 		return rv;
392 	if (value < 0 || value >= c.num)
393 		return -EINVAL;
394 	rv = set_acpi(eeepc, CM_ASL_CPUFV, value);
395 	if (rv)
396 		return rv;
397 	return count;
398 }
399 
400 static ssize_t cpufv_disabled_show(struct device *dev,
401 			  struct device_attribute *attr,
402 			  char *buf)
403 {
404 	struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
405 
406 	return sprintf(buf, "%d\n", eeepc->cpufv_disabled);
407 }
408 
409 static ssize_t cpufv_disabled_store(struct device *dev,
410 			   struct device_attribute *attr,
411 			   const char *buf, size_t count)
412 {
413 	struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
414 	int rv, value;
415 
416 	rv = parse_arg(buf, &value);
417 	if (rv < 0)
418 		return rv;
419 
420 	switch (value) {
421 	case 0:
422 		if (eeepc->cpufv_disabled)
423 			pr_warn("cpufv enabled (not officially supported on this model)\n");
424 		eeepc->cpufv_disabled = false;
425 		return count;
426 	case 1:
427 		return -EPERM;
428 	default:
429 		return -EINVAL;
430 	}
431 }
432 
433 
434 static DEVICE_ATTR_RW(cpufv);
435 static DEVICE_ATTR_RO(available_cpufv);
436 static DEVICE_ATTR_RW(cpufv_disabled);
437 
438 static struct attribute *platform_attributes[] = {
439 	&dev_attr_camera.attr,
440 	&dev_attr_cardr.attr,
441 	&dev_attr_disp.attr,
442 	&dev_attr_cpufv.attr,
443 	&dev_attr_available_cpufv.attr,
444 	&dev_attr_cpufv_disabled.attr,
445 	NULL
446 };
447 
448 static const struct attribute_group platform_attribute_group = {
449 	.attrs = platform_attributes
450 };
451 
452 static int eeepc_platform_init(struct eeepc_laptop *eeepc)
453 {
454 	int result;
455 
456 	eeepc->platform_device = platform_device_alloc(EEEPC_LAPTOP_FILE, -1);
457 	if (!eeepc->platform_device)
458 		return -ENOMEM;
459 	platform_set_drvdata(eeepc->platform_device, eeepc);
460 
461 	result = platform_device_add(eeepc->platform_device);
462 	if (result)
463 		goto fail_platform_device;
464 
465 	result = sysfs_create_group(&eeepc->platform_device->dev.kobj,
466 				    &platform_attribute_group);
467 	if (result)
468 		goto fail_sysfs;
469 	return 0;
470 
471 fail_sysfs:
472 	platform_device_del(eeepc->platform_device);
473 fail_platform_device:
474 	platform_device_put(eeepc->platform_device);
475 	return result;
476 }
477 
478 static void eeepc_platform_exit(struct eeepc_laptop *eeepc)
479 {
480 	sysfs_remove_group(&eeepc->platform_device->dev.kobj,
481 			   &platform_attribute_group);
482 	platform_device_unregister(eeepc->platform_device);
483 }
484 
485 /*
486  * LEDs
487  */
488 /*
489  * These functions actually update the LED's, and are called from a
490  * workqueue. By doing this as separate work rather than when the LED
491  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
492  * potentially bad time, such as a timer interrupt.
493  */
494 static void tpd_led_update(struct work_struct *work)
495  {
496 	struct eeepc_laptop *eeepc;
497 
498 	eeepc = container_of(work, struct eeepc_laptop, tpd_led_work);
499 
500 	set_acpi(eeepc, CM_ASL_TPD, eeepc->tpd_led_wk);
501 }
502 
503 static void tpd_led_set(struct led_classdev *led_cdev,
504 			enum led_brightness value)
505 {
506 	struct eeepc_laptop *eeepc;
507 
508 	eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
509 
510 	eeepc->tpd_led_wk = (value > 0) ? 1 : 0;
511 	queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
512 }
513 
514 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
515 {
516 	struct eeepc_laptop *eeepc;
517 
518 	eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
519 
520 	return get_acpi(eeepc, CM_ASL_TPD);
521 }
522 
523 static int eeepc_led_init(struct eeepc_laptop *eeepc)
524 {
525 	int rv;
526 
527 	if (get_acpi(eeepc, CM_ASL_TPD) == -ENODEV)
528 		return 0;
529 
530 	eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
531 	if (!eeepc->led_workqueue)
532 		return -ENOMEM;
533 	INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
534 
535 	eeepc->tpd_led.name = "eeepc::touchpad";
536 	eeepc->tpd_led.brightness_set = tpd_led_set;
537 	if (get_acpi(eeepc, CM_ASL_TPD) >= 0) /* if method is available */
538 		eeepc->tpd_led.brightness_get = tpd_led_get;
539 	eeepc->tpd_led.max_brightness = 1;
540 
541 	rv = led_classdev_register(&eeepc->platform_device->dev,
542 				   &eeepc->tpd_led);
543 	if (rv) {
544 		destroy_workqueue(eeepc->led_workqueue);
545 		return rv;
546 	}
547 
548 	return 0;
549 }
550 
551 static void eeepc_led_exit(struct eeepc_laptop *eeepc)
552 {
553 	if (!IS_ERR_OR_NULL(eeepc->tpd_led.dev))
554 		led_classdev_unregister(&eeepc->tpd_led);
555 	if (eeepc->led_workqueue)
556 		destroy_workqueue(eeepc->led_workqueue);
557 }
558 
559 
560 /*
561  * PCI hotplug (for wlan rfkill)
562  */
563 static bool eeepc_wlan_rfkill_blocked(struct eeepc_laptop *eeepc)
564 {
565 	if (get_acpi(eeepc, CM_ASL_WLAN) == 1)
566 		return false;
567 	return true;
568 }
569 
570 static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
571 {
572 	struct pci_dev *port;
573 	struct pci_dev *dev;
574 	struct pci_bus *bus;
575 	bool blocked = eeepc_wlan_rfkill_blocked(eeepc);
576 	bool absent;
577 	u32 l;
578 
579 	if (eeepc->wlan_rfkill)
580 		rfkill_set_sw_state(eeepc->wlan_rfkill, blocked);
581 
582 	mutex_lock(&eeepc->hotplug_lock);
583 	pci_lock_rescan_remove();
584 
585 	if (!eeepc->hotplug_slot)
586 		goto out_unlock;
587 
588 	port = acpi_get_pci_dev(handle);
589 	if (!port) {
590 		pr_warning("Unable to find port\n");
591 		goto out_unlock;
592 	}
593 
594 	bus = port->subordinate;
595 
596 	if (!bus) {
597 		pr_warn("Unable to find PCI bus 1?\n");
598 		goto out_put_dev;
599 	}
600 
601 	if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
602 		pr_err("Unable to read PCI config space?\n");
603 		goto out_put_dev;
604 	}
605 
606 	absent = (l == 0xffffffff);
607 
608 	if (blocked != absent) {
609 		pr_warn("BIOS says wireless lan is %s, but the pci device is %s\n",
610 			blocked ? "blocked" : "unblocked",
611 			absent ? "absent" : "present");
612 		pr_warn("skipped wireless hotplug as probably inappropriate for this model\n");
613 		goto out_put_dev;
614 	}
615 
616 	if (!blocked) {
617 		dev = pci_get_slot(bus, 0);
618 		if (dev) {
619 			/* Device already present */
620 			pci_dev_put(dev);
621 			goto out_put_dev;
622 		}
623 		dev = pci_scan_single_device(bus, 0);
624 		if (dev) {
625 			pci_bus_assign_resources(bus);
626 			pci_bus_add_device(dev);
627 		}
628 	} else {
629 		dev = pci_get_slot(bus, 0);
630 		if (dev) {
631 			pci_stop_and_remove_bus_device(dev);
632 			pci_dev_put(dev);
633 		}
634 	}
635 out_put_dev:
636 	pci_dev_put(port);
637 
638 out_unlock:
639 	pci_unlock_rescan_remove();
640 	mutex_unlock(&eeepc->hotplug_lock);
641 }
642 
643 static void eeepc_rfkill_hotplug_update(struct eeepc_laptop *eeepc, char *node)
644 {
645 	acpi_status status = AE_OK;
646 	acpi_handle handle;
647 
648 	status = acpi_get_handle(NULL, node, &handle);
649 
650 	if (ACPI_SUCCESS(status))
651 		eeepc_rfkill_hotplug(eeepc, handle);
652 }
653 
654 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
655 {
656 	struct eeepc_laptop *eeepc = data;
657 
658 	if (event != ACPI_NOTIFY_BUS_CHECK)
659 		return;
660 
661 	eeepc_rfkill_hotplug(eeepc, handle);
662 }
663 
664 static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
665 					  char *node)
666 {
667 	acpi_status status;
668 	acpi_handle handle;
669 
670 	status = acpi_get_handle(NULL, node, &handle);
671 
672 	if (ACPI_FAILURE(status))
673 		return -ENODEV;
674 
675 	status = acpi_install_notify_handler(handle,
676 					     ACPI_SYSTEM_NOTIFY,
677 					     eeepc_rfkill_notify,
678 					     eeepc);
679 	if (ACPI_FAILURE(status))
680 		pr_warn("Failed to register notify on %s\n", node);
681 
682 	/*
683 	 * Refresh pci hotplug in case the rfkill state was
684 	 * changed during setup.
685 	 */
686 	eeepc_rfkill_hotplug(eeepc, handle);
687 	return 0;
688 }
689 
690 static void eeepc_unregister_rfkill_notifier(struct eeepc_laptop *eeepc,
691 					     char *node)
692 {
693 	acpi_status status = AE_OK;
694 	acpi_handle handle;
695 
696 	status = acpi_get_handle(NULL, node, &handle);
697 
698 	if (ACPI_FAILURE(status))
699 		return;
700 
701 	status = acpi_remove_notify_handler(handle,
702 					     ACPI_SYSTEM_NOTIFY,
703 					     eeepc_rfkill_notify);
704 	if (ACPI_FAILURE(status))
705 		pr_err("Error removing rfkill notify handler %s\n",
706 			node);
707 		/*
708 		 * Refresh pci hotplug in case the rfkill
709 		 * state was changed after
710 		 * eeepc_unregister_rfkill_notifier()
711 		 */
712 	eeepc_rfkill_hotplug(eeepc, handle);
713 }
714 
715 static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
716 				    u8 *value)
717 {
718 	struct eeepc_laptop *eeepc = hotplug_slot->private;
719 	int val = get_acpi(eeepc, CM_ASL_WLAN);
720 
721 	if (val == 1 || val == 0)
722 		*value = val;
723 	else
724 		return -EINVAL;
725 
726 	return 0;
727 }
728 
729 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
730 {
731 	kfree(hotplug_slot->info);
732 	kfree(hotplug_slot);
733 }
734 
735 static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
736 	.owner = THIS_MODULE,
737 	.get_adapter_status = eeepc_get_adapter_status,
738 	.get_power_status = eeepc_get_adapter_status,
739 };
740 
741 static int eeepc_setup_pci_hotplug(struct eeepc_laptop *eeepc)
742 {
743 	int ret = -ENOMEM;
744 	struct pci_bus *bus = pci_find_bus(0, 1);
745 
746 	if (!bus) {
747 		pr_err("Unable to find wifi PCI bus\n");
748 		return -ENODEV;
749 	}
750 
751 	eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
752 	if (!eeepc->hotplug_slot)
753 		goto error_slot;
754 
755 	eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
756 					    GFP_KERNEL);
757 	if (!eeepc->hotplug_slot->info)
758 		goto error_info;
759 
760 	eeepc->hotplug_slot->private = eeepc;
761 	eeepc->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
762 	eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
763 	eeepc_get_adapter_status(eeepc->hotplug_slot,
764 				 &eeepc->hotplug_slot->info->adapter_status);
765 
766 	ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
767 	if (ret) {
768 		pr_err("Unable to register hotplug slot - %d\n", ret);
769 		goto error_register;
770 	}
771 
772 	return 0;
773 
774 error_register:
775 	kfree(eeepc->hotplug_slot->info);
776 error_info:
777 	kfree(eeepc->hotplug_slot);
778 	eeepc->hotplug_slot = NULL;
779 error_slot:
780 	return ret;
781 }
782 
783 /*
784  * Rfkill devices
785  */
786 static int eeepc_rfkill_set(void *data, bool blocked)
787 {
788 	acpi_handle handle = data;
789 
790 	return write_acpi_int(handle, NULL, !blocked);
791 }
792 
793 static const struct rfkill_ops eeepc_rfkill_ops = {
794 	.set_block = eeepc_rfkill_set,
795 };
796 
797 static int eeepc_new_rfkill(struct eeepc_laptop *eeepc,
798 			    struct rfkill **rfkill,
799 			    const char *name,
800 			    enum rfkill_type type, int cm)
801 {
802 	acpi_handle handle;
803 	int result;
804 
805 	result = acpi_setter_handle(eeepc, cm, &handle);
806 	if (result < 0)
807 		return result;
808 
809 	*rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
810 			       &eeepc_rfkill_ops, handle);
811 
812 	if (!*rfkill)
813 		return -EINVAL;
814 
815 	rfkill_init_sw_state(*rfkill, get_acpi(eeepc, cm) != 1);
816 	result = rfkill_register(*rfkill);
817 	if (result) {
818 		rfkill_destroy(*rfkill);
819 		*rfkill = NULL;
820 		return result;
821 	}
822 	return 0;
823 }
824 
825 static char EEEPC_RFKILL_NODE_1[] = "\\_SB.PCI0.P0P5";
826 static char EEEPC_RFKILL_NODE_2[] = "\\_SB.PCI0.P0P6";
827 static char EEEPC_RFKILL_NODE_3[] = "\\_SB.PCI0.P0P7";
828 
829 static void eeepc_rfkill_exit(struct eeepc_laptop *eeepc)
830 {
831 	eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_1);
832 	eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_2);
833 	eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_3);
834 	if (eeepc->wlan_rfkill) {
835 		rfkill_unregister(eeepc->wlan_rfkill);
836 		rfkill_destroy(eeepc->wlan_rfkill);
837 		eeepc->wlan_rfkill = NULL;
838 	}
839 
840 	if (eeepc->hotplug_slot)
841 		pci_hp_deregister(eeepc->hotplug_slot);
842 
843 	if (eeepc->bluetooth_rfkill) {
844 		rfkill_unregister(eeepc->bluetooth_rfkill);
845 		rfkill_destroy(eeepc->bluetooth_rfkill);
846 		eeepc->bluetooth_rfkill = NULL;
847 	}
848 	if (eeepc->wwan3g_rfkill) {
849 		rfkill_unregister(eeepc->wwan3g_rfkill);
850 		rfkill_destroy(eeepc->wwan3g_rfkill);
851 		eeepc->wwan3g_rfkill = NULL;
852 	}
853 	if (eeepc->wimax_rfkill) {
854 		rfkill_unregister(eeepc->wimax_rfkill);
855 		rfkill_destroy(eeepc->wimax_rfkill);
856 		eeepc->wimax_rfkill = NULL;
857 	}
858 }
859 
860 static int eeepc_rfkill_init(struct eeepc_laptop *eeepc)
861 {
862 	int result = 0;
863 
864 	mutex_init(&eeepc->hotplug_lock);
865 
866 	result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
867 				  "eeepc-wlan", RFKILL_TYPE_WLAN,
868 				  CM_ASL_WLAN);
869 
870 	if (result && result != -ENODEV)
871 		goto exit;
872 
873 	result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
874 				  "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
875 				  CM_ASL_BLUETOOTH);
876 
877 	if (result && result != -ENODEV)
878 		goto exit;
879 
880 	result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
881 				  "eeepc-wwan3g", RFKILL_TYPE_WWAN,
882 				  CM_ASL_3G);
883 
884 	if (result && result != -ENODEV)
885 		goto exit;
886 
887 	result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
888 				  "eeepc-wimax", RFKILL_TYPE_WIMAX,
889 				  CM_ASL_WIMAX);
890 
891 	if (result && result != -ENODEV)
892 		goto exit;
893 
894 	if (eeepc->hotplug_disabled)
895 		return 0;
896 
897 	result = eeepc_setup_pci_hotplug(eeepc);
898 	/*
899 	 * If we get -EBUSY then something else is handling the PCI hotplug -
900 	 * don't fail in this case
901 	 */
902 	if (result == -EBUSY)
903 		result = 0;
904 
905 	eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_1);
906 	eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_2);
907 	eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_3);
908 
909 exit:
910 	if (result && result != -ENODEV)
911 		eeepc_rfkill_exit(eeepc);
912 	return result;
913 }
914 
915 /*
916  * Platform driver - hibernate/resume callbacks
917  */
918 static int eeepc_hotk_thaw(struct device *device)
919 {
920 	struct eeepc_laptop *eeepc = dev_get_drvdata(device);
921 
922 	if (eeepc->wlan_rfkill) {
923 		int wlan;
924 
925 		/*
926 		 * Work around bios bug - acpi _PTS turns off the wireless led
927 		 * during suspend.  Normally it restores it on resume, but
928 		 * we should kick it ourselves in case hibernation is aborted.
929 		 */
930 		wlan = get_acpi(eeepc, CM_ASL_WLAN);
931 		if (wlan >= 0)
932 			set_acpi(eeepc, CM_ASL_WLAN, wlan);
933 	}
934 
935 	return 0;
936 }
937 
938 static int eeepc_hotk_restore(struct device *device)
939 {
940 	struct eeepc_laptop *eeepc = dev_get_drvdata(device);
941 
942 	/* Refresh both wlan rfkill state and pci hotplug */
943 	if (eeepc->wlan_rfkill) {
944 		eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_1);
945 		eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_2);
946 		eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_3);
947 	}
948 
949 	if (eeepc->bluetooth_rfkill)
950 		rfkill_set_sw_state(eeepc->bluetooth_rfkill,
951 				    get_acpi(eeepc, CM_ASL_BLUETOOTH) != 1);
952 	if (eeepc->wwan3g_rfkill)
953 		rfkill_set_sw_state(eeepc->wwan3g_rfkill,
954 				    get_acpi(eeepc, CM_ASL_3G) != 1);
955 	if (eeepc->wimax_rfkill)
956 		rfkill_set_sw_state(eeepc->wimax_rfkill,
957 				    get_acpi(eeepc, CM_ASL_WIMAX) != 1);
958 
959 	return 0;
960 }
961 
962 static const struct dev_pm_ops eeepc_pm_ops = {
963 	.thaw = eeepc_hotk_thaw,
964 	.restore = eeepc_hotk_restore,
965 };
966 
967 static struct platform_driver platform_driver = {
968 	.driver = {
969 		.name = EEEPC_LAPTOP_FILE,
970 		.pm = &eeepc_pm_ops,
971 	}
972 };
973 
974 /*
975  * Hwmon device
976  */
977 
978 #define EEEPC_EC_SC00      0x61
979 #define EEEPC_EC_FAN_PWM   (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
980 #define EEEPC_EC_FAN_HRPM  (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
981 #define EEEPC_EC_FAN_LRPM  (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
982 
983 #define EEEPC_EC_SFB0      0xD0
984 #define EEEPC_EC_FAN_CTRL  (EEEPC_EC_SFB0 + 3) /* Byte containing SF25  */
985 
986 static inline int eeepc_pwm_to_lmsensors(int value)
987 {
988 	return value * 255 / 100;
989 }
990 
991 static inline int eeepc_lmsensors_to_pwm(int value)
992 {
993 	value = clamp_val(value, 0, 255);
994 	return value * 100 / 255;
995 }
996 
997 static int eeepc_get_fan_pwm(void)
998 {
999 	u8 value = 0;
1000 
1001 	ec_read(EEEPC_EC_FAN_PWM, &value);
1002 	return eeepc_pwm_to_lmsensors(value);
1003 }
1004 
1005 static void eeepc_set_fan_pwm(int value)
1006 {
1007 	value = eeepc_lmsensors_to_pwm(value);
1008 	ec_write(EEEPC_EC_FAN_PWM, value);
1009 }
1010 
1011 static int eeepc_get_fan_rpm(void)
1012 {
1013 	u8 high = 0;
1014 	u8 low = 0;
1015 
1016 	ec_read(EEEPC_EC_FAN_HRPM, &high);
1017 	ec_read(EEEPC_EC_FAN_LRPM, &low);
1018 	return high << 8 | low;
1019 }
1020 
1021 #define EEEPC_EC_FAN_CTRL_BIT	0x02
1022 #define EEEPC_FAN_CTRL_MANUAL	1
1023 #define EEEPC_FAN_CTRL_AUTO	2
1024 
1025 static int eeepc_get_fan_ctrl(void)
1026 {
1027 	u8 value = 0;
1028 
1029 	ec_read(EEEPC_EC_FAN_CTRL, &value);
1030 	if (value & EEEPC_EC_FAN_CTRL_BIT)
1031 		return EEEPC_FAN_CTRL_MANUAL;
1032 	else
1033 		return EEEPC_FAN_CTRL_AUTO;
1034 }
1035 
1036 static void eeepc_set_fan_ctrl(int manual)
1037 {
1038 	u8 value = 0;
1039 
1040 	ec_read(EEEPC_EC_FAN_CTRL, &value);
1041 	if (manual == EEEPC_FAN_CTRL_MANUAL)
1042 		value |= EEEPC_EC_FAN_CTRL_BIT;
1043 	else
1044 		value &= ~EEEPC_EC_FAN_CTRL_BIT;
1045 	ec_write(EEEPC_EC_FAN_CTRL, value);
1046 }
1047 
1048 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
1049 {
1050 	int rv, value;
1051 
1052 	rv = parse_arg(buf, &value);
1053 	if (rv < 0)
1054 		return rv;
1055 	set(value);
1056 	return count;
1057 }
1058 
1059 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
1060 {
1061 	return sprintf(buf, "%d\n", get());
1062 }
1063 
1064 #define EEEPC_SENSOR_SHOW_FUNC(_name, _get)				\
1065 	static ssize_t _name##_show(struct device *dev,			\
1066 				    struct device_attribute *attr,	\
1067 				    char *buf)				\
1068 	{								\
1069 		return show_sys_hwmon(_get, buf);			\
1070 	}
1071 
1072 #define EEEPC_SENSOR_STORE_FUNC(_name, _set)				\
1073 	static ssize_t _name##_store(struct device *dev,		\
1074 				     struct device_attribute *attr,	\
1075 				     const char *buf, size_t count)	\
1076 	{								\
1077 		return store_sys_hwmon(_set, buf, count);		\
1078 	}
1079 
1080 #define EEEPC_CREATE_SENSOR_ATTR_RW(_name, _get, _set)			\
1081 	EEEPC_SENSOR_SHOW_FUNC(_name, _get)				\
1082 	EEEPC_SENSOR_STORE_FUNC(_name, _set)				\
1083 	static DEVICE_ATTR_RW(_name)
1084 
1085 #define EEEPC_CREATE_SENSOR_ATTR_RO(_name, _get)			\
1086 	EEEPC_SENSOR_SHOW_FUNC(_name, _get)				\
1087 	static DEVICE_ATTR_RO(_name)
1088 
1089 EEEPC_CREATE_SENSOR_ATTR_RO(fan1_input, eeepc_get_fan_rpm);
1090 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1, eeepc_get_fan_pwm,
1091 			    eeepc_set_fan_pwm);
1092 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1_enable, eeepc_get_fan_ctrl,
1093 			    eeepc_set_fan_ctrl);
1094 
1095 static struct attribute *hwmon_attrs[] = {
1096 	&dev_attr_pwm1.attr,
1097 	&dev_attr_fan1_input.attr,
1098 	&dev_attr_pwm1_enable.attr,
1099 	NULL
1100 };
1101 ATTRIBUTE_GROUPS(hwmon);
1102 
1103 static int eeepc_hwmon_init(struct eeepc_laptop *eeepc)
1104 {
1105 	struct device *dev = &eeepc->platform_device->dev;
1106 	struct device *hwmon;
1107 
1108 	hwmon = devm_hwmon_device_register_with_groups(dev, "eeepc", NULL,
1109 						       hwmon_groups);
1110 	if (IS_ERR(hwmon)) {
1111 		pr_err("Could not register eeepc hwmon device\n");
1112 		return PTR_ERR(hwmon);
1113 	}
1114 	return 0;
1115 }
1116 
1117 /*
1118  * Backlight device
1119  */
1120 static int read_brightness(struct backlight_device *bd)
1121 {
1122 	struct eeepc_laptop *eeepc = bl_get_data(bd);
1123 
1124 	return get_acpi(eeepc, CM_ASL_PANELBRIGHT);
1125 }
1126 
1127 static int set_brightness(struct backlight_device *bd, int value)
1128 {
1129 	struct eeepc_laptop *eeepc = bl_get_data(bd);
1130 
1131 	return set_acpi(eeepc, CM_ASL_PANELBRIGHT, value);
1132 }
1133 
1134 static int update_bl_status(struct backlight_device *bd)
1135 {
1136 	return set_brightness(bd, bd->props.brightness);
1137 }
1138 
1139 static const struct backlight_ops eeepcbl_ops = {
1140 	.get_brightness = read_brightness,
1141 	.update_status = update_bl_status,
1142 };
1143 
1144 static int eeepc_backlight_notify(struct eeepc_laptop *eeepc)
1145 {
1146 	struct backlight_device *bd = eeepc->backlight_device;
1147 	int old = bd->props.brightness;
1148 
1149 	backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1150 
1151 	return old;
1152 }
1153 
1154 static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
1155 {
1156 	struct backlight_properties props;
1157 	struct backlight_device *bd;
1158 
1159 	memset(&props, 0, sizeof(struct backlight_properties));
1160 	props.type = BACKLIGHT_PLATFORM;
1161 	props.max_brightness = 15;
1162 	bd = backlight_device_register(EEEPC_LAPTOP_FILE,
1163 				       &eeepc->platform_device->dev, eeepc,
1164 				       &eeepcbl_ops, &props);
1165 	if (IS_ERR(bd)) {
1166 		pr_err("Could not register eeepc backlight device\n");
1167 		eeepc->backlight_device = NULL;
1168 		return PTR_ERR(bd);
1169 	}
1170 	eeepc->backlight_device = bd;
1171 	bd->props.brightness = read_brightness(bd);
1172 	bd->props.power = FB_BLANK_UNBLANK;
1173 	backlight_update_status(bd);
1174 	return 0;
1175 }
1176 
1177 static void eeepc_backlight_exit(struct eeepc_laptop *eeepc)
1178 {
1179 	backlight_device_unregister(eeepc->backlight_device);
1180 	eeepc->backlight_device = NULL;
1181 }
1182 
1183 
1184 /*
1185  * Input device (i.e. hotkeys)
1186  */
1187 static int eeepc_input_init(struct eeepc_laptop *eeepc)
1188 {
1189 	struct input_dev *input;
1190 	int error;
1191 
1192 	input = input_allocate_device();
1193 	if (!input)
1194 		return -ENOMEM;
1195 
1196 	input->name = "Asus EeePC extra buttons";
1197 	input->phys = EEEPC_LAPTOP_FILE "/input0";
1198 	input->id.bustype = BUS_HOST;
1199 	input->dev.parent = &eeepc->platform_device->dev;
1200 
1201 	error = sparse_keymap_setup(input, eeepc_keymap, NULL);
1202 	if (error) {
1203 		pr_err("Unable to setup input device keymap\n");
1204 		goto err_free_dev;
1205 	}
1206 
1207 	error = input_register_device(input);
1208 	if (error) {
1209 		pr_err("Unable to register input device\n");
1210 		goto err_free_dev;
1211 	}
1212 
1213 	eeepc->inputdev = input;
1214 	return 0;
1215 
1216 err_free_dev:
1217 	input_free_device(input);
1218 	return error;
1219 }
1220 
1221 static void eeepc_input_exit(struct eeepc_laptop *eeepc)
1222 {
1223 	if (eeepc->inputdev)
1224 		input_unregister_device(eeepc->inputdev);
1225 	eeepc->inputdev = NULL;
1226 }
1227 
1228 /*
1229  * ACPI driver
1230  */
1231 static void eeepc_input_notify(struct eeepc_laptop *eeepc, int event)
1232 {
1233 	if (!eeepc->inputdev)
1234 		return;
1235 	if (!sparse_keymap_report_event(eeepc->inputdev, event, 1, true))
1236 		pr_info("Unknown key %x pressed\n", event);
1237 }
1238 
1239 static void eeepc_acpi_notify(struct acpi_device *device, u32 event)
1240 {
1241 	struct eeepc_laptop *eeepc = acpi_driver_data(device);
1242 	int old_brightness, new_brightness;
1243 	u16 count;
1244 
1245 	if (event > ACPI_MAX_SYS_NOTIFY)
1246 		return;
1247 	count = eeepc->event_count[event % 128]++;
1248 	acpi_bus_generate_netlink_event(device->pnp.device_class,
1249 					dev_name(&device->dev), event,
1250 					count);
1251 
1252 	/* Brightness events are special */
1253 	if (event < NOTIFY_BRN_MIN || event > NOTIFY_BRN_MAX) {
1254 		eeepc_input_notify(eeepc, event);
1255 		return;
1256 	}
1257 
1258 	/* Ignore them completely if the acpi video driver is used */
1259 	if (!eeepc->backlight_device)
1260 		return;
1261 
1262 	/* Update the backlight device. */
1263 	old_brightness = eeepc_backlight_notify(eeepc);
1264 
1265 	/* Convert event to keypress (obsolescent hack) */
1266 	new_brightness = event - NOTIFY_BRN_MIN;
1267 
1268 	if (new_brightness < old_brightness) {
1269 		event = NOTIFY_BRN_MIN; /* brightness down */
1270 	} else if (new_brightness > old_brightness) {
1271 		event = NOTIFY_BRN_MAX; /* brightness up */
1272 	} else {
1273 		/*
1274 		 * no change in brightness - already at min/max,
1275 		 * event will be desired value (or else ignored)
1276 		 */
1277 	}
1278 	eeepc_input_notify(eeepc, event);
1279 }
1280 
1281 static void eeepc_dmi_check(struct eeepc_laptop *eeepc)
1282 {
1283 	const char *model;
1284 
1285 	model = dmi_get_system_info(DMI_PRODUCT_NAME);
1286 	if (!model)
1287 		return;
1288 
1289 	/*
1290 	 * Blacklist for setting cpufv (cpu speed).
1291 	 *
1292 	 * EeePC 4G ("701") implements CFVS, but it is not supported
1293 	 * by the pre-installed OS, and the original option to change it
1294 	 * in the BIOS setup screen was removed in later versions.
1295 	 *
1296 	 * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
1297 	 * this applies to all "701" models (4G/4G Surf/2G Surf).
1298 	 *
1299 	 * So Asus made a deliberate decision not to support it on this model.
1300 	 * We have several reports that using it can cause the system to hang
1301 	 *
1302 	 * The hang has also been reported on a "702" (Model name "8G"?).
1303 	 *
1304 	 * We avoid dmi_check_system() / dmi_match(), because they use
1305 	 * substring matching.  We don't want to affect the "701SD"
1306 	 * and "701SDX" models, because they do support S.H.E.
1307 	 */
1308 	if (strcmp(model, "701") == 0 || strcmp(model, "702") == 0) {
1309 		eeepc->cpufv_disabled = true;
1310 		pr_info("model %s does not officially support setting cpu speed\n",
1311 			model);
1312 		pr_info("cpufv disabled to avoid instability\n");
1313 	}
1314 
1315 	/*
1316 	 * Blacklist for wlan hotplug
1317 	 *
1318 	 * Eeepc 1005HA doesn't work like others models and don't need the
1319 	 * hotplug code. In fact, current hotplug code seems to unplug another
1320 	 * device...
1321 	 */
1322 	if (strcmp(model, "1005HA") == 0 || strcmp(model, "1201N") == 0 ||
1323 	    strcmp(model, "1005PE") == 0) {
1324 		eeepc->hotplug_disabled = true;
1325 		pr_info("wlan hotplug disabled\n");
1326 	}
1327 }
1328 
1329 static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
1330 {
1331 	int dummy;
1332 
1333 	/* Some BIOSes do not report cm although it is available.
1334 	   Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1335 	if (!(eeepc->cm_supported & (1 << cm))
1336 	    && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
1337 		pr_info("%s (%x) not reported by BIOS, enabling anyway\n",
1338 			name, 1 << cm);
1339 		eeepc->cm_supported |= 1 << cm;
1340 	}
1341 }
1342 
1343 static void cmsg_quirks(struct eeepc_laptop *eeepc)
1344 {
1345 	cmsg_quirk(eeepc, CM_ASL_LID, "LID");
1346 	cmsg_quirk(eeepc, CM_ASL_TYPE, "TYPE");
1347 	cmsg_quirk(eeepc, CM_ASL_PANELPOWER, "PANELPOWER");
1348 	cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
1349 }
1350 
1351 static int eeepc_acpi_init(struct eeepc_laptop *eeepc)
1352 {
1353 	unsigned int init_flags;
1354 	int result;
1355 
1356 	result = acpi_bus_get_status(eeepc->device);
1357 	if (result)
1358 		return result;
1359 	if (!eeepc->device->status.present) {
1360 		pr_err("Hotkey device not present, aborting\n");
1361 		return -ENODEV;
1362 	}
1363 
1364 	init_flags = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1365 	pr_notice("Hotkey init flags 0x%x\n", init_flags);
1366 
1367 	if (write_acpi_int(eeepc->handle, "INIT", init_flags)) {
1368 		pr_err("Hotkey initialization failed\n");
1369 		return -ENODEV;
1370 	}
1371 
1372 	/* get control methods supported */
1373 	if (read_acpi_int(eeepc->handle, "CMSG", &eeepc->cm_supported)) {
1374 		pr_err("Get control methods supported failed\n");
1375 		return -ENODEV;
1376 	}
1377 	cmsg_quirks(eeepc);
1378 	pr_info("Get control methods supported: 0x%x\n", eeepc->cm_supported);
1379 
1380 	return 0;
1381 }
1382 
1383 static void eeepc_enable_camera(struct eeepc_laptop *eeepc)
1384 {
1385 	/*
1386 	 * If the following call to set_acpi() fails, it's because there's no
1387 	 * camera so we can ignore the error.
1388 	 */
1389 	if (get_acpi(eeepc, CM_ASL_CAMERA) == 0)
1390 		set_acpi(eeepc, CM_ASL_CAMERA, 1);
1391 }
1392 
1393 static bool eeepc_device_present;
1394 
1395 static int eeepc_acpi_add(struct acpi_device *device)
1396 {
1397 	struct eeepc_laptop *eeepc;
1398 	int result;
1399 
1400 	pr_notice(EEEPC_LAPTOP_NAME "\n");
1401 	eeepc = kzalloc(sizeof(struct eeepc_laptop), GFP_KERNEL);
1402 	if (!eeepc)
1403 		return -ENOMEM;
1404 	eeepc->handle = device->handle;
1405 	strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
1406 	strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
1407 	device->driver_data = eeepc;
1408 	eeepc->device = device;
1409 
1410 	eeepc->hotplug_disabled = hotplug_disabled;
1411 
1412 	eeepc_dmi_check(eeepc);
1413 
1414 	result = eeepc_acpi_init(eeepc);
1415 	if (result)
1416 		goto fail_platform;
1417 	eeepc_enable_camera(eeepc);
1418 
1419 	/*
1420 	 * Register the platform device first.  It is used as a parent for the
1421 	 * sub-devices below.
1422 	 *
1423 	 * Note that if there are multiple instances of this ACPI device it
1424 	 * will bail out, because the platform device is registered with a
1425 	 * fixed name.  Of course it doesn't make sense to have more than one,
1426 	 * and machine-specific scripts find the fixed name convenient.  But
1427 	 * It's also good for us to exclude multiple instances because both
1428 	 * our hwmon and our wlan rfkill subdevice use global ACPI objects
1429 	 * (the EC and the wlan PCI slot respectively).
1430 	 */
1431 	result = eeepc_platform_init(eeepc);
1432 	if (result)
1433 		goto fail_platform;
1434 
1435 	if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1436 		result = eeepc_backlight_init(eeepc);
1437 		if (result)
1438 			goto fail_backlight;
1439 	}
1440 
1441 	result = eeepc_input_init(eeepc);
1442 	if (result)
1443 		goto fail_input;
1444 
1445 	result = eeepc_hwmon_init(eeepc);
1446 	if (result)
1447 		goto fail_hwmon;
1448 
1449 	result = eeepc_led_init(eeepc);
1450 	if (result)
1451 		goto fail_led;
1452 
1453 	result = eeepc_rfkill_init(eeepc);
1454 	if (result)
1455 		goto fail_rfkill;
1456 
1457 	eeepc_device_present = true;
1458 	return 0;
1459 
1460 fail_rfkill:
1461 	eeepc_led_exit(eeepc);
1462 fail_led:
1463 fail_hwmon:
1464 	eeepc_input_exit(eeepc);
1465 fail_input:
1466 	eeepc_backlight_exit(eeepc);
1467 fail_backlight:
1468 	eeepc_platform_exit(eeepc);
1469 fail_platform:
1470 	kfree(eeepc);
1471 
1472 	return result;
1473 }
1474 
1475 static int eeepc_acpi_remove(struct acpi_device *device)
1476 {
1477 	struct eeepc_laptop *eeepc = acpi_driver_data(device);
1478 
1479 	eeepc_backlight_exit(eeepc);
1480 	eeepc_rfkill_exit(eeepc);
1481 	eeepc_input_exit(eeepc);
1482 	eeepc_led_exit(eeepc);
1483 	eeepc_platform_exit(eeepc);
1484 
1485 	kfree(eeepc);
1486 	return 0;
1487 }
1488 
1489 
1490 static const struct acpi_device_id eeepc_device_ids[] = {
1491 	{EEEPC_ACPI_HID, 0},
1492 	{"", 0},
1493 };
1494 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
1495 
1496 static struct acpi_driver eeepc_acpi_driver = {
1497 	.name = EEEPC_LAPTOP_NAME,
1498 	.class = EEEPC_ACPI_CLASS,
1499 	.owner = THIS_MODULE,
1500 	.ids = eeepc_device_ids,
1501 	.flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1502 	.ops = {
1503 		.add = eeepc_acpi_add,
1504 		.remove = eeepc_acpi_remove,
1505 		.notify = eeepc_acpi_notify,
1506 	},
1507 };
1508 
1509 
1510 static int __init eeepc_laptop_init(void)
1511 {
1512 	int result;
1513 
1514 	result = platform_driver_register(&platform_driver);
1515 	if (result < 0)
1516 		return result;
1517 
1518 	result = acpi_bus_register_driver(&eeepc_acpi_driver);
1519 	if (result < 0)
1520 		goto fail_acpi_driver;
1521 
1522 	if (!eeepc_device_present) {
1523 		result = -ENODEV;
1524 		goto fail_no_device;
1525 	}
1526 
1527 	return 0;
1528 
1529 fail_no_device:
1530 	acpi_bus_unregister_driver(&eeepc_acpi_driver);
1531 fail_acpi_driver:
1532 	platform_driver_unregister(&platform_driver);
1533 	return result;
1534 }
1535 
1536 static void __exit eeepc_laptop_exit(void)
1537 {
1538 	acpi_bus_unregister_driver(&eeepc_acpi_driver);
1539 	platform_driver_unregister(&platform_driver);
1540 }
1541 
1542 module_init(eeepc_laptop_init);
1543 module_exit(eeepc_laptop_exit);
1544