4 files changed, 421 insertions, 156 deletions

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index a726f3b01a6b..6abb95919c38 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -145,6 +145,7 @@ config ACER_WMI
         depends on NEW_LEDS
         depends on BACKLIGHT_CLASS_DEVICE
         depends on SERIO_I8042
+        depends on RFKILL
         select ACPI_WMI
         ---help---
           This is a driver for newer Acer (and Wistron) laptops. It adds
diff --git a/drivers/misc/acer-wmi.c b/drivers/misc/acer-wmi.c
index d8b0d326e452..0532a2de2ce4 100644
--- a/drivers/misc/acer-wmi.c
+++ b/drivers/misc/acer-wmi.c
@@ -33,6 +33,8 @@
 #include <linux/platform_device.h>
 #include <linux/acpi.h>
 #include <linux/i8042.h>
+#include <linux/rfkill.h>
+#include <linux/workqueue.h>
 #include <linux/debugfs.h>
 
 #include <acpi/acpi_drivers.h>
@@ -123,21 +125,15 @@ enum interface_flags {
 
 static int max_brightness = 0xF;
 
-static int wireless = -1;
-static int bluetooth = -1;
 static int mailled = -1;
 static int brightness = -1;
 static int threeg = -1;
 static int force_series;
 
 module_param(mailled, int, 0444);
-module_param(wireless, int, 0444);
-module_param(bluetooth, int, 0444);
 module_param(brightness, int, 0444);
 module_param(threeg, int, 0444);
 module_param(force_series, int, 0444);
-MODULE_PARM_DESC(wireless, "Set initial state of Wireless hardware");
-MODULE_PARM_DESC(bluetooth, "Set initial state of Bluetooth hardware");
 MODULE_PARM_DESC(mailled, "Set initial state of Mail LED");
 MODULE_PARM_DESC(brightness, "Set initial LCD backlight brightness");
 MODULE_PARM_DESC(threeg, "Set initial state of 3G hardware");
@@ -145,8 +141,6 @@ MODULE_PARM_DESC(force_series, "Force a different laptop series");
 
 struct acer_data {
         int mailled;
-        int wireless;
-        int bluetooth;
         int threeg;
         int brightness;
 };
@@ -157,6 +151,9 @@ struct acer_debug {
         u32 wmid_devices;
 };
 
+static struct rfkill *wireless_rfkill;
+static struct rfkill *bluetooth_rfkill;
+
 /* Each low-level interface must define at least some of the following */
 struct wmi_interface {
         /* The WMI device type */
@@ -476,7 +473,7 @@ struct wmi_interface *iface)
                 }
                 break;
         default:
-                return AE_BAD_ADDRESS;
+                return AE_ERROR;
         }
         return AE_OK;
 }
@@ -514,7 +511,7 @@ static acpi_status AMW0_set_u32(u32 value, u32 cap, struct wmi_interface *iface)
                         break;
                 }
         default:
-                return AE_BAD_ADDRESS;
+                return AE_ERROR;
         }
 
         /* Actually do the set */
@@ -689,7 +686,7 @@ struct wmi_interface *iface)
                         return 0;
                 }
         default:
-                return AE_BAD_ADDRESS;
+                return AE_ERROR;
         }
         status = WMI_execute_u32(method_id, 0, &result);
 
@@ -735,7 +732,7 @@ static acpi_status WMID_set_u32(u32 value, u32 cap, struct wmi_interface *iface)
                 }
                 break;
         default:
-                return AE_BAD_ADDRESS;
+                return AE_ERROR;
         }
         return WMI_execute_u32(method_id, (u32)value, NULL);
 }
