Merge branch 'asus' into release
[linux-2.6.git] / drivers / platform / x86 / eeepc-laptop.c
index e647a856b9bf684d9e57a88d4b3321edb770232b..5838c69b2fb304937da89c53cab090bf6d9a65de 100644 (file)
@@ -1,5 +1,5 @@
 /*
- *  eepc-laptop.c - Asus Eee PC extras
+ *  eeepc-laptop.c - Asus Eee PC extras
  *
  *  Based on asus_acpi.c as patched for the Eee PC by Asus:
  *  ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar
 #include <linux/rfkill.h>
 #include <linux/pci.h>
 #include <linux/pci_hotplug.h>
+#include <linux/leds.h>
 
 #define EEEPC_LAPTOP_VERSION   "0.1"
+#define EEEPC_LAPTOP_NAME      "Eee PC Hotkey Driver"
+#define EEEPC_LAPTOP_FILE      "eeepc"
 
-#define EEEPC_HOTK_NAME                "Eee PC Hotkey Driver"
-#define EEEPC_HOTK_FILE                "eeepc"
-#define EEEPC_HOTK_CLASS       "hotkey"
-#define EEEPC_HOTK_DEVICE_NAME "Hotkey"
-#define EEEPC_HOTK_HID         "ASUS010"
+#define EEEPC_ACPI_CLASS       "hotkey"
+#define EEEPC_ACPI_DEVICE_NAME "Hotkey"
+#define EEEPC_ACPI_HID         "ASUS010"
 
+MODULE_AUTHOR("Corentin Chary, Eric Cooper");
+MODULE_DESCRIPTION(EEEPC_LAPTOP_NAME);
+MODULE_LICENSE("GPL");
 
 /*
  * Definitions for Asus EeePC
  */
-#define        NOTIFY_WLAN_ON  0x10
 #define NOTIFY_BRN_MIN 0x20
 #define NOTIFY_BRN_MAX 0x2f
 
@@ -117,58 +120,6 @@ static const char *cm_setv[] = {
        NULL, NULL, "PBPS", "TPDS"
 };
 
