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.ops)
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;
719 	int val;
720 
721 	eeepc = container_of(hotplug_slot, struct eeepc_laptop, hotplug_slot);
722 	val = get_acpi(eeepc, CM_ASL_WLAN);
723 
724 	if (val == 1 || val == 0)
725 		*value = val;
726 	else
727 		return -EINVAL;
728 
729 	return 0;
730 }
731 
732 static const struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
733 	.get_adapter_status = eeepc_get_adapter_status,
734 	.get_power_status = eeepc_get_adapter_status,
735 };
736 
737 static int eeepc_setup_pci_hotplug(struct eeepc_laptop *eeepc)
738 {
739 	int ret = -ENOMEM;
740 	struct pci_bus *bus = pci_find_bus(0, 1);
741 
742 	if (!bus) {
743 		pr_err("Unable to find wifi PCI bus\n");
744 		return -ENODEV;
745 	}
746 
747 	eeepc->hotplug_slot.ops = &eeepc_hotplug_slot_ops;
748 
749 	ret = pci_hp_register(&eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
750 	if (ret) {
751 		pr_err("Unable to register hotplug slot - %d\n", ret);
752 		goto error_register;
753 	}
754 
755 	return 0;
756 
757 error_register:
758 	eeepc->hotplug_slot.ops = NULL;
759 	return ret;
760 }
761 
762 /*
763  * Rfkill devices
764  */
765 static int eeepc_rfkill_set(void *data, bool blocked)
766 {
767 	acpi_handle handle = data;
768 
769 	return write_acpi_int(handle, NULL, !blocked);
770 }
771 
772 static const struct rfkill_ops eeepc_rfkill_ops = {
773 	.set_block = eeepc_rfkill_set,
774 };
775 
776 static int eeepc_new_rfkill(struct eeepc_laptop *eeepc,
777 			    struct rfkill **rfkill,
778 			    const char *name,
779 			    enum rfkill_type type, int cm)
780 {
781 	acpi_handle handle;
782 	int result;
783 
784 	result = acpi_setter_handle(eeepc, cm, &handle);
785 	if (result < 0)
786 		return result;
787 
788 	*rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
789 			       &eeepc_rfkill_ops, handle);
790 
791 	if (!*rfkill)
792 		return -EINVAL;
793 
794 	rfkill_init_sw_state(*rfkill, get_acpi(eeepc, cm) != 1);
795 	result = rfkill_register(*rfkill);
796 	if (result) {
797 		rfkill_destroy(*rfkill);
798 		*rfkill = NULL;
799 		return result;
800 	}
801 	return 0;
802 }
803 
804 static char EEEPC_RFKILL_NODE_1[] = "\\_SB.PCI0.P0P5";
805 static char EEEPC_RFKILL_NODE_2[] = "\\_SB.PCI0.P0P6";
806 static char EEEPC_RFKILL_NODE_3[] = "\\_SB.PCI0.P0P7";
807 
808 static void eeepc_rfkill_exit(struct eeepc_laptop *eeepc)
809 {
810 	eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_1);
811 	eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_2);
812 	eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_3);
813 	if (eeepc->wlan_rfkill) {
814 		rfkill_unregister(eeepc->wlan_rfkill);
815 		rfkill_destroy(eeepc->wlan_rfkill);
816 		eeepc->wlan_rfkill = NULL;
817 	}
818 
819 	if (eeepc->hotplug_slot.ops)
820 		pci_hp_deregister(&eeepc->hotplug_slot);
821 
822 	if (eeepc->bluetooth_rfkill) {
823 		rfkill_unregister(eeepc->bluetooth_rfkill);
824 		rfkill_destroy(eeepc->bluetooth_rfkill);
825 		eeepc->bluetooth_rfkill = NULL;
826 	}
827 	if (eeepc->wwan3g_rfkill) {
828 		rfkill_unregister(eeepc->wwan3g_rfkill);
829 		rfkill_destroy(eeepc->wwan3g_rfkill);
830 		eeepc->wwan3g_rfkill = NULL;
831 	}
832 	if (eeepc->wimax_rfkill) {
833 		rfkill_unregister(eeepc->wimax_rfkill);
834 		rfkill_destroy(eeepc->wimax_rfkill);
835 		eeepc->wimax_rfkill = NULL;
836 	}
837 }
838 
839 static int eeepc_rfkill_init(struct eeepc_laptop *eeepc)
840 {
841 	int result = 0;
842 
843 	mutex_init(&eeepc->hotplug_lock);
844 
845 	result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
846 				  "eeepc-wlan", RFKILL_TYPE_WLAN,
847 				  CM_ASL_WLAN);
848 
849 	if (result && result != -ENODEV)
850 		goto exit;
851 
852 	result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
853 				  "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
854 				  CM_ASL_BLUETOOTH);
855 
856 	if (result && result != -ENODEV)
857 		goto exit;
858 
859 	result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
860 				  "eeepc-wwan3g", RFKILL_TYPE_WWAN,
861 				  CM_ASL_3G);
862 
863 	if (result && result != -ENODEV)
864 		goto exit;
865 
866 	result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
867 				  "eeepc-wimax", RFKILL_TYPE_WIMAX,
868 				  CM_ASL_WIMAX);
869 
870 	if (result && result != -ENODEV)
871 		goto exit;
872 
873 	if (eeepc->hotplug_disabled)
874 		return 0;
875 
876 	result = eeepc_setup_pci_hotplug(eeepc);
877 	/*
878 	 * If we get -EBUSY then something else is handling the PCI hotplug -
879 	 * don't fail in this case
880 	 */
881 	if (result == -EBUSY)
882 		result = 0;
883 
884 	eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_1);
885 	eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_2);
886 	eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_3);
887 
888 exit:
889 	if (result && result != -ENODEV)
890 		eeepc_rfkill_exit(eeepc);
891 	return result;
892 }
893 
894 /*
895  * Platform driver - hibernate/resume callbacks
896  */
897 static int eeepc_hotk_thaw(struct device *device)
898 {
899 	struct eeepc_laptop *eeepc = dev_get_drvdata(device);
900 
901 	if (eeepc->wlan_rfkill) {
902 		int wlan;
903 
904 		/*
905 		 * Work around bios bug - acpi _PTS turns off the wireless led
906 		 * during suspend.  Normally it restores it on resume, but
907 		 * we should kick it ourselves in case hibernation is aborted.
908 		 */
909 		wlan = get_acpi(eeepc, CM_ASL_WLAN);
910 		if (wlan >= 0)
911 			set_acpi(eeepc, CM_ASL_WLAN, wlan);
912 	}
913 
914 	return 0;
915 }
916 
917 static int eeepc_hotk_restore(struct device *device)
918 {
919 	struct eeepc_laptop *eeepc = dev_get_drvdata(device);
920 
921 	/* Refresh both wlan rfkill state and pci hotplug */
922 	if (eeepc->wlan_rfkill) {
923 		eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_1);
924 		eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_2);
925 		eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_3);
926 	}
927 
928 	if (eeepc->bluetooth_rfkill)
929 		rfkill_set_sw_state(eeepc->bluetooth_rfkill,
930 				    get_acpi(eeepc, CM_ASL_BLUETOOTH) != 1);
931 	if (eeepc->wwan3g_rfkill)
932 		rfkill_set_sw_state(eeepc->wwan3g_rfkill,
933 				    get_acpi(eeepc, CM_ASL_3G) != 1);
934 	if (eeepc->wimax_rfkill)
935 		rfkill_set_sw_state(eeepc->wimax_rfkill,
936 				    get_acpi(eeepc, CM_ASL_WIMAX) != 1);
937 
938 	return 0;
939 }
940 
941 static const struct dev_pm_ops eeepc_pm_ops = {
942 	.thaw = eeepc_hotk_thaw,
943 	.restore = eeepc_hotk_restore,
944 };
945 
946 static struct platform_driver platform_driver = {
947 	.driver = {
948 		.name = EEEPC_LAPTOP_FILE,
949 		.pm = &eeepc_pm_ops,
950 	}
951 };
952 
953 /*
954  * Hwmon device
955  */
956 
957 #define EEEPC_EC_SC00      0x61
958 #define EEEPC_EC_FAN_PWM   (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
959 #define EEEPC_EC_FAN_HRPM  (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
960 #define EEEPC_EC_FAN_LRPM  (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
961 
962 #define EEEPC_EC_SFB0      0xD0
963 #define EEEPC_EC_FAN_CTRL  (EEEPC_EC_SFB0 + 3) /* Byte containing SF25  */
964 
965 static inline int eeepc_pwm_to_lmsensors(int value)
966 {
967 	return value * 255 / 100;
968 }
969 
970 static inline int eeepc_lmsensors_to_pwm(int value)
971 {
972 	value = clamp_val(value, 0, 255);
973 	return value * 100 / 255;
974 }
975 
976 static int eeepc_get_fan_pwm(void)
977 {
978 	u8 value = 0;
979 
980 	ec_read(EEEPC_EC_FAN_PWM, &value);
981 	return eeepc_pwm_to_lmsensors(value);
982 }
983 
984 static void eeepc_set_fan_pwm(int value)
985 {
986 	value = eeepc_lmsensors_to_pwm(value);
987 	ec_write(EEEPC_EC_FAN_PWM, value);
988 }
989 
990 static int eeepc_get_fan_rpm(void)
991 {
992 	u8 high = 0;
993 	u8 low = 0;
994 
995 	ec_read(EEEPC_EC_FAN_HRPM, &high);
996 	ec_read(EEEPC_EC_FAN_LRPM, &low);
997 	return high << 8 | low;
998 }
999 
1000 #define EEEPC_EC_FAN_CTRL_BIT	0x02
1001 #define EEEPC_FAN_CTRL_MANUAL	1
1002 #define EEEPC_FAN_CTRL_AUTO	2
1003 
1004 static int eeepc_get_fan_ctrl(void)
1005 {
1006 	u8 value = 0;
1007 
1008 	ec_read(EEEPC_EC_FAN_CTRL, &value);
1009 	if (value & EEEPC_EC_FAN_CTRL_BIT)
1010 		return EEEPC_FAN_CTRL_MANUAL;
1011 	else
1012 		return EEEPC_FAN_CTRL_AUTO;
1013 }
1014 
1015 static void eeepc_set_fan_ctrl(int manual)
1016 {
1017 	u8 value = 0;
1018 
1019 	ec_read(EEEPC_EC_FAN_CTRL, &value);
1020 	if (manual == EEEPC_FAN_CTRL_MANUAL)
1021 		value |= EEEPC_EC_FAN_CTRL_BIT;
1022 	else
1023 		value &= ~EEEPC_EC_FAN_CTRL_BIT;
1024 	ec_write(EEEPC_EC_FAN_CTRL, value);
1025 }
1026 
1027 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
1028 {
1029 	int rv, value;
1030 
1031 	rv = parse_arg(buf, &value);
1032 	if (rv < 0)
1033 		return rv;
1034 	set(value);
1035 	return count;
1036 }
1037 
1038 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
1039 {
1040 	return sprintf(buf, "%d\n", get());
1041 }
1042 
1043 #define EEEPC_SENSOR_SHOW_FUNC(_name, _get)				\
1044 	static ssize_t _name##_show(struct device *dev,			\
1045 				    struct device_attribute *attr,	\
1046 				    char *buf)				\
1047 	{								\
1048 		return show_sys_hwmon(_get, buf);			\
1049 	}
1050 
1051 #define EEEPC_SENSOR_STORE_FUNC(_name, _set)				\
1052 	static ssize_t _name##_store(struct device *dev,		\
1053 				     struct device_attribute *attr,	\
1054 				     const char *buf, size_t count)	\
1055 	{								\
1056 		return store_sys_hwmon(_set, buf, count);		\
1057 	}
1058 
1059 #define EEEPC_CREATE_SENSOR_ATTR_RW(_name, _get, _set)			\
1060 	EEEPC_SENSOR_SHOW_FUNC(_name, _get)				\
1061 	EEEPC_SENSOR_STORE_FUNC(_name, _set)				\
1062 	static DEVICE_ATTR_RW(_name)
1063 
1064 #define EEEPC_CREATE_SENSOR_ATTR_RO(_name, _get)			\
1065 	EEEPC_SENSOR_SHOW_FUNC(_name, _get)				\
1066 	static DEVICE_ATTR_RO(_name)
1067 
1068 EEEPC_CREATE_SENSOR_ATTR_RO(fan1_input, eeepc_get_fan_rpm);
1069 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1, eeepc_get_fan_pwm,
1070 			    eeepc_set_fan_pwm);
1071 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1_enable, eeepc_get_fan_ctrl,
1072 			    eeepc_set_fan_ctrl);
1073 
1074 static struct attribute *hwmon_attrs[] = {
1075 	&dev_attr_pwm1.attr,
1076 	&dev_attr_fan1_input.attr,
1077 	&dev_attr_pwm1_enable.attr,
1078 	NULL
1079 };
1080 ATTRIBUTE_GROUPS(hwmon);
1081 
1082 static int eeepc_hwmon_init(struct eeepc_laptop *eeepc)
1083 {
1084 	struct device *dev = &eeepc->platform_device->dev;
1085 	struct device *hwmon;
1086 
1087 	hwmon = devm_hwmon_device_register_with_groups(dev, "eeepc", NULL,
1088 						       hwmon_groups);
1089 	if (IS_ERR(hwmon)) {
1090 		pr_err("Could not register eeepc hwmon device\n");
1091 		return PTR_ERR(hwmon);
1092 	}
1093 	return 0;
1094 }
1095 
1096 /*
1097  * Backlight device
1098  */
1099 static int read_brightness(struct backlight_device *bd)
1100 {
1101 	struct eeepc_laptop *eeepc = bl_get_data(bd);
1102 
1103 	return get_acpi(eeepc, CM_ASL_PANELBRIGHT);
1104 }
1105 
1106 static int set_brightness(struct backlight_device *bd, int value)
1107 {
1108 	struct eeepc_laptop *eeepc = bl_get_data(bd);
1109 
1110 	return set_acpi(eeepc, CM_ASL_PANELBRIGHT, value);
1111 }
1112 
1113 static int update_bl_status(struct backlight_device *bd)
1114 {
1115 	return set_brightness(bd, bd->props.brightness);
1116 }
1117 
1118 static const struct backlight_ops eeepcbl_ops = {
1119 	.get_brightness = read_brightness,
1120 	.update_status = update_bl_status,
1121 };
1122 
1123 static int eeepc_backlight_notify(struct eeepc_laptop *eeepc)
1124 {
1125 	struct backlight_device *bd = eeepc->backlight_device;
1126 	int old = bd->props.brightness;
1127 
1128 	backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1129 
1130 	return old;
1131 }
1132 
1133 static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
1134 {
1135 	struct backlight_properties props;
1136 	struct backlight_device *bd;
1137 
1138 	memset(&props, 0, sizeof(struct backlight_properties));
1139 	props.type = BACKLIGHT_PLATFORM;
1140 	props.max_brightness = 15;
1141 	bd = backlight_device_register(EEEPC_LAPTOP_FILE,
1142 				       &eeepc->platform_device->dev, eeepc,
1143 				       &eeepcbl_ops, &props);
1144 	if (IS_ERR(bd)) {
1145 		pr_err("Could not register eeepc backlight device\n");
1146 		eeepc->backlight_device = NULL;
1147 		return PTR_ERR(bd);
1148 	}
1149 	eeepc->backlight_device = bd;
1150 	bd->props.brightness = read_brightness(bd);
1151 	bd->props.power = FB_BLANK_UNBLANK;
1152 	backlight_update_status(bd);
1153 	return 0;
1154 }
1155 
1156 static void eeepc_backlight_exit(struct eeepc_laptop *eeepc)
1157 {
1158 	backlight_device_unregister(eeepc->backlight_device);
1159 	eeepc->backlight_device = NULL;
1160 }
1161 
1162 
1163 /*
1164  * Input device (i.e. hotkeys)
1165  */
1166 static int eeepc_input_init(struct eeepc_laptop *eeepc)
1167 {
1168 	struct input_dev *input;
1169 	int error;
1170 
1171 	input = input_allocate_device();
1172 	if (!input)
1173 		return -ENOMEM;
1174 
1175 	input->name = "Asus EeePC extra buttons";
1176 	input->phys = EEEPC_LAPTOP_FILE "/input0";
1177 	input->id.bustype = BUS_HOST;
1178 	input->dev.parent = &eeepc->platform_device->dev;
1179 
1180 	error = sparse_keymap_setup(input, eeepc_keymap, NULL);
1181 	if (error) {
1182 		pr_err("Unable to setup input device keymap\n");
1183 		goto err_free_dev;
1184 	}
1185 
1186 	error = input_register_device(input);
1187 	if (error) {
1188 		pr_err("Unable to register input device\n");
1189 		goto err_free_dev;
1190 	}
1191 
1192 	eeepc->inputdev = input;
1193 	return 0;
1194 
1195 err_free_dev:
1196 	input_free_device(input);
1197 	return error;
1198 }
1199 
1200 static void eeepc_input_exit(struct eeepc_laptop *eeepc)
1201 {
1202 	if (eeepc->inputdev)
1203 		input_unregister_device(eeepc->inputdev);
1204 	eeepc->inputdev = NULL;
1205 }
1206 
1207 /*
1208  * ACPI driver
1209  */
1210 static void eeepc_input_notify(struct eeepc_laptop *eeepc, int event)
1211 {
1212 	if (!eeepc->inputdev)
1213 		return;
1214 	if (!sparse_keymap_report_event(eeepc->inputdev, event, 1, true))
1215 		pr_info("Unknown key %x pressed\n", event);
1216 }
1217 
1218 static void eeepc_acpi_notify(struct acpi_device *device, u32 event)
1219 {
1220 	struct eeepc_laptop *eeepc = acpi_driver_data(device);
1221 	int old_brightness, new_brightness;
1222 	u16 count;
1223 
1224 	if (event > ACPI_MAX_SYS_NOTIFY)
1225 		return;
1226 	count = eeepc->event_count[event % 128]++;
1227 	acpi_bus_generate_netlink_event(device->pnp.device_class,
1228 					dev_name(&device->dev), event,
1229 					count);
1230 
1231 	/* Brightness events are special */
1232 	if (event < NOTIFY_BRN_MIN || event > NOTIFY_BRN_MAX) {
1233 		eeepc_input_notify(eeepc, event);
1234 		return;
1235 	}
1236 
1237 	/* Ignore them completely if the acpi video driver is used */
1238 	if (!eeepc->backlight_device)
1239 		return;
1240 
1241 	/* Update the backlight device. */
1242 	old_brightness = eeepc_backlight_notify(eeepc);
1243 
1244 	/* Convert event to keypress (obsolescent hack) */
1245 	new_brightness = event - NOTIFY_BRN_MIN;
1246 
1247 	if (new_brightness < old_brightness) {
1248 		event = NOTIFY_BRN_MIN; /* brightness down */
1249 	} else if (new_brightness > old_brightness) {
1250 		event = NOTIFY_BRN_MAX; /* brightness up */
1251 	} else {
1252 		/*
1253 		 * no change in brightness - already at min/max,
1254 		 * event will be desired value (or else ignored)
1255 		 */
1256 	}
1257 	eeepc_input_notify(eeepc, event);
1258 }
1259 
1260 static void eeepc_dmi_check(struct eeepc_laptop *eeepc)
1261 {
1262 	const char *model;
1263 
1264 	model = dmi_get_system_info(DMI_PRODUCT_NAME);
1265 	if (!model)
1266 		return;
1267 
1268 	/*
1269 	 * Blacklist for setting cpufv (cpu speed).
1270 	 *
1271 	 * EeePC 4G ("701") implements CFVS, but it is not supported
1272 	 * by the pre-installed OS, and the original option to change it
1273 	 * in the BIOS setup screen was removed in later versions.
1274 	 *
1275 	 * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
1276 	 * this applies to all "701" models (4G/4G Surf/2G Surf).
1277 	 *
1278 	 * So Asus made a deliberate decision not to support it on this model.
1279 	 * We have several reports that using it can cause the system to hang
1280 	 *
1281 	 * The hang has also been reported on a "702" (Model name "8G"?).
1282 	 *
1283 	 * We avoid dmi_check_system() / dmi_match(), because they use
1284 	 * substring matching.  We don't want to affect the "701SD"
1285 	 * and "701SDX" models, because they do support S.H.E.
1286 	 */
1287 	if (strcmp(model, "701") == 0 || strcmp(model, "702") == 0) {
1288 		eeepc->cpufv_disabled = true;
1289 		pr_info("model %s does not officially support setting cpu speed\n",
1290 			model);
1291 		pr_info("cpufv disabled to avoid instability\n");
1292 	}
1293 
1294 	/*
1295 	 * Blacklist for wlan hotplug
1296 	 *
1297 	 * Eeepc 1005HA doesn't work like others models and don't need the
1298 	 * hotplug code. In fact, current hotplug code seems to unplug another
1299 	 * device...
1300 	 */
1301 	if (strcmp(model, "1005HA") == 0 || strcmp(model, "1201N") == 0 ||
1302 	    strcmp(model, "1005PE") == 0) {
1303 		eeepc->hotplug_disabled = true;
1304 		pr_info("wlan hotplug disabled\n");
1305 	}
1306 }
1307 
1308 static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
1309 {
1310 	int dummy;
1311 
1312 	/* Some BIOSes do not report cm although it is available.
1313 	   Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1314 	if (!(eeepc->cm_supported & (1 << cm))
1315 	    && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
1316 		pr_info("%s (%x) not reported by BIOS, enabling anyway\n",
1317 			name, 1 << cm);
1318 		eeepc->cm_supported |= 1 << cm;
1319 	}
1320 }
1321 
1322 static void cmsg_quirks(struct eeepc_laptop *eeepc)
1323 {
1324 	cmsg_quirk(eeepc, CM_ASL_LID, "LID");
1325 	cmsg_quirk(eeepc, CM_ASL_TYPE, "TYPE");
1326 	cmsg_quirk(eeepc, CM_ASL_PANELPOWER, "PANELPOWER");
1327 	cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
1328 }
1329 
1330 static int eeepc_acpi_init(struct eeepc_laptop *eeepc)
1331 {
1332 	unsigned int init_flags;
1333 	int result;
1334 
1335 	result = acpi_bus_get_status(eeepc->device);
1336 	if (result)
1337 		return result;
1338 	if (!eeepc->device->status.present) {
1339 		pr_err("Hotkey device not present, aborting\n");
1340 		return -ENODEV;
1341 	}
1342 
1343 	init_flags = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1344 	pr_notice("Hotkey init flags 0x%x\n", init_flags);
1345 
1346 	if (write_acpi_int(eeepc->handle, "INIT", init_flags)) {
1347 		pr_err("Hotkey initialization failed\n");
1348 		return -ENODEV;
1349 	}
1350 
1351 	/* get control methods supported */
1352 	if (read_acpi_int(eeepc->handle, "CMSG", &eeepc->cm_supported)) {
1353 		pr_err("Get control methods supported failed\n");
1354 		return -ENODEV;
1355 	}
1356 	cmsg_quirks(eeepc);
1357 	pr_info("Get control methods supported: 0x%x\n", eeepc->cm_supported);
1358 
1359 	return 0;
1360 }
1361 
1362 static void eeepc_enable_camera(struct eeepc_laptop *eeepc)
1363 {
1364 	/*
1365 	 * If the following call to set_acpi() fails, it's because there's no
1366 	 * camera so we can ignore the error.
1367 	 */
1368 	if (get_acpi(eeepc, CM_ASL_CAMERA) == 0)
1369 		set_acpi(eeepc, CM_ASL_CAMERA, 1);
1370 }
1371 
1372 static bool eeepc_device_present;
1373 
1374 static int eeepc_acpi_add(struct acpi_device *device)
1375 {
1376 	struct eeepc_laptop *eeepc;
1377 	int result;
1378 
1379 	pr_notice(EEEPC_LAPTOP_NAME "\n");
1380 	eeepc = kzalloc(sizeof(struct eeepc_laptop), GFP_KERNEL);
1381 	if (!eeepc)
1382 		return -ENOMEM;
1383 	eeepc->handle = device->handle;
1384 	strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
1385 	strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
1386 	device->driver_data = eeepc;
1387 	eeepc->device = device;
1388 
1389 	eeepc->hotplug_disabled = hotplug_disabled;
1390 
1391 	eeepc_dmi_check(eeepc);
1392 
1393 	result = eeepc_acpi_init(eeepc);
1394 	if (result)
1395 		goto fail_platform;
1396 	eeepc_enable_camera(eeepc);
1397 
1398 	/*
1399 	 * Register the platform device first.  It is used as a parent for the
1400 	 * sub-devices below.
1401 	 *
1402 	 * Note that if there are multiple instances of this ACPI device it
1403 	 * will bail out, because the platform device is registered with a
1404 	 * fixed name.  Of course it doesn't make sense to have more than one,
1405 	 * and machine-specific scripts find the fixed name convenient.  But
1406 	 * It's also good for us to exclude multiple instances because both
1407 	 * our hwmon and our wlan rfkill subdevice use global ACPI objects
1408 	 * (the EC and the wlan PCI slot respectively).
1409 	 */
1410 	result = eeepc_platform_init(eeepc);
1411 	if (result)
1412 		goto fail_platform;
1413 
1414 	if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1415 		result = eeepc_backlight_init(eeepc);
1416 		if (result)
1417 			goto fail_backlight;
1418 	}
1419 
1420 	result = eeepc_input_init(eeepc);
1421 	if (result)
1422 		goto fail_input;
1423 
1424 	result = eeepc_hwmon_init(eeepc);
1425 	if (result)
1426 		goto fail_hwmon;
1427 
1428 	result = eeepc_led_init(eeepc);
1429 	if (result)
1430 		goto fail_led;
1431 
1432 	result = eeepc_rfkill_init(eeepc);
1433 	if (result)
1434 		goto fail_rfkill;
1435 
1436 	eeepc_device_present = true;
1437 	return 0;
1438 
1439 fail_rfkill:
1440 	eeepc_led_exit(eeepc);
1441 fail_led:
1442 fail_hwmon:
1443 	eeepc_input_exit(eeepc);
1444 fail_input:
1445 	eeepc_backlight_exit(eeepc);
1446 fail_backlight:
1447 	eeepc_platform_exit(eeepc);
1448 fail_platform:
1449 	kfree(eeepc);
1450 
1451 	return result;
1452 }
1453 
1454 static int eeepc_acpi_remove(struct acpi_device *device)
1455 {
1456 	struct eeepc_laptop *eeepc = acpi_driver_data(device);
1457 
1458 	eeepc_backlight_exit(eeepc);
1459 	eeepc_rfkill_exit(eeepc);
1460 	eeepc_input_exit(eeepc);
1461 	eeepc_led_exit(eeepc);
1462 	eeepc_platform_exit(eeepc);
1463 
1464 	kfree(eeepc);
1465 	return 0;
1466 }
1467 
1468 
1469 static const struct acpi_device_id eeepc_device_ids[] = {
1470 	{EEEPC_ACPI_HID, 0},
1471 	{"", 0},
1472 };
1473 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
1474 
1475 static struct acpi_driver eeepc_acpi_driver = {
1476 	.name = EEEPC_LAPTOP_NAME,
1477 	.class = EEEPC_ACPI_CLASS,
1478 	.owner = THIS_MODULE,
1479 	.ids = eeepc_device_ids,
1480 	.flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1481 	.ops = {
1482 		.add = eeepc_acpi_add,
1483 		.remove = eeepc_acpi_remove,
1484 		.notify = eeepc_acpi_notify,
1485 	},
1486 };
1487 
1488 
1489 static int __init eeepc_laptop_init(void)
1490 {
1491 	int result;
1492 
1493 	result = platform_driver_register(&platform_driver);
1494 	if (result < 0)
1495 		return result;
1496 
1497 	result = acpi_bus_register_driver(&eeepc_acpi_driver);
1498 	if (result < 0)
1499 		goto fail_acpi_driver;
1500 
1501 	if (!eeepc_device_present) {
1502 		result = -ENODEV;
1503 		goto fail_no_device;
1504 	}
1505 
1506 	return 0;
1507 
1508 fail_no_device:
1509 	acpi_bus_unregister_driver(&eeepc_acpi_driver);
1510 fail_acpi_driver:
1511 	platform_driver_unregister(&platform_driver);
1512 	return result;
1513 }
1514 
1515 static void __exit eeepc_laptop_exit(void)
1516 {
1517 	acpi_bus_unregister_driver(&eeepc_acpi_driver);
1518 	platform_driver_unregister(&platform_driver);
1519 }
1520 
1521 module_init(eeepc_laptop_init);
1522 module_exit(eeepc_laptop_exit);
1523