@@ -785,7 +782,7 @@ static struct wmi_interface wmid_interface = {
 
 static acpi_status get_u32(u32 *value, u32 cap)
 {
-        acpi_status status = AE_BAD_ADDRESS;
+        acpi_status status = AE_ERROR;
 
         switch (interface->type) {
         case ACER_AMW0:
@@ -846,8 +843,6 @@ static void __init acer_commandline_init(void)
          * capability isn't available on the given interface
          */
         set_u32(mailled, ACER_CAP_MAILLED);
-        set_u32(wireless, ACER_CAP_WIRELESS);
-        set_u32(bluetooth, ACER_CAP_BLUETOOTH);
         set_u32(threeg, ACER_CAP_THREEG);
         set_u32(brightness, ACER_CAP_BRIGHTNESS);
 }
@@ -933,40 +928,135 @@ static void acer_backlight_exit(void)
 }
 
 /*
- * Read/ write bool sysfs macro
+ * Rfkill devices
  */
-#define show_set_bool(value, cap) \
-static ssize_t \
-show_bool_##value(struct device *dev, struct device_attribute *attr, \
-        char *buf) \
-{ \
-        u32 result; \
-        acpi_status status = get_u32(&result, cap); \
-        if (ACPI_SUCCESS(status)) \
-                return sprintf(buf, "%u\n", result); \
-        return sprintf(buf, "Read error\n"); \
-} \
-\
-static ssize_t \
-set_bool_##value(struct device *dev, struct device_attribute *attr, \
-        const char *buf, size_t count) \
-{ \
-        u32 tmp = simple_strtoul(buf, NULL, 10); \
-        acpi_status status = set_u32(tmp, cap); \
-                if (ACPI_FAILURE(status)) \
-                        return -EINVAL; \
-        return count; \
-} \
-static DEVICE_ATTR(value, S_IWUGO | S_IRUGO | S_IWUSR, \
-        show_bool_##value, set_bool_##value);
-
-show_set_bool(wireless, ACER_CAP_WIRELESS);
-show_set_bool(bluetooth, ACER_CAP_BLUETOOTH);
-show_set_bool(threeg, ACER_CAP_THREEG);
+static void acer_rfkill_update(struct work_struct *ignored);
+static DECLARE_DELAYED_WORK(acer_rfkill_work, acer_rfkill_update);
+static void acer_rfkill_update(struct work_struct *ignored)
+{
+        u32 state;
+        acpi_status status;
+
+        status = get_u32(&state, ACER_CAP_WIRELESS);
+        if (ACPI_SUCCESS(status))
+                rfkill_force_state(wireless_rfkill, state ?
+                        RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED);
+
+        if (has_cap(ACER_CAP_BLUETOOTH)) {
+                status = get_u32(&state, ACER_CAP_BLUETOOTH);
+                if (ACPI_SUCCESS(status))
+                        rfkill_force_state(bluetooth_rfkill, state ?
+                                RFKILL_STATE_UNBLOCKED :
+                                RFKILL_STATE_SOFT_BLOCKED);
+        }
+
+        schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
+}
+
+static int acer_rfkill_set(void *data, enum rfkill_state state)
+{
+        acpi_status status;
+        u32 *cap = data;
+        status = set_u32((u32) (state == RFKILL_STATE_UNBLOCKED), *cap);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+        return 0;
+}
+
+static struct rfkill * acer_rfkill_register(struct device *dev,
+enum rfkill_type type, char *name, u32 cap)
+{
+        int err;
+        u32 state;
+        u32 *data;
+        struct rfkill *rfkill_dev;
+
+        rfkill_dev = rfkill_allocate(dev, type);
+        if (!rfkill_dev)
+                return ERR_PTR(-ENOMEM);
+        rfkill_dev->name = name;
+        get_u32(&state, cap);
+        rfkill_dev->state = state ? RFKILL_STATE_UNBLOCKED :
+                RFKILL_STATE_SOFT_BLOCKED;
+        data = kzalloc(sizeof(u32), GFP_KERNEL);
+        if (!data) {
+                rfkill_free(rfkill_dev);
+                return ERR_PTR(-ENOMEM);
+        }
+        *data = cap;
+        rfkill_dev->data = data;
+        rfkill_dev->toggle_radio = acer_rfkill_set;
+        rfkill_dev->user_claim_unsupported = 1;
+
+        err = rfkill_register(rfkill_dev);
+        if (err) {
+                kfree(rfkill_dev->data);
+                rfkill_free(rfkill_dev);
+                return ERR_PTR(err);
+        }
+        return rfkill_dev;
+}
+
+static int acer_rfkill_init(struct device *dev)
+{
+        wireless_rfkill = acer_rfkill_register(dev, RFKILL_TYPE_WLAN,
+                "acer-wireless", ACER_CAP_WIRELESS);
+        if (IS_ERR(wireless_rfkill))
+                return PTR_ERR(wireless_rfkill);
+
+        if (has_cap(ACER_CAP_BLUETOOTH)) {
+                bluetooth_rfkill = acer_rfkill_register(dev,
+                        RFKILL_TYPE_BLUETOOTH, "acer-bluetooth",
+                        ACER_CAP_BLUETOOTH);
+                if (IS_ERR(bluetooth_rfkill)) {
+                        kfree(wireless_rfkill->data);
+                        rfkill_unregister(wireless_rfkill);
+                        return PTR_ERR(bluetooth_rfkill);
+                }
+        }
+
+        schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
+
+        return 0;
+}
+
+static void acer_rfkill_exit(void)
+{
+        cancel_delayed_work_sync(&acer_rfkill_work);
+        kfree(wireless_rfkill->data);
+        rfkill_unregister(wireless_rfkill);
+        if (has_cap(ACER_CAP_BLUETOOTH)) {
+                kfree(wireless_rfkill->data);
+                rfkill_unregister(bluetooth_rfkill);
+        }
+        return;
+}
 
 /*
- * Read interface sysfs macro
+ * sysfs interface
  */
+static ssize_t show_bool_threeg(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        u32 result; \
+        acpi_status status = get_u32(&result, ACER_CAP_THREEG);
+        if (ACPI_SUCCESS(status))
+                return sprintf(buf, "%u\n", result);
+        return sprintf(buf, "Read error\n");
+}
+
+static ssize_t set_bool_threeg(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        u32 tmp = simple_strtoul(buf, NULL, 10);
+        acpi_status status = set_u32(tmp, ACER_CAP_THREEG);
+                if (ACPI_FAILURE(status))
+                        return -EINVAL;
+        return count;
+}
+static DEVICE_ATTR(threeg, S_IWUGO | S_IRUGO | S_IWUSR, show_bool_threeg,
+        set_bool_threeg);
+
 static ssize_t show_interface(struct device *dev, struct device_attribute *attr,
         char *buf)
 {
@@ -1026,7 +1116,9 @@ static int __devinit acer_platform_probe(struct platform_device *device)
                         goto error_brightness;
         }
 
-        return 0;
+        err = acer_rfkill_init(&device->dev);
+
+        return err;
 
 error_brightness:
         acer_led_exit();
@@ -1040,6 +1132,8 @@ static int acer_platform_remove(struct platform_device *device)
                 acer_led_exit();
         if (has_cap(ACER_CAP_BRIGHTNESS))
                 acer_backlight_exit();
+
+        acer_rfkill_exit();
         return 0;
 }
 