-#define EEEPC_EC       "\\_SB.PCI0.SBRG.EC0."
-
-#define EEEPC_EC_FAN_PWM       EEEPC_EC "SC02" /* Fan PWM duty cycle (%) */
-#define EEEPC_EC_SC02          0x63
-#define EEEPC_EC_FAN_HRPM      EEEPC_EC "SC05" /* High byte, fan speed (RPM) */
-#define EEEPC_EC_FAN_LRPM      EEEPC_EC "SC06" /* Low byte, fan speed (RPM) */
-#define EEEPC_EC_FAN_CTRL      EEEPC_EC "SFB3" /* Byte containing SF25  */
-#define EEEPC_EC_SFB3          0xD3
-
-/*
- * This is the main structure, we can use it to store useful information
- * about the hotk device
- */
-struct eeepc_hotk {
-       struct acpi_device *device;     /* the device we are in */
-       acpi_handle handle;             /* the handle of the hotk device */
-       u32 cm_supported;               /* the control methods supported
-                                          by this BIOS */
-       uint init_flag;                 /* Init flags */
-       u16 event_count[128];           /* count for each event */
-       struct input_dev *inputdev;
-       u16 *keycode_map;
-       struct rfkill *wlan_rfkill;
-       struct rfkill *bluetooth_rfkill;
-       struct rfkill *wwan3g_rfkill;
-       struct rfkill *wimax_rfkill;
-       struct hotplug_slot *hotplug_slot;
-       struct mutex hotplug_lock;
-};
-
-/* The actual device the driver binds to */
-static struct eeepc_hotk *ehotk;
-
-/* Platform device/driver */
-static int eeepc_hotk_thaw(struct device *device);
-static int eeepc_hotk_restore(struct device *device);
-
-static const struct dev_pm_ops eeepc_pm_ops = {
-       .thaw = eeepc_hotk_thaw,
-       .restore = eeepc_hotk_restore,
-};
-
-static struct platform_driver platform_driver = {
-       .driver = {
-               .name = EEEPC_HOTK_FILE,
-               .owner = THIS_MODULE,
-               .pm = &eeepc_pm_ops,
-       }
-};
-
-static struct platform_device *platform_device;
-
 struct key_entry {
        char type;
        u8 code;
@@ -177,7 +128,7 @@ struct key_entry {
 
 enum { KE_KEY, KE_END };
 
-static struct key_entry eeepc_keymap[] = {
+static const struct key_entry eeepc_keymap[] = {
        /* Sleep already handled via generic ACPI code */
        {KE_KEY, 0x10, KEY_WLAN },
        {KE_KEY, 0x11, KEY_WLAN },
@@ -185,77 +136,56 @@ static struct key_entry eeepc_keymap[] = {
        {KE_KEY, 0x13, KEY_MUTE },
        {KE_KEY, 0x14, KEY_VOLUMEDOWN },
        {KE_KEY, 0x15, KEY_VOLUMEUP },
+       {KE_KEY, 0x16, KEY_DISPLAY_OFF },
        {KE_KEY, 0x1a, KEY_COFFEE },
        {KE_KEY, 0x1b, KEY_ZOOM },
        {KE_KEY, 0x1c, KEY_PROG2 },
        {KE_KEY, 0x1d, KEY_PROG3 },
-       {KE_KEY, NOTIFY_BRN_MIN,     KEY_BRIGHTNESSDOWN },
-       {KE_KEY, NOTIFY_BRN_MIN + 2, KEY_BRIGHTNESSUP },
+       {KE_KEY, NOTIFY_BRN_MIN, KEY_BRIGHTNESSDOWN },
+       {KE_KEY, NOTIFY_BRN_MAX, KEY_BRIGHTNESSUP },
        {KE_KEY, 0x30, KEY_SWITCHVIDEOMODE },
        {KE_KEY, 0x31, KEY_SWITCHVIDEOMODE },
        {KE_KEY, 0x32, KEY_SWITCHVIDEOMODE },
+       {KE_KEY, 0x37, KEY_F13 }, /* Disable Touchpad */
+       {KE_KEY, 0x38, KEY_F14 },
        {KE_END, 0},
 };
 
+
 /*
- * The hotkey driver declaration
+ * This is the main structure, we can use it to store useful information
  */
-static int eeepc_hotk_add(struct acpi_device *device);
-static int eeepc_hotk_remove(struct acpi_device *device, int type);
-static void eeepc_hotk_notify(struct acpi_device *device, u32 event);
-
-static const struct acpi_device_id eeepc_device_ids[] = {
-       {EEEPC_HOTK_HID, 0},
-       {"", 0},
-};
-MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
-
-static struct acpi_driver eeepc_hotk_driver = {
-       .name = EEEPC_HOTK_NAME,
-       .class = EEEPC_HOTK_CLASS,
-       .ids = eeepc_device_ids,
-       .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
-       .ops = {
-               .add = eeepc_hotk_add,
-               .remove = eeepc_hotk_remove,
-               .notify = eeepc_hotk_notify,
-       },
-};
+struct eeepc_laptop {
+       acpi_handle handle;             /* the handle of the acpi device */
+       u32 cm_supported;               /* the control methods supported
+                                          by this BIOS */
+       u16 event_count[128];           /* count for each event */
 
-/* PCI hotplug ops */
-static int eeepc_get_adapter_status(struct hotplug_slot *slot, u8 *value);
+       struct platform_device *platform_device;
+       struct device *hwmon_device;
+       struct backlight_device *backlight_device;
 
-static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
-       .owner = THIS_MODULE,
-       .get_adapter_status = eeepc_get_adapter_status,
-       .get_power_status = eeepc_get_adapter_status,
-};
+       struct input_dev *inputdev;
+       struct key_entry *keymap;
 
-/* The backlight device /sys/class/backlight */
-static struct backlight_device *eeepc_backlight_device;
+       struct rfkill *wlan_rfkill;
+       struct rfkill *bluetooth_rfkill;
+       struct rfkill *wwan3g_rfkill;
+       struct rfkill *wimax_rfkill;
 
-/* The hwmon device */
-static struct device *eeepc_hwmon_device;
+       struct hotplug_slot *hotplug_slot;
+       struct mutex hotplug_lock;
 
-/*
- * The backlight class declaration
- */
-static int read_brightness(struct backlight_device *bd);
-static int update_bl_status(struct backlight_device *bd);
-static struct backlight_ops eeepcbl_ops = {
-       .get_brightness = read_brightness,
-       .update_status = update_bl_status,
+       struct led_classdev tpd_led;
+       int tpd_led_wk;
+       struct workqueue_struct *led_workqueue;
+       struct work_struct tpd_led_work;
 };
 
-MODULE_AUTHOR("Corentin Chary, Eric Cooper");
-MODULE_DESCRIPTION(EEEPC_HOTK_NAME);
-MODULE_LICENSE("GPL");
-
 /*
  * ACPI Helpers
  */
-static int write_acpi_int(acpi_handle handle, const char *method, int val,
-                         struct acpi_buffer *output)
+static int write_acpi_int(acpi_handle handle, const char *method, int val)
 {
        struct acpi_object_list params;
        union acpi_object in_obj;
@@ -266,7 +196,7 @@ static int write_acpi_int(acpi_handle handle, const char *method, int val,
        in_obj.type = ACPI_TYPE_INTEGER;
        in_obj.integer.value = val;
 
-       status = acpi_evaluate_object(handle, (char *)method, &params, output);
+       status = acpi_evaluate_object(handle, (char *)method, &params, NULL);
        return (status == AE_OK ? 0 : -1);
 }
 
@@ -285,81 +215,56 @@ static int read_acpi_int(acpi_handle handle, const char *method, int *val)
        }
 }
 
-static int set_acpi(int cm, int value)
-{
-       if (ehotk->cm_supported & (0x1 << cm)) {
-               const char *method = cm_setv[cm];
-               if (method == NULL)
-                       return -ENODEV;
-               if (write_acpi_int(ehotk->handle, method, value, NULL))
-                       pr_warning("Error writing %s\n", method);
-       }
-       return 0;
-}
-
-static int get_acpi(int cm)
+static int set_acpi(struct eeepc_laptop *eeepc, int cm, int value)
 {
-       int value = -ENODEV;
-       if ((ehotk->cm_supported & (0x1 << cm))) {
-               const char *method = cm_getv[cm];
-               if (method == NULL)
-                       return -ENODEV;
-               if (read_acpi_int(ehotk->handle, method, &value))
-                       pr_warning("Error reading %s\n", method);
-       }
-       return value;
-}
+       const char *method = cm_setv[cm];
 
-/*
- * Backlight
- */
-static int read_brightness(struct backlight_device *bd)
-{
-       return get_acpi(CM_ASL_PANELBRIGHT);
-}
+       if (method == NULL)
+               return -ENODEV;
+       if ((eeepc->cm_supported & (0x1 << cm)) == 0)
+               return -ENODEV;
 
-static int set_brightness(struct backlight_device *bd, int value)
-{
-       value = max(0, min(15, value));
-       return set_acpi(CM_ASL_PANELBRIGHT, value);
+       if (write_acpi_int(eeepc->handle, method, value))
+               pr_warning("Error writing %s\n", method);
+       return 0;
 }
 
-static int update_bl_status(struct backlight_device *bd)
+static int get_acpi(struct eeepc_laptop *eeepc, int cm)
 {
-       return set_brightness(bd, bd->props.brightness);
-}
+       const char *method = cm_getv[cm];
+       int value;
 
-/*
- * Rfkill helpers
- */
+       if (method == NULL)
+               return -ENODEV;
+       if ((eeepc->cm_supported & (0x1 << cm)) == 0)
+               return -ENODEV;
 
-static bool eeepc_wlan_rfkill_blocked(void)
-{
-       if (get_acpi(CM_ASL_WLAN) == 1)
-               return false;
-       return true;
+       if (read_acpi_int(eeepc->handle, method, &value))
+               pr_warning("Error reading %s\n", method);
+       return value;
 }
 
-static int eeepc_rfkill_set(void *data, bool blocked)
+static int acpi_setter_handle(struct eeepc_laptop *eeepc, int cm,
+                             acpi_handle *handle)
 {
-       unsigned long asl = (unsigned long)data;
-       return set_acpi(asl, !blocked);
-}
+       const char *method = cm_setv[cm];
+       acpi_status status;
 
-static const struct rfkill_ops eeepc_rfkill_ops = {
-       .set_block = eeepc_rfkill_set,
-};
+       if (method == NULL)
+               return -ENODEV;
+       if ((eeepc->cm_supported & (0x1 << cm)) == 0)
+               return -ENODEV;
 
-static void __devinit eeepc_enable_camera(void)
-{
-       /*
-        * If the following call to set_acpi() fails, it's because there's no
-        * camera so we can ignore the error.
-        */
-       if (get_acpi(CM_ASL_CAMERA) == 0)
-               set_acpi(CM_ASL_CAMERA, 1);
+       status = acpi_get_handle(eeepc->handle, (char *)method,
+                                handle);
+       if (status != AE_OK) {
+               pr_warning("Error finding %s\n", method);
+               return -ENODEV;
+       }
+       return 0;
 }
 
+
 /*
  * Sys helpers
  */
@@ -372,60 +277,63 @@ static int parse_arg(const char *buf, unsigned long count, int *val)
        return count;
 }
 
-static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
+static ssize_t store_sys_acpi(struct device *dev, int cm,
+                             const char *buf, size_t count)
 {
+       struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
        int rv, value;
 
        rv = parse_arg(buf, count, &value);
        if (rv > 0)
-               value = set_acpi(cm, value);
+               value = set_acpi(eeepc, cm, value);
        if (value < 0)
-               return value;
+               return -EIO;
        return rv;
 }
 
-static ssize_t show_sys_acpi(int cm, char *buf)
+static ssize_t show_sys_acpi(struct device *dev, int cm, char *buf)
 {
-       int value = get_acpi(cm);
+       struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
+       int value = get_acpi(eeepc, cm);
 
        if (value < 0)
-               return value;
+               return -EIO;
        return sprintf(buf, "%d\n", value);
 }
 
-#define EEEPC_CREATE_DEVICE_ATTR(_name, _cm)                           \
+#define EEEPC_CREATE_DEVICE_ATTR(_name, _mode, _cm)                    \
        static ssize_t show_##_name(struct device *dev,                 \
                                    struct device_attribute *attr,      \
                                    char *buf)                          \
        {                                                               \
-               return show_sys_acpi(_cm, buf);                         \
+               return show_sys_acpi(dev, _cm, buf);                    \
        }                                                               \
        static ssize_t store_##_name(struct device *dev,                \
                                     struct device_attribute *attr,     \
                                     const char *buf, size_t count)     \
        {                                                               \
-               return store_sys_acpi(_cm, buf, count);                 \
+               return store_sys_acpi(dev, _cm, buf, count);            \
        }                                                               \
        static struct device_attribute dev_attr_##_name = {             \
                .attr = {                                               \
                        .name = __stringify(_name),                     \
-                       .mode = 0644 },                                 \
+                       .mode = _mode },                                \
                .show   = show_##_name,                                 \
                .store  = store_##_name,                                \
        }
 
-EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
-EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
-EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
+EEEPC_CREATE_DEVICE_ATTR(camera, 0644, CM_ASL_CAMERA);
+EEEPC_CREATE_DEVICE_ATTR(cardr, 0644, CM_ASL_CARDREADER);
+EEEPC_CREATE_DEVICE_ATTR(disp, 0200, CM_ASL_DISPLAYSWITCH);
 
 struct eeepc_cpufv {
        int num;
        int cur;
 };
 
