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