@@ -1052,16 +1146,6 @@ pm_message_t state)
         if (!data)
                 return -ENOMEM;
 
-        if (has_cap(ACER_CAP_WIRELESS)) {
-                get_u32(&value, ACER_CAP_WIRELESS);
-                data->wireless = value;
-        }
-
-        if (has_cap(ACER_CAP_BLUETOOTH)) {
-                get_u32(&value, ACER_CAP_BLUETOOTH);
-                data->bluetooth = value;
-        }
-
         if (has_cap(ACER_CAP_MAILLED)) {
                 get_u32(&value, ACER_CAP_MAILLED);
                 data->mailled = value;
@@ -1082,15 +1166,6 @@ static int acer_platform_resume(struct platform_device *device)
         if (!data)
                 return -ENOMEM;
 
-        if (has_cap(ACER_CAP_WIRELESS))
-                set_u32(data->wireless, ACER_CAP_WIRELESS);
-
-        if (has_cap(ACER_CAP_BLUETOOTH))
-                set_u32(data->bluetooth, ACER_CAP_BLUETOOTH);
-
-        if (has_cap(ACER_CAP_THREEG))
-                set_u32(data->threeg, ACER_CAP_THREEG);
-
         if (has_cap(ACER_CAP_MAILLED))
                 set_u32(data->mailled, ACER_CAP_MAILLED);
 
@@ -1115,12 +1190,6 @@ static struct platform_device *acer_platform_device;
 
 static int remove_sysfs(struct platform_device *device)
 {
-        if (has_cap(ACER_CAP_WIRELESS))
-                device_remove_file(&device->dev, &dev_attr_wireless);
-
-        if (has_cap(ACER_CAP_BLUETOOTH))
-                device_remove_file(&device->dev, &dev_attr_bluetooth);
-
         if (has_cap(ACER_CAP_THREEG))
                 device_remove_file(&device->dev, &dev_attr_threeg);
 
@@ -1133,20 +1202,6 @@ static int create_sysfs(void)
 {
         int retval = -ENOMEM;
 
-        if (has_cap(ACER_CAP_WIRELESS)) {
-                retval = device_create_file(&acer_platform_device->dev,
-                        &dev_attr_wireless);
-                if (retval)
-                        goto error_sysfs;
-        }
-
-        if (has_cap(ACER_CAP_BLUETOOTH)) {
-                retval = device_create_file(&acer_platform_device->dev,
-                        &dev_attr_bluetooth);
-                if (retval)
-                        goto error_sysfs;
-        }
-
         if (has_cap(ACER_CAP_THREEG)) {
                 retval = device_create_file(&acer_platform_device->dev,
                         &dev_attr_threeg);
diff --git a/drivers/misc/eeepc-laptop.c b/drivers/misc/eeepc-laptop.c
index c1247056116c..7b39e0f0f1be 100644
--- a/drivers/misc/eeepc-laptop.c
+++ b/drivers/misc/eeepc-laptop.c
@@ -28,6 +28,8 @@
 #include <acpi/acpi_drivers.h>
 #include <acpi/acpi_bus.h>
 #include <linux/uaccess.h>
+#include <linux/input.h>
+#include <linux/rfkill.h>
 
 #define EEEPC_LAPTOP_VERSION    "0.1"
 
@@ -125,6 +127,10 @@ struct eeepc_hotk {
                                            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 *eeepc_wlan_rfkill;
+        struct rfkill *eeepc_bluetooth_rfkill;
 };
 
 /* The actual device the driver binds to */
@@ -140,6 +146,27 @@ static struct platform_driver platform_driver = {
 
 static struct platform_device *platform_device;
 
+struct key_entry {
+        char type;
+        u8 code;
+        u16 keycode;
+};
+
+enum { KE_KEY, KE_END };
+
+static struct key_entry eeepc_keymap[] = {
+        /* Sleep already handled via generic ACPI code */
+        {KE_KEY, 0x10, KEY_WLAN },
+        {KE_KEY, 0x12, KEY_PROG1 },
+        {KE_KEY, 0x13, KEY_MUTE },
+        {KE_KEY, 0x14, KEY_VOLUMEDOWN },
+        {KE_KEY, 0x15, KEY_VOLUMEUP },
+        {KE_KEY, 0x30, KEY_SWITCHVIDEOMODE },
+        {KE_KEY, 0x31, KEY_SWITCHVIDEOMODE },
+        {KE_KEY, 0x32, KEY_SWITCHVIDEOMODE },
+        {KE_END, 0},
+};
+
 /*
  * The hotkey driver declaration
  */
@@ -261,6 +288,44 @@ static int update_bl_status(struct backlight_device *bd)
 }
 
 /*
+ * Rfkill helpers
+ */
+
+static int eeepc_wlan_rfkill_set(void *data, enum rfkill_state state)
+{
+        if (state == RFKILL_STATE_SOFT_BLOCKED)
+                return set_acpi(CM_ASL_WLAN, 0);
+        else
+                return set_acpi(CM_ASL_WLAN, 1);
+}
+
+static int eeepc_wlan_rfkill_state(void *data, enum rfkill_state *state)
+{
+        if (get_acpi(CM_ASL_WLAN) == 1)
+                *state = RFKILL_STATE_UNBLOCKED;
+        else
+                *state = RFKILL_STATE_SOFT_BLOCKED;
+        return 0;
+}
+
+static int eeepc_bluetooth_rfkill_set(void *data, enum rfkill_state state)
+{
+        if (state == RFKILL_STATE_SOFT_BLOCKED)
+                return set_acpi(CM_ASL_BLUETOOTH, 0);
+        else
+                return set_acpi(CM_ASL_BLUETOOTH, 1);
+}
+
+static int eeepc_bluetooth_rfkill_state(void *data, enum rfkill_state *state)
+{
+        if (get_acpi(CM_ASL_BLUETOOTH) == 1)
+                *state = RFKILL_STATE_UNBLOCKED;
+        else
+                *state = RFKILL_STATE_SOFT_BLOCKED;
+        return 0;
+}
+
+/*
  * Sys helpers
  */
 static int parse_arg(const char *buf, unsigned long count, int *val)
@@ -311,13 +376,11 @@ static ssize_t show_sys_acpi(int cm, char *buf)
 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(wlan, CM_ASL_WLAN);
 
 static struct attribute *platform_attributes[] = {
         &dev_attr_camera.attr,
         &dev_attr_cardr.attr,
         &dev_attr_disp.attr,
-        &dev_attr_wlan.attr,
         NULL
 };
 
@@ -328,8 +391,64 @@ static struct attribute_group platform_attribute_group = {
 /*
  * Hotkey functions
  */
+static struct key_entry *eepc_get_entry_by_scancode(int code)
+{
+        struct key_entry *key;
+
+        for (key = eeepc_keymap; key->type != KE_END; key++)
+                if (code == key->code)
+                        return key;
+
+        return NULL;
+}
+
+static struct key_entry *eepc_get_entry_by_keycode(int code)
+{
+        struct key_entry *key;
+
+        for (key = eeepc_keymap; key->type != KE_END; key++)
+                if (code == key->keycode && key->type == KE_KEY)
+                        return key;
+
+        return NULL;
+}
+
+static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode)
+{
+        struct key_entry *key = eepc_get_entry_by_scancode(scancode);
+
+        if (key && key->type == KE_KEY) {
+                *keycode = key->keycode;
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
+{
+        struct key_entry *key;
+        int old_keycode;
+
+        if (keycode < 0 || keycode > KEY_MAX)
+                return -EINVAL;
+
+        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;
+        }
+
+        return -EINVAL;
+}
+
 static int eeepc_hotk_check(void)
 {
+        const struct key_entry *key;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         int result;
 
@@ -356,6 +475,31 @@ static int eeepc_hotk_check(void)
                                "Get control methods supported: 0x%x\n",
                                ehotk->cm_supported);
                 }
+                ehotk->inputdev = input_allocate_device();
+                if (!ehotk->inputdev) {
+                        printk(EEEPC_INFO "Unable to allocate input device\n");
+                        return 0;
+                }
+                ehotk->inputdev->name = "Asus EeePC extra buttons";
+                ehotk->inputdev->phys = EEEPC_HOTK_FILE "/input0";
+                ehotk->inputdev->id.bustype = BUS_HOST;
+                ehotk->inputdev->getkeycode = eeepc_getkeycode;
+                ehotk->inputdev->setkeycode = eeepc_setkeycode;
+
+                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);
+                                break;
+                        }
+                }
+                result = input_register_device(ehotk->inputdev);
+                if (result) {
+                        printk(EEEPC_INFO "Unable to register input device\n");
+                        input_free_device(ehotk->inputdev);
+                        return 0;
+                }
         } else {
                 printk(EEEPC_ERR "Hotkey device not present, aborting\n");
                 return -EINVAL;
@@ -363,21 +507,6 @@ static int eeepc_hotk_check(void)
         return 0;
 }
 