-static int get_cpufv(struct eeepc_cpufv *c)
+static int get_cpufv(struct eeepc_laptop *eeepc, struct eeepc_cpufv *c)
 {
-       c->cur = get_acpi(CM_ASL_CPUFV);
+       c->cur = get_acpi(eeepc, CM_ASL_CPUFV);
        c->num = (c->cur >> 8) & 0xff;
        c->cur &= 0xff;
        if (c->cur < 0 || c->num <= 0 || c->num > 12)
@@ -437,11 +345,12 @@ static ssize_t show_available_cpufv(struct device *dev,
                                    struct device_attribute *attr,
                                    char *buf)
 {
+       struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
        struct eeepc_cpufv c;
        int i;
        ssize_t len = 0;
 
-       if (get_cpufv(&c))
+       if (get_cpufv(eeepc, &c))
                return -ENODEV;
        for (i = 0; i < c.num; i++)
                len += sprintf(buf + len, "%d ", i);
@@ -453,9 +362,10 @@ static ssize_t show_cpufv(struct device *dev,
                          struct device_attribute *attr,
                          char *buf)
 {
+       struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
        struct eeepc_cpufv c;
 
-       if (get_cpufv(&c))
+       if (get_cpufv(eeepc, &c))
                return -ENODEV;
        return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
 }
@@ -464,17 +374,18 @@ static ssize_t store_cpufv(struct device *dev,
                           struct device_attribute *attr,
                           const char *buf, size_t count)
 {
+       struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
        struct eeepc_cpufv c;
        int rv, value;
 
-       if (get_cpufv(&c))
+       if (get_cpufv(eeepc, &c))
                return -ENODEV;
        rv = parse_arg(buf, count, &value);
        if (rv < 0)
                return rv;
        if (!rv || value < 0 || value >= c.num)
                return -EINVAL;
-       set_acpi(CM_ASL_CPUFV, value);
+       set_acpi(eeepc, CM_ASL_CPUFV, value);
        return rv;
 }
 
@@ -506,156 +417,125 @@ static struct attribute_group platform_attribute_group = {
        .attrs = platform_attributes
 };
 
-/*
- * Hotkey functions
- */
-static struct key_entry *eepc_get_entry_by_scancode(int code)
+static int eeepc_platform_init(struct eeepc_laptop *eeepc)
 {
-       struct key_entry *key;
-
-       for (key = eeepc_keymap; key->type != KE_END; key++)
-               if (code == key->code)
-                       return key;
+       int result;
 
-       return NULL;
-}
+       eeepc->platform_device = platform_device_alloc(EEEPC_LAPTOP_FILE, -1);
+       if (!eeepc->platform_device)
+               return -ENOMEM;
+       platform_set_drvdata(eeepc->platform_device, eeepc);
 
-static struct key_entry *eepc_get_entry_by_keycode(int code)
-{
-       struct key_entry *key;
+       result = platform_device_add(eeepc->platform_device);
+       if (result)
+               goto fail_platform_device;
 
-       for (key = eeepc_keymap; key->type != KE_END; key++)
-               if (code == key->keycode && key->type == KE_KEY)
-                       return key;
+       result = sysfs_create_group(&eeepc->platform_device->dev.kobj,
+                                   &platform_attribute_group);
+       if (result)
+               goto fail_sysfs;
+       return 0;
 
-       return NULL;
+fail_sysfs:
+       platform_device_del(eeepc->platform_device);
+fail_platform_device:
+       platform_device_put(eeepc->platform_device);
+       return result;
 }
 
-static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode)
+static void eeepc_platform_exit(struct eeepc_laptop *eeepc)
 {
-       struct key_entry *key = eepc_get_entry_by_scancode(scancode);
+       sysfs_remove_group(&eeepc->platform_device->dev.kobj,
+                          &platform_attribute_group);
+       platform_device_unregister(eeepc->platform_device);
+}
 
-       if (key && key->type == KE_KEY) {
-               *keycode = key->keycode;
-               return 0;
-       }
+/*
+ * LEDs
+ */
+/*
+ * These functions actually update the LED's, and are called from a
+ * workqueue. By doing this as separate work rather than when the LED
+ * subsystem asks, we avoid messing with the Asus ACPI stuff during a
+ * potentially bad time, such as a timer interrupt.
+ */
+static void tpd_led_update(struct work_struct *work)
+ {
+       struct eeepc_laptop *eeepc;
 
-       return -EINVAL;
+       eeepc = container_of(work, struct eeepc_laptop, tpd_led_work);
+
+       set_acpi(eeepc, CM_ASL_TPD, eeepc->tpd_led_wk);
 }
 
-static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
+static void tpd_led_set(struct led_classdev *led_cdev,
+                       enum led_brightness value)
 {
-       struct key_entry *key;
-       int old_keycode;
-
-       if (keycode < 0 || keycode > KEY_MAX)
-               return -EINVAL;
+       struct eeepc_laptop *eeepc;
 
-       key = eepc_get_entry_by_scancode(scancode);
-       if (key && key->type == KE_KEY) {
-               old_keycode = key->keycode;
-               key->keycode = keycode;
-               set_bit(keycode, dev->keybit);
-               if (!eepc_get_entry_by_keycode(old_keycode))
-                       clear_bit(old_keycode, dev->keybit);
-               return 0;
-       }
+       eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
 
-       return -EINVAL;
+       eeepc->tpd_led_wk = (value > 0) ? 1 : 0;
+       queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
 }
 
-static void cmsg_quirk(int cm, const char *name)
+static int eeepc_led_init(struct eeepc_laptop *eeepc)
 {
-       int dummy;
+       int rv;
 
-       /* Some BIOSes do not report cm although it is avaliable.
-          Check if cm_getv[cm] works and, if yes, assume cm should be set. */
-       if (!(ehotk->cm_supported & (1 << cm))
-           && !read_acpi_int(ehotk->handle, cm_getv[cm], &dummy)) {
-               pr_info("%s (%x) not reported by BIOS,"
-                       " enabling anyway\n", name, 1 << cm);
-               ehotk->cm_supported |= 1 << cm;
-       }
-}
+       if (get_acpi(eeepc, CM_ASL_TPD) == -ENODEV)
+               return 0;
 
-static void cmsg_quirks(void)
-{
-       cmsg_quirk(CM_ASL_LID, "LID");
-       cmsg_quirk(CM_ASL_TYPE, "TYPE");
-       cmsg_quirk(CM_ASL_PANELPOWER, "PANELPOWER");
-       cmsg_quirk(CM_ASL_TPD, "TPD");
-}
+       eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
+       if (!eeepc->led_workqueue)
+               return -ENOMEM;
+       INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
 
-static int eeepc_hotk_check(void)
-{
-       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-       int result;
+       eeepc->tpd_led.name = "eeepc::touchpad";
+       eeepc->tpd_led.brightness_set = tpd_led_set;
+       eeepc->tpd_led.max_brightness = 1;
 
-       result = acpi_bus_get_status(ehotk->device);
-       if (result)
-               return result;
-       if (ehotk->device->status.present) {
-               if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
-                                   &buffer)) {
-                       pr_err("Hotkey initialization failed\n");
-                       return -ENODEV;
-               } else {
-                       pr_notice("Hotkey init flags 0x%x\n", ehotk->init_flag);
-               }
-               /* get control methods supported */
-               if (read_acpi_int(ehotk->handle, "CMSG"
-                                  , &ehotk->cm_supported)) {
-                       pr_err("Get control methods supported failed\n");
-                       return -ENODEV;
-               } else {
-                       cmsg_quirks();
-                       pr_info("Get control methods supported: 0x%x\n",
-                               ehotk->cm_supported);
-               }
-       } else {
-               pr_err("Hotkey device not present, aborting\n");
-               return -EINVAL;
+       rv = led_classdev_register(&eeepc->platform_device->dev,
+                                  &eeepc->tpd_led);
+       if (rv) {
+               destroy_workqueue(eeepc->led_workqueue);
+               return rv;
        }
+
        return 0;
 }
 
-static int notify_brn(void)
+static void eeepc_led_exit(struct eeepc_laptop *eeepc)
 {
-       /* returns the *previous* brightness, or -1 */
-       struct backlight_device *bd = eeepc_backlight_device;
-       if (bd) {
-               int old = bd->props.brightness;
-               backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
-               return old;
-       }
-       return -1;
+       if (eeepc->tpd_led.dev)
+               led_classdev_unregister(&eeepc->tpd_led);
+       if (eeepc->led_workqueue)
+               destroy_workqueue(eeepc->led_workqueue);
 }
 
