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