-static void notify_wlan(u32 *event)
-{
-        /* if DISABLE_ASL_WLAN is set, the notify code for fn+f2
-           will always be 0x10 */
-        if (ehotk->cm_supported & (0x1 << CM_ASL_WLAN)) {
-                const char *method = cm_getv[CM_ASL_WLAN];
-                int value;
-                if (read_acpi_int(ehotk->handle, method, &value))
-                        printk(EEEPC_WARNING "Error reading %s\n",
-                               method);
-                else if (value == 1)
-                        *event = 0x11;
-        }
-}
-
 static void notify_brn(void)
 {
         struct backlight_device *bd = eeepc_backlight_device;
@@ -386,14 +515,28 @@ static void notify_brn(void)
 
 static void eeepc_hotk_notify(acpi_handle handle, u32 event, void *data)
 {
+        static struct key_entry *key;
         if (!ehotk)
                 return;
-        if (event == NOTIFY_WLAN_ON && (DISABLE_ASL_WLAN & ehotk->init_flag))
-                notify_wlan(&event);
         if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
                 notify_brn();
         acpi_bus_generate_proc_event(ehotk->device, event,
                                      ehotk->event_count[event % 128]++);
+        if (ehotk->inputdev) {
+                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;
+                        }
+                }
+        }
 }
 
 static int eeepc_hotk_add(struct acpi_device *device)