-static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
-                                   u8 *value)
-{
-       int val = get_acpi(CM_ASL_WLAN);
-
-       if (val == 1 || val == 0)
-               *value = val;
-       else
-               return -EINVAL;
 
-       return 0;
+/*
+ * PCI hotplug (for wlan rfkill)
+ */
+static bool eeepc_wlan_rfkill_blocked(struct eeepc_laptop *eeepc)
+{
+       if (get_acpi(eeepc, CM_ASL_WLAN) == 1)
+               return false;
+       return true;
 }
 
-static void eeepc_rfkill_hotplug(void)
+static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc)
 {
        struct pci_dev *dev;
        struct pci_bus *bus;
-       bool blocked = eeepc_wlan_rfkill_blocked();
+       bool blocked = eeepc_wlan_rfkill_blocked(eeepc);
 
-       if (ehotk->wlan_rfkill)
-               rfkill_set_sw_state(ehotk->wlan_rfkill, blocked);
+       if (eeepc->wlan_rfkill)
+               rfkill_set_sw_state(eeepc->wlan_rfkill, blocked);
 
-       mutex_lock(&ehotk->hotplug_lock);
+       mutex_lock(&eeepc->hotplug_lock);
 
-       if (ehotk->hotplug_slot) {
+       if (eeepc->hotplug_slot) {
                bus = pci_find_bus(0, 1);
                if (!bus) {
                        pr_warning("Unable to find PCI bus 1?\n");
@@ -685,69 +565,23 @@ static void eeepc_rfkill_hotplug(void)
        }
 
 out_unlock:
-       mutex_unlock(&ehotk->hotplug_lock);
+       mutex_unlock(&eeepc->hotplug_lock);
 }
 
 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
 {
+       struct eeepc_laptop *eeepc = data;
+
        if (event != ACPI_NOTIFY_BUS_CHECK)
                return;
 
-       eeepc_rfkill_hotplug();
-}
-
-static void eeepc_hotk_notify(struct acpi_device *device, u32 event)
-{
-       static struct key_entry *key;
-       u16 count;
-       int brn = -ENODEV;
-
-       if (!ehotk)
-               return;
-       if (event > ACPI_MAX_SYS_NOTIFY)
-               return;
-       if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
-               brn = notify_brn();
-       count = ehotk->event_count[event % 128]++;
-       acpi_bus_generate_proc_event(ehotk->device, event, count);
-       acpi_bus_generate_netlink_event(ehotk->device->pnp.device_class,
-                                       dev_name(&ehotk->device->dev), event,
-                                       count);
-       if (ehotk->inputdev) {
-               if (brn != -ENODEV) {
-                       /* brightness-change events need special
-                        * handling for conversion to key events
-                        */
-                       if (brn < 0)
-                               brn = event;
-                       else
-                               brn += NOTIFY_BRN_MIN;
-                       if (event < brn)
-                               event = NOTIFY_BRN_MIN; /* brightness down */
-                       else if (event > brn)
-                               event = NOTIFY_BRN_MIN + 2; /* ... up */
-                       else
-                               event = NOTIFY_BRN_MIN + 1; /* ... unchanged */
-               }
-               key = eepc_get_entry_by_scancode(event);
-               if (key) {
-                       switch (key->type) {
-                       case KE_KEY:
-                               input_report_key(ehotk->inputdev, key->keycode,
-                                                1);
-                               input_sync(ehotk->inputdev);
-                               input_report_key(ehotk->inputdev, key->keycode,
-                                                0);
-                               input_sync(ehotk->inputdev);
-                               break;
-                       }
-               }
-       }
+       eeepc_rfkill_hotplug(eeepc);
 }
 
-static int eeepc_register_rfkill_notifier(char *node)
+static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
+                                         char *node)
 {
-       acpi_status status = AE_OK;
+       acpi_status status;
        acpi_handle handle;
 
        status = acpi_get_handle(NULL, node, &handle);
@@ -756,7 +590,7 @@ static int eeepc_register_rfkill_notifier(char *node)
                status = acpi_install_notify_handler(handle,
                                                     ACPI_SYSTEM_NOTIFY,
                                                     eeepc_rfkill_notify,
-                                                    NULL);
+                                                    eeepc);
                if (ACPI_FAILURE(status))
                        pr_warning("Failed to register notify on %s\n", node);
        } else
@@ -765,7 +599,8 @@ static int eeepc_register_rfkill_notifier(char *node)
        return 0;
 }
 
-static void eeepc_unregister_rfkill_notifier(char *node)
+static void eeepc_unregister_rfkill_notifier(struct eeepc_laptop *eeepc,
+                                            char *node)
 {
        acpi_status status = AE_OK;
        acpi_handle handle;
@@ -782,13 +617,33 @@ static void eeepc_unregister_rfkill_notifier(char *node)
        }
 }
 
+static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
+                                   u8 *value)
+{
+       struct eeepc_laptop *eeepc = hotplug_slot->private;
+       int val = get_acpi(eeepc, CM_ASL_WLAN);
+
+       if (val == 1 || val == 0)
+               *value = val;
+       else
+               return -EINVAL;
+
+       return 0;
+}
+
 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
 {
        kfree(hotplug_slot->info);
        kfree(hotplug_slot);
 }
 
-static int eeepc_setup_pci_hotplug(void)
+static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
+       .owner = THIS_MODULE,
+       .get_adapter_status = eeepc_get_adapter_status,
+       .get_power_status = eeepc_get_adapter_status,
+};
+
+static int eeepc_setup_pci_hotplug(struct eeepc_laptop *eeepc)
 {
        int ret = -ENOMEM;
        struct pci_bus *bus = pci_find_bus(0, 1);
@@ -798,22 +653,22 @@ static int eeepc_setup_pci_hotplug(void)
                return -ENODEV;
        }
 
-       ehotk->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
-       if (!ehotk->hotplug_slot)
+       eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+       if (!eeepc->hotplug_slot)
                goto error_slot;
 
-       ehotk->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+       eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
                                            GFP_KERNEL);
-       if (!ehotk->hotplug_slot->info)
+       if (!eeepc->hotplug_slot->info)
                goto error_info;
 
-       ehotk->hotplug_slot->private = ehotk;
-       ehotk->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
-       ehotk->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
-       eeepc_get_adapter_status(ehotk->hotplug_slot,
-                                &ehotk->hotplug_slot->info->adapter_status);
+       eeepc->hotplug_slot->private = eeepc;
+       eeepc->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
+       eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
+       eeepc_get_adapter_status(eeepc->hotplug_slot,
+                                &eeepc->hotplug_slot->info->adapter_status);
 
-       ret = pci_hp_register(ehotk->hotplug_slot, bus, 0, "eeepc-wifi");
+       ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
        if (ret) {
                pr_err("Unable to register hotplug slot - %d\n", ret);
                goto error_register;
@@ -822,97 +677,262 @@ static int eeepc_setup_pci_hotplug(void)
        return 0;
 
 error_register:
-       kfree(ehotk->hotplug_slot->info);
+       kfree(eeepc->hotplug_slot->info);
 error_info:
-       kfree(ehotk->hotplug_slot);
-       ehotk->hotplug_slot = NULL;
+       kfree(eeepc->hotplug_slot);
+       eeepc->hotplug_slot = NULL;
 error_slot:
        return ret;
 }
 
-static int eeepc_hotk_thaw(struct device *device)
+/*
+ * Rfkill devices
+ */
+static int eeepc_rfkill_set(void *data, bool blocked)
 {
-       if (ehotk->wlan_rfkill) {
-               bool wlan;
-
-               /*
-                * Work around bios bug - acpi _PTS turns off the wireless led
-                * during suspend.  Normally it restores it on resume, but
-                * we should kick it ourselves in case hibernation is aborted.
-                */
-               wlan = get_acpi(CM_ASL_WLAN);
-               set_acpi(CM_ASL_WLAN, wlan);
-       }
+       acpi_handle handle = data;
 
-       return 0;
+       return write_acpi_int(handle, NULL, !blocked);
 }
 
