platform-drivers: x86: fix common misspellings
[linux-2.6.git] / drivers / platform / x86 / eeepc-laptop.c
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 available.
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);