@@ -420,6 +563,47 @@ static int eeepc_hotk_add(struct acpi_device *device)
                                              eeepc_hotk_notify, ehotk);
         if (ACPI_FAILURE(status))
                 printk(EEEPC_ERR "Error installing notify handler\n");
+
+        if (get_acpi(CM_ASL_WLAN) != -1) {
+                ehotk->eeepc_wlan_rfkill = rfkill_allocate(&device->dev,
+                                                           RFKILL_TYPE_WLAN);
+
+                if (!ehotk->eeepc_wlan_rfkill)
+                        goto end;
+
+                ehotk->eeepc_wlan_rfkill->name = "eeepc-wlan";
+                ehotk->eeepc_wlan_rfkill->toggle_radio = eeepc_wlan_rfkill_set;
+                ehotk->eeepc_wlan_rfkill->get_state = eeepc_wlan_rfkill_state;
+                if (get_acpi(CM_ASL_WLAN) == 1)
+                        ehotk->eeepc_wlan_rfkill->state =
+                                RFKILL_STATE_UNBLOCKED;
+                else
+                        ehotk->eeepc_wlan_rfkill->state =
+                                RFKILL_STATE_SOFT_BLOCKED;
+                rfkill_register(ehotk->eeepc_wlan_rfkill);
+        }
+
+        if (get_acpi(CM_ASL_BLUETOOTH) != -1) {
+                ehotk->eeepc_bluetooth_rfkill =
+                        rfkill_allocate(&device->dev, RFKILL_TYPE_BLUETOOTH);
+
+                if (!ehotk->eeepc_bluetooth_rfkill)
+                        goto end;
+
+                ehotk->eeepc_bluetooth_rfkill->name = "eeepc-bluetooth";
+                ehotk->eeepc_bluetooth_rfkill->toggle_radio =
+                        eeepc_bluetooth_rfkill_set;
+                ehotk->eeepc_bluetooth_rfkill->get_state =
+                        eeepc_bluetooth_rfkill_state;
+                if (get_acpi(CM_ASL_BLUETOOTH) == 1)
+                        ehotk->eeepc_bluetooth_rfkill->state =
+                                RFKILL_STATE_UNBLOCKED;
+                else
+                        ehotk->eeepc_bluetooth_rfkill->state =
+                                RFKILL_STATE_SOFT_BLOCKED;
+                rfkill_register(ehotk->eeepc_bluetooth_rfkill);
+        }
+
  end:
         if (result) {
                 kfree(ehotk);
@@ -553,6 +737,12 @@ static void eeepc_backlight_exit(void)
 {
         if (eeepc_backlight_device)
                 backlight_device_unregister(eeepc_backlight_device);
+        if (ehotk->inputdev)
+                input_unregister_device(ehotk->inputdev);
+        if (ehotk->eeepc_wlan_rfkill)
+                rfkill_unregister(ehotk->eeepc_wlan_rfkill);
+        if (ehotk->eeepc_bluetooth_rfkill)
+                rfkill_unregister(ehotk->eeepc_bluetooth_rfkill);
         eeepc_backlight_device = NULL;
 }
 
diff --git a/drivers/misc/fujitsu-laptop.c b/drivers/misc/fujitsu-laptop.c
index 7b69cfb7de5d..8555a17f00ef 100644
--- a/drivers/misc/fujitsu-laptop.c
+++ b/drivers/misc/fujitsu-laptop.c
@@ -44,8 +44,9 @@
  * Hotkeys present on certain Fujitsu laptops (eg: the S6xxx series) are
  * also supported by this driver.
  *
- * This driver has been tested on a Fujitsu Lifebook S6410 and S7020.  It
- * should work on most P-series and S-series Lifebooks, but YMMV.
+ * This driver has been tested on a Fujitsu Lifebook S6410, S7020 and
+ * P8010.  It should work on most P-series and S-series Lifebooks, but
+ * YMMV.
  *
  * The module parameter use_alt_lcd_levels switches between different ACPI
  * brightness controls which are used by different Fujitsu laptops.  In most
@@ -65,7 +66,7 @@
 #include <linux/video_output.h>
 #include <linux/platform_device.h>
 
-#define FUJITSU_DRIVER_VERSION "0.4.2"
+#define FUJITSU_DRIVER_VERSION "0.4.3"
 
 #define FUJITSU_LCD_N_LEVELS 8
 
@@ -83,10 +84,10 @@
 #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS     0x87
 
 /* Hotkey details */
-#define LOCK_KEY        0x410   /* codes for the keys in the GIRB register */
-#define DISPLAY_KEY     0x411   /* keys are mapped to KEY_SCREENLOCK (the key with the key symbol) */
-#define ENERGY_KEY      0x412   /* KEY_MEDIA (the key with the laptop symbol, KEY_EMAIL (E key)) */
-#define REST_KEY        0x413   /* KEY_SUSPEND (R key) */
+#define KEY1_CODE       0x410   /* codes for the keys in the GIRB register */
+#define KEY2_CODE       0x411
+#define KEY3_CODE       0x412
+#define KEY4_CODE       0x413
 
 #define MAX_HOTKEY_RINGBUFFER_SIZE 100
 #define RINGBUFFERSIZE 40
@@ -123,6 +124,7 @@ struct fujitsu_t {
         char phys[32];
         struct backlight_device *bl_device;
         struct platform_device *pf_device;
+        int keycode1, keycode2, keycode3, keycode4;
 
         unsigned int max_brightness;
         unsigned int brightness_changed;
@@ -430,7 +432,7 @@ static struct platform_driver fujitsupf_driver = {
                    }
 };
 
-static int dmi_check_cb_s6410(const struct dmi_system_id *id)
+static void dmi_check_cb_common(const struct dmi_system_id *id)
 {
         acpi_handle handle;
         int have_blnf;
@@ -452,24 +454,40 @@ static int dmi_check_cb_s6410(const struct dmi_system_id *id)
                             "auto-detecting disable_adjust\n");
                 disable_brightness_adjust = have_blnf ? 0 : 1;
         }