-static int eeepc_hotk_restore(struct device *device)
-{
-       /* Refresh both wlan rfkill state and pci hotplug */
-       if (ehotk->wlan_rfkill)
-               eeepc_rfkill_hotplug();
-
-       if (ehotk->bluetooth_rfkill)
-               rfkill_set_sw_state(ehotk->bluetooth_rfkill,
-                                   get_acpi(CM_ASL_BLUETOOTH) != 1);
-       if (ehotk->wwan3g_rfkill)
-               rfkill_set_sw_state(ehotk->wwan3g_rfkill,
-                                   get_acpi(CM_ASL_3G) != 1);
-       if (ehotk->wimax_rfkill)
-               rfkill_set_sw_state(ehotk->wimax_rfkill,
-                                   get_acpi(CM_ASL_WIMAX) != 1);
+static const struct rfkill_ops eeepc_rfkill_ops = {
+       .set_block = eeepc_rfkill_set,
+};
+
+static int eeepc_new_rfkill(struct eeepc_laptop *eeepc,
+                           struct rfkill **rfkill,
+                           const char *name,
+                           enum rfkill_type type, int cm)
+{
+       acpi_handle handle;
+       int result;
+
+       result = acpi_setter_handle(eeepc, cm, &handle);
+       if (result < 0)
+               return result;
+
+       *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
+                              &eeepc_rfkill_ops, handle);
 
+       if (!*rfkill)
+               return -EINVAL;
+
+       rfkill_init_sw_state(*rfkill, get_acpi(eeepc, cm) != 1);
+       result = rfkill_register(*rfkill);
+       if (result) {
+               rfkill_destroy(*rfkill);
+               *rfkill = NULL;
+               return result;
+       }
        return 0;
 }
 
+static void eeepc_rfkill_exit(struct eeepc_laptop *eeepc)
+{
+       eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
+       eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
+       eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
+       if (eeepc->wlan_rfkill) {
+               rfkill_unregister(eeepc->wlan_rfkill);
+               rfkill_destroy(eeepc->wlan_rfkill);
+               eeepc->wlan_rfkill = NULL;
+       }
+       /*
+        * Refresh pci hotplug in case the rfkill state was changed after
+        * eeepc_unregister_rfkill_notifier()
+        */
+       eeepc_rfkill_hotplug(eeepc);
+       if (eeepc->hotplug_slot)
+               pci_hp_deregister(eeepc->hotplug_slot);
+
+       if (eeepc->bluetooth_rfkill) {
+               rfkill_unregister(eeepc->bluetooth_rfkill);
+               rfkill_destroy(eeepc->bluetooth_rfkill);
+               eeepc->bluetooth_rfkill = NULL;
+       }
+       if (eeepc->wwan3g_rfkill) {
+               rfkill_unregister(eeepc->wwan3g_rfkill);
+               rfkill_destroy(eeepc->wwan3g_rfkill);
+               eeepc->wwan3g_rfkill = NULL;
+       }
+       if (eeepc->wimax_rfkill) {
+               rfkill_unregister(eeepc->wimax_rfkill);
+               rfkill_destroy(eeepc->wimax_rfkill);
+               eeepc->wimax_rfkill = NULL;
+       }
+}
+
+static int eeepc_rfkill_init(struct eeepc_laptop *eeepc)
+{
+       int result = 0;
+
+       mutex_init(&eeepc->hotplug_lock);
+
+       result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
+                                 "eeepc-wlan", RFKILL_TYPE_WLAN,
+                                 CM_ASL_WLAN);
+
+       if (result && result != -ENODEV)
+               goto exit;
+
+       result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
+                                 "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
+                                 CM_ASL_BLUETOOTH);
+
+       if (result && result != -ENODEV)
+               goto exit;
+
+       result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
+                                 "eeepc-wwan3g", RFKILL_TYPE_WWAN,
+                                 CM_ASL_3G);
+
+       if (result && result != -ENODEV)
+               goto exit;
+
+       result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
+                                 "eeepc-wimax", RFKILL_TYPE_WIMAX,
+                                 CM_ASL_WIMAX);
+
+       if (result && result != -ENODEV)
+               goto exit;
+
+       result = eeepc_setup_pci_hotplug(eeepc);
+       /*
+        * If we get -EBUSY then something else is handling the PCI hotplug -
+        * don't fail in this case
+        */
+       if (result == -EBUSY)
+               result = 0;
+
+       eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
+       eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
+       eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
+       /*
+        * Refresh pci hotplug in case the rfkill state was changed during
+        * setup.
+        */
+       eeepc_rfkill_hotplug(eeepc);
+
+exit:
+       if (result && result != -ENODEV)
+               eeepc_rfkill_exit(eeepc);
+       return result;
+}
+
 /*
- * Hwmon
+ * Platform driver - hibernate/resume callbacks
  */
+static int eeepc_hotk_thaw(struct device *device)
+{
+       struct eeepc_laptop *eeepc = dev_get_drvdata(device);
+
+       if (eeepc->wlan_rfkill) {
+               bool wlan;
+
+               /*
+                * Work around bios bug - acpi _PTS turns off the wireless led
+                * during suspend.  Normally it restores it on resume, but
+                * we should kick it ourselves in case hibernation is aborted.
+                */
+               wlan = get_acpi(eeepc, CM_ASL_WLAN);
+               set_acpi(eeepc, CM_ASL_WLAN, wlan);
+       }
+
+       return 0;
+}
+
+static int eeepc_hotk_restore(struct device *device)
+{
+       struct eeepc_laptop *eeepc = dev_get_drvdata(device);
+
+       /* Refresh both wlan rfkill state and pci hotplug */
+       if (eeepc->wlan_rfkill)
+               eeepc_rfkill_hotplug(eeepc);
+
+       if (eeepc->bluetooth_rfkill)
+               rfkill_set_sw_state(eeepc->bluetooth_rfkill,
+                                   get_acpi(eeepc, CM_ASL_BLUETOOTH) != 1);
+       if (eeepc->wwan3g_rfkill)
+               rfkill_set_sw_state(eeepc->wwan3g_rfkill,
+                                   get_acpi(eeepc, CM_ASL_3G) != 1);
+       if (eeepc->wimax_rfkill)
+               rfkill_set_sw_state(eeepc->wimax_rfkill,
+                                   get_acpi(eeepc, CM_ASL_WIMAX) != 1);
+
+       return 0;
+}
+
+static const struct dev_pm_ops eeepc_pm_ops = {
+       .thaw = eeepc_hotk_thaw,
+       .restore = eeepc_hotk_restore,
+};
+
+static struct platform_driver platform_driver = {
+       .driver = {
+               .name = EEEPC_LAPTOP_FILE,
+               .owner = THIS_MODULE,
+               .pm = &eeepc_pm_ops,
+       }
+};
+
+/*
+ * Hwmon device
+ */
+
+#define EEEPC_EC_SC00      0x61
+#define EEEPC_EC_FAN_PWM   (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
+#define EEEPC_EC_FAN_HRPM  (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
+#define EEEPC_EC_FAN_LRPM  (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
+
+#define EEEPC_EC_SFB0      0xD0
+#define EEEPC_EC_FAN_CTRL  (EEEPC_EC_SFB0 + 3) /* Byte containing SF25  */
+
 static int eeepc_get_fan_pwm(void)
 {
-       int value = 0;
+       u8 value = 0;
 
-       read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value);
-       value = value * 255 / 100;
-       return (value);
+       ec_read(EEEPC_EC_FAN_PWM, &value);
+       return value * 255 / 100;
 }
 
 static void eeepc_set_fan_pwm(int value)
 {
        value = SENSORS_LIMIT(value, 0, 255);
        value = value * 100 / 255;
-       ec_write(EEEPC_EC_SC02, value);
+       ec_write(EEEPC_EC_FAN_PWM, value);
 }
 
 static int eeepc_get_fan_rpm(void)
 {
-       int high = 0;
-       int low = 0;
+       u8 high = 0;
+       u8 low = 0;
 
-       read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high);
-       read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low);
-       return (high << 8 | low);
+       ec_read(EEEPC_EC_FAN_HRPM, &high);
+       ec_read(EEEPC_EC_FAN_LRPM, &low);
+       return high << 8 | low;
 }
 
 static int eeepc_get_fan_ctrl(void)
 {
-       int value = 0;
+       u8 value = 0;
 
-       read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
-       return ((value & 0x02 ? 1 : 0));
+       ec_read(EEEPC_EC_FAN_CTRL, &value);
+       if (value & 0x02)
+               return 1; /* manual */
+       else
+               return 2; /* automatic */
 }
 
 static void eeepc_set_fan_ctrl(int manual)
 {
-       int value = 0;
+       u8 value = 0;
 
-       read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
-       if (manual)
+       ec_read(EEEPC_EC_FAN_CTRL, &value);
+       if (manual == 1)
                value |= 0x02;
        else
                value &= ~0x02;
-       ec_write(EEEPC_EC_SFB3, value);
+       ec_write(EEEPC_EC_FAN_CTRL, value);
 }
 
 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