+}
+
+static int dmi_check_cb_s6410(const struct dmi_system_id *id)
+{
+        dmi_check_cb_common(id);
+        fujitsu->keycode1 = KEY_SCREENLOCK;     /* "Lock" */
+        fujitsu->keycode2 = KEY_HELP;   /* "Mobility Center" */
+        return 0;
+}
+
+static int dmi_check_cb_p8010(const struct dmi_system_id *id)
+{
+        dmi_check_cb_common(id);
+        fujitsu->keycode1 = KEY_HELP;   /* "Support" */
+        fujitsu->keycode3 = KEY_SWITCHVIDEOMODE;        /* "Presentation" */
+        fujitsu->keycode4 = KEY_WWW;    /* "Internet" */
         return 0;
 }
 
 static struct dmi_system_id __initdata fujitsu_dmi_table[] = {
         {
-         .ident = "Fujitsu Siemens",
+         .ident = "Fujitsu Siemens S6410",
          .matches = {
                      DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
                      DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK S6410"),
                      },
          .callback = dmi_check_cb_s6410},
         {
-         .ident = "FUJITSU LifeBook P8010",
+         .ident = "Fujitsu LifeBook P8010",
          .matches = {
                      DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
                      DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook P8010"),
-                    },
-         .callback = dmi_check_cb_s6410},
+                     },
+         .callback = dmi_check_cb_p8010},
         {}
 };
 
@@ -547,7 +565,6 @@ static int acpi_fujitsu_add(struct acpi_device *device)
         }
 
         /* do config (detect defaults) */
-        dmi_check_system(fujitsu_dmi_table);
         use_alt_lcd_levels = use_alt_lcd_levels == 1 ? 1 : 0;
         disable_brightness_keys = disable_brightness_keys == 1 ? 1 : 0;
         disable_brightness_adjust = disable_brightness_adjust == 1 ? 1 : 0;
@@ -623,17 +640,17 @@ static void acpi_fujitsu_notify(acpi_handle handle, u32 event, void *data)
                         keycode = 0;
                         if (disable_brightness_keys != 1) {
                                 if (oldb == 0) {
-                                        acpi_bus_generate_proc_event(fujitsu->
-                                                dev,
-                                                ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS,
-                                                0);
+                                        acpi_bus_generate_proc_event
+                                            (fujitsu->dev,
+                                             ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS,
+                                             0);
                                         keycode = KEY_BRIGHTNESSDOWN;
                                 } else if (oldb ==
                                            (fujitsu->max_brightness) - 1) {
-                                        acpi_bus_generate_proc_event(fujitsu->
-                                                dev,
-                                                ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS,
-                                                0);
+                                        acpi_bus_generate_proc_event
+                                            (fujitsu->dev,
+                                             ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS,
+                                             0);
                                         keycode = KEY_BRIGHTNESSUP;
                                 }
                         }