@@ -970,348 +990,485 @@ static struct attribute_group hwmon_attribute_group = {
        .attrs = hwmon_attributes
 };
 
-/*
- * exit/init
- */
-static void eeepc_backlight_exit(void)
+static void eeepc_hwmon_exit(struct eeepc_laptop *eeepc)
 {
-       if (eeepc_backlight_device)
-               backlight_device_unregister(eeepc_backlight_device);
-       eeepc_backlight_device = NULL;
+       struct device *hwmon;
+
+       hwmon = eeepc->hwmon_device;
+       if (!hwmon)
+               return;
+       sysfs_remove_group(&hwmon->kobj,
+                          &hwmon_attribute_group);
+       hwmon_device_unregister(hwmon);
+       eeepc->hwmon_device = NULL;
 }
 
-static void eeepc_rfkill_exit(void)
+static int eeepc_hwmon_init(struct eeepc_laptop *eeepc)
 {
-       eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P5");
-       eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
-       eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
-       if (ehotk->wlan_rfkill) {
-               rfkill_unregister(ehotk->wlan_rfkill);
-               rfkill_destroy(ehotk->wlan_rfkill);
-               ehotk->wlan_rfkill = NULL;
-       }
-       /*
-        * Refresh pci hotplug in case the rfkill state was changed after
-        * eeepc_unregister_rfkill_notifier()
-        */
-       eeepc_rfkill_hotplug();
-       if (ehotk->hotplug_slot)
-               pci_hp_deregister(ehotk->hotplug_slot);
-
-       if (ehotk->bluetooth_rfkill) {
-               rfkill_unregister(ehotk->bluetooth_rfkill);
-               rfkill_destroy(ehotk->bluetooth_rfkill);
-               ehotk->bluetooth_rfkill = NULL;
-       }
-       if (ehotk->wwan3g_rfkill) {
-               rfkill_unregister(ehotk->wwan3g_rfkill);
-               rfkill_destroy(ehotk->wwan3g_rfkill);
-               ehotk->wwan3g_rfkill = NULL;
-       }
-       if (ehotk->wimax_rfkill) {
-               rfkill_unregister(ehotk->wimax_rfkill);
-               rfkill_destroy(ehotk->wimax_rfkill);
-               ehotk->wimax_rfkill = NULL;
+       struct device *hwmon;
+       int result;
+
+       hwmon = hwmon_device_register(&eeepc->platform_device->dev);
+       if (IS_ERR(hwmon)) {
+               pr_err("Could not register eeepc hwmon device\n");
+               eeepc->hwmon_device = NULL;
+               return PTR_ERR(hwmon);
        }
+       eeepc->hwmon_device = hwmon;
+       result = sysfs_create_group(&hwmon->kobj,
+                                   &hwmon_attribute_group);
+       if (result)
+               eeepc_hwmon_exit(eeepc);
+       return result;
 }
 
-static void eeepc_input_exit(void)
+/*
+ * Backlight device
+ */
+static int read_brightness(struct backlight_device *bd)
 {
-       if (ehotk->inputdev)
-               input_unregister_device(ehotk->inputdev);
+       struct eeepc_laptop *eeepc = bl_get_data(bd);
+
+       return get_acpi(eeepc, CM_ASL_PANELBRIGHT);
 }
 
-static void eeepc_hwmon_exit(void)
+static int set_brightness(struct backlight_device *bd, int value)
 {
-       struct device *hwmon;
+       struct eeepc_laptop *eeepc = bl_get_data(bd);
 
-       hwmon = eeepc_hwmon_device;
-       if (!hwmon)
-               return ;
-       sysfs_remove_group(&hwmon->kobj,
-                          &hwmon_attribute_group);
-       hwmon_device_unregister(hwmon);
-       eeepc_hwmon_device = NULL;
+       return set_acpi(eeepc, CM_ASL_PANELBRIGHT, value);
 }
 
-static int eeepc_new_rfkill(struct rfkill **rfkill,
-                           const char *name, struct device *dev,
-                           enum rfkill_type type, int cm)
+static int update_bl_status(struct backlight_device *bd)
 {
-       int result;
+       return set_brightness(bd, bd->props.brightness);
+}
 
-       result = get_acpi(cm);
-       if (result < 0)
-               return result;
+static struct backlight_ops eeepcbl_ops = {
+       .get_brightness = read_brightness,
+       .update_status = update_bl_status,
+};
 
-       *rfkill = rfkill_alloc(name, dev, type,
-                              &eeepc_rfkill_ops, (void *)(unsigned long)cm);
+static int eeepc_backlight_notify(struct eeepc_laptop *eeepc)
+{
+       struct backlight_device *bd = eeepc->backlight_device;
+       int old = bd->props.brightness;
 
-       if (!*rfkill)
-               return -EINVAL;
+       backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
 
-       rfkill_init_sw_state(*rfkill, get_acpi(cm) != 1);
-       result = rfkill_register(*rfkill);
-       if (result) {
-               rfkill_destroy(*rfkill);
-               *rfkill = NULL;
-               return result;
-       }
-       return 0;
+       return old;
 }
 
-
-static int eeepc_rfkill_init(struct device *dev)
+static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
 {
-       int result = 0;
-
-       mutex_init(&ehotk->hotplug_lock);
+       struct backlight_device *bd;
 
-       result = eeepc_new_rfkill(&ehotk->wlan_rfkill,
-                                 "eeepc-wlan", dev,
-                                 RFKILL_TYPE_WLAN, CM_ASL_WLAN);
+       bd = backlight_device_register(EEEPC_LAPTOP_FILE,
+                                      &eeepc->platform_device->dev,
+                                      eeepc, &eeepcbl_ops);
+       if (IS_ERR(bd)) {
+               pr_err("Could not register eeepc backlight device\n");
+               eeepc->backlight_device = NULL;
+               return PTR_ERR(bd);
+       }
+       eeepc->backlight_device = bd;
+       bd->props.max_brightness = 15;
+       bd->props.brightness = read_brightness(bd);
+       bd->props.power = FB_BLANK_UNBLANK;
+       backlight_update_status(bd);
+       return 0;
+}
 
-       if (result && result != -ENODEV)
-               goto exit;
+static void eeepc_backlight_exit(struct eeepc_laptop *eeepc)
+{
+       if (eeepc->backlight_device)
+               backlight_device_unregister(eeepc->backlight_device);
+       eeepc->backlight_device = NULL;
+}
 
-       result = eeepc_new_rfkill(&ehotk->bluetooth_rfkill,
-                                 "eeepc-bluetooth", dev,
-                                 RFKILL_TYPE_BLUETOOTH, CM_ASL_BLUETOOTH);
 
-       if (result && result != -ENODEV)
-               goto exit;
+/*
+ * Input device (i.e. hotkeys)
+ */
+static struct key_entry *eeepc_get_entry_by_scancode(
+       struct eeepc_laptop *eeepc,
+       int code)
+{
+       struct key_entry *key;
 
-       result = eeepc_new_rfkill(&ehotk->wwan3g_rfkill,
-                                 "eeepc-wwan3g", dev,
-                                 RFKILL_TYPE_WWAN, CM_ASL_3G);
+       for (key = eeepc->keymap; key->type != KE_END; key++)
+               if (code == key->code)
+                       return key;
 
-       if (result && result != -ENODEV)
-               goto exit;
+       return NULL;
+}
 
-       result = eeepc_new_rfkill(&ehotk->wimax_rfkill,
-                                 "eeepc-wimax", dev,
-                                 RFKILL_TYPE_WIMAX, CM_ASL_WIMAX);
+static void eeepc_input_notify(struct eeepc_laptop *eeepc, int event)
+{
+       static struct key_entry *key;
 
-       if (result && result != -ENODEV)
-               goto exit;
+       key = eeepc_get_entry_by_scancode(eeepc, event);
+       if (key) {
+               switch (key->type) {
+               case KE_KEY:
+                       input_report_key(eeepc->inputdev, key->keycode,
+                                               1);
+                       input_sync(eeepc->inputdev);
+                       input_report_key(eeepc->inputdev, key->keycode,
+                                               0);
+                       input_sync(eeepc->inputdev);
+                       break;
+               }
+       }
+}
 
-       result = eeepc_setup_pci_hotplug();
-       /*
-        * If we get -EBUSY then something else is handling the PCI hotplug -
-        * don't fail in this case
-        */
-       if (result == -EBUSY)
-               result = 0;
+static struct key_entry *eeepc_get_entry_by_keycode(
+       struct eeepc_laptop *eeepc, int code)
+{
+       struct key_entry *key;
 
-       eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P5");
-       eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
-       eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
-       /*
-        * Refresh pci hotplug in case the rfkill state was changed during
-        * setup.
-        */
-       eeepc_rfkill_hotplug();
+       for (key = eeepc->keymap; key->type != KE_END; key++)
+               if (code == key->keycode && key->type == KE_KEY)
+                       return key;
 
-exit:
-       if (result && result != -ENODEV)
-               eeepc_rfkill_exit();
-       return result;
+       return NULL;
 }
 
-static int eeepc_backlight_init(struct device *dev)
+static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode)
 {
-       struct backlight_device *bd;
+       struct eeepc_laptop *eeepc = input_get_drvdata(dev);
+       struct key_entry *key = eeepc_get_entry_by_scancode(eeepc, scancode);
 
-       bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
-                                      NULL, &eeepcbl_ops);
-       if (IS_ERR(bd)) {
-               pr_err("Could not register eeepc backlight device\n");
-               eeepc_backlight_device = NULL;
-               return PTR_ERR(bd);
+       if (key && key->type == KE_KEY) {
+               *keycode = key->keycode;
+               return 0;
        }
-       eeepc_backlight_device = bd;
-       bd->props.max_brightness = 15;
-       bd->props.brightness = read_brightness(NULL);
-       bd->props.power = FB_BLANK_UNBLANK;
-       backlight_update_status(bd);
-       return 0;
+
+       return -EINVAL;
 }
 
-static int eeepc_hwmon_init(struct device *dev)
+static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
 {
-       struct device *hwmon;
-       int result;
+       struct eeepc_laptop *eeepc = input_get_drvdata(dev);
+       struct key_entry *key;
+       int old_keycode;
 
-       hwmon = hwmon_device_register(dev);
-       if (IS_ERR(hwmon)) {
-               pr_err("Could not register eeepc hwmon device\n");
-               eeepc_hwmon_device = NULL;
-               return PTR_ERR(hwmon);
+       if (keycode < 0 || keycode > KEY_MAX)
+               return -EINVAL;
+
+       key = eeepc_get_entry_by_scancode(eeepc, scancode);
+       if (key && key->type == KE_KEY) {
+               old_keycode = key->keycode;
+               key->keycode = keycode;
+               set_bit(keycode, dev->keybit);
+               if (!eeepc_get_entry_by_keycode(eeepc, old_keycode))
+                       clear_bit(old_keycode, dev->keybit);
+               return 0;
        }
-       eeepc_hwmon_device = hwmon;
-       result = sysfs_create_group(&hwmon->kobj,
-                                   &hwmon_attribute_group);
-       if (result)
-               eeepc_hwmon_exit();
-       return result;
+
+       return -EINVAL;
 }
 
-static int eeepc_input_init(struct device *dev)
+static int eeepc_input_init(struct eeepc_laptop *eeepc)
 {
        const struct key_entry *key;
        int result;
 
-       ehotk->inputdev = input_allocate_device();
-       if (!ehotk->inputdev) {
+       eeepc->inputdev = input_allocate_device();
+       if (!eeepc->inputdev) {
                pr_info("Unable to allocate input device\n");
                return -ENOMEM;
        }
-       ehotk->inputdev->name = "Asus EeePC extra buttons";
-       ehotk->inputdev->dev.parent = dev;
-       ehotk->inputdev->phys = EEEPC_HOTK_FILE "/input0";
-       ehotk->inputdev->id.bustype = BUS_HOST;
-       ehotk->inputdev->getkeycode = eeepc_getkeycode;
-       ehotk->inputdev->setkeycode = eeepc_setkeycode;
-
+       eeepc->inputdev->name = "Asus EeePC extra buttons";
+       eeepc->inputdev->dev.parent = &eeepc->platform_device->dev;
+       eeepc->inputdev->phys = EEEPC_LAPTOP_FILE "/input0";
+       eeepc->inputdev->id.bustype = BUS_HOST;
+       eeepc->inputdev->getkeycode = eeepc_getkeycode;
+       eeepc->inputdev->setkeycode = eeepc_setkeycode;
+       input_set_drvdata(eeepc->inputdev, eeepc);
+
+       eeepc->keymap = kmemdup(eeepc_keymap, sizeof(eeepc_keymap),
+                               GFP_KERNEL);
        for (key = eeepc_keymap; key->type != KE_END; key++) {
                switch (key->type) {
                case KE_KEY:
-                       set_bit(EV_KEY, ehotk->inputdev->evbit);
-                       set_bit(key->keycode, ehotk->inputdev->keybit);
+                       set_bit(EV_KEY, eeepc->inputdev->evbit);
+                       set_bit(key->keycode, eeepc->inputdev->keybit);
                        break;
                }
        }
-       result = input_register_device(ehotk->inputdev);
+       result = input_register_device(eeepc->inputdev);
        if (result) {
                pr_info("Unable to register input device\n");
-               input_free_device(ehotk->inputdev);
+               input_free_device(eeepc->inputdev);
                return result;
        }
        return 0;
 }
 
-static int __devinit eeepc_hotk_add(struct acpi_device *device)
+static void eeepc_input_exit(struct eeepc_laptop *eeepc)
 {
-       struct device *dev;
+       if (eeepc->inputdev) {
+               input_unregister_device(eeepc->inputdev);
+               kfree(eeepc->keymap);
+       }
+}
+
+/*
+ * ACPI driver
+ */
+static void eeepc_acpi_notify(struct acpi_device *device, u32 event)
+{
+       struct eeepc_laptop *eeepc = acpi_driver_data(device);
+       u16 count;
+
+       if (event > ACPI_MAX_SYS_NOTIFY)
+               return;
+       count = eeepc->event_count[event % 128]++;
+       acpi_bus_generate_proc_event(device, event, count);
+       acpi_bus_generate_netlink_event(device->pnp.device_class,
+                                       dev_name(&device->dev), event,
+                                       count);
+
+       /* Brightness events are special */
+       if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX) {
+
+               /* Ignore them completely if the acpi video driver is used */
+               if (eeepc->backlight_device != NULL) {
+                       int old_brightness, new_brightness;
+
+                       /* Update the backlight device. */
+                       old_brightness = eeepc_backlight_notify(eeepc);
+
+                       /* Convert event to keypress (obsolescent hack) */
+                       new_brightness = event - NOTIFY_BRN_MIN;
+
+                       if (new_brightness < old_brightness) {
+                               event = NOTIFY_BRN_MIN; /* brightness down */
+                       } else if (new_brightness > old_brightness) {
+                               event = NOTIFY_BRN_MAX; /* brightness up */
+                       } else {
+                               /*
+                               * no change in brightness - already at min/max,
+                               * event will be desired value (or else ignored)
+                               */
+                       }
+                       eeepc_input_notify(eeepc, event);
+               }
+       } else {
+               /* Everything else is a bona-fide keypress event */
+               eeepc_input_notify(eeepc, event);
+       }
+}
+
+static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
+{
+       int dummy;
+
+       /* Some BIOSes do not report cm although it is avaliable.
+          Check if cm_getv[cm] works and, if yes, assume cm should be set. */
+       if (!(eeepc->cm_supported & (1 << cm))
+           && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
+               pr_info("%s (%x) not reported by BIOS,"
+                       " enabling anyway\n", name, 1 << cm);
+               eeepc->cm_supported |= 1 << cm;
+       }
+}
+
+static void cmsg_quirks(struct eeepc_laptop *eeepc)
+{
+       cmsg_quirk(eeepc, CM_ASL_LID, "LID");
+       cmsg_quirk(eeepc, CM_ASL_TYPE, "TYPE");
+       cmsg_quirk(eeepc, CM_ASL_PANELPOWER, "PANELPOWER");
+       cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
+}
+
+static int eeepc_acpi_init(struct eeepc_laptop *eeepc,
+                          struct acpi_device *device)
+{
+       unsigned int init_flags;
        int result;
 
-       if (!device)
-               return -EINVAL;
-       pr_notice(EEEPC_HOTK_NAME "\n");
-       ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
-       if (!ehotk)
-               return -ENOMEM;
-       ehotk->init_flag = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
-       ehotk->handle = device->handle;
-       strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME);
-       strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS);
-       device->driver_data = ehotk;
-       ehotk->device = device;
-
-       result = eeepc_hotk_check();
+       result = acpi_bus_get_status(device);
        if (result)