@@ -646,8 +663,7 @@ static void acpi_fujitsu_notify(acpi_handle handle, u32 event, void *data)
                         }
                         if (disable_brightness_keys != 1) {
                                 acpi_bus_generate_proc_event(fujitsu->dev,
-                                        ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS,
-                                        0);
+                                        ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS, 0);
                                 keycode = KEY_BRIGHTNESSUP;
                         }
                 } else if (oldb > newb) {
@@ -659,8 +675,7 @@ static void acpi_fujitsu_notify(acpi_handle handle, u32 event, void *data)
                         }
                         if (disable_brightness_keys != 1) {
                                 acpi_bus_generate_proc_event(fujitsu->dev,
-                                        ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS,
-                                        0);
+                                        ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS, 0);
                                 keycode = KEY_BRIGHTNESSDOWN;
                         }
                 } else {
@@ -742,10 +757,10 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
         input->id.product = 0x06;
         input->dev.parent = &device->dev;
         input->evbit[0] = BIT(EV_KEY);
-        set_bit(KEY_SCREENLOCK, input->keybit);
-        set_bit(KEY_MEDIA, input->keybit);
-        set_bit(KEY_EMAIL, input->keybit);
-        set_bit(KEY_SUSPEND, input->keybit);
+        set_bit(fujitsu->keycode1, input->keybit);
+        set_bit(fujitsu->keycode2, input->keybit);
+        set_bit(fujitsu->keycode3, input->keybit);
+        set_bit(fujitsu->keycode4, input->keybit);
         set_bit(KEY_UNKNOWN, input->keybit);
 
         error = input_register_device(input);
@@ -833,24 +848,24 @@ static void acpi_fujitsu_hotkey_notify(acpi_handle handle, u32 event,
                                     irb);
 
                         switch (irb & 0x4ff) {
-                        case LOCK_KEY:
-                                keycode = KEY_SCREENLOCK;
+                        case KEY1_CODE:
+                                keycode = fujitsu->keycode1;
                                 break;
-                        case DISPLAY_KEY:
-                                keycode = KEY_MEDIA;
+                        case KEY2_CODE:
+                                keycode = fujitsu->keycode2;
                                 break;
-                        case ENERGY_KEY:
-                                keycode = KEY_EMAIL;
+                        case KEY3_CODE:
+                                keycode = fujitsu->keycode3;
                                 break;
-                        case REST_KEY:
-                                keycode = KEY_SUSPEND;
+                        case KEY4_CODE:
+                                keycode = fujitsu->keycode4;
                                 break;
                         case 0:
                                 keycode = 0;
                                 break;
                         default:
                                 vdbg_printk(FUJLAPTOP_DBG_WARN,
-                                        "Unknown GIRB result [%x]\n", irb);
+                                            "Unknown GIRB result [%x]\n", irb);
                                 keycode = -1;
                                 break;
                         }
@@ -859,12 +874,12 @@ static void acpi_fujitsu_hotkey_notify(acpi_handle handle, u32 event,
                                         "Push keycode into ringbuffer [%d]\n",
                                         keycode);
                                 status = kfifo_put(fujitsu_hotkey->fifo,
-                                                (unsigned char *)&keycode,
-                                                sizeof(keycode));
+                                                   (unsigned char *)&keycode,
+                                                   sizeof(keycode));
                                 if (status != sizeof(keycode)) {
                                         vdbg_printk(FUJLAPTOP_DBG_WARN,
-                                                "Could not push keycode [0x%x]\n",
-                                                keycode);
+                                            "Could not push keycode [0x%x]\n",
+                                            keycode);
                                 } else {
                                         input_report_key(input, keycode, 1);
                                         input_sync(input);
@@ -879,8 +894,8 @@ static void acpi_fujitsu_hotkey_notify(acpi_handle handle, u32 event,
                                         input_report_key(input, keycode_r, 0);
                                         input_sync(input);
                                         vdbg_printk(FUJLAPTOP_DBG_TRACE,
-                                                    "Pop keycode from ringbuffer [%d]\n",
-                                                    keycode_r);
+                                          "Pop keycode from ringbuffer [%d]\n",
+                                          keycode_r);
                                 }
                         }
                 }
@@ -943,6 +958,11 @@ static int __init fujitsu_init(void)
         if (!fujitsu)
                 return -ENOMEM;
         memset(fujitsu, 0, sizeof(struct fujitsu_t));
+        fujitsu->keycode1 = KEY_PROG1;
+        fujitsu->keycode2 = KEY_PROG2;
+        fujitsu->keycode3 = KEY_PROG3;
+        fujitsu->keycode4 = KEY_PROG4;
+        dmi_check_system(fujitsu_dmi_table);
 
         result = acpi_bus_register_driver(&acpi_fujitsu_driver);
         if (result < 0) {
@@ -1076,15 +1096,14 @@ MODULE_DESCRIPTION("Fujitsu laptop extras support");
 MODULE_VERSION(FUJITSU_DRIVER_VERSION);
 MODULE_LICENSE("GPL");
 
-MODULE_ALIAS
-    ("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1D3:*:cvrS6410:*");
-MODULE_ALIAS
-    ("dmi:*:svnFUJITSU:*:pvr:rvnFUJITSU:rnFJNB19C:*:cvrS7020:*");
+MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1D3:*:cvrS6410:*");
+MODULE_ALIAS("dmi:*:svnFUJITSU:*:pvr:rvnFUJITSU:rnFJNB19C:*:cvrS7020:*");
 
 static struct pnp_device_id pnp_ids[] = {
-        { .id = "FUJ02bf" },
-        { .id = "FUJ02B1" },
-        { .id = "FUJ02E3" },
-        { .id = "" }
+        {.id = "FUJ02bf"},
+        {.id = "FUJ02B1"},
+        {.id = "FUJ02E3"},
+        {.id = ""}
 };
+
 MODULE_DEVICE_TABLE(pnp, pnp_ids);