-               goto fail_platform_driver;
-       eeepc_enable_camera();
+               return result;
+       if (!device->status.present) {
+               pr_err("Hotkey device not present, aborting\n");
+               return -ENODEV;
+       }
 
-       /* Register platform stuff */
-       result = platform_driver_register(&platform_driver);
-       if (result)
-               goto fail_platform_driver;
-       platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1);
-       if (!platform_device) {
-               result = -ENOMEM;
-               goto fail_platform_device1;
+       init_flags = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
+       pr_notice("Hotkey init flags 0x%x\n", init_flags);
+
+       if (write_acpi_int(eeepc->handle, "INIT", init_flags)) {
+               pr_err("Hotkey initialization failed\n");
+               return -ENODEV;
        }
-       result = platform_device_add(platform_device);
-       if (result)
-               goto fail_platform_device2;
-       result = sysfs_create_group(&platform_device->dev.kobj,
-                                   &platform_attribute_group);
+
+       /* get control methods supported */
+       if (read_acpi_int(eeepc->handle, "CMSG", &eeepc->cm_supported)) {
+               pr_err("Get control methods supported failed\n");
+               return -ENODEV;
+       }
+       cmsg_quirks(eeepc);
+       pr_info("Get control methods supported: 0x%x\n", eeepc->cm_supported);
+
+       return 0;
+}
+
+static void __devinit eeepc_enable_camera(struct eeepc_laptop *eeepc)
+{
+       /*
+        * If the following call to set_acpi() fails, it's because there's no
+        * camera so we can ignore the error.
+        */
+       if (get_acpi(eeepc, CM_ASL_CAMERA) == 0)
+               set_acpi(eeepc, CM_ASL_CAMERA, 1);
+}
+
+static bool eeepc_device_present;
+
+static int __devinit eeepc_acpi_add(struct acpi_device *device)
+{
+       struct eeepc_laptop *eeepc;
+       int result;
+
+       pr_notice(EEEPC_LAPTOP_NAME "\n");
+       eeepc = kzalloc(sizeof(struct eeepc_laptop), GFP_KERNEL);
+       if (!eeepc)
+               return -ENOMEM;
+       eeepc->handle = device->handle;
+       strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
+       strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
+       device->driver_data = eeepc;
+
+       result = eeepc_acpi_init(eeepc, device);
        if (result)
-               goto fail_sysfs;
+               goto fail_platform;
+       eeepc_enable_camera(eeepc);
 
-       dev = &platform_device->dev;
+       /*
+        * Register the platform device first.  It is used as a parent for the
+        * sub-devices below.
+        *
+        * Note that if there are multiple instances of this ACPI device it
+        * will bail out, because the platform device is registered with a
+        * fixed name.  Of course it doesn't make sense to have more than one,
+        * and machine-specific scripts find the fixed name convenient.  But
+        * It's also good for us to exclude multiple instances because both
+        * our hwmon and our wlan rfkill subdevice use global ACPI objects
+        * (the EC and the wlan PCI slot respectively).
+        */
+       result = eeepc_platform_init(eeepc);
+       if (result)
+               goto fail_platform;
 
        if (!acpi_video_backlight_support()) {
-               result = eeepc_backlight_init(dev);
+               result = eeepc_backlight_init(eeepc);
                if (result)
                        goto fail_backlight;
        } else
-               pr_info("Backlight controlled by ACPI video "
-                       "driver\n");
+               pr_info("Backlight controlled by ACPI video driver\n");
 
-       result = eeepc_input_init(dev);
+       result = eeepc_input_init(eeepc);
        if (result)
                goto fail_input;
 
-       result = eeepc_hwmon_init(dev);
+       result = eeepc_hwmon_init(eeepc);
        if (result)
                goto fail_hwmon;
 
-       result = eeepc_rfkill_init(dev);
+       result = eeepc_led_init(eeepc);
+       if (result)
+               goto fail_led;
+
+       result = eeepc_rfkill_init(eeepc);
        if (result)
                goto fail_rfkill;
 
+       eeepc_device_present = true;
        return 0;
 
 fail_rfkill:
-       eeepc_hwmon_exit();
+       eeepc_led_exit(eeepc);
+fail_led:
+       eeepc_hwmon_exit(eeepc);
 fail_hwmon:
-       eeepc_input_exit();
+       eeepc_input_exit(eeepc);
 fail_input:
-       eeepc_backlight_exit();
+       eeepc_backlight_exit(eeepc);
 fail_backlight:
-       sysfs_remove_group(&platform_device->dev.kobj,
-                          &platform_attribute_group);
-fail_sysfs:
-       platform_device_del(platform_device);
-fail_platform_device2:
-       platform_device_put(platform_device);
-fail_platform_device1:
-       platform_driver_unregister(&platform_driver);
-fail_platform_driver:
-       kfree(ehotk);
+       eeepc_platform_exit(eeepc);
+fail_platform:
+       kfree(eeepc);
 
        return result;
 }
 
-static int eeepc_hotk_remove(struct acpi_device *device, int type)
+static int eeepc_acpi_remove(struct acpi_device *device, int type)
 {
-       if (!device || !acpi_driver_data(device))
-               return -EINVAL;
+       struct eeepc_laptop *eeepc = acpi_driver_data(device);
 
-       eeepc_backlight_exit();
-       eeepc_rfkill_exit();
-       eeepc_input_exit();
-       eeepc_hwmon_exit();
-       sysfs_remove_group(&platform_device->dev.kobj,
-                          &platform_attribute_group);
-       platform_device_unregister(platform_device);
-       platform_driver_unregister(&platform_driver);
+       eeepc_backlight_exit(eeepc);
+       eeepc_rfkill_exit(eeepc);
+       eeepc_input_exit(eeepc);
+       eeepc_hwmon_exit(eeepc);
+       eeepc_led_exit(eeepc);
+       eeepc_platform_exit(eeepc);
 
-       kfree(ehotk);
+       kfree(eeepc);
        return 0;
 }
 
+
+static const struct acpi_device_id eeepc_device_ids[] = {
+       {EEEPC_ACPI_HID, 0},
+       {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
+
+static struct acpi_driver eeepc_acpi_driver = {
+       .name = EEEPC_LAPTOP_NAME,
+       .class = EEEPC_ACPI_CLASS,
+       .owner = THIS_MODULE,
+       .ids = eeepc_device_ids,
+       .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
+       .ops = {
+               .add = eeepc_acpi_add,
+               .remove = eeepc_acpi_remove,
+               .notify = eeepc_acpi_notify,
+       },
+};
+
+
 static int __init eeepc_laptop_init(void)
 {
        int result;
 
-       if (acpi_disabled)
-               return -ENODEV;
-       result = acpi_bus_register_driver(&eeepc_hotk_driver);
+       result = platform_driver_register(&platform_driver);
        if (result < 0)
                return result;
-       if (!ehotk) {
-               acpi_bus_unregister_driver(&eeepc_hotk_driver);
-               return -ENODEV;
+
+       result = acpi_bus_register_driver(&eeepc_acpi_driver);
+       if (result < 0)
+               goto fail_acpi_driver;
+       if (!eeepc_device_present) {
+               result = -ENODEV;
+               goto fail_no_device;
        }
        return 0;
+
+fail_no_device:
+       acpi_bus_unregister_driver(&eeepc_acpi_driver);
+fail_acpi_driver:
+       platform_driver_unregister(&platform_driver);
+       return result;
 }
 
 static void __exit eeepc_laptop_exit(void)
 {
-       acpi_bus_unregister_driver(&eeepc_hotk_driver);
+       acpi_bus_unregister_driver(&eeepc_acpi_driver);
+       platform_driver_unregister(&platform_driver);
 }
 
 module_init(eeepc_laptop_init);