47 files changed, 9636 insertions, 2652 deletions

diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index cff7cc2c1f02..45e0191c35dd 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -18,12 +18,14 @@ if X86_PLATFORM_DEVICES
 config ACER_WMI
         tristate "Acer WMI Laptop Extras"
         depends on ACPI
-        depends on LEDS_CLASS
-        depends on NEW_LEDS
+        select LEDS_CLASS
+        select NEW_LEDS
         depends on BACKLIGHT_CLASS_DEVICE
         depends on SERIO_I8042
+        depends on INPUT
         depends on RFKILL || RFKILL = n
-        select ACPI_WMI
+        depends on ACPI_WMI
+        select INPUT_SPARSEKMAP
         ---help---
           This is a driver for newer Acer (and Wistron) laptops. It adds
           wireless radio and bluetooth control, and on some laptops,
@@ -37,7 +39,7 @@ config ACER_WMI
 
 config ACERHDF
         tristate "Acer Aspire One temperature and fan driver"
-        depends on THERMAL && THERMAL_HWMON && ACPI
+        depends on THERMAL && ACPI
         ---help---
           This is a driver for Acer Aspire One netbooks. It allows to access
           the temperature sensor and to control the fan.
@@ -92,12 +94,26 @@ config DELL_WMI
         tristate "Dell WMI extras"
         depends on ACPI_WMI
         depends on INPUT
+        select INPUT_SPARSEKMAP
         ---help---
           Say Y here if you want to support WMI-based hotkeys on Dell laptops.
 
           To compile this driver as a module, choose M here: the module will
           be called dell-wmi.
 
+config DELL_WMI_AIO
+        tristate "WMI Hotkeys for Dell All-In-One series"
+        depends on ACPI_WMI
+        depends on INPUT
+        select INPUT_SPARSEKMAP
+        ---help---
+          Say Y here if you want to support WMI-based hotkeys on Dell
+          All-In-One machines.
+
+          To compile this driver as a module, choose M here: the module will
+          be called dell-wmi-aio.
+
+
 config FUJITSU_LAPTOP
         tristate "Fujitsu Laptop Extras"
         depends on ACPI
@@ -130,16 +146,35 @@ config TC1100_WMI
         depends on !X86_64
         depends on EXPERIMENTAL
         depends on ACPI
-        select ACPI_WMI
+        depends on ACPI_WMI
         ---help---
           This is a driver for the WMI extensions (wireless and bluetooth power
           control) of the HP Compaq TC1100 tablet.
 
+config HP_ACCEL
+        tristate "HP laptop accelerometer"
+        depends on INPUT && ACPI
+        select SENSORS_LIS3LV02D
+        select NEW_LEDS
+        select LEDS_CLASS
+        help
+          This driver provides support for the "Mobile Data Protection System 3D"
+          or "3D DriveGuard" feature of HP laptops. On such systems the driver
+          should load automatically (via ACPI alias).
+
+          Support for a led indicating disk protection will be provided as
+          hp::hddprotect. For more information on the feature, refer to
+          Documentation/hwmon/lis3lv02d.
+
+          To compile this driver as a module, choose M here: the module will
+          be called hp_accel.
+
 config HP_WMI
         tristate "HP WMI extras"
         depends on ACPI_WMI
         depends on INPUT
         depends on RFKILL || RFKILL = n
+        select INPUT_SPARSEKMAP
         help
          Say Y here if you want to support WMI-based hotkeys on HP laptops and
          to read data from WMI such as docking or ambient light sensor state.
@@ -152,7 +187,8 @@ config MSI_LAPTOP
         depends on ACPI
         depends on BACKLIGHT_CLASS_DEVICE
         depends on RFKILL
-        depends on SERIO_I8042
+        depends on INPUT && SERIO_I8042
+        select INPUT_SPARSEKMAP
         ---help---
           This is a driver for laptops built by MSI (MICRO-STAR
           INTERNATIONAL):
@@ -171,6 +207,7 @@ config PANASONIC_LAPTOP
         tristate "Panasonic Laptop Extras"
         depends on INPUT && ACPI
         depends on BACKLIGHT_CLASS_DEVICE
+        select INPUT_SPARSEKMAP
         ---help---
           This driver adds support for access to backlight control and hotkeys
           on Panasonic Let's Note laptops.
@@ -219,10 +256,11 @@ config SONYPI_COMPAT
           ---help---
           Build the sonypi driver compatibility code into the sony-laptop driver.
 
-config IDEAPAD_ACPI
-        tristate "Lenovo IdeaPad ACPI Laptop Extras"
+config IDEAPAD_LAPTOP
+        tristate "Lenovo IdeaPad Laptop Extras"
         depends on ACPI
-        depends on RFKILL
+        depends on RFKILL && INPUT
+        select INPUT_SPARSEKMAP
         help
           This is a driver for the rfkill switches on Lenovo IdeaPad netbooks.
 
@@ -365,6 +403,26 @@ config THINKPAD_ACPI_HOTKEY_POLL
           If you are not sure, say Y here.  The driver enables polling only if
           it is strictly necessary to do so.
 
+config SENSORS_HDAPS
+        tristate "Thinkpad Hard Drive Active Protection System (hdaps)"
+        depends on INPUT && X86
+        select INPUT_POLLDEV
+        default n
+        help
+          This driver provides support for the IBM Hard Drive Active Protection
+          System (hdaps), which provides an accelerometer and other misc. data.
+          ThinkPads starting with the R50, T41, and X40 are supported.  The
+          accelerometer data is readable via sysfs.
+
+          This driver also provides an absolute input class device, allowing
+          the laptop to act as a pinball machine-esque joystick.
+
+          If your ThinkPad is not recognized by the driver, please update to latest
+          BIOS. This is especially the case for some R52 ThinkPads.
+
+          Say Y here if you have an applicable laptop and want to experience
+          the awesome power of hdaps.
+
 config INTEL_MENLOW
         tristate "Thermal Management driver for Intel menlow platform"
         depends on ACPI_THERMAL
@@ -394,20 +452,53 @@ config EEEPC_LAPTOP
           Bluetooth, backlight and allows powering on/off some other
           devices.
 
-          If you have an Eee PC laptop, say Y or M here.
+          If you have an Eee PC laptop, say Y or M here. If this driver
+          doesn't work on your Eee PC, try eeepc-wmi instead.
 
-config EEEPC_WMI
-        tristate "Eee PC WMI Hotkey Driver (EXPERIMENTAL)"
+config ASUS_WMI
+        tristate "ASUS WMI Driver (EXPERIMENTAL)"
         depends on ACPI_WMI
         depends on INPUT
+        depends on HWMON
         depends on EXPERIMENTAL
         depends on BACKLIGHT_CLASS_DEVICE
+        depends on RFKILL || RFKILL = n
+        depends on HOTPLUG_PCI
         select INPUT_SPARSEKMAP
+        select LEDS_CLASS
+        select NEW_LEDS
         ---help---
-          Say Y here if you want to support WMI-based hotkeys on Eee PC laptops.
+          Say Y here if you have a WMI aware Asus laptop (like Eee PCs or new
+          Asus Notebooks).
 
           To compile this driver as a module, choose M here: the module will
-          be called eeepc-wmi.
+          be called asus-wmi.
+
+config ASUS_NB_WMI
+        tristate "Asus Notebook WMI Driver (EXPERIMENTAL)"
+        depends on ASUS_WMI
+        ---help---
+          This is a driver for newer Asus notebooks. It adds extra features
+          like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+          For more informations, see
+          <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+          If you have an ACPI-WMI compatible Asus Notebook, say Y or M
+          here.
+
+config EEEPC_WMI
+        tristate "Eee PC WMI Driver (EXPERIMENTAL)"
+        depends on ASUS_WMI
+        ---help---
+          This is a driver for newer Eee PC laptops. It adds extra features
+          like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+          For more informations, see
+          <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+          If you have an ACPI-WMI compatible Eee PC laptop (>= 1000), say Y or M
+          here.
 
 config ACPI_WMI
         tristate "WMI"
@@ -478,6 +569,7 @@ config TOPSTAR_LAPTOP
         tristate "Topstar Laptop Extras"
         depends on ACPI
         depends on INPUT
+        select INPUT_SPARSEKMAP
         ---help---
           This driver adds support for hotkeys found on Topstar laptops.
 
@@ -486,12 +578,13 @@ config TOPSTAR_LAPTOP
 config ACPI_TOSHIBA
         tristate "Toshiba Laptop Extras"
         depends on ACPI
-        depends on LEDS_CLASS
-        depends on NEW_LEDS
+        select LEDS_CLASS
+        select NEW_LEDS
         depends on BACKLIGHT_CLASS_DEVICE
         depends on INPUT
         depends on RFKILL || RFKILL = n
         select INPUT_POLLDEV
+        select INPUT_SPARSEKMAP
         ---help---
           This driver adds support for access to certain system settings
           on "legacy free" Toshiba laptops.  These laptops can be recognized by
@@ -551,6 +644,15 @@ config INTEL_SCU_IPC
           some embedded Intel x86 platforms. This is not needed for PC-type
           machines.
 
+config INTEL_SCU_IPC_UTIL
+        tristate "Intel SCU IPC utility driver"
+        depends on INTEL_SCU_IPC
+        default y
+        ---help---
+          The IPC Util driver provides an interface with the SCU enabling
+          low level access for debug work and updating the firmware. Say
+          N unless you will be doing this on an Intel MID platform.
+
 config GPIO_INTEL_PMIC
         bool "Intel PMIC GPIO support"
         depends on INTEL_SCU_IPC && GPIOLIB
@@ -558,6 +660,21 @@ config GPIO_INTEL_PMIC
           Say Y here to support GPIO via the SCU IPC interface
           on Intel MID platforms.
 
+config INTEL_MID_POWER_BUTTON
+        tristate "power button driver for Intel MID platforms"
+        depends on INTEL_SCU_IPC && INPUT
+        help
+          This driver handles the power button on the Intel MID platforms.
+
+          If unsure, say N.
+
+config INTEL_MFLD_THERMAL
+       tristate "Thermal driver for Intel Medfield platform"
+       depends on INTEL_SCU_IPC && THERMAL
+       help
+         Say Y here to enable thermal driver support for the  Intel Medfield
+         platform.
+
 config RAR_REGISTER
         bool "Restricted Access Region Register Driver"
         depends on PCI && X86_MRST
@@ -590,4 +707,66 @@ config INTEL_IPS
           functionality.  If in doubt, say Y here; it will only load on
           supported platforms.
 
+config IBM_RTL
+        tristate "Device driver to enable PRTL support"
+        depends on X86 && PCI
+        ---help---
+         Enable support for IBM Premium Real Time Mode (PRTM).
+         This module will allow you the enter and exit PRTM in the BIOS via
+         sysfs on platforms that support this feature.  System in PRTM will
+         not receive CPU-generated SMIs for recoverable errors.  Use of this
+         feature without proper support may void your hardware warranty.
+
+         If the proper BIOS support is found the driver will load and create
+         /sys/devices/system/ibm_rtl/.  The "state" variable will indicate
+         whether or not the BIOS is in PRTM.
+         state = 0 (BIOS SMIs on)
+         state = 1 (BIOS SMIs off)
+
+config XO1_RFKILL
+        tristate "OLPC XO-1 software RF kill switch"
+        depends on OLPC
+        depends on RFKILL
+        ---help---
+          Support for enabling/disabling the WLAN interface on the OLPC XO-1
+          laptop.
+
+config XO15_EBOOK
+        tristate "OLPC XO-1.5 ebook switch"
+        depends on ACPI && INPUT
+        ---help---
+          Support for the ebook switch on the OLPC XO-1.5 laptop.
+
+          This switch is triggered as the screen is rotated and folded down to
+          convert the device into ebook form.
+
+config SAMSUNG_LAPTOP
+        tristate "Samsung Laptop driver"
+        depends on RFKILL && BACKLIGHT_CLASS_DEVICE && X86
+        ---help---
+          This module implements a driver for a wide range of different
+          Samsung laptops.  It offers control over the different
+          function keys, wireless LED, LCD backlight level, and
+          sometimes provides a "performance_control" sysfs file to allow
+          the performance level of the laptop to be changed.
+
+          To compile this driver as a module, choose M here: the module
+          will be called samsung-laptop.
+
+config MXM_WMI
+       tristate "WMI support for MXM Laptop Graphics"
+       depends on ACPI_WMI
+       ---help---
+          MXM is a standard for laptop graphics cards, the WMI interface
+          is required for switchable nvidia graphics machines
+
+config INTEL_OAKTRAIL
+        tristate "Intel Oaktrail Platform Extras"
+        depends on ACPI
+        depends on RFKILL && BACKLIGHT_CLASS_DEVICE && ACPI
+        ---help---
+          Intel Oaktrail platform need this driver to provide interfaces to
+          enable/disable the Camera, WiFi, BT etc. devices. If in doubt, say Y
+          here; it will only load on supported platforms.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 85fb2b84f57e..afc1f832aa67 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -3,6 +3,8 @@
 # x86 Platform-Specific Drivers
 #
 obj-$(CONFIG_ASUS_LAPTOP)       += asus-laptop.o
+obj-$(CONFIG_ASUS_WMI)          += asus-wmi.o
+obj-$(CONFIG_ASUS_NB_WMI)       += asus-nb-wmi.o
 obj-$(CONFIG_EEEPC_LAPTOP)      += eeepc-laptop.o
 obj-$(CONFIG_EEEPC_WMI)         += eeepc-wmi.o
 obj-$(CONFIG_MSI_LAPTOP)        += msi-laptop.o
@@ -10,13 +12,16 @@ obj-$(CONFIG_ACPI_CMPC)		+= classmate-laptop.o
 obj-$(CONFIG_COMPAL_LAPTOP)     += compal-laptop.o
 obj-$(CONFIG_DELL_LAPTOP)       += dell-laptop.o
 obj-$(CONFIG_DELL_WMI)          += dell-wmi.o
+obj-$(CONFIG_DELL_WMI_AIO)      += dell-wmi-aio.o
 obj-$(CONFIG_ACER_WMI)          += acer-wmi.o
 obj-$(CONFIG_ACERHDF)           += acerhdf.o
+obj-$(CONFIG_HP_ACCEL)          += hp_accel.o
 obj-$(CONFIG_HP_WMI)            += hp-wmi.o
 obj-$(CONFIG_TC1100_WMI)        += tc1100-wmi.o
 obj-$(CONFIG_SONY_LAPTOP)       += sony-laptop.o
-obj-$(CONFIG_IDEAPAD_ACPI)      += ideapad_acpi.o
+obj-$(CONFIG_IDEAPAD_LAPTOP)    += ideapad-laptop.o
 obj-$(CONFIG_THINKPAD_ACPI)     += thinkpad_acpi.o
+obj-$(CONFIG_SENSORS_HDAPS)     += hdaps.o
 obj-$(CONFIG_FUJITSU_LAPTOP)    += fujitsu-laptop.o
 obj-$(CONFIG_PANASONIC_LAPTOP)  += panasonic-laptop.o
 obj-$(CONFIG_INTEL_MENLOW)      += intel_menlow.o
@@ -27,7 +32,15 @@ obj-$(CONFIG_TOPSTAR_LAPTOP)	+= topstar-laptop.o
 obj-$(CONFIG_ACPI_TOSHIBA)      += toshiba_acpi.o
 obj-$(CONFIG_TOSHIBA_BT_RFKILL) += toshiba_bluetooth.o
 obj-$(CONFIG_INTEL_SCU_IPC)     += intel_scu_ipc.o
+obj-$(CONFIG_INTEL_SCU_IPC_UTIL) += intel_scu_ipcutil.o
+obj-$(CONFIG_INTEL_MFLD_THERMAL) += intel_mid_thermal.o
 obj-$(CONFIG_RAR_REGISTER)      += intel_rar_register.o
 obj-$(CONFIG_INTEL_IPS)         += intel_ips.o
 obj-$(CONFIG_GPIO_INTEL_PMIC)   += intel_pmic_gpio.o
-
+obj-$(CONFIG_XO1_RFKILL)        += xo1-rfkill.o
+obj-$(CONFIG_XO15_EBOOK)        += xo15-ebook.o
+obj-$(CONFIG_IBM_RTL)           += ibm_rtl.o
+obj-$(CONFIG_SAMSUNG_LAPTOP)    += samsung-laptop.o
+obj-$(CONFIG_MXM_WMI)           += mxm-wmi.o
+obj-$(CONFIG_INTEL_MID_POWER_BUTTON)    += intel_mid_powerbtn.o
+obj-$(CONFIG_INTEL_OAKTRAIL)    += intel_oaktrail.o
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index 2badee2fdeed..e1c4938b301b 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -22,6 +22,8 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -37,6 +39,8 @@
 #include <linux/workqueue.h>
 #include <linux/debugfs.h>
 #include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 
 #include <acpi/acpi_drivers.h>
 
@@ -44,11 +48,6 @@ MODULE_AUTHOR("Carlos Corbacho");
 MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
 MODULE_LICENSE("GPL");
 
-#define ACER_LOGPREFIX "acer-wmi: "
-#define ACER_ERR KERN_ERR ACER_LOGPREFIX
-#define ACER_NOTICE KERN_NOTICE ACER_LOGPREFIX
-#define ACER_INFO KERN_INFO ACER_LOGPREFIX
-
 /*
  * Magic Number
  * Meaning is unknown - this number is required for writing to ACPI for AMW0
@@ -80,11 +79,98 @@ MODULE_LICENSE("GPL");
  */
 #define AMW0_GUID1              "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
 #define AMW0_GUID2              "431F16ED-0C2B-444C-B267-27DEB140CF9C"
-#define WMID_GUID1              "6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3"
-#define WMID_GUID2              "95764E09-FB56-4e83-B31A-37761F60994A"
+#define WMID_GUID1              "6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3"
+#define WMID_GUID2              "95764E09-FB56-4E83-B31A-37761F60994A"
+#define WMID_GUID3              "61EF69EA-865C-4BC3-A502-A0DEBA0CB531"
+
+/*
+ * Acer ACPI event GUIDs
+ */
+#define ACERWMID_EVENT_GUID "676AA15E-6A47-4D9F-A2CC-1E6D18D14026"
 
 MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
-MODULE_ALIAS("wmi:6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3");
+MODULE_ALIAS("wmi:6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3");
+MODULE_ALIAS("wmi:676AA15E-6A47-4D9F-A2CC-1E6D18D14026");
+
+enum acer_wmi_event_ids {
+        WMID_HOTKEY_EVENT = 0x1,
+};
+
+static const struct key_entry acer_wmi_keymap[] = {
+        {KE_KEY, 0x01, {KEY_WLAN} },     /* WiFi */
+        {KE_KEY, 0x03, {KEY_WLAN} },     /* WiFi */
+        {KE_KEY, 0x12, {KEY_BLUETOOTH} },       /* BT */
+        {KE_KEY, 0x21, {KEY_PROG1} },    /* Backup */
+        {KE_KEY, 0x22, {KEY_PROG2} },    /* Arcade */
+        {KE_KEY, 0x23, {KEY_PROG3} },    /* P_Key */
+        {KE_KEY, 0x24, {KEY_PROG4} },    /* Social networking_Key */
+        {KE_IGNORE, 0x41, {KEY_MUTE} },
+        {KE_IGNORE, 0x42, {KEY_PREVIOUSSONG} },
+        {KE_IGNORE, 0x43, {KEY_NEXTSONG} },
+        {KE_IGNORE, 0x44, {KEY_PLAYPAUSE} },
+        {KE_IGNORE, 0x45, {KEY_STOP} },
+        {KE_IGNORE, 0x48, {KEY_VOLUMEUP} },
+        {KE_IGNORE, 0x49, {KEY_VOLUMEDOWN} },
+        {KE_IGNORE, 0x61, {KEY_SWITCHVIDEOMODE} },
+        {KE_IGNORE, 0x62, {KEY_BRIGHTNESSUP} },
+        {KE_IGNORE, 0x63, {KEY_BRIGHTNESSDOWN} },
+        {KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */
+        {KE_IGNORE, 0x81, {KEY_SLEEP} },
+        {KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad On/Off */
+        {KE_IGNORE, 0x83, {KEY_TOUCHPAD_TOGGLE} },
+        {KE_END, 0}
+};
+
+static struct input_dev *acer_wmi_input_dev;
+
+struct event_return_value {
+        u8 function;
+        u8 key_num;
+        u16 device_state;
+        u32 reserved;
+} __attribute__((packed));
+
+/*
+ * GUID3 Get Device Status device flags
+ */
+#define ACER_WMID3_GDS_WIRELESS         (1<<0)  /* WiFi */
+#define ACER_WMID3_GDS_THREEG           (1<<6)  /* 3G */
+#define ACER_WMID3_GDS_WIMAX            (1<<7)  /* WiMAX */
+#define ACER_WMID3_GDS_BLUETOOTH        (1<<11) /* BT */
+
+struct lm_input_params {
+        u8 function_num;        /* Function Number */
+        u16 commun_devices;     /* Communication type devices default status */
+        u16 devices;            /* Other type devices default status */
+        u8 lm_status;           /* Launch Manager Status */
+        u16 reserved;
+} __attribute__((packed));
+
+struct lm_return_value {
+        u8 error_code;          /* Error Code */
+        u8 ec_return_value;     /* EC Return Value */
+        u16 reserved;
+} __attribute__((packed));
+
+struct wmid3_gds_input_param {  /* Get Device Status input parameter */
+        u8 function_num;        /* Function Number */
+        u8 hotkey_number;       /* Hotkey Number */
+        u16 devices;            /* Get Device */
+} __attribute__((packed));
+
+struct wmid3_gds_return_value { /* Get Device Status return value*/
+        u8 error_code;          /* Error Code */
+        u8 ec_return_value;     /* EC Return Value */
+        u16 devices;            /* Current Device Status */
+        u32 reserved;
+} __attribute__((packed));
+
+struct hotkey_function_type_aa {
+        u8 type;
+        u8 length;
+        u16 handle;
+        u16 commun_func_bitmap;
+} __attribute__((packed));
 
 /*
  * Interface capability flags
@@ -116,15 +202,19 @@ static int mailled = -1;
 static int brightness = -1;
 static int threeg = -1;
 static int force_series;
+static bool ec_raw_mode;
+static bool has_type_aa;
 
 module_param(mailled, int, 0444);
 module_param(brightness, int, 0444);
 module_param(threeg, int, 0444);
 module_param(force_series, int, 0444);
+module_param(ec_raw_mode, bool, 0444);
 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");
 MODULE_PARM_DESC(force_series, "Force a different laptop series");
+MODULE_PARM_DESC(ec_raw_mode, "Enable EC raw mode");
 
 struct acer_data {
         int mailled;
@@ -140,6 +230,8 @@ struct acer_debug {
 
 static struct rfkill *wireless_rfkill;
 static struct rfkill *bluetooth_rfkill;
+static struct rfkill *threeg_rfkill;
+static bool rfkill_inited;
 
 /* Each low-level interface must define at least some of the following */
 struct wmi_interface {
@@ -659,8 +751,11 @@ WMI_execute_u32(u32 method_id, u32 in, u32 *out)
 
         obj = (union acpi_object *) result.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 tmp = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                tmp = (u32) obj->integer.value;
         } else {
                 tmp = 0;
         }
@@ -753,6 +848,28 @@ static acpi_status WMID_set_u32(u32 value, u32 cap, struct wmi_interface *iface)
         return WMI_execute_u32(method_id, (u32)value, NULL);
 }
 
+static void type_aa_dmi_decode(const struct dmi_header *header, void *dummy)
+{
+        struct hotkey_function_type_aa *type_aa;
+
+        /* We are looking for OEM-specific Type AAh */
+        if (header->type != 0xAA)
+                return;
+
+        has_type_aa = true;
+        type_aa = (struct hotkey_function_type_aa *) header;
+
+        pr_info("Function bitmap for Communication Button: 0x%x\n",
+                type_aa->commun_func_bitmap);
+
+        if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_WIRELESS)
+                interface->capability |= ACER_CAP_WIRELESS;
+        if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_THREEG)
+                interface->capability |= ACER_CAP_THREEG;
+        if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_BLUETOOTH)
+                interface->capability |= ACER_CAP_BLUETOOTH;
+}
+
 static acpi_status WMID_set_capabilities(void)
 {
         struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
@@ -766,23 +883,28 @@ static acpi_status WMID_set_capabilities(void)
 
         obj = (union acpi_object *) out.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 devices = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                devices = (u32) obj->integer.value;
         } else {
                 kfree(out.pointer);
                 return AE_ERROR;
         }
 
-        /* Not sure on the meaning of the relevant bits yet to detect these */
-        interface->capability |= ACER_CAP_WIRELESS;
-        interface->capability |= ACER_CAP_THREEG;
+        dmi_walk(type_aa_dmi_decode, NULL);
+        if (!has_type_aa) {
+                interface->capability |= ACER_CAP_WIRELESS;
+                if (devices & 0x40)
+                        interface->capability |= ACER_CAP_THREEG;
+                if (devices & 0x10)
+                        interface->capability |= ACER_CAP_BLUETOOTH;
+        }
 
         /* WMID always provides brightness methods */
         interface->capability |= ACER_CAP_BRIGHTNESS;
 
-        if (devices & 0x10)
-                interface->capability |= ACER_CAP_BLUETOOTH;
-
         if (!(devices & 0x20))
                 max_brightness = 0x9;
 
@@ -860,9 +982,12 @@ static void __init acer_commandline_init(void)
          * These will all fail silently if the value given is invalid, or the
          * capability isn't available on the given interface
          */
-        set_u32(mailled, ACER_CAP_MAILLED);
-        set_u32(threeg, ACER_CAP_THREEG);
-        set_u32(brightness, ACER_CAP_BRIGHTNESS);
+        if (mailled >= 0)
+                set_u32(mailled, ACER_CAP_MAILLED);
+        if (!has_type_aa && threeg >= 0)
+                set_u32(threeg, ACER_CAP_THREEG);
+        if (brightness >= 0)
+                set_u32(brightness, ACER_CAP_BRIGHTNESS);
 }
 
 /*
@@ -886,6 +1011,7 @@ static int __devinit acer_led_init(struct device *dev)
 
 static void acer_led_exit(void)
 {
+        set_u32(LED_OFF, ACER_CAP_MAILLED);
         led_classdev_unregister(&mail_led);
 }
 
@@ -915,7 +1041,7 @@ static int update_bl_status(struct backlight_device *bd)
         return 0;
 }
 
-static struct backlight_ops acer_bl_ops = {
+static const struct backlight_ops acer_bl_ops = {
         .get_brightness = read_brightness,
         .update_status = update_bl_status,
 };
@@ -926,11 +1052,12 @@ static int __devinit acer_backlight_init(struct device *dev)
         struct backlight_device *bd;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = max_brightness;
         bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops,
                                        &props);
         if (IS_ERR(bd)) {
-                printk(ACER_ERR "Could not register Acer backlight device\n");
+                pr_err("Could not register Acer backlight device\n");
                 acer_backlight_device = NULL;
                 return PTR_ERR(bd);
         }
@@ -948,6 +1075,186 @@ static void acer_backlight_exit(void)
         backlight_device_unregister(acer_backlight_device);
 }
 
+static acpi_status wmid3_get_device_status(u32 *value, u16 device)
+{
+        struct wmid3_gds_return_value return_value;
+        acpi_status status;
+        union acpi_object *obj;
+        struct wmid3_gds_input_param params = {
+                .function_num = 0x1,
+                .hotkey_number = 0x01,
+                .devices = device,
+        };
+        struct acpi_buffer input = {
+                sizeof(struct wmid3_gds_input_param),
+                &params
+        };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input, &output);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 8) {
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        if (return_value.error_code || return_value.ec_return_value)
+                pr_warn("Get Device Status failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
+                        return_value.ec_return_value);
+        else
+                *value = !!(return_value.devices & device);
+
+        return status;
+}
+
+static acpi_status get_device_status(u32 *value, u32 cap)
+{
+        if (wmi_has_guid(WMID_GUID3)) {
+                u16 device;
+
+                switch (cap) {
+                case ACER_CAP_WIRELESS:
+                        device = ACER_WMID3_GDS_WIRELESS;
+                        break;
+                case ACER_CAP_BLUETOOTH:
+                        device = ACER_WMID3_GDS_BLUETOOTH;
+                        break;
+                case ACER_CAP_THREEG:
+                        device = ACER_WMID3_GDS_THREEG;
+                        break;
+                default:
+                        return AE_ERROR;
+                }
+                return wmid3_get_device_status(value, device);
+
+        } else {
+                return get_u32(value, cap);
+        }
+}
+
+static acpi_status wmid3_set_device_status(u32 value, u16 device)
+{
+        struct wmid3_gds_return_value return_value;
+        acpi_status status;
+        union acpi_object *obj;
+        u16 devices;
+        struct wmid3_gds_input_param params = {
+                .function_num = 0x1,
+                .hotkey_number = 0x01,
+                .devices = ACER_WMID3_GDS_WIRELESS |
+                                ACER_WMID3_GDS_THREEG |
+                                ACER_WMID3_GDS_WIMAX |
+                                ACER_WMID3_GDS_BLUETOOTH,
+        };
+        struct acpi_buffer input = {
+                sizeof(struct wmid3_gds_input_param),
+                &params
+        };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer output2 = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input, &output);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 8) {
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        if (return_value.error_code || return_value.ec_return_value) {
+                pr_warning("Get Current Device Status failed: "
+                        "0x%x - 0x%x\n", return_value.error_code,
+                        return_value.ec_return_value);
+                return status;
+        }
+
+        devices = return_value.devices;
+        params.function_num = 0x2;
+        params.hotkey_number = 0x01;
+        params.devices = (value) ? (devices | device) : (devices & ~device);
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &input, &output2);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output2.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 4) {
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        if (return_value.error_code || return_value.ec_return_value)
+                pr_warning("Set Device Status failed: "
+                        "0x%x - 0x%x\n", return_value.error_code,
+                        return_value.ec_return_value);
+
+        return status;
+}
+
+static acpi_status set_device_status(u32 value, u32 cap)
+{
+        if (wmi_has_guid(WMID_GUID3)) {
+                u16 device;
+
+                switch (cap) {
+                case ACER_CAP_WIRELESS:
+                        device = ACER_WMID3_GDS_WIRELESS;
+                        break;
+                case ACER_CAP_BLUETOOTH:
+                        device = ACER_WMID3_GDS_BLUETOOTH;
+                        break;
+                case ACER_CAP_THREEG:
+                        device = ACER_WMID3_GDS_THREEG;
+                        break;
+                default:
+                        return AE_ERROR;
+                }
+                return wmid3_set_device_status(value, device);
+
+        } else {
+                return set_u32(value, cap);
+        }
+}
+
 /*
  * Rfkill devices
  */
@@ -968,6 +1275,13 @@ static void acer_rfkill_update(struct work_struct *ignored)
                         rfkill_set_sw_state(bluetooth_rfkill, !state);
         }
 
+        if (has_cap(ACER_CAP_THREEG) && wmi_has_guid(WMID_GUID3)) {
+                status = wmid3_get_device_status(&state,
+                                ACER_WMID3_GDS_THREEG);
+                if (ACPI_SUCCESS(status))
+                        rfkill_set_sw_state(threeg_rfkill, !state);
+        }
+
         schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
 }
 
@@ -975,9 +1289,13 @@ static int acer_rfkill_set(void *data, bool blocked)
 {
         acpi_status status;
         u32 cap = (unsigned long)data;
-        status = set_u32(!blocked, cap);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
+
+        if (rfkill_inited) {
+                status = set_device_status(!blocked, cap);
+                if (ACPI_FAILURE(status))
+                        return -ENODEV;
+        }
+
         return 0;
 }
 
@@ -991,6 +1309,8 @@ static struct rfkill *acer_rfkill_register(struct device *dev,
 {
         int err;
         struct rfkill *rfkill_dev;
+        u32 state;
+        acpi_status status;
 
         rfkill_dev = rfkill_alloc(name, dev, type,
                                   &acer_rfkill_ops,
@@ -998,11 +1318,17 @@ static struct rfkill *acer_rfkill_register(struct device *dev,
         if (!rfkill_dev)
                 return ERR_PTR(-ENOMEM);
 
+        status = get_device_status(&state, cap);
+
         err = rfkill_register(rfkill_dev);
         if (err) {
                 rfkill_destroy(rfkill_dev);
                 return ERR_PTR(err);
         }
+
+        if (ACPI_SUCCESS(status))
+                rfkill_set_sw_state(rfkill_dev, !state);
+
         return rfkill_dev;
 }
 
@@ -1024,14 +1350,32 @@ static int acer_rfkill_init(struct device *dev)
                 }
         }
 
-        schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
+        if (has_cap(ACER_CAP_THREEG)) {
+                threeg_rfkill = acer_rfkill_register(dev,
+                        RFKILL_TYPE_WWAN, "acer-threeg",
+                        ACER_CAP_THREEG);
+                if (IS_ERR(threeg_rfkill)) {
+                        rfkill_unregister(wireless_rfkill);
+                        rfkill_destroy(wireless_rfkill);
+                        rfkill_unregister(bluetooth_rfkill);
+                        rfkill_destroy(bluetooth_rfkill);
+                        return PTR_ERR(threeg_rfkill);
+                }
+        }
+
+        rfkill_inited = true;
+
+        if (ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID))
+                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);
+        if (ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID))
+                cancel_delayed_work_sync(&acer_rfkill_work);
 
         rfkill_unregister(wireless_rfkill);
         rfkill_destroy(wireless_rfkill);
@@ -1040,6 +1384,11 @@ static void acer_rfkill_exit(void)
                 rfkill_unregister(bluetooth_rfkill);
                 rfkill_destroy(bluetooth_rfkill);
         }
+
+        if (has_cap(ACER_CAP_THREEG)) {
+                rfkill_unregister(threeg_rfkill);
+                rfkill_destroy(threeg_rfkill);
+        }
         return;
 }
 
@@ -1050,7 +1399,12 @@ 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);
+        acpi_status status;
+        if (wmi_has_guid(WMID_GUID3))
+                status = wmid3_get_device_status(&result,
+                                ACER_WMID3_GDS_THREEG);
+        else
+                status = get_u32(&result, ACER_CAP_THREEG);
         if (ACPI_SUCCESS(status))
                 return sprintf(buf, "%u\n", result);
         return sprintf(buf, "Read error\n");
@@ -1065,7 +1419,7 @@ static ssize_t set_bool_threeg(struct device *dev,
                         return -EINVAL;
         return count;
 }
-static DEVICE_ATTR(threeg, S_IWUGO | S_IRUGO | S_IWUSR, show_bool_threeg,
+static DEVICE_ATTR(threeg, S_IRUGO | S_IWUSR, show_bool_threeg,
         set_bool_threeg);
 
 static ssize_t show_interface(struct device *dev, struct device_attribute *attr,
@@ -1085,6 +1439,199 @@ static ssize_t show_interface(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(interface, S_IRUGO, show_interface, NULL);
 
+static void acer_wmi_notify(u32 value, void *context)
+{
+        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        struct event_return_value return_value;
+        acpi_status status;
+        u16 device_state;
+        const struct key_entry *key;
+
+        status = wmi_get_event_data(value, &response);
+        if (status != AE_OK) {
+                pr_warn("bad event status 0x%x\n", status);
+                return;
+        }
+
+        obj = (union acpi_object *)response.pointer;
+
+        if (!obj)
+                return;
+        if (obj->type != ACPI_TYPE_BUFFER) {
+                pr_warn("Unknown response received %d\n", obj->type);
+                kfree(obj);
+                return;
+        }
+        if (obj->buffer.length != 8) {
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return;
+        }
+
+        return_value = *((struct event_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        switch (return_value.function) {
+        case WMID_HOTKEY_EVENT:
+                device_state = return_value.device_state;
+                pr_debug("device state: 0x%x\n", device_state);
+
+                key = sparse_keymap_entry_from_scancode(acer_wmi_input_dev,
+                                                        return_value.key_num);
+                if (!key) {
+                        pr_warn("Unknown key number - 0x%x\n",
+                                return_value.key_num);
+                } else {
+                        switch (key->keycode) {
+                        case KEY_WLAN:
+                        case KEY_BLUETOOTH:
+                                if (has_cap(ACER_CAP_WIRELESS))
+                                        rfkill_set_sw_state(wireless_rfkill,
+                                                !(device_state & ACER_WMID3_GDS_WIRELESS));
+                                if (has_cap(ACER_CAP_THREEG))
+                                        rfkill_set_sw_state(threeg_rfkill,
+                                                !(device_state & ACER_WMID3_GDS_THREEG));
+                                if (has_cap(ACER_CAP_BLUETOOTH))
+                                        rfkill_set_sw_state(bluetooth_rfkill,
+                                                !(device_state & ACER_WMID3_GDS_BLUETOOTH));
+                                break;
+                        }
+                        sparse_keymap_report_entry(acer_wmi_input_dev, key,
+                                                   1, true);
+                }
+                break;
+        default:
+                pr_warn("Unknown function number - %d - %d\n",
+                        return_value.function, return_value.key_num);
+                break;
+        }
+}
+
+static acpi_status
+wmid3_set_lm_mode(struct lm_input_params *params,
+                  struct lm_return_value *return_value)
+{
+        acpi_status status;
+        union acpi_object *obj;
+
+        struct acpi_buffer input = { sizeof(struct lm_input_params), params };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &input, &output);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 4) {
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        *return_value = *((struct lm_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        return status;
+}
+
+static int acer_wmi_enable_ec_raw(void)
+{
+        struct lm_return_value return_value;
+        acpi_status status;
+        struct lm_input_params params = {
+                .function_num = 0x1,
+                .commun_devices = 0xFFFF,
+                .devices = 0xFFFF,
+                .lm_status = 0x00,            /* Launch Manager Deactive */
+        };
+
+        status = wmid3_set_lm_mode(&params, &return_value);
+
+        if (return_value.error_code || return_value.ec_return_value)
+                pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
+                        return_value.ec_return_value);
+        else
+                pr_info("Enabled EC raw mode\n");
+
+        return status;
+}
+
+static int acer_wmi_enable_lm(void)
+{
+        struct lm_return_value return_value;
+        acpi_status status;
+        struct lm_input_params params = {
+                .function_num = 0x1,
+                .commun_devices = 0xFFFF,
+                .devices = 0xFFFF,
+                .lm_status = 0x01,            /* Launch Manager Active */
+        };
+
+        status = wmid3_set_lm_mode(&params, &return_value);
+
+        if (return_value.error_code || return_value.ec_return_value)
+                pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
+                        return_value.ec_return_value);
+
+        return status;
+}
+
+static int __init acer_wmi_input_setup(void)
+{
+        acpi_status status;
+        int err;
+
+        acer_wmi_input_dev = input_allocate_device();
+        if (!acer_wmi_input_dev)
+                return -ENOMEM;
+
+        acer_wmi_input_dev->name = "Acer WMI hotkeys";
+        acer_wmi_input_dev->phys = "wmi/input0";
+        acer_wmi_input_dev->id.bustype = BUS_HOST;
+
+        err = sparse_keymap_setup(acer_wmi_input_dev, acer_wmi_keymap, NULL);
+        if (err)
+                goto err_free_dev;
+
+        status = wmi_install_notify_handler(ACERWMID_EVENT_GUID,
+                                                acer_wmi_notify, NULL);
+        if (ACPI_FAILURE(status)) {
+                err = -EIO;
+                goto err_free_keymap;
+        }
+
+        err = input_register_device(acer_wmi_input_dev);
+        if (err)
+                goto err_uninstall_notifier;
+
+        return 0;
+
+err_uninstall_notifier:
+        wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
+err_free_keymap:
+        sparse_keymap_free(acer_wmi_input_dev);
+err_free_dev:
+        input_free_device(acer_wmi_input_dev);
+        return err;
+}
+
+static void acer_wmi_input_destroy(void)
+{
+        wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
+        sparse_keymap_free(acer_wmi_input_dev);
+        input_unregister_device(acer_wmi_input_dev);
+}
+
 /*
  * debugfs functions
  */
@@ -1101,8 +1648,11 @@ static u32 get_wmid_devices(void)
 
         obj = (union acpi_object *) out.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 devices = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                devices = (u32) obj->integer.value;
         }
 
         kfree(out.pointer);
@@ -1166,6 +1716,7 @@ pm_message_t state)
 
         if (has_cap(ACER_CAP_MAILLED)) {
                 get_u32(&value, ACER_CAP_MAILLED);
+                set_u32(LED_OFF, ACER_CAP_MAILLED);
                 data->mailled = value;
         }
 
@@ -1193,6 +1744,17 @@ static int acer_platform_resume(struct platform_device *device)
         return 0;
 }
 
+static void acer_platform_shutdown(struct platform_device *device)
+{
+        struct acer_data *data = &interface->data;
+
+        if (!data)
+                return;
+
+        if (has_cap(ACER_CAP_MAILLED))
+                set_u32(LED_OFF, ACER_CAP_MAILLED);
+}
+
 static struct platform_driver acer_platform_driver = {
         .driver = {
                 .name = "acer-wmi",
@@ -1202,6 +1764,7 @@ static struct platform_driver acer_platform_driver = {
         .remove = acer_platform_remove,
         .suspend = acer_platform_suspend,
         .resume = acer_platform_resume,
+        .shutdown = acer_platform_shutdown,
 };
 
 static struct platform_device *acer_platform_device;
@@ -1249,7 +1812,7 @@ static int create_debugfs(void)
 {
         interface->debug.root = debugfs_create_dir("acer-wmi", NULL);
         if (!interface->debug.root) {
-                printk(ACER_ERR "Failed to create debugfs directory");
+                pr_err("Failed to create debugfs directory");
                 return -ENOMEM;
         }
 
@@ -1270,11 +1833,10 @@ static int __init acer_wmi_init(void)
 {
         int err;
 
-        printk(ACER_INFO "Acer Laptop ACPI-WMI Extras\n");
+        pr_info("Acer Laptop ACPI-WMI Extras\n");
 
         if (dmi_check_system(acer_blacklist)) {
-                printk(ACER_INFO "Blacklisted hardware detected - "
-                                "not loading\n");
+                pr_info("Blacklisted hardware detected - not loading\n");
                 return -ENODEV;
         }
 
@@ -1291,12 +1853,11 @@ static int __init acer_wmi_init(void)
 
         if (wmi_has_guid(WMID_GUID2) && interface) {
                 if (ACPI_FAILURE(WMID_set_capabilities())) {
-                        printk(ACER_ERR "Unable to detect available WMID "
-                                        "devices\n");
+                        pr_err("Unable to detect available WMID devices\n");
                         return -ENODEV;
                 }
         } else if (!wmi_has_guid(WMID_GUID2) && interface) {
-                printk(ACER_ERR "No WMID device detection method found\n");
+                pr_err("No WMID device detection method found\n");
                 return -ENODEV;
         }
 
@@ -1304,8 +1865,7 @@ static int __init acer_wmi_init(void)
                 interface = &AMW0_interface;
 
                 if (ACPI_FAILURE(AMW0_set_capabilities())) {
-                        printk(ACER_ERR "Unable to detect available AMW0 "
-                                        "devices\n");
+                        pr_err("Unable to detect available AMW0 devices\n");
                         return -ENODEV;
                 }
         }
@@ -1314,8 +1874,7 @@ static int __init acer_wmi_init(void)
                 AMW0_find_mailled();
 
         if (!interface) {
-                printk(ACER_ERR "No or unsupported WMI interface, unable to "
-                                "load\n");
+                pr_err("No or unsupported WMI interface, unable to load\n");
                 return -ENODEV;
         }
 
@@ -1323,13 +1882,33 @@ static int __init acer_wmi_init(void)
 
         if (acpi_video_backlight_support() && has_cap(ACER_CAP_BRIGHTNESS)) {
                 interface->capability &= ~ACER_CAP_BRIGHTNESS;
-                printk(ACER_INFO "Brightness must be controlled by "
+                pr_info("Brightness must be controlled by "
                        "generic video driver\n");
         }
 
+        if (wmi_has_guid(WMID_GUID3)) {
+                if (ec_raw_mode) {
+                        if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) {
+                                pr_err("Cannot enable EC raw mode\n");
+                                return -ENODEV;
+                        }
+                } else if (ACPI_FAILURE(acer_wmi_enable_lm())) {
+                        pr_err("Cannot enable Launch Manager mode\n");
+                        return -ENODEV;
+                }
+        } else if (ec_raw_mode) {
+                pr_info("No WMID EC raw mode enable method\n");
+        }
+
+        if (wmi_has_guid(ACERWMID_EVENT_GUID)) {
+                err = acer_wmi_input_setup();
+                if (err)
+                        return err;
+        }
+
         err = platform_driver_register(&acer_platform_driver);
         if (err) {
-                printk(ACER_ERR "Unable to register platform driver.\n");
+                pr_err("Unable to register platform driver.\n");
                 goto error_platform_register;
         }
 
@@ -1368,17 +1947,23 @@ error_device_add:
 error_device_alloc:
         platform_driver_unregister(&acer_platform_driver);
 error_platform_register:
+        if (wmi_has_guid(ACERWMID_EVENT_GUID))
+                acer_wmi_input_destroy();
+
         return err;
 }
 
 static void __exit acer_wmi_exit(void)
 {
+        if (wmi_has_guid(ACERWMID_EVENT_GUID))
+                acer_wmi_input_destroy();
+
         remove_sysfs(acer_platform_device);
         remove_debugfs();
         platform_device_unregister(acer_platform_device);
         platform_driver_unregister(&acer_platform_driver);
 
-        printk(ACER_INFO "Acer Laptop WMI Extras unloaded\n");
+        pr_info("Acer Laptop WMI Extras unloaded\n");
         return;
 }
 
diff --git a/drivers/platform/x86/acerhdf.c b/drivers/platform/x86/acerhdf.c
index 60f9cfcac93f..fca3489218b7 100644
--- a/drivers/platform/x86/acerhdf.c
+++ b/drivers/platform/x86/acerhdf.c
@@ -35,10 +35,8 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/fs.h>
 #include <linux/dmi.h>
-#include <acpi/acpi_drivers.h>
-#include <linux/sched.h>
+#include <linux/acpi.h>
 #include <linux/thermal.h>
 #include <linux/platform_device.h>
 
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index b756e07d41b4..d65df92e2acc 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -29,7 +29,7 @@
  *  John Belmonte  - ACPI code for Toshiba laptop was a good starting point.
  *  Eric Burghard  - LED display support for W1N
  *  Josh Green     - Light Sens support
- *  Thomas Tuttle  - His first patch for led support was very helpfull
+ *  Thomas Tuttle  - His first patch for led support was very helpful
  *  Sam Lin        - GPS support
  */
 
@@ -50,6 +50,7 @@
 #include <linux/input/sparse-keymap.h>
 #include <linux/rfkill.h>
 #include <linux/slab.h>
+#include <linux/dmi.h>
 #include <acpi/acpi_drivers.h>
 #include <acpi/acpi_bus.h>
 
@@ -81,6 +82,8 @@ MODULE_PARM_DESC(wapf, "WAPF value");
 
 static int wlan_status = 1;
 static int bluetooth_status = 1;
+static int wimax_status = -1;
+static int wwan_status = -1;
 
 module_param(wlan_status, int, 0444);
 MODULE_PARM_DESC(wlan_status, "Set the wireless status on boot "
@@ -92,6 +95,16 @@ MODULE_PARM_DESC(bluetooth_status, "Set the wireless status on boot "
                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
                  "default is 1");
 
+module_param(wimax_status, int, 0444);
+MODULE_PARM_DESC(wimax_status, "Set the wireless status on boot "
+                 "(0 = disabled, 1 = enabled, -1 = don't do anything). "
+                 "default is 1");
+
+module_param(wwan_status, int, 0444);
+MODULE_PARM_DESC(wwan_status, "Set the wireless status on boot "
+                 "(0 = disabled, 1 = enabled, -1 = don't do anything). "
+                 "default is 1");
+
 /*
  * Some events we use, same for all Asus
  */
@@ -114,6 +127,8 @@ MODULE_PARM_DESC(bluetooth_status, "Set the wireless status on boot "
  */
 #define WL_RSTS         0x01    /* internal Wifi */
 #define BT_RSTS         0x02    /* internal Bluetooth */
+#define WM_RSTS         0x08    /* internal wimax */
+#define WW_RSTS         0x20    /* internal wwan */
 
 /* LED */
 #define METHOD_MLED             "MLED"
@@ -132,52 +147,20 @@ MODULE_PARM_DESC(bluetooth_status, "Set the wireless status on boot "
  */
 #define METHOD_WLAN             "WLED"
 #define METHOD_BLUETOOTH        "BLED"
+
+/* WWAN and WIMAX */
+#define METHOD_WWAN             "GSMC"
+#define METHOD_WIMAX            "WMXC"
+
 #define METHOD_WL_STATUS        "RSTS"
 
 /* Brightness */
 #define METHOD_BRIGHTNESS_SET   "SPLV"
 #define METHOD_BRIGHTNESS_GET   "GPLV"
 
-/* Backlight */
-static acpi_handle lcd_switch_handle;
-static char *lcd_switch_paths[] = {
-  "\\_SB.PCI0.SBRG.EC0._Q10",   /* All new models */
-  "\\_SB.PCI0.ISA.EC0._Q10",    /* A1x */
-  "\\_SB.PCI0.PX40.ECD0._Q10",  /* L3C */
-  "\\_SB.PCI0.PX40.EC0.Q10",    /* M1A */
-  "\\_SB.PCI0.LPCB.EC0._Q10",   /* P30 */
-  "\\_SB.PCI0.LPCB.EC0._Q0E", /* P30/P35 */
-  "\\_SB.PCI0.PX40.Q10",        /* S1x */
-  "\\Q10"};             /* A2x, L2D, L3D, M2E */
-
 /* Display */
 #define METHOD_SWITCH_DISPLAY   "SDSP"
 
-static acpi_handle display_get_handle;
-static char *display_get_paths[] = {
-  /* A6B, A6K A6R A7D F3JM L4R M6R A3G M6A M6V VX-1 V6J V6V W3Z */
-  "\\_SB.PCI0.P0P1.VGA.GETD",
-  /* A3E A4K, A4D A4L A6J A7J A8J Z71V M9V S5A M5A z33A W1Jc W2V G1 */
-  "\\_SB.PCI0.P0P2.VGA.GETD",
-  /* A6V A6Q */
-  "\\_SB.PCI0.P0P3.VGA.GETD",
-  /* A6T, A6M */
-  "\\_SB.PCI0.P0PA.VGA.GETD",
-  /* L3C */
-  "\\_SB.PCI0.PCI1.VGAC.NMAP",
-  /* Z96F */
-  "\\_SB.PCI0.VGA.GETD",
-  /* A2D */
-  "\\ACTD",
-  /* A4G Z71A W1N W5A W5F M2N M3N M5N M6N S1N S5N */
-  "\\ADVG",
-  /* P30 */
-  "\\DNXT",
-  /* A2H D1 L2D L3D L3H L2E L5D L5C M1A M2E L4L W3V */
-  "\\INFB",
-  /* A3F A6F A3N A3L M6N W3N W6A */
-  "\\SSTE"};
-
 #define METHOD_ALS_CONTROL      "ALSC" /* Z71A Z71V */
 #define METHOD_ALS_LEVEL        "ALSL" /* Z71A Z71V */
 
@@ -227,7 +210,6 @@ struct asus_laptop {
 
         int wireless_status;
         bool have_rsts;
-        int lcd_state;
 
         struct rfkill *gps_rfkill;
 
@@ -236,7 +218,6 @@ struct asus_laptop {
         u8 light_level;         /* light sensor level */
         u8 light_switch;        /* light sensor switch value */
         u16 event_count[128];   /* count for each event TODO make this better */
-        u16 *keycode_map;
 };
 
 static const struct key_entry asus_keymap[] = {
@@ -278,6 +259,7 @@ static const struct key_entry asus_keymap[] = {
         {KE_KEY, 0x99, { KEY_PHONE } },
         {KE_KEY, 0xc4, { KEY_KBDILLUMUP } },
         {KE_KEY, 0xc5, { KEY_KBDILLUMDOWN } },
+        {KE_KEY, 0xb5, { KEY_CALC } },
         {KE_END, 0},
 };
 
@@ -336,7 +318,7 @@ static int acpi_check_handle(acpi_handle handle, const char *method,
 
         if (status != AE_OK) {
                 if (ret)
-                        pr_warning("Error finding %s\n", method);
+                        pr_warn("Error finding %s\n", method);
                 return -ENODEV;
         }
         return 0;
@@ -401,7 +383,7 @@ static int asus_kled_lvl(struct asus_laptop *asus)
         rv = acpi_evaluate_integer(asus->handle, METHOD_KBD_LIGHT_GET,
                                    &params, &kblv);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading kled level\n");
+                pr_warn("Error reading kled level\n");
                 return -ENODEV;
         }
         return kblv;
@@ -415,7 +397,7 @@ static int asus_kled_set(struct asus_laptop *asus, int kblv)
                 kblv = 0;
 
         if (write_acpi_int(asus->handle, METHOD_KBD_LIGHT_SET, kblv)) {
-                pr_warning("Keyboard LED display write failed\n");
+                pr_warn("Keyboard LED display write failed\n");
                 return -EINVAL;
         }
         return 0;
@@ -540,48 +522,6 @@ error:
 /*
  * Backlight device
  */
-static int asus_lcd_status(struct asus_laptop *asus)
-{
-        return asus->lcd_state;
-}
-
-static int asus_lcd_set(struct asus_laptop *asus, int value)
-{
-        int lcd = 0;
-        acpi_status status = 0;
-
-        lcd = !!value;
-
-        if (lcd == asus_lcd_status(asus))
-                return 0;
-
-        if (!lcd_switch_handle)
-                return -ENODEV;
-
-        status = acpi_evaluate_object(lcd_switch_handle,
-                                      NULL, NULL, NULL);
-
-        if (ACPI_FAILURE(status)) {
-                pr_warning("Error switching LCD\n");
-                return -ENODEV;
-        }
-
-        asus->lcd_state = lcd;
-        return 0;
-}
-
-static void lcd_blank(struct asus_laptop *asus, int blank)
-{
-        struct backlight_device *bd = asus->backlight_device;
-
-        asus->lcd_state = (blank == FB_BLANK_UNBLANK);
-
-        if (bd) {
-                bd->props.power = blank;
-                backlight_update_status(bd);
-        }
-}
-
 static int asus_read_brightness(struct backlight_device *bd)
 {
         struct asus_laptop *asus = bl_get_data(bd);
@@ -591,7 +531,7 @@ static int asus_read_brightness(struct backlight_device *bd)
         rv = acpi_evaluate_integer(asus->handle, METHOD_BRIGHTNESS_GET,
                                    NULL, &value);
         if (ACPI_FAILURE(rv))
-                pr_warning("Error reading brightness\n");
+                pr_warn("Error reading brightness\n");
 
         return value;
 }
@@ -601,7 +541,7 @@ static int asus_set_brightness(struct backlight_device *bd, int value)
         struct asus_laptop *asus = bl_get_data(bd);
 
         if (write_acpi_int(asus->handle, METHOD_BRIGHTNESS_SET, value)) {
-                pr_warning("Error changing brightness\n");
+                pr_warn("Error changing brightness\n");
                 return -EIO;
         }
         return 0;
@@ -609,19 +549,12 @@ static int asus_set_brightness(struct backlight_device *bd, int value)
 
 static int update_bl_status(struct backlight_device *bd)
 {
-        struct asus_laptop *asus = bl_get_data(bd);
-        int rv;
         int value = bd->props.brightness;
 
-        rv = asus_set_brightness(bd, value);
-        if (rv)
-                return rv;
-
-        value = (bd->props.power == FB_BLANK_UNBLANK) ? 1 : 0;
-        return asus_lcd_set(asus, value);
+        return asus_set_brightness(bd, value);
 }
 
-static struct backlight_ops asusbl_ops = {
+static const struct backlight_ops asusbl_ops = {
         .get_brightness = asus_read_brightness,
         .update_status = update_bl_status,
 };
@@ -639,29 +572,29 @@ static int asus_backlight_notify(struct asus_laptop *asus)
 static int asus_backlight_init(struct asus_laptop *asus)
 {
         struct backlight_device *bd;
-        struct device *dev = &asus->platform_device->dev;
         struct backlight_properties props;
 
-        if (!acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_GET, NULL) &&
-            !acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL) &&
-            lcd_switch_handle) {
-                memset(&props, 0, sizeof(struct backlight_properties));
-                props.max_brightness = 15;
-
-                bd = backlight_device_register(ASUS_LAPTOP_FILE, dev,
-                                               asus, &asusbl_ops, &props);
-                if (IS_ERR(bd)) {
-                        pr_err("Could not register asus backlight device\n");
-                        asus->backlight_device = NULL;
-                        return PTR_ERR(bd);
-                }
-
-                asus->backlight_device = bd;
+        if (acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_GET, NULL) ||
+            acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL))
+                return 0;
 
-                bd->props.power = FB_BLANK_UNBLANK;
-                bd->props.brightness = asus_read_brightness(bd);
-                backlight_update_status(bd);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 15;
+        props.type = BACKLIGHT_PLATFORM;
+
+        bd = backlight_device_register(ASUS_LAPTOP_FILE,
+                                       &asus->platform_device->dev, asus,
+                                       &asusbl_ops, &props);
+        if (IS_ERR(bd)) {
+                pr_err("Could not register asus backlight device\n");
+                asus->backlight_device = NULL;
+                return PTR_ERR(bd);
         }
+
+        asus->backlight_device = bd;
+        bd->props.brightness = asus_read_brightness(bd);
+        bd->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(bd);
         return 0;
 }
 
@@ -797,7 +730,7 @@ static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
         rv = parse_arg(buf, count, &value);
         if (rv > 0) {
                 if (write_acpi_int(asus->handle, METHOD_LEDD, value)) {
-                        pr_warning("LED display write failed\n");
+                        pr_warn("LED display write failed\n");
                         return -ENODEV;
                 }
                 asus->ledd_status = (u32) value;
@@ -819,7 +752,7 @@ static int asus_wireless_status(struct asus_laptop *asus, int mask)
         rv = acpi_evaluate_integer(asus->handle, METHOD_WL_STATUS,
                                    NULL, &status);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading Wireless status\n");
+                pr_warn("Error reading Wireless status\n");
                 return -EINVAL;
         }
         return !!(status & mask);
@@ -831,7 +764,7 @@ static int asus_wireless_status(struct asus_laptop *asus, int mask)
 static int asus_wlan_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_WLAN, !!status)) {
-                pr_warning("Error setting wlan status to %d", status);
+                pr_warn("Error setting wlan status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -859,7 +792,7 @@ static ssize_t store_wlan(struct device *dev, struct device_attribute *attr,
 static int asus_bluetooth_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_BLUETOOTH, !!status)) {
-                pr_warning("Error setting bluetooth status to %d", status);
+                pr_warn("Error setting bluetooth status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -883,49 +816,72 @@ static ssize_t store_bluetooth(struct device *dev,
 }
 
 /*
- * Display
+ * Wimax
  */
-static void asus_set_display(struct asus_laptop *asus, int value)
+static int asus_wimax_set(struct asus_laptop *asus, int status)
 {
-        /* no sanity check needed for now */
-        if (write_acpi_int(asus->handle, METHOD_SWITCH_DISPLAY, value))
-                pr_warning("Error setting display\n");
-        return;
+        if (write_acpi_int(asus->handle, METHOD_WIMAX, !!status)) {
+                pr_warn("Error setting wimax status to %d\n", status);
+                return -EIO;
+        }
+        return 0;
 }
 
-static int read_display(struct asus_laptop *asus)
+static ssize_t show_wimax(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
-        unsigned long long value = 0;
-        acpi_status rv = AE_OK;
+        struct asus_laptop *asus = dev_get_drvdata(dev);
 
-        /*
-         * In most of the case, we know how to set the display, but sometime
-         * we can't read it
-         */
-        if (display_get_handle) {
-                rv = acpi_evaluate_integer(display_get_handle, NULL,
-                                           NULL, &value);
-                if (ACPI_FAILURE(rv))
-                        pr_warning("Error reading display status\n");
-        }
+        return sprintf(buf, "%d\n", asus_wireless_status(asus, WM_RSTS));
+}
 
-        value &= 0x0F; /* needed for some models, shouldn't hurt others */
+static ssize_t store_wimax(struct device *dev,
+                               struct device_attribute *attr, const char *buf,
+                               size_t count)
+{
+        struct asus_laptop *asus = dev_get_drvdata(dev);
 
-        return value;
+        return sysfs_acpi_set(asus, buf, count, METHOD_WIMAX);
 }
 
 /*
- * Now, *this* one could be more user-friendly, but so far, no-one has
- * complained. The significance of bits is the same as in store_disp()
+ * Wwan
  */
-static ssize_t show_disp(struct device *dev,
-                         struct device_attribute *attr, char *buf)
+static int asus_wwan_set(struct asus_laptop *asus, int status)
+{
+        if (write_acpi_int(asus->handle, METHOD_WWAN, !!status)) {
+                pr_warn("Error setting wwan status to %d\n", status);
+                return -EIO;
+        }
+        return 0;
+}
+
+static ssize_t show_wwan(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
-        if (!display_get_handle)
-                return -ENODEV;
-        return sprintf(buf, "%d\n", read_display(asus));
+        return sprintf(buf, "%d\n", asus_wireless_status(asus, WW_RSTS));
+}
+
+static ssize_t store_wwan(struct device *dev,
+                               struct device_attribute *attr, const char *buf,
+                               size_t count)
+{
+        struct asus_laptop *asus = dev_get_drvdata(dev);
+
+        return sysfs_acpi_set(asus, buf, count, METHOD_WWAN);
+}
+
+/*
+ * Display
+ */
+static void asus_set_display(struct asus_laptop *asus, int value)
+{
+        /* no sanity check needed for now */
+        if (write_acpi_int(asus->handle, METHOD_SWITCH_DISPLAY, value))
+                pr_warn("Error setting display\n");
+        return;
 }
 
 /*
@@ -953,7 +909,7 @@ static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
 static void asus_als_switch(struct asus_laptop *asus, int value)
 {
         if (write_acpi_int(asus->handle, METHOD_ALS_CONTROL, value))
-                pr_warning("Error setting light sensor switch\n");
+                pr_warn("Error setting light sensor switch\n");
         asus->light_switch = value;
 }
 
@@ -981,7 +937,7 @@ static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
 static void asus_als_level(struct asus_laptop *asus, int value)
 {
         if (write_acpi_int(asus->handle, METHOD_ALS_LEVEL, value))
-                pr_warning("Error setting light sensor level\n");
+                pr_warn("Error setting light sensor level\n");
         asus->light_level = value;
 }
 
@@ -1020,7 +976,7 @@ static int asus_gps_status(struct asus_laptop *asus)
         rv = acpi_evaluate_integer(asus->handle, METHOD_GPS_STATUS,
                                    NULL, &status);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading GPS status\n");
+                pr_warn("Error reading GPS status\n");
                 return -ENODEV;
         }
         return !!status;
@@ -1065,9 +1021,9 @@ static ssize_t store_gps(struct device *dev, struct device_attribute *attr,
  */
 static int asus_gps_rfkill_set(void *data, bool blocked)
 {
-        acpi_handle handle = data;
+        struct asus_laptop *asus = data;
 
-        return asus_gps_switch(handle, !blocked);
+        return asus_gps_switch(asus, !blocked);
 }
 
 static const struct rfkill_ops asus_gps_rfkill_ops = {
@@ -1094,7 +1050,7 @@ static int asus_rfkill_init(struct asus_laptop *asus)
 
         asus->gps_rfkill = rfkill_alloc("asus-gps", &asus->platform_device->dev,
                                         RFKILL_TYPE_GPS,
-                                        &asus_gps_rfkill_ops, NULL);
+                                        &asus_gps_rfkill_ops, asus);
         if (!asus->gps_rfkill)
                 return -EINVAL;
 
@@ -1130,7 +1086,6 @@ static int asus_input_init(struct asus_laptop *asus)
         input->phys = ASUS_LAPTOP_FILE "/input0";
         input->id.bustype = BUS_HOST;
         input->dev.parent = &asus->platform_device->dev;
-        input_set_drvdata(input, asus);
 
         error = sparse_keymap_setup(input, asus_keymap, NULL);
         if (error) {
@@ -1159,6 +1114,7 @@ static void asus_input_exit(struct asus_laptop *asus)
                 sparse_keymap_free(asus->inputdev);
                 input_unregister_device(asus->inputdev);
         }
+        asus->inputdev = NULL;
 }
 
 /*
@@ -1169,15 +1125,6 @@ static void asus_acpi_notify(struct acpi_device *device, u32 event)
         struct asus_laptop *asus = acpi_driver_data(device);
         u16 count;
 
-        /*
-         * We need to tell the backlight device when the backlight power is
-         * switched
-         */
-        if (event == ATKD_LCD_ON)
-                lcd_blank(asus, FB_BLANK_UNBLANK);
-        else if (event == ATKD_LCD_OFF)
-                lcd_blank(asus, FB_BLANK_POWERDOWN);
-
         /* TODO Find a better way to handle events count. */
         count = asus->event_count[event % 128]++;
         acpi_bus_generate_proc_event(asus->device, event, count);
@@ -1200,111 +1147,111 @@ static void asus_acpi_notify(struct acpi_device *device, u32 event)
 
 static DEVICE_ATTR(infos, S_IRUGO, show_infos, NULL);
 static DEVICE_ATTR(wlan, S_IRUGO | S_IWUSR, show_wlan, store_wlan);
-static DEVICE_ATTR(bluetooth, S_IRUGO | S_IWUSR, show_bluetooth,
-                   store_bluetooth);
-static DEVICE_ATTR(display, S_IRUGO | S_IWUSR, show_disp, store_disp);
+static DEVICE_ATTR(bluetooth, S_IRUGO | S_IWUSR,
+                   show_bluetooth, store_bluetooth);
+static DEVICE_ATTR(wimax, S_IRUGO | S_IWUSR, show_wimax, store_wimax);
+static DEVICE_ATTR(wwan, S_IRUGO | S_IWUSR, show_wwan, store_wwan);
+static DEVICE_ATTR(display, S_IWUSR, NULL, store_disp);
 static DEVICE_ATTR(ledd, S_IRUGO | S_IWUSR, show_ledd, store_ledd);
 static DEVICE_ATTR(ls_level, S_IRUGO | S_IWUSR, show_lslvl, store_lslvl);
 static DEVICE_ATTR(ls_switch, S_IRUGO | S_IWUSR, show_lssw, store_lssw);
 static DEVICE_ATTR(gps, S_IRUGO | S_IWUSR, show_gps, store_gps);
 
-static void asus_sysfs_exit(struct asus_laptop *asus)
-{
-        struct platform_device *device = asus->platform_device;
-
-        device_remove_file(&device->dev, &dev_attr_infos);
-        device_remove_file(&device->dev, &dev_attr_wlan);
-        device_remove_file(&device->dev, &dev_attr_bluetooth);
-        device_remove_file(&device->dev, &dev_attr_display);
-        device_remove_file(&device->dev, &dev_attr_ledd);
-        device_remove_file(&device->dev, &dev_attr_ls_switch);
-        device_remove_file(&device->dev, &dev_attr_ls_level);
-        device_remove_file(&device->dev, &dev_attr_gps);
-}
+static struct attribute *asus_attributes[] = {
+        &dev_attr_infos.attr,
+        &dev_attr_wlan.attr,
+        &dev_attr_bluetooth.attr,
+        &dev_attr_wimax.attr,
+        &dev_attr_wwan.attr,
+        &dev_attr_display.attr,
+        &dev_attr_ledd.attr,
+        &dev_attr_ls_level.attr,
+        &dev_attr_ls_switch.attr,
+        &dev_attr_gps.attr,
+        NULL
+};
 
-static int asus_sysfs_init(struct asus_laptop *asus)
+static mode_t asus_sysfs_is_visible(struct kobject *kobj,
+                                    struct attribute *attr,
+                                    int idx)
 {
-        struct platform_device *device = asus->platform_device;
-        int err;
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct asus_laptop *asus = platform_get_drvdata(pdev);
+        acpi_handle handle = asus->handle;
+        bool supported;
 
-        err = device_create_file(&device->dev, &dev_attr_infos);
-        if (err)
-                return err;
+        if (attr == &dev_attr_wlan.attr) {
+                supported = !acpi_check_handle(handle, METHOD_WLAN, NULL);
 
-        if (!acpi_check_handle(asus->handle, METHOD_WLAN, NULL)) {
-                err = device_create_file(&device->dev, &dev_attr_wlan);
-                if (err)
-                        return err;
-        }
+        } else if (attr == &dev_attr_bluetooth.attr) {
+                supported = !acpi_check_handle(handle, METHOD_BLUETOOTH, NULL);
 
-        if (!acpi_check_handle(asus->handle, METHOD_BLUETOOTH, NULL)) {
-                err = device_create_file(&device->dev, &dev_attr_bluetooth);
-                if (err)
-                        return err;
-        }
+        } else if (attr == &dev_attr_display.attr) {
+                supported = !acpi_check_handle(handle, METHOD_SWITCH_DISPLAY, NULL);
 
-        if (!acpi_check_handle(asus->handle, METHOD_SWITCH_DISPLAY, NULL)) {
-                err = device_create_file(&device->dev, &dev_attr_display);
-                if (err)
-                        return err;
-        }
+        } else if (attr == &dev_attr_wimax.attr) {
+                supported =
+                        !acpi_check_handle(asus->handle, METHOD_WIMAX, NULL);
 
-        if (!acpi_check_handle(asus->handle, METHOD_LEDD, NULL)) {
-                err = device_create_file(&device->dev, &dev_attr_ledd);
-                if (err)
-                        return err;
-        }
+        } else if (attr == &dev_attr_wwan.attr) {
+                supported = !acpi_check_handle(asus->handle, METHOD_WWAN, NULL);
 
-        if (!acpi_check_handle(asus->handle, METHOD_ALS_CONTROL, NULL) &&
-            !acpi_check_handle(asus->handle, METHOD_ALS_LEVEL, NULL)) {
-                err = device_create_file(&device->dev, &dev_attr_ls_switch);
-                if (err)
-                        return err;
-                err = device_create_file(&device->dev, &dev_attr_ls_level);
-                if (err)
-                        return err;
-        }
+        } else if (attr == &dev_attr_ledd.attr) {
+                supported = !acpi_check_handle(handle, METHOD_LEDD, NULL);
+
+        } else if (attr == &dev_attr_ls_switch.attr ||
+                   attr == &dev_attr_ls_level.attr) {
+                supported = !acpi_check_handle(handle, METHOD_ALS_CONTROL, NULL) &&
+                            !acpi_check_handle(handle, METHOD_ALS_LEVEL, NULL);
 
-        if (!acpi_check_handle(asus->handle, METHOD_GPS_ON, NULL) &&
-            !acpi_check_handle(asus->handle, METHOD_GPS_OFF, NULL) &&
-            !acpi_check_handle(asus->handle, METHOD_GPS_STATUS, NULL)) {
-                err = device_create_file(&device->dev, &dev_attr_gps);
-                if (err)
-                        return err;
+        } else if (attr == &dev_attr_gps.attr) {
+                supported = !acpi_check_handle(handle, METHOD_GPS_ON, NULL) &&
+                            !acpi_check_handle(handle, METHOD_GPS_OFF, NULL) &&
+                            !acpi_check_handle(handle, METHOD_GPS_STATUS, NULL);
+        } else {
+                supported = true;
         }
 
-        return err;
+        return supported ? attr->mode : 0;
 }
 
+
+static const struct attribute_group asus_attr_group = {
+        .is_visible     = asus_sysfs_is_visible,
+        .attrs          = asus_attributes,
+};
+
 static int asus_platform_init(struct asus_laptop *asus)
 {
-        int err;
+        int result;
 
         asus->platform_device = platform_device_alloc(ASUS_LAPTOP_FILE, -1);
         if (!asus->platform_device)
                 return -ENOMEM;
         platform_set_drvdata(asus->platform_device, asus);
 
-        err = platform_device_add(asus->platform_device);
-        if (err)
+        result = platform_device_add(asus->platform_device);
+        if (result)
                 goto fail_platform_device;
 
-        err = asus_sysfs_init(asus);
-        if (err)
+        result = sysfs_create_group(&asus->platform_device->dev.kobj,
+                                    &asus_attr_group);
+        if (result)
                 goto fail_sysfs;
+
         return 0;
 
 fail_sysfs:
-        asus_sysfs_exit(asus);
         platform_device_del(asus->platform_device);
 fail_platform_device:
         platform_device_put(asus->platform_device);
-        return err;
+        return result;
 }
 
 static void asus_platform_exit(struct asus_laptop *asus)
 {
-        asus_sysfs_exit(asus);
+        sysfs_remove_group(&asus->platform_device->dev.kobj, &asus_attr_group);
         platform_device_unregister(asus->platform_device);
 }
 
@@ -1315,26 +1262,6 @@ static struct platform_driver platform_driver = {
         }
 };
 
-static int asus_handle_init(char *name, acpi_handle * handle,
-                            char **paths, int num_paths)
-{
-        int i;
-        acpi_status status;
-
-        for (i = 0; i < num_paths; i++) {
-                status = acpi_get_handle(NULL, paths[i], handle);
-                if (ACPI_SUCCESS(status))
-                        return 0;
-        }
-
-        *handle = NULL;
-        return -ENODEV;
-}
-
-#define ASUS_HANDLE_INIT(object)                                        \
-        asus_handle_init(#object, &object##_handle, object##_paths,     \
-                         ARRAY_SIZE(object##_paths))
-
 /*
  * This function is used to initialize the context with right values. In this
  * method, we can make all the detection we want, and modify the asus_laptop
@@ -1357,7 +1284,7 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
          */
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus->dsdt_info);
         if (ACPI_FAILURE(status))
-                pr_warning("Couldn't get the DSDT table header\n");
+                pr_warn("Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
         if (write_acpi_int_ret(asus->handle, "INIT", 0, &buffer)) {
@@ -1369,7 +1296,7 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
         status =
             acpi_evaluate_integer(asus->handle, "BSTS", NULL, &bsts_result);
         if (ACPI_FAILURE(status))
-                pr_warning("Error calling BSTS\n");
+                pr_warn("Error calling BSTS\n");
         else if (bsts_result)
                 pr_notice("BSTS called, 0x%02x returned\n",
                        (uint) bsts_result);
@@ -1408,7 +1335,8 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
 
         /*
          * The HWRS method return informations about the hardware.
-         * 0x80 bit is for WLAN, 0x100 for Bluetooth.
+         * 0x80 bit is for WLAN, 0x100 for Bluetooth,
+         * 0x40 for WWAN, 0x10 for WIMAX.
          * The significance of others is yet to be found.
          */
         status =
@@ -1419,17 +1347,11 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
         if (!acpi_check_handle(asus->handle, METHOD_WL_STATUS, NULL))
                 asus->have_rsts = true;
 
-        /* Scheduled for removal */
-        ASUS_HANDLE_INIT(lcd_switch);
-        ASUS_HANDLE_INIT(display_get);
-
         kfree(model);
 
         return AE_OK;
 }
 
-static bool asus_device_present;
-
 static int __devinit asus_acpi_init(struct asus_laptop *asus)
 {
         int result = 0;
@@ -1453,6 +1375,12 @@ static int __devinit asus_acpi_init(struct asus_laptop *asus)
         if (wlan_status >= 0)
                 asus_wlan_set(asus, !!wlan_status);
 
+        if (wimax_status >= 0)
+                asus_wimax_set(asus, !!wimax_status);
+
+        if (wwan_status >= 0)
+                asus_wwan_set(asus, !!wwan_status);
+
         /* Keyboard Backlight is on by default */
         if (!acpi_check_handle(asus->handle, METHOD_KBD_LIGHT_SET, NULL))
                 asus_kled_set(asus, 1);
@@ -1470,10 +1398,25 @@ static int __devinit asus_acpi_init(struct asus_laptop *asus)
                 asus_als_level(asus, asus->light_level);
         }
 
-        asus->lcd_state = 1; /* LCD should be on when the module load */
         return result;
 }
 
+static void __devinit asus_dmi_check(void)
+{
+        const char *model;
+
+        model = dmi_get_system_info(DMI_PRODUCT_NAME);
+        if (!model)
+                return;
+
+        /* On L1400B WLED control the sound card, don't mess with it ... */
+        if (strncmp(model, "L1400B", 6) == 0) {
+                wlan_status = -1;
+        }
+}
+
+static bool asus_device_present;
+
 static int __devinit asus_acpi_add(struct acpi_device *device)
 {
         struct asus_laptop *asus;
@@ -1490,6 +1433,8 @@ static int __devinit asus_acpi_add(struct acpi_device *device)
         device->driver_data = asus;
         asus->device = device;
 
+        asus_dmi_check();
+
         result = asus_acpi_init(asus);
         if (result)
                 goto fail_platform;
diff --git a/drivers/platform/x86/asus-nb-wmi.c b/drivers/platform/x86/asus-nb-wmi.c
new file mode 100644
index 000000000000..0580d99b0798
--- /dev/null
+++ b/drivers/platform/x86/asus-nb-wmi.c
@@ -0,0 +1,98 @@
+/*
+ * Asus Notebooks WMI hotkey driver
+ *
+ * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+
+#include "asus-wmi.h"
+
+#define ASUS_NB_WMI_FILE        "asus-nb-wmi"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
+MODULE_DESCRIPTION("Asus Notebooks WMI Hotkey Driver");
+MODULE_LICENSE("GPL");
+
+#define ASUS_NB_WMI_EVENT_GUID  "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
+
+MODULE_ALIAS("wmi:"ASUS_NB_WMI_EVENT_GUID);
+
+static const struct key_entry asus_nb_wmi_keymap[] = {
+        { KE_KEY, 0x30, { KEY_VOLUMEUP } },
+        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 0x32, { KEY_MUTE } },
+        { KE_KEY, 0x33, { KEY_DISPLAYTOGGLE } }, /* LCD on */
+        { KE_KEY, 0x34, { KEY_DISPLAY_OFF } }, /* LCD off */
+        { KE_KEY, 0x40, { KEY_PREVIOUSSONG } },
+        { KE_KEY, 0x41, { KEY_NEXTSONG } },
+        { KE_KEY, 0x43, { KEY_STOPCD } },
+        { KE_KEY, 0x45, { KEY_PLAYPAUSE } },
+        { KE_KEY, 0x4c, { KEY_MEDIA } },
+        { KE_KEY, 0x50, { KEY_EMAIL } },
+        { KE_KEY, 0x51, { KEY_WWW } },
+        { KE_KEY, 0x55, { KEY_CALC } },
+        { KE_KEY, 0x5C, { KEY_F15 } },  /* Power Gear key */
+        { KE_KEY, 0x5D, { KEY_WLAN } },
+        { KE_KEY, 0x5E, { KEY_WLAN } },
+        { KE_KEY, 0x5F, { KEY_WLAN } },
+        { KE_KEY, 0x60, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x61, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x62, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x63, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x6B, { KEY_TOUCHPAD_TOGGLE } },
+        { KE_KEY, 0x7E, { KEY_BLUETOOTH } },
+        { KE_KEY, 0x7D, { KEY_BLUETOOTH } },
+        { KE_KEY, 0x82, { KEY_CAMERA } },
+        { KE_KEY, 0x88, { KEY_RFKILL  } },
+        { KE_KEY, 0x8A, { KEY_PROG1 } },
+        { KE_KEY, 0x95, { KEY_MEDIA } },
+        { KE_KEY, 0x99, { KEY_PHONE } },
+        { KE_KEY, 0xb5, { KEY_CALC } },
+        { KE_KEY, 0xc4, { KEY_KBDILLUMUP } },
+        { KE_KEY, 0xc5, { KEY_KBDILLUMDOWN } },
+        { KE_END, 0},
+};
+
+static struct asus_wmi_driver asus_nb_wmi_driver = {
+        .name = ASUS_NB_WMI_FILE,
+        .owner = THIS_MODULE,
+        .event_guid = ASUS_NB_WMI_EVENT_GUID,
+        .keymap = asus_nb_wmi_keymap,
+        .input_name = "Asus WMI hotkeys",
+        .input_phys = ASUS_NB_WMI_FILE "/input0",
+};
+
+
+static int __init asus_nb_wmi_init(void)
+{
+        return asus_wmi_register_driver(&asus_nb_wmi_driver);
+}
+
+static void __exit asus_nb_wmi_exit(void)
+{
+        asus_wmi_unregister_driver(&asus_nb_wmi_driver);
+}
+
+module_init(asus_nb_wmi_init);
+module_exit(asus_nb_wmi_exit);
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
new file mode 100644
index 000000000000..3c7857c71a23
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.c
@@ -0,0 +1,1657 @@
+/*
+ * Asus PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/leds.h>
+#include <linux/rfkill.h>
+#include <linux/pci.h>
+#include <linux/pci_hotplug.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/platform_device.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#include "asus-wmi.h"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
+              "Yong Wang <yong.y.wang@intel.com>");
+MODULE_DESCRIPTION("Asus Generic WMI Driver");
+MODULE_LICENSE("GPL");
+
+#define to_platform_driver(drv)                                 \
+        (container_of((drv), struct platform_driver, driver))
+
+#define to_asus_wmi_driver(pdrv)                                        \
+        (container_of((pdrv), struct asus_wmi_driver, platform_driver))
+
+#define ASUS_WMI_MGMT_GUID      "97845ED0-4E6D-11DE-8A39-0800200C9A66"
+
+#define NOTIFY_BRNUP_MIN                0x11
+#define NOTIFY_BRNUP_MAX                0x1f
+#define NOTIFY_BRNDOWN_MIN              0x20
+#define NOTIFY_BRNDOWN_MAX              0x2e
+
+/* WMI Methods */
+#define ASUS_WMI_METHODID_SPEC          0x43455053 /* BIOS SPECification */
+#define ASUS_WMI_METHODID_SFBD          0x44424653 /* Set First Boot Device */
+#define ASUS_WMI_METHODID_GLCD          0x44434C47 /* Get LCD status */
+#define ASUS_WMI_METHODID_GPID          0x44495047 /* Get Panel ID?? (Resol) */
+#define ASUS_WMI_METHODID_QMOD          0x444F4D51 /* Quiet MODe */
+#define ASUS_WMI_METHODID_SPLV          0x4C425053 /* Set Panel Light Value */
+#define ASUS_WMI_METHODID_SFUN          0x4E554653 /* FUNCtionalities */
+#define ASUS_WMI_METHODID_SDSP          0x50534453 /* Set DiSPlay output */
+#define ASUS_WMI_METHODID_GDSP          0x50534447 /* Get DiSPlay output */
+#define ASUS_WMI_METHODID_DEVP          0x50564544 /* DEVice Policy */
+#define ASUS_WMI_METHODID_OSVR          0x5256534F /* OS VeRsion */
+#define ASUS_WMI_METHODID_DSTS          0x53544344 /* Device STatuS */
+#define ASUS_WMI_METHODID_DSTS2         0x53545344 /* Device STatuS #2*/
+#define ASUS_WMI_METHODID_BSTS          0x53545342 /* Bios STatuS ? */
+#define ASUS_WMI_METHODID_DEVS          0x53564544 /* DEVice Set */
+#define ASUS_WMI_METHODID_CFVS          0x53564643 /* CPU Frequency Volt Set */
+#define ASUS_WMI_METHODID_KBFT          0x5446424B /* KeyBoard FilTer */
+#define ASUS_WMI_METHODID_INIT          0x54494E49 /* INITialize */
+#define ASUS_WMI_METHODID_HKEY          0x59454B48 /* Hot KEY ?? */
+
+#define ASUS_WMI_UNSUPPORTED_METHOD     0xFFFFFFFE
+
+/* Wireless */
+#define ASUS_WMI_DEVID_HW_SWITCH        0x00010001
+#define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
+#define ASUS_WMI_DEVID_WLAN             0x00010011
+#define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
+#define ASUS_WMI_DEVID_GPS              0x00010015
+#define ASUS_WMI_DEVID_WIMAX            0x00010017
+#define ASUS_WMI_DEVID_WWAN3G           0x00010019
+#define ASUS_WMI_DEVID_UWB              0x00010021
+
+/* Leds */
+/* 0x000200XX and 0x000400XX */
+
+/* Backlight and Brightness */
+#define ASUS_WMI_DEVID_BACKLIGHT        0x00050011
+#define ASUS_WMI_DEVID_BRIGHTNESS       0x00050012
+#define ASUS_WMI_DEVID_KBD_BACKLIGHT    0x00050021
+#define ASUS_WMI_DEVID_LIGHT_SENSOR     0x00050022 /* ?? */
+
+/* Misc */
+#define ASUS_WMI_DEVID_CAMERA           0x00060013
+
+/* Storage */
+#define ASUS_WMI_DEVID_CARDREADER       0x00080013
+
+/* Input */
+#define ASUS_WMI_DEVID_TOUCHPAD         0x00100011
+#define ASUS_WMI_DEVID_TOUCHPAD_LED     0x00100012
+
+/* Fan, Thermal */
+#define ASUS_WMI_DEVID_THERMAL_CTRL     0x00110011
+#define ASUS_WMI_DEVID_FAN_CTRL         0x00110012
+
+/* Power */
+#define ASUS_WMI_DEVID_PROCESSOR_STATE  0x00120012
+
+/* DSTS masks */
+#define ASUS_WMI_DSTS_STATUS_BIT        0x00000001
+#define ASUS_WMI_DSTS_UNKNOWN_BIT       0x00000002
+#define ASUS_WMI_DSTS_PRESENCE_BIT      0x00010000
+#define ASUS_WMI_DSTS_USER_BIT          0x00020000
+#define ASUS_WMI_DSTS_BIOS_BIT          0x00040000
+#define ASUS_WMI_DSTS_BRIGHTNESS_MASK   0x000000FF
+#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK   0x0000FF00
+
+struct bios_args {
+        u32 arg0;
+        u32 arg1;
+} __packed;
+
+/*
+ * <platform>/    - debugfs root directory
+ *   dev_id      - current dev_id
+ *   ctrl_param  - current ctrl_param
+ *   method_id   - current method_id
+ *   devs        - call DEVS(dev_id, ctrl_param) and print result
+ *   dsts        - call DSTS(dev_id)  and print result
+ *   call        - call method_id(dev_id, ctrl_param) and print result
+ */
+struct asus_wmi_debug {
+        struct dentry *root;
+        u32 method_id;
+        u32 dev_id;
+        u32 ctrl_param;
+};
+
+struct asus_rfkill {
+        struct asus_wmi *asus;
+        struct rfkill *rfkill;
+        u32 dev_id;
+};
+
+struct asus_wmi {
+        int dsts_id;
+        int spec;
+        int sfun;
+
+        struct input_dev *inputdev;
+        struct backlight_device *backlight_device;
+        struct device *hwmon_device;
+        struct platform_device *platform_device;
+
+        struct led_classdev tpd_led;
+        int tpd_led_wk;
+        struct workqueue_struct *led_workqueue;
+        struct work_struct tpd_led_work;
+
+        struct asus_rfkill wlan;
+        struct asus_rfkill bluetooth;
+        struct asus_rfkill wimax;
+        struct asus_rfkill wwan3g;
+
+        struct hotplug_slot *hotplug_slot;
+        struct mutex hotplug_lock;
+        struct mutex wmi_lock;
+        struct workqueue_struct *hotplug_workqueue;
+        struct work_struct hotplug_work;
+
+        struct asus_wmi_debug debug;
+
+        struct asus_wmi_driver *driver;
+};
+
+static int asus_wmi_input_init(struct asus_wmi *asus)
+{
+        int err;
+
+        asus->inputdev = input_allocate_device();
+        if (!asus->inputdev)
+                return -ENOMEM;
+
+        asus->inputdev->name = asus->driver->input_name;
+        asus->inputdev->phys = asus->driver->input_phys;
+        asus->inputdev->id.bustype = BUS_HOST;
+        asus->inputdev->dev.parent = &asus->platform_device->dev;
+
+        err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
+        if (err)
+                goto err_free_dev;
+
+        err = input_register_device(asus->inputdev);
+        if (err)
+                goto err_free_keymap;
+
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(asus->inputdev);
+err_free_dev:
+        input_free_device(asus->inputdev);
+        return err;
+}
+
+static void asus_wmi_input_exit(struct asus_wmi *asus)
+{
+        if (asus->inputdev) {
+                sparse_keymap_free(asus->inputdev);
+                input_unregister_device(asus->inputdev);
+        }
+
+        asus->inputdev = NULL;
+}
+
+static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
+                                    u32 *retval)
+{
+        struct bios_args args = {
+                .arg0 = arg0,
+                .arg1 = arg1,
+        };
+        struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        acpi_status status;
+        union acpi_object *obj;
+        u32 tmp;
+
+        status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
+                                     &input, &output);
+
+        if (ACPI_FAILURE(status))
+                goto exit;
+
+        obj = (union acpi_object *)output.pointer;
+        if (obj && obj->type == ACPI_TYPE_INTEGER)
+                tmp = (u32) obj->integer.value;
+        else
+                tmp = 0;
+
+        if (retval)
+                *retval = tmp;
+
+        kfree(obj);
+
+exit:
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
+                return -ENODEV;
+
+        return 0;
+}
+
+static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
+{
+        return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
+}
+
+static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
+                                 u32 *retval)
+{
+        return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
+                                        ctrl_param, retval);
+}
+
+/* Helper for special devices with magic return codes */
+static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
+                                      u32 dev_id, u32 mask)
+{
+        u32 retval = 0;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, dev_id, &retval);
+
+        if (err < 0)
+                return err;
+
+        if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
+                return -ENODEV;
+
+        if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
+                if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
+                        return -ENODEV;
+        }
+
+        return retval & mask;
+}
+
+static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
+{
+        return asus_wmi_get_devstate_bits(asus, dev_id,
+                                          ASUS_WMI_DSTS_STATUS_BIT);
+}
+
+/*
+ * 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)
+{
+        int ctrl_param;
+        struct asus_wmi *asus;
+
+        asus = container_of(work, struct asus_wmi, tpd_led_work);
+
+        ctrl_param = asus->tpd_led_wk;
+        asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
+}
+
+static void tpd_led_set(struct led_classdev *led_cdev,
+                        enum led_brightness value)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(led_cdev, struct asus_wmi, tpd_led);
+
+        asus->tpd_led_wk = !!value;
+        queue_work(asus->led_workqueue, &asus->tpd_led_work);
+}
+
+static int read_tpd_led_state(struct asus_wmi *asus)
+{
+        return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
+}
+
+static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(led_cdev, struct asus_wmi, tpd_led);
+
+        return read_tpd_led_state(asus);
+}
+
+static int asus_wmi_led_init(struct asus_wmi *asus)
+{
+        int rv;
+
+        if (read_tpd_led_state(asus) < 0)
+                return 0;
+
+        asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
+        if (!asus->led_workqueue)
+                return -ENOMEM;
+        INIT_WORK(&asus->tpd_led_work, tpd_led_update);
+
+        asus->tpd_led.name = "asus::touchpad";
+        asus->tpd_led.brightness_set = tpd_led_set;
+        asus->tpd_led.brightness_get = tpd_led_get;
+        asus->tpd_led.max_brightness = 1;
+
+        rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
+        if (rv) {
+                destroy_workqueue(asus->led_workqueue);
+                return rv;
+        }
+
+        return 0;
+}
+
+static void asus_wmi_led_exit(struct asus_wmi *asus)
+{
+        if (asus->tpd_led.dev)
+                led_classdev_unregister(&asus->tpd_led);
+        if (asus->led_workqueue)
+                destroy_workqueue(asus->led_workqueue);
+}
+
+/*
+ * PCI hotplug (for wlan rfkill)
+ */
+static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
+{
+        int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+
+        if (result < 0)
+                return false;
+        return !result;
+}
+
+static void asus_rfkill_hotplug(struct asus_wmi *asus)
+{
+        struct pci_dev *dev;
+        struct pci_bus *bus;
+        bool blocked;
+        bool absent;
+        u32 l;
+
+        mutex_lock(&asus->wmi_lock);
+        blocked = asus_wlan_rfkill_blocked(asus);
+        mutex_unlock(&asus->wmi_lock);
+
+        mutex_lock(&asus->hotplug_lock);
+
+        if (asus->wlan.rfkill)
+                rfkill_set_sw_state(asus->wlan.rfkill, blocked);
+
+        if (asus->hotplug_slot) {
+                bus = pci_find_bus(0, 1);
+                if (!bus) {
+                        pr_warn("Unable to find PCI bus 1?\n");
+                        goto out_unlock;
+                }
+
+                if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
+                        pr_err("Unable to read PCI config space?\n");
+                        goto out_unlock;
+                }
+                absent = (l == 0xffffffff);
+
+                if (blocked != absent) {
+                        pr_warn("BIOS says wireless lan is %s, "
+                                "but the pci device is %s\n",
+                                blocked ? "blocked" : "unblocked",
+                                absent ? "absent" : "present");
+                        pr_warn("skipped wireless hotplug as probably "
+                                "inappropriate for this model\n");
+                        goto out_unlock;
+                }
+
+                if (!blocked) {
+                        dev = pci_get_slot(bus, 0);
+                        if (dev) {
+                                /* Device already present */
+                                pci_dev_put(dev);
+                                goto out_unlock;
+                        }
+                        dev = pci_scan_single_device(bus, 0);
+                        if (dev) {
+                                pci_bus_assign_resources(bus);
+                                if (pci_bus_add_device(dev))
+                                        pr_err("Unable to hotplug wifi\n");
+                        }
+                } else {
+                        dev = pci_get_slot(bus, 0);
+                        if (dev) {
+                                pci_remove_bus_device(dev);
+                                pci_dev_put(dev);
+                        }
+                }
+        }
+
+out_unlock:
+        mutex_unlock(&asus->hotplug_lock);
+}
+
+static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct asus_wmi *asus = data;
+
+        if (event != ACPI_NOTIFY_BUS_CHECK)
+                return;
+
+        /*
+         * We can't call directly asus_rfkill_hotplug because most
+         * of the time WMBC is still being executed and not reetrant.
+         * There is currently no way to tell ACPICA that  we want this
+         * method to be serialized, we schedule a asus_rfkill_hotplug
+         * call later, in a safer context.
+         */
+        queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
+}
+
+static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
+{
+        acpi_status status;
+        acpi_handle handle;
+
+        status = acpi_get_handle(NULL, node, &handle);
+
+        if (ACPI_SUCCESS(status)) {
+                status = acpi_install_notify_handler(handle,
+                                                     ACPI_SYSTEM_NOTIFY,
+                                                     asus_rfkill_notify, asus);
+                if (ACPI_FAILURE(status))
+                        pr_warn("Failed to register notify on %s\n", node);
+        } else
+                return -ENODEV;
+
+        return 0;
+}
+
+static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
+{
+        acpi_status status = AE_OK;
+        acpi_handle handle;
+
+        status = acpi_get_handle(NULL, node, &handle);
+
+        if (ACPI_SUCCESS(status)) {
+                status = acpi_remove_notify_handler(handle,
+                                                    ACPI_SYSTEM_NOTIFY,
+                                                    asus_rfkill_notify);
+                if (ACPI_FAILURE(status))
+                        pr_err("Error removing rfkill notify handler %s\n",
+                               node);
+        }
+}
+
+static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
+                                   u8 *value)
+{
+        struct asus_wmi *asus = hotplug_slot->private;
+        int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+
+        if (result < 0)
+                return result;
+
+        *value = !!result;
+        return 0;
+}
+
+static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
+{
+        kfree(hotplug_slot->info);
+        kfree(hotplug_slot);
+}
+
+static struct hotplug_slot_ops asus_hotplug_slot_ops = {
+        .owner = THIS_MODULE,
+        .get_adapter_status = asus_get_adapter_status,
+        .get_power_status = asus_get_adapter_status,
+};
+
+static void asus_hotplug_work(struct work_struct *work)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(work, struct asus_wmi, hotplug_work);
+        asus_rfkill_hotplug(asus);
+}
+
+static int asus_setup_pci_hotplug(struct asus_wmi *asus)
+{
+        int ret = -ENOMEM;
+        struct pci_bus *bus = pci_find_bus(0, 1);
+
+        if (!bus) {
+                pr_err("Unable to find wifi PCI bus\n");
+                return -ENODEV;
+        }
+
+        asus->hotplug_workqueue =
+            create_singlethread_workqueue("hotplug_workqueue");
+        if (!asus->hotplug_workqueue)
+                goto error_workqueue;
+
+        INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
+
+        asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+        if (!asus->hotplug_slot)
+                goto error_slot;
+
+        asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+                                           GFP_KERNEL);
+        if (!asus->hotplug_slot->info)
+                goto error_info;
+
+        asus->hotplug_slot->private = asus;
+        asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
+        asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
+        asus_get_adapter_status(asus->hotplug_slot,
+                                &asus->hotplug_slot->info->adapter_status);
+
+        ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
+        if (ret) {
+                pr_err("Unable to register hotplug slot - %d\n", ret);
+                goto error_register;
+        }
+
+        return 0;
+
+error_register:
+        kfree(asus->hotplug_slot->info);
+error_info:
+        kfree(asus->hotplug_slot);
+        asus->hotplug_slot = NULL;
+error_slot:
+        destroy_workqueue(asus->hotplug_workqueue);
+error_workqueue:
+        return ret;
+}
+
+/*
+ * Rfkill devices
+ */
+static int asus_rfkill_set(void *data, bool blocked)
+{
+        struct asus_rfkill *priv = data;
+        u32 ctrl_param = !blocked;
+
+        return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
+}
+
+static void asus_rfkill_query(struct rfkill *rfkill, void *data)
+{
+        struct asus_rfkill *priv = data;
+        int result;
+
+        result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
+
+        if (result < 0)
+                return;
+
+        rfkill_set_sw_state(priv->rfkill, !result);
+}
+
+static int asus_rfkill_wlan_set(void *data, bool blocked)
+{
+        struct asus_rfkill *priv = data;
+        struct asus_wmi *asus = priv->asus;
+        int ret;
+
+        /*
+         * This handler is enabled only if hotplug is enabled.
+         * In this case, the asus_wmi_set_devstate() will
+         * trigger a wmi notification and we need to wait
+         * this call to finish before being able to call
+         * any wmi method
+         */
+        mutex_lock(&asus->wmi_lock);
+        ret = asus_rfkill_set(data, blocked);
+        mutex_unlock(&asus->wmi_lock);
+        return ret;
+}
+
+static const struct rfkill_ops asus_rfkill_wlan_ops = {
+        .set_block = asus_rfkill_wlan_set,
+        .query = asus_rfkill_query,
+};
+
+static const struct rfkill_ops asus_rfkill_ops = {
+        .set_block = asus_rfkill_set,
+        .query = asus_rfkill_query,
+};
+
+static int asus_new_rfkill(struct asus_wmi *asus,
+                           struct asus_rfkill *arfkill,
+                           const char *name, enum rfkill_type type, int dev_id)
+{
+        int result = asus_wmi_get_devstate_simple(asus, dev_id);
+        struct rfkill **rfkill = &arfkill->rfkill;
+
+        if (result < 0)
+                return result;
+
+        arfkill->dev_id = dev_id;
+        arfkill->asus = asus;
+
+        if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
+                *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+                                       &asus_rfkill_wlan_ops, arfkill);
+        else
+                *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+                                       &asus_rfkill_ops, arfkill);
+
+        if (!*rfkill)
+                return -EINVAL;
+
+        rfkill_init_sw_state(*rfkill, !result);
+        result = rfkill_register(*rfkill);
+        if (result) {
+                rfkill_destroy(*rfkill);
+                *rfkill = NULL;
+                return result;
+        }
+        return 0;
+}
+
+static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
+{
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
+        if (asus->wlan.rfkill) {
+                rfkill_unregister(asus->wlan.rfkill);
+                rfkill_destroy(asus->wlan.rfkill);
+                asus->wlan.rfkill = NULL;
+        }
+        /*
+         * Refresh pci hotplug in case the rfkill state was changed after
+         * asus_unregister_rfkill_notifier()
+         */
+        asus_rfkill_hotplug(asus);
+        if (asus->hotplug_slot)
+                pci_hp_deregister(asus->hotplug_slot);
+        if (asus->hotplug_workqueue)
+                destroy_workqueue(asus->hotplug_workqueue);
+
+        if (asus->bluetooth.rfkill) {
+                rfkill_unregister(asus->bluetooth.rfkill);
+                rfkill_destroy(asus->bluetooth.rfkill);
+                asus->bluetooth.rfkill = NULL;
+        }
+        if (asus->wimax.rfkill) {
+                rfkill_unregister(asus->wimax.rfkill);
+                rfkill_destroy(asus->wimax.rfkill);
+                asus->wimax.rfkill = NULL;
+        }
+        if (asus->wwan3g.rfkill) {
+                rfkill_unregister(asus->wwan3g.rfkill);
+                rfkill_destroy(asus->wwan3g.rfkill);
+                asus->wwan3g.rfkill = NULL;
+        }
+}
+
+static int asus_wmi_rfkill_init(struct asus_wmi *asus)
+{
+        int result = 0;
+
+        mutex_init(&asus->hotplug_lock);
+        mutex_init(&asus->wmi_lock);
+
+        result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
+                                 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->bluetooth,
+                                 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
+                                 ASUS_WMI_DEVID_BLUETOOTH);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
+                                 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
+                                 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        if (!asus->driver->hotplug_wireless)
+                goto exit;
+
+        result = asus_setup_pci_hotplug(asus);
+        /*
+         * If we get -EBUSY then something else is handling the PCI hotplug -
+         * don't fail in this case
+         */
+        if (result == -EBUSY)
+                result = 0;
+
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
+        /*
+         * Refresh pci hotplug in case the rfkill state was changed during
+         * setup.
+         */
+        asus_rfkill_hotplug(asus);
+
+exit:
+        if (result && result != -ENODEV)
+                asus_wmi_rfkill_exit(asus);
+
+        if (result == -ENODEV)
+                result = 0;
+
+        return result;
+}
+
+/*
+ * Hwmon device
+ */
+static ssize_t asus_hwmon_pwm1(struct device *dev,
+                            struct device_attribute *attr,
+                            char *buf)
+{
+        struct asus_wmi *asus = dev_get_drvdata(dev);
+        u32 value;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
+
+        if (err < 0)
+                return err;
+
+        value |= 0xFF;
+
+        if (value == 1) /* Low Speed */
+                value = 85;
+        else if (value == 2)
+                value = 170;
+        else if (value == 3)
+                value = 255;
+        else if (value != 0) {
+                pr_err("Unknown fan speed %#x", value);
+                value = -1;
+        }
+
+        return sprintf(buf, "%d\n", value);
+}
+
+static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
+
+static ssize_t
+show_name(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "asus\n");
+}
+static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
+
+static struct attribute *hwmon_attributes[] = {
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_name.dev_attr.attr,
+        NULL
+};
+
+static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
+                                    struct attribute *attr, int idx)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev->parent);
+        struct asus_wmi *asus = platform_get_drvdata(pdev);
+        bool ok = true;
+        int dev_id = -1;
+        u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
+
+        if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
+                dev_id = ASUS_WMI_DEVID_FAN_CTRL;
+
+        if (dev_id != -1) {
+                int err = asus_wmi_get_devstate(asus, dev_id, &value);
+
+                if (err < 0)
+                        return err;
+        }
+
+        if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
+                /*
+                 * We need to find a better way, probably using sfun,
+                 * bits or spec ...
+                 * Currently we disable it if:
+                 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
+                 * - reverved bits are non-zero
+                 * - sfun and presence bit are not set
+                 */
+                if (value != ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
+                    || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
+                        ok = false;
+        }
+
+        return ok ? attr->mode : 0;
+}
+
+static struct attribute_group hwmon_attribute_group = {
+        .is_visible = asus_hwmon_sysfs_is_visible,
+        .attrs = hwmon_attributes
+};
+
+static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
+{
+        struct device *hwmon;
+
+        hwmon = asus->hwmon_device;
+        if (!hwmon)
+                return;
+        sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
+        hwmon_device_unregister(hwmon);
+        asus->hwmon_device = NULL;
+}
+
+static int asus_wmi_hwmon_init(struct asus_wmi *asus)
+{
+        struct device *hwmon;
+        int result;
+
+        hwmon = hwmon_device_register(&asus->platform_device->dev);
+        if (IS_ERR(hwmon)) {
+                pr_err("Could not register asus hwmon device\n");
+                return PTR_ERR(hwmon);
+        }
+        asus->hwmon_device = hwmon;
+        result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
+        if (result)
+                asus_wmi_hwmon_exit(asus);
+        return result;
+}
+
+/*
+ * Backlight
+ */
+static int read_backlight_power(struct asus_wmi *asus)
+{
+        int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
+
+        if (ret < 0)
+                return ret;
+
+        return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
+}
+
+static int read_brightness_max(struct asus_wmi *asus)
+{
+        u32 retval;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+
+        if (err < 0)
+                return err;
+
+        retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
+        retval >>= 8;
+
+        if (!retval)
+                return -ENODEV;
+
+        return retval;
+}
+
+static int read_brightness(struct backlight_device *bd)
+{
+        struct asus_wmi *asus = bl_get_data(bd);
+        u32 retval;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+
+        if (err < 0)
+                return err;
+
+        return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
+}
+
+static int update_bl_status(struct backlight_device *bd)
+{
+        struct asus_wmi *asus = bl_get_data(bd);
+        u32 ctrl_param;
+        int power, err;
+
+        ctrl_param = bd->props.brightness;
+
+        err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
+                                    ctrl_param, NULL);
+
+        if (err < 0)
+                return err;
+
+        power = read_backlight_power(asus);
+        if (power != -ENODEV && bd->props.power != power) {
+                ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
+                err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
+                                            ctrl_param, NULL);
+        }
+        return err;
+}
+
+static const struct backlight_ops asus_wmi_bl_ops = {
+        .get_brightness = read_brightness,
+        .update_status = update_bl_status,
+};
+
+static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
+{
+        struct backlight_device *bd = asus->backlight_device;
+        int old = bd->props.brightness;
+        int new = old;
+
+        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+                new = code - NOTIFY_BRNUP_MIN + 1;
+        else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
+                new = code - NOTIFY_BRNDOWN_MIN;
+
+        bd->props.brightness = new;
+        backlight_update_status(bd);
+        backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
+
+        return old;
+}
+
+static int asus_wmi_backlight_init(struct asus_wmi *asus)
+{
+        struct backlight_device *bd;
+        struct backlight_properties props;
+        int max;
+        int power;
+
+        max = read_brightness_max(asus);
+
+        if (max == -ENODEV)
+                max = 0;
+        else if (max < 0)
+                return max;
+
+        power = read_backlight_power(asus);
+
+        if (power == -ENODEV)
+                power = FB_BLANK_UNBLANK;
+        else if (power < 0)
+                return power;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = max;
+        bd = backlight_device_register(asus->driver->name,
+                                       &asus->platform_device->dev, asus,
+                                       &asus_wmi_bl_ops, &props);
+        if (IS_ERR(bd)) {
+                pr_err("Could not register backlight device\n");
+                return PTR_ERR(bd);
+        }
+
+        asus->backlight_device = bd;
+
+        bd->props.brightness = read_brightness(bd);
+        bd->props.power = power;
+        backlight_update_status(bd);
+
+        return 0;
+}
+
+static void asus_wmi_backlight_exit(struct asus_wmi *asus)
+{
+        if (asus->backlight_device)
+                backlight_device_unregister(asus->backlight_device);
+
+        asus->backlight_device = NULL;
+}
+
+static void asus_wmi_notify(u32 value, void *context)
+{
+        struct asus_wmi *asus = context;
+        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+        int code;
+        int orig_code;
+
+        status = wmi_get_event_data(value, &response);
+        if (status != AE_OK) {
+                pr_err("bad event status 0x%x\n", status);
+                return;
+        }
+
+        obj = (union acpi_object *)response.pointer;
+
+        if (!obj || obj->type != ACPI_TYPE_INTEGER)
+                goto exit;
+
+        code = obj->integer.value;
+        orig_code = code;
+
+        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+                code = NOTIFY_BRNUP_MIN;
+        else if (code >= NOTIFY_BRNDOWN_MIN &&
+                 code <= NOTIFY_BRNDOWN_MAX)
+                code = NOTIFY_BRNDOWN_MIN;
+
+        if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
+                if (!acpi_video_backlight_support())
+                        asus_wmi_backlight_notify(asus, orig_code);
+        } else if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
+                pr_info("Unknown key %x pressed\n", code);
+
+exit:
+        kfree(obj);
+}
+
+/*
+ * Sys helpers
+ */
+static int parse_arg(const char *buf, unsigned long count, int *val)
+{
+        if (!count)
+                return 0;
+        if (sscanf(buf, "%i", val) != 1)
+                return -EINVAL;
+        return count;
+}
+
+static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
+                             const char *buf, size_t count)
+{
+        u32 retval;
+        int rv, err, value;
+
+        value = asus_wmi_get_devstate_simple(asus, devid);
+        if (value == -ENODEV)   /* Check device presence */
+                return value;
+
+        rv = parse_arg(buf, count, &value);
+        err = asus_wmi_set_devstate(devid, value, &retval);
+
+        if (err < 0)
+                return err;
+
+        return rv;
+}
+
+static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
+{
+        int value = asus_wmi_get_devstate_simple(asus, devid);
+
+        if (value < 0)
+                return value;
+
+        return sprintf(buf, "%d\n", value);
+}
+
+#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)                  \
+        static ssize_t show_##_name(struct device *dev,                 \
+                                    struct device_attribute *attr,      \
+                                    char *buf)                          \
+        {                                                               \
+                struct asus_wmi *asus = dev_get_drvdata(dev);           \
+                                                                        \
+                return show_sys_wmi(asus, _cm, buf);                    \
+        }                                                               \
+        static ssize_t store_##_name(struct device *dev,                \
+                                     struct device_attribute *attr,     \
+                                     const char *buf, size_t count)     \
+        {                                                               \
+                struct asus_wmi *asus = dev_get_drvdata(dev);           \
+                                                                        \
+                return store_sys_wmi(asus, _cm, buf, count);            \
+        }                                                               \
+        static struct device_attribute dev_attr_##_name = {             \
+                .attr = {                                               \
+                        .name = __stringify(_name),                     \
+                        .mode = _mode },                                \
+                .show   = show_##_name,                                 \
+                .store  = store_##_name,                                \
+        }
+
+ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
+ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
+ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
+
+static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        int value;
+
+        if (!count || sscanf(buf, "%i", &value) != 1)
+                return -EINVAL;
+        if (value < 0 || value > 2)
+                return -EINVAL;
+
+        return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
+}
+
+static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
+
+static struct attribute *platform_attributes[] = {
+        &dev_attr_cpufv.attr,
+        &dev_attr_camera.attr,
+        &dev_attr_cardr.attr,
+        &dev_attr_touchpad.attr,
+        NULL
+};
+
+static mode_t asus_sysfs_is_visible(struct kobject *kobj,
+                                    struct attribute *attr, int idx)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct asus_wmi *asus = platform_get_drvdata(pdev);
+        bool ok = true;
+        int devid = -1;
+
+        if (attr == &dev_attr_camera.attr)
+                devid = ASUS_WMI_DEVID_CAMERA;
+        else if (attr == &dev_attr_cardr.attr)
+                devid = ASUS_WMI_DEVID_CARDREADER;
+        else if (attr == &dev_attr_touchpad.attr)
+                devid = ASUS_WMI_DEVID_TOUCHPAD;
+
+        if (devid != -1)
+                ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
+
+        return ok ? attr->mode : 0;
+}
+
+static struct attribute_group platform_attribute_group = {
+        .is_visible = asus_sysfs_is_visible,
+        .attrs = platform_attributes
+};
+
+static void asus_wmi_sysfs_exit(struct platform_device *device)
+{
+        sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+static int asus_wmi_sysfs_init(struct platform_device *device)
+{
+        return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+/*
+ * Platform device
+ */
+static int asus_wmi_platform_init(struct asus_wmi *asus)
+{
+        int rv;
+
+        /* INIT enable hotkeys on some models */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
+                pr_info("Initialization: %#x", rv);
+
+        /* We don't know yet what to do with this version... */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
+                pr_info("BIOS WMI version: %d.%d", rv >> 8, rv & 0xFF);
+                asus->spec = rv;
+        }
+
+        /*
+         * The SFUN method probably allows the original driver to get the list
+         * of features supported by a given model. For now, 0x0100 or 0x0800
+         * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
+         * The significance of others is yet to be found.
+         */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
+                pr_info("SFUN value: %#x", rv);
+                asus->sfun = rv;
+        }
+
+        /*
+         * Eee PC and Notebooks seems to have different method_id for DSTS,
+         * but it may also be related to the BIOS's SPEC.
+         * Note, on most Eeepc, there is no way to check if a method exist
+         * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
+         * but once again, SPEC may probably be used for that kind of things.
+         */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
+                asus->dsts_id = ASUS_WMI_METHODID_DSTS;
+        else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
+                asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
+
+        if (!asus->dsts_id) {
+                pr_err("Can't find DSTS");
+                return -ENODEV;
+        }
+
+        return asus_wmi_sysfs_init(asus->platform_device);
+}
+
+static void asus_wmi_platform_exit(struct asus_wmi *asus)
+{
+        asus_wmi_sysfs_exit(asus->platform_device);
+}
+
+/*
+ * debugfs
+ */
+struct asus_wmi_debugfs_node {
+        struct asus_wmi *asus;
+        char *name;
+        int (*show) (struct seq_file *m, void *data);
+};
+
+static int show_dsts(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        int err;
+        u32 retval = -1;
+
+        err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
+
+        if (err < 0)
+                return err;
+
+        seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
+
+        return 0;
+}
+
+static int show_devs(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        int err;
+        u32 retval = -1;
+
+        err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
+                                    &retval);
+
+        if (err < 0)
+                return err;
+
+        seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
+                   asus->debug.ctrl_param, retval);
+
+        return 0;
+}
+
+static int show_call(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        struct bios_args args = {
+                .arg0 = asus->debug.dev_id,
+                .arg1 = asus->debug.ctrl_param,
+        };
+        struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
+                                     1, asus->debug.method_id,
+                                     &input, &output);
+
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        obj = (union acpi_object *)output.pointer;
+        if (obj && obj->type == ACPI_TYPE_INTEGER)
+                seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
+                           asus->debug.dev_id, asus->debug.ctrl_param,
+                           (u32) obj->integer.value);
+        else
+                seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
+                           asus->debug.dev_id, asus->debug.ctrl_param,
+                           obj ? obj->type : -1);
+
+        kfree(obj);
+
+        return 0;
+}
+
+static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
+        {NULL, "devs", show_devs},
+        {NULL, "dsts", show_dsts},
+        {NULL, "call", show_call},
+};
+
+static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
+{
+        struct asus_wmi_debugfs_node *node = inode->i_private;
+
+        return single_open(file, node->show, node->asus);
+}
+
+static const struct file_operations asus_wmi_debugfs_io_ops = {
+        .owner = THIS_MODULE,
+        .open = asus_wmi_debugfs_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
+{
+        debugfs_remove_recursive(asus->debug.root);
+}
+
+static int asus_wmi_debugfs_init(struct asus_wmi *asus)
+{
+        struct dentry *dent;
+        int i;
+
+        asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
+        if (!asus->debug.root) {
+                pr_err("failed to create debugfs directory");
+                goto error_debugfs;
+        }
+
+        dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.method_id);
+        if (!dent)
+                goto error_debugfs;
+
+        dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.dev_id);
+        if (!dent)
+                goto error_debugfs;
+
+        dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.ctrl_param);
+        if (!dent)
+                goto error_debugfs;
+
+        for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
+                struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
+
+                node->asus = asus;
+                dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
+                                           asus->debug.root, node,
+                                           &asus_wmi_debugfs_io_ops);
+                if (!dent) {
+                        pr_err("failed to create debug file: %s\n", node->name);
+                        goto error_debugfs;
+                }
+        }
+
+        return 0;
+
+error_debugfs:
+        asus_wmi_debugfs_exit(asus);
+        return -ENOMEM;
+}
+
+/*
+ * WMI Driver
+ */
+static int asus_wmi_add(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+        struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+        struct asus_wmi *asus;
+        acpi_status status;
+        int err;
+
+        asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
+        if (!asus)
+                return -ENOMEM;
+
+        asus->driver = wdrv;
+        asus->platform_device = pdev;
+        wdrv->platform_device = pdev;
+        platform_set_drvdata(asus->platform_device, asus);
+
+        if (wdrv->quirks)
+                wdrv->quirks(asus->driver);
+
+        err = asus_wmi_platform_init(asus);
+        if (err)
+                goto fail_platform;
+
+        err = asus_wmi_input_init(asus);
+        if (err)
+                goto fail_input;
+
+        err = asus_wmi_hwmon_init(asus);
+        if (err)
+                goto fail_hwmon;
+
+        err = asus_wmi_led_init(asus);
+        if (err)
+                goto fail_leds;
+
+        err = asus_wmi_rfkill_init(asus);
+        if (err)
+                goto fail_rfkill;
+
+        if (!acpi_video_backlight_support()) {
+                err = asus_wmi_backlight_init(asus);
+                if (err && err != -ENODEV)
+                        goto fail_backlight;
+        } else
+                pr_info("Backlight controlled by ACPI video driver\n");
+
+        status = wmi_install_notify_handler(asus->driver->event_guid,
+                                            asus_wmi_notify, asus);
+        if (ACPI_FAILURE(status)) {
+                pr_err("Unable to register notify handler - %d\n", status);
+                err = -ENODEV;
+                goto fail_wmi_handler;
+        }
+
+        err = asus_wmi_debugfs_init(asus);
+        if (err)
+                goto fail_debugfs;
+
+        return 0;
+
+fail_debugfs:
+        wmi_remove_notify_handler(asus->driver->event_guid);
+fail_wmi_handler:
+        asus_wmi_backlight_exit(asus);
+fail_backlight:
+        asus_wmi_rfkill_exit(asus);
+fail_rfkill:
+        asus_wmi_led_exit(asus);
+fail_leds:
+        asus_wmi_hwmon_exit(asus);
+fail_hwmon:
+        asus_wmi_input_exit(asus);
+fail_input:
+        asus_wmi_platform_exit(asus);
+fail_platform:
+        kfree(asus);
+        return err;
+}
+
+static int asus_wmi_remove(struct platform_device *device)
+{
+        struct asus_wmi *asus;
+
+        asus = platform_get_drvdata(device);
+        wmi_remove_notify_handler(asus->driver->event_guid);
+        asus_wmi_backlight_exit(asus);
+        asus_wmi_input_exit(asus);
+        asus_wmi_hwmon_exit(asus);
+        asus_wmi_led_exit(asus);
+        asus_wmi_rfkill_exit(asus);
+        asus_wmi_debugfs_exit(asus);
+        asus_wmi_platform_exit(asus);
+
+        kfree(asus);
+        return 0;
+}
+
+/*
+ * Platform driver - hibernate/resume callbacks
+ */
+static int asus_hotk_thaw(struct device *device)
+{
+        struct asus_wmi *asus = dev_get_drvdata(device);
+
+        if (asus->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 = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+                asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
+        }
+
+        return 0;
+}
+
+static int asus_hotk_restore(struct device *device)
+{
+        struct asus_wmi *asus = dev_get_drvdata(device);
+        int bl;
+
+        /* Refresh both wlan rfkill state and pci hotplug */
+        if (asus->wlan.rfkill)
+                asus_rfkill_hotplug(asus);
+
+        if (asus->bluetooth.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus,
+                                                   ASUS_WMI_DEVID_BLUETOOTH);
+                rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
+        }
+        if (asus->wimax.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
+                rfkill_set_sw_state(asus->wimax.rfkill, bl);
+        }
+        if (asus->wwan3g.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
+                rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
+        }
+
+        return 0;
+}
+
+static const struct dev_pm_ops asus_pm_ops = {
+        .thaw = asus_hotk_thaw,
+        .restore = asus_hotk_restore,
+};
+
+static int asus_wmi_probe(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+        struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+        int ret;
+
+        if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+                pr_warn("Management GUID not found\n");
+                return -ENODEV;
+        }
+
+        if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
+                pr_warn("Event GUID not found\n");
+                return -ENODEV;
+        }
+
+        if (wdrv->probe) {
+                ret = wdrv->probe(pdev);
+                if (ret)
+                        return ret;
+        }
+
+        return asus_wmi_add(pdev);
+}
+
+static bool used;
+
+int asus_wmi_register_driver(struct asus_wmi_driver *driver)
+{
+        struct platform_driver *platform_driver;
+        struct platform_device *platform_device;
+
+        if (used)
+                return -EBUSY;
+
+        platform_driver = &driver->platform_driver;
+        platform_driver->remove = asus_wmi_remove;
+        platform_driver->driver.owner = driver->owner;
+        platform_driver->driver.name = driver->name;
+        platform_driver->driver.pm = &asus_pm_ops;
+
+        platform_device = platform_create_bundle(platform_driver,
+                                                 asus_wmi_probe,
+                                                 NULL, 0, NULL, 0);
+        if (IS_ERR(platform_device))
+                return PTR_ERR(platform_device);
+
+        used = true;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
+
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
+{
+        platform_device_unregister(driver->platform_device);
+        platform_driver_unregister(&driver->platform_driver);
+        used = false;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
+
+static int __init asus_wmi_init(void)
+{
+        if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+                pr_info("Asus Management GUID not found");
+                return -ENODEV;
+        }
+
+        pr_info("ASUS WMI generic driver loaded");
+        return 0;
+}
+
+static void __exit asus_wmi_exit(void)
+{
+        pr_info("ASUS WMI generic driver unloaded");
+}
+
+module_init(asus_wmi_init);
+module_exit(asus_wmi_exit);
diff --git a/drivers/platform/x86/asus-wmi.h b/drivers/platform/x86/asus-wmi.h
new file mode 100644
index 000000000000..c044522c8766
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.h
@@ -0,0 +1,58 @@
+/*
+ * Asus PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _ASUS_WMI_H_
+#define _ASUS_WMI_H_
+
+#include <linux/platform_device.h>
+
+struct module;
+struct key_entry;
+struct asus_wmi;
+
+struct asus_wmi_driver {
+        bool                    hotplug_wireless;
+
+        const char              *name;
+        struct module           *owner;
+
+        const char              *event_guid;
+
+        const struct key_entry  *keymap;
+        const char              *input_name;
+        const char              *input_phys;
+
+        int (*probe) (struct platform_device *device);
+        void (*quirks) (struct asus_wmi_driver *driver);
+
+        struct platform_driver  platform_driver;
+        struct platform_device *platform_device;
+};
+
+int asus_wmi_register_driver(struct asus_wmi_driver *driver);
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver);
+
+#endif /* !_ASUS_WMI_H_ */
diff --git a/drivers/platform/x86/asus_acpi.c b/drivers/platform/x86/asus_acpi.c
index ca05aefd03bf..d9312b3073e5 100644
--- a/drivers/platform/x86/asus_acpi.c
+++ b/drivers/platform/x86/asus_acpi.c
@@ -30,6 +30,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -581,8 +583,7 @@ static int read_led(const char *ledname, int ledmask)
                 if (read_acpi_int(NULL, ledname, &led_status))
                         return led_status;
                 else
-                        printk(KERN_WARNING "Asus ACPI: Error reading LED "
-                               "status\n");
+                        pr_warn("Error reading LED status\n");
         }
         return (hotk->status & ledmask) ? 1 : 0;
 }
@@ -621,8 +622,7 @@ write_led(const char __user *buffer, unsigned long count,
                 led_out = !led_out;
 
         if (!write_acpi_int(hotk->handle, ledname, led_out, NULL))
-                printk(KERN_WARNING "Asus ACPI: LED (%s) write failed\n",
-                       ledname);
+                pr_warn("LED (%s) write failed\n", ledname);
 
         return rv;
 }
@@ -679,8 +679,7 @@ static ssize_t ledd_proc_write(struct file *file, const char __user *buffer,
         if (rv > 0) {
                 if (!write_acpi_int
                     (hotk->handle, hotk->methods->mt_ledd, value, NULL))
-                        printk(KERN_WARNING
-                               "Asus ACPI: LED display write failed\n");
+                        pr_warn("LED display write failed\n");
                 else
                         hotk->ledd_status = (u32) value;
         }
@@ -838,8 +837,7 @@ static int get_lcd_state(void)
         } else {
                 /* We don't have to check anything if we are here */
                 if (!read_acpi_int(NULL, hotk->methods->lcd_status, &lcd))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading LCD status\n");
+                        pr_warn("Error reading LCD status\n");
 
                 if (hotk->model == L2D)
                         lcd = ~lcd;
@@ -871,7 +869,7 @@ static int set_lcd_state(int value)
                            the exact behaviour is simulated here */
                 }
                 if (ACPI_FAILURE(status))
-                        printk(KERN_WARNING "Asus ACPI: Error switching LCD\n");
+                        pr_warn("Error switching LCD\n");
         }
         return 0;
 
@@ -915,13 +913,11 @@ static int read_brightness(struct backlight_device *bd)
         if (hotk->methods->brightness_get) {    /* SPLV/GPLV laptop */
                 if (!read_acpi_int(hotk->handle, hotk->methods->brightness_get,
                                    &value))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading brightness\n");
+                        pr_warn("Error reading brightness\n");
         } else if (hotk->methods->brightness_status) {  /* For D1 for example */
                 if (!read_acpi_int(NULL, hotk->methods->brightness_status,
                                    &value))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading brightness\n");
+                        pr_warn("Error reading brightness\n");
         } else                  /* No GPLV method */
                 value = hotk->brightness;
         return value;
@@ -939,8 +935,7 @@ static int set_brightness(int value)
         if (hotk->methods->brightness_set) {
                 if (!write_acpi_int(hotk->handle, hotk->methods->brightness_set,
                                     value, NULL)) {
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error changing brightness\n");
+                        pr_warn("Error changing brightness\n");
                         ret = -EIO;
                 }
                 goto out;
@@ -955,8 +950,7 @@ static int set_brightness(int value)
                                               NULL, NULL);
                 (value > 0) ? value-- : value++;
                 if (ACPI_FAILURE(status)) {
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error changing brightness\n");
+                        pr_warn("Error changing brightness\n");
                         ret = -EIO;
                 }
         }
@@ -1008,7 +1002,7 @@ static void set_display(int value)
         /* no sanity check needed for now */
         if (!write_acpi_int(hotk->handle, hotk->methods->display_set,
                             value, NULL))
-                printk(KERN_WARNING "Asus ACPI: Error setting display\n");
+                pr_warn("Error setting display\n");
         return;
 }
 
@@ -1021,8 +1015,7 @@ static int disp_proc_show(struct seq_file *m, void *v)
         int value = 0;
 
         if (!read_acpi_int(hotk->handle, hotk->methods->display_get, &value))
-                printk(KERN_WARNING
-                       "Asus ACPI: Error reading display status\n");
+                pr_warn("Error reading display status\n");
         value &= 0x07;  /* needed for some models, shouldn't hurt others */
         seq_printf(m, "%d\n", value);
         return 0;
@@ -1068,7 +1061,7 @@ asus_proc_add(char *name, const struct file_operations *proc_fops, mode_t mode,
         proc = proc_create_data(name, mode, acpi_device_dir(device),
                                 proc_fops, acpi_driver_data(device));
         if (!proc) {
-                printk(KERN_WARNING "  Unable to create %s fs entry\n", name);
+                pr_warn("  Unable to create %s fs entry\n", name);
                 return -1;
         }
         proc->uid = asus_uid;
@@ -1081,18 +1074,12 @@ static int asus_hotk_add_fs(struct acpi_device *device)
         struct proc_dir_entry *proc;
         mode_t mode;
 
-        /*
-         * If parameter uid or gid is not changed, keep the default setting for
-         * our proc entries (-rw-rw-rw-) else, it means we care about security,
-         * and then set to -rw-rw----
-         */
-
         if ((asus_uid == 0) && (asus_gid == 0)) {
-                mode = S_IFREG | S_IRUGO | S_IWUGO;
+                mode = S_IFREG | S_IRUGO | S_IWUSR | S_IWGRP;
         } else {
                 mode = S_IFREG | S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP;
-                printk(KERN_WARNING "  asus_uid and asus_gid parameters are "
-                       "deprecated, use chown and chmod instead!\n");
+                pr_warn("  asus_uid and asus_gid parameters are "
+                        "deprecated, use chown and chmod instead!\n");
         }
 
         acpi_device_dir(device) = asus_proc_dir;
@@ -1105,8 +1092,7 @@ static int asus_hotk_add_fs(struct acpi_device *device)
                 proc->uid = asus_uid;
                 proc->gid = asus_gid;
         } else {
-                printk(KERN_WARNING "  Unable to create " PROC_INFO
-                       " fs entry\n");
+                pr_warn("  Unable to create " PROC_INFO " fs entry\n");
         }
 
         if (hotk->methods->mt_wled) {
@@ -1289,20 +1275,19 @@ static int asus_hotk_get_info(void)
          */
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info);
         if (ACPI_FAILURE(status))
-                printk(KERN_WARNING "  Couldn't get the DSDT table header\n");
+                pr_warn("  Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
         if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
-                printk(KERN_ERR "  Hotkey initialization failed\n");
+                pr_err("  Hotkey initialization failed\n");
                 return -ENODEV;
         }
 
         /* This needs to be called for some laptops to init properly */
         if (!read_acpi_int(hotk->handle, "BSTS", &bsts_result))
-                printk(KERN_WARNING "  Error calling BSTS\n");
+                pr_warn("  Error calling BSTS\n");
         else if (bsts_result)
-                printk(KERN_NOTICE "  BSTS called, 0x%02x returned\n",
-                       bsts_result);
+                pr_notice("  BSTS called, 0x%02x returned\n", bsts_result);
 
         /*
          * Try to match the object returned by INIT to the specific model.
@@ -1330,23 +1315,21 @@ static int asus_hotk_get_info(void)
                 if (asus_info &&
                     strncmp(asus_info->oem_table_id, "ODEM", 4) == 0) {
                         hotk->model = P30;
-                        printk(KERN_NOTICE
-                               "  Samsung P30 detected, supported\n");
+                        pr_notice("  Samsung P30 detected, supported\n");
                         hotk->methods = &model_conf[hotk->model];
                         kfree(model);
                         return 0;
                 } else {
                         hotk->model = M2E;
-                        printk(KERN_NOTICE "  unsupported model %s, trying "
-                               "default values\n", string);
-                        printk(KERN_NOTICE
-                               "  send /proc/acpi/dsdt to the developers\n");
+                        pr_notice("  unsupported model %s, trying default values\n",
+                                  string);
+                        pr_notice("  send /proc/acpi/dsdt to the developers\n");
                         kfree(model);
                         return -ENODEV;
                 }
         }
         hotk->methods = &model_conf[hotk->model];
-        printk(KERN_NOTICE "  %s model detected, supported\n", string);
+        pr_notice("  %s model detected, supported\n", string);
 
         /* Sort of per-model blacklist */
         if (strncmp(string, "L2B", 3) == 0)
@@ -1391,7 +1374,7 @@ static int asus_hotk_check(void)
         if (hotk->device->status.present) {
                 result = asus_hotk_get_info();
         } else {
-                printk(KERN_ERR "  Hotkey device not present, aborting\n");
+                pr_err("  Hotkey device not present, aborting\n");
                 return -EINVAL;
         }
 
@@ -1405,8 +1388,7 @@ static int asus_hotk_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         int result;
 
-        printk(KERN_NOTICE "Asus Laptop ACPI Extras version %s\n",
-               ASUS_ACPI_VERSION);
+        pr_notice("Asus Laptop ACPI Extras version %s\n", ASUS_ACPI_VERSION);
 
         hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
         if (!hotk)
@@ -1434,15 +1416,14 @@ static int asus_hotk_add(struct acpi_device *device)
                     acpi_evaluate_object(NULL, hotk->methods->brightness_down,
                                          NULL, NULL);
                 if (ACPI_FAILURE(status))
-                        printk(KERN_WARNING "  Error changing brightness\n");
+                        pr_warn("  Error changing brightness\n");
                 else {
                         status =
                             acpi_evaluate_object(NULL,
                                                  hotk->methods->brightness_up,
                                                  NULL, NULL);
                         if (ACPI_FAILURE(status))
-                                printk(KERN_WARNING "  Strange, error changing"
-                                       " brightness\n");
+                                pr_warn("  Strange, error changing brightness\n");
                 }
         }
 
@@ -1467,7 +1448,7 @@ static int asus_hotk_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static struct backlight_ops asus_backlight_data = {
+static const struct backlight_ops asus_backlight_data = {
         .get_brightness = read_brightness,
         .update_status  = set_brightness_status,
 };
@@ -1494,7 +1475,7 @@ static int __init asus_acpi_init(void)
 
         asus_proc_dir = proc_mkdir(PROC_ASUS, acpi_root_dir);
         if (!asus_proc_dir) {
-                printk(KERN_ERR "Asus ACPI: Unable to create /proc entry\n");
+                pr_err("Unable to create /proc entry\n");
                 acpi_bus_unregister_driver(&asus_hotk_driver);
                 return -ENODEV;
         }
@@ -1513,12 +1494,13 @@ static int __init asus_acpi_init(void)
         }
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = 15;
         asus_backlight_device = backlight_device_register("asus", NULL, NULL,
                                                           &asus_backlight_data,
                                                           &props);
         if (IS_ERR(asus_backlight_device)) {
-                printk(KERN_ERR "Could not register asus backlight device\n");
+                pr_err("Could not register asus backlight device\n");
                 asus_backlight_device = NULL;
                 asus_acpi_exit();
                 return -ENODEV;
diff --git a/drivers/platform/x86/classmate-laptop.c b/drivers/platform/x86/classmate-laptop.c
index 341cbfef93ee..94f93b621d7b 100644
--- a/drivers/platform/x86/classmate-laptop.c
+++ b/drivers/platform/x86/classmate-laptop.c
@@ -522,18 +522,20 @@ static int cmpc_rfkill_block(void *data, bool blocked)
         acpi_status status;
         acpi_handle handle;
         unsigned long long state;
+        bool is_blocked;
 
         handle = data;
         status = cmpc_get_rfkill_wlan(handle, &state);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
-        if (blocked)
-                state &= ~1;
-        else
-                state |= 1;
-        status = cmpc_set_rfkill_wlan(handle, state);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
+        /* Check if we really need to call cmpc_set_rfkill_wlan */
+        is_blocked = state & 1 ? false : true;
+        if (is_blocked != blocked) {
+                state = blocked ? 0 : 1;
+                status = cmpc_set_rfkill_wlan(handle, state);
+                if (ACPI_FAILURE(status))
+                        return -ENODEV;
+        }
         return 0;
 }
 
@@ -562,6 +564,7 @@ static int cmpc_ipml_add(struct acpi_device *acpi)
                 return -ENOMEM;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = 7;
         ipml->bd = backlight_device_register("cmpc_bl", &acpi->dev,
                                              acpi->handle, &cmpc_bl_ops,
@@ -653,8 +656,9 @@ static void cmpc_keys_handler(struct acpi_device *dev, u32 event)
 
         if ((event & 0x0F) < ARRAY_SIZE(cmpc_keys_codes))
                 code = cmpc_keys_codes[event & 0x0F];
-        inputdev = dev_get_drvdata(&dev->dev);;
+        inputdev = dev_get_drvdata(&dev->dev);
         input_report_key(inputdev, code, !(event & 0x10));
+        input_sync(inputdev);
 }
 
 static void cmpc_keys_idev_init(struct input_dev *inputdev)
diff --git a/drivers/platform/x86/compal-laptop.c b/drivers/platform/x86/compal-laptop.c
index 097083cac413..8877b836d27c 100644
--- a/drivers/platform/x86/compal-laptop.c
+++ b/drivers/platform/x86/compal-laptop.c
@@ -68,6 +68,8 @@
  * only enabled on a JHL90 board until it is verified that they work on the
  * other boards too.  See the extra_features variable. */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -200,8 +202,8 @@ static bool extra_features;
  * watching the output of address 0x4F (do an ec_transaction writing 0x33
  * into 0x4F and read a few bytes from the output, like so:
  *      u8 writeData = 0x33;
- *      ec_transaction(0x4F, &writeData, 1, buffer, 32, 0);
- * That address is labled "fan1 table information" in the service manual.
+ *      ec_transaction(0x4F, &writeData, 1, buffer, 32);
+ * That address is labeled "fan1 table information" in the service manual.
  * It should be clear which value in 'buffer' changes). This seems to be
  * related to fan speed. It isn't a proper 'realtime' fan speed value
  * though, because physically stopping or speeding up the fan doesn't
@@ -275,7 +277,7 @@ static int set_backlight_level(int level)
 
         ec_write(BACKLIGHT_LEVEL_ADDR, level);
 
-        return 1;
+        return 0;
 }
 
 static int get_backlight_level(void)
@@ -286,7 +288,7 @@ static int get_backlight_level(void)
 static void set_backlight_state(bool on)
 {
         u8 data = on ? BACKLIGHT_STATE_ON_DATA : BACKLIGHT_STATE_OFF_DATA;
-        ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0, 0);
+        ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0);
 }
 
 
@@ -294,24 +296,24 @@ static void set_backlight_state(bool on)
 static void pwm_enable_control(void)
 {
         unsigned char writeData = PWM_ENABLE_DATA;
-        ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0, 0);
+        ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0);
 }
 
 static void pwm_disable_control(void)
 {
         unsigned char writeData = PWM_DISABLE_DATA;
-        ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0, 0);
+        ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0);
 }
 
 static void set_pwm(int pwm)
 {
-        ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0, 0);
+        ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0);
 }
 
 static int get_fan_rpm(void)
 {
         u8 value, data = FAN_DATA;
-        ec_transaction(FAN_ADDRESS, &data, 1, &value, 1, 0);
+        ec_transaction(FAN_ADDRESS, &data, 1, &value, 1);
         return 100 * (int)value;
 }
 
@@ -760,19 +762,17 @@ static struct rfkill *bt_rfkill;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s'\n",
-                id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         extra_features = false;
-        return 0;
+        return 1;
 }
 
 static int dmi_check_cb_extra(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s', "
-                "enabling extra features\n",
+        pr_info("Identified laptop model '%s', enabling extra features\n",
                 id->ident);
         extra_features = true;
-        return 0;
+        return 1;
 }
 
 static struct dmi_system_id __initdata compal_dmi_table[] = {
@@ -872,6 +872,14 @@ static struct dmi_system_id __initdata compal_dmi_table[] = {
                 },
                 .callback = dmi_check_cb_extra
         },
+        {
+                .ident = "KHLB2",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_NAME, "KHLB2"),
+                        DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
+                },
+                .callback = dmi_check_cb_extra
+        },
         { }
 };
 
@@ -948,20 +956,19 @@ static int __init compal_init(void)
         int ret;
 
         if (acpi_disabled) {
-                printk(KERN_ERR DRIVER_NAME": ACPI needs to be enabled for "
-                                                "this driver to work!\n");
+                pr_err("ACPI needs to be enabled for this driver to work!\n");
                 return -ENODEV;
         }
 
         if (!force && !dmi_check_system(compal_dmi_table)) {
-                printk(KERN_ERR DRIVER_NAME": Motherboard not recognized (You "
-                                "could try the module's force-parameter)");
+                pr_err("Motherboard not recognized (You could try the module's force-parameter)\n");
                 return -ENODEV;
         }
 
         if (!acpi_video_backlight_support()) {
                 struct backlight_properties props;
                 memset(&props, 0, sizeof(struct backlight_properties));
+                props.type = BACKLIGHT_PLATFORM;
                 props.max_brightness = BACKLIGHT_LEVEL_MAX;
                 compalbl_device = backlight_device_register(DRIVER_NAME,
                                                             NULL, NULL,
@@ -989,8 +996,7 @@ static int __init compal_init(void)
         if (ret)
                 goto err_rfkill;
 
-        printk(KERN_INFO DRIVER_NAME": Driver "DRIVER_VERSION
-                                                " successfully loaded\n");
+        pr_info("Driver " DRIVER_VERSION " successfully loaded\n");
         return 0;
 
 err_rfkill:
@@ -1024,8 +1030,10 @@ static int __devinit compal_probe(struct platform_device *pdev)
         initialize_fan_control_data(data);
 
         err = sysfs_create_group(&pdev->dev.kobj, &compal_attribute_group);
-        if (err)
+        if (err) {
+                kfree(data);
                 return err;
+        }
 
         data->hwmon_dev = hwmon_device_register(&pdev->dev);
         if (IS_ERR(data->hwmon_dev)) {
@@ -1055,7 +1063,7 @@ static void __exit compal_cleanup(void)
         rfkill_destroy(wifi_rfkill);
         rfkill_destroy(bt_rfkill);
 
-        printk(KERN_INFO DRIVER_NAME": Driver unloaded\n");
+        pr_info("Driver unloaded\n");
 }
 
 static int __devexit compal_remove(struct platform_device *pdev)
@@ -1065,8 +1073,7 @@ static int __devexit compal_remove(struct platform_device *pdev)
         if (!extra_features)
                 return 0;
 
-        printk(KERN_INFO DRIVER_NAME": Unloading: resetting fan control "
-                                                        "to motherboard\n");
+        pr_info("Unloading: resetting fan control to motherboard\n");
         pwm_disable_control();
 
         data = platform_get_drvdata(pdev);
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index 4413975912e0..e39ab1d3ed87 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -11,6 +11,8 @@
  *  published by the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -25,6 +27,8 @@
 #include <linux/mm.h>
 #include <linux/i8042.h>
 #include <linux/slab.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 #include "../../firmware/dcdbas.h"
 
 #define BRIGHTNESS_TOKEN 0x7d
@@ -325,6 +329,75 @@ static const struct rfkill_ops dell_rfkill_ops = {
         .query = dell_rfkill_query,
 };
 
+static struct dentry *dell_laptop_dir;
+
+static int dell_debugfs_show(struct seq_file *s, void *data)
+{
+        int status;
+
+        get_buffer();
+        dell_send_request(buffer, 17, 11);
+        status = buffer->output[1];
+        release_buffer();
+
+        seq_printf(s, "status:\t0x%X\n", status);
+        seq_printf(s, "Bit 0 : Hardware switch supported:   %lu\n",
+                   status & BIT(0));
+        seq_printf(s, "Bit 1 : Wifi locator supported:      %lu\n",
+                  (status & BIT(1)) >> 1);
+        seq_printf(s, "Bit 2 : Wifi is supported:           %lu\n",
+                  (status & BIT(2)) >> 2);
+        seq_printf(s, "Bit 3 : Bluetooth is supported:      %lu\n",
+                  (status & BIT(3)) >> 3);
+        seq_printf(s, "Bit 4 : WWAN is supported:           %lu\n",
+                  (status & BIT(4)) >> 4);
+        seq_printf(s, "Bit 5 : Wireless keyboard supported: %lu\n",
+                  (status & BIT(5)) >> 5);
+        seq_printf(s, "Bit 8 : Wifi is installed:           %lu\n",
+                  (status & BIT(8)) >> 8);
+        seq_printf(s, "Bit 9 : Bluetooth is installed:      %lu\n",
+                  (status & BIT(9)) >> 9);
+        seq_printf(s, "Bit 10: WWAN is installed:           %lu\n",
+                  (status & BIT(10)) >> 10);
+        seq_printf(s, "Bit 16: Hardware switch is on:       %lu\n",
+                  (status & BIT(16)) >> 16);
+        seq_printf(s, "Bit 17: Wifi is blocked:             %lu\n",
+                  (status & BIT(17)) >> 17);
+        seq_printf(s, "Bit 18: Bluetooth is blocked:        %lu\n",
+                  (status & BIT(18)) >> 18);
+        seq_printf(s, "Bit 19: WWAN is blocked:             %lu\n",
+                  (status & BIT(19)) >> 19);
+
+        seq_printf(s, "\nhwswitch_state:\t0x%X\n", hwswitch_state);
+        seq_printf(s, "Bit 0 : Wifi controlled by switch:      %lu\n",
+                   hwswitch_state & BIT(0));
+        seq_printf(s, "Bit 1 : Bluetooth controlled by switch: %lu\n",
+                   (hwswitch_state & BIT(1)) >> 1);
+        seq_printf(s, "Bit 2 : WWAN controlled by switch:      %lu\n",
+                   (hwswitch_state & BIT(2)) >> 2);
+        seq_printf(s, "Bit 7 : Wireless switch config locked:  %lu\n",
+                   (hwswitch_state & BIT(7)) >> 7);
+        seq_printf(s, "Bit 8 : Wifi locator enabled:           %lu\n",
+                   (hwswitch_state & BIT(8)) >> 8);
+        seq_printf(s, "Bit 15: Wifi locator setting locked:    %lu\n",
+                   (hwswitch_state & BIT(15)) >> 15);
+
+        return 0;
+}
+
+static int dell_debugfs_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, dell_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations dell_debugfs_fops = {
+        .owner = THIS_MODULE,
+        .open = dell_debugfs_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
 static void dell_update_rfkill(struct work_struct *ignored)
 {
         if (wifi_rfkill)
@@ -343,8 +416,7 @@ static int __init dell_setup_rfkill(void)
         int ret;
 
         if (dmi_check_system(dell_blacklist)) {
-                printk(KERN_INFO "dell-laptop: Blacklisted hardware detected - "
-                                "not enabling rfkill\n");
+                pr_info("Blacklisted hardware detected - not enabling rfkill\n");
                 return 0;
         }
 
@@ -468,14 +540,14 @@ static int dell_get_intensity(struct backlight_device *bd)
         else
                 dell_send_request(buffer, 0, 1);
 
+        ret = buffer->output[1];
+
 out:
         release_buffer();
-        if (ret)
-                return ret;
-        return buffer->output[1];
+        return ret;
 }
 
-static struct backlight_ops dell_ops = {
+static const struct backlight_ops dell_ops = {
         .get_brightness = dell_get_intensity,
         .update_status  = dell_send_intensity,
 };
@@ -515,7 +587,7 @@ static int __init dell_init(void)
         dmi_walk(find_tokens, NULL);
 
         if (!da_tokens)  {
-                printk(KERN_INFO "dell-laptop: Unable to find dmi tokens\n");
+                pr_info("Unable to find dmi tokens\n");
                 return -ENODEV;
         }
 
@@ -545,17 +617,21 @@ static int __init dell_init(void)
         ret = dell_setup_rfkill();
 
         if (ret) {
-                printk(KERN_WARNING "dell-laptop: Unable to setup rfkill\n");
+                pr_warn("Unable to setup rfkill\n");
                 goto fail_rfkill;
         }
 
         ret = i8042_install_filter(dell_laptop_i8042_filter);
         if (ret) {
-                printk(KERN_WARNING
-                       "dell-laptop: Unable to install key filter\n");
+                pr_warn("Unable to install key filter\n");
                 goto fail_filter;
         }
 
+        dell_laptop_dir = debugfs_create_dir("dell_laptop", NULL);
+        if (dell_laptop_dir != NULL)
+                debugfs_create_file("rfkill", 0444, dell_laptop_dir, NULL,
+                                    &dell_debugfs_fops);
+
 #ifdef CONFIG_ACPI
         /* In the event of an ACPI backlight being available, don't
          * register the platform controller.
@@ -575,6 +651,7 @@ static int __init dell_init(void)
         if (max_intensity) {
                 struct backlight_properties props;
                 memset(&props, 0, sizeof(struct backlight_properties));
+                props.type = BACKLIGHT_PLATFORM;
                 props.max_brightness = max_intensity;
                 dell_backlight_device = backlight_device_register("dell_backlight",
                                                                   &platform_device->dev,
@@ -615,6 +692,7 @@ fail_platform_driver:
 
 static void __exit dell_exit(void)
 {
+        debugfs_remove_recursive(dell_laptop_dir);
         i8042_remove_filter(dell_laptop_i8042_filter);
         cancel_delayed_work_sync(&dell_rfkill_work);
         backlight_device_unregister(dell_backlight_device);
diff --git a/drivers/platform/x86/dell-wmi-aio.c b/drivers/platform/x86/dell-wmi-aio.c
new file mode 100644
index 000000000000..3f945457f71c
--- /dev/null
+++ b/drivers/platform/x86/dell-wmi-aio.c
@@ -0,0 +1,172 @@
+/*
+ *  WMI hotkeys support for Dell All-In-One series
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <acpi/acpi_drivers.h>
+#include <linux/acpi.h>
+#include <linux/string.h>
+
+MODULE_DESCRIPTION("WMI hotkeys driver for Dell All-In-One series");
+MODULE_LICENSE("GPL");
+
+#define EVENT_GUID1 "284A0E6B-380E-472A-921F-E52786257FB4"
+#define EVENT_GUID2 "02314822-307C-4F66-BF0E-48AEAEB26CC8"
+
+static const char *dell_wmi_aio_guids[] = {
+        EVENT_GUID1,
+        EVENT_GUID2,
+        NULL
+};
+
+MODULE_ALIAS("wmi:"EVENT_GUID1);
+MODULE_ALIAS("wmi:"EVENT_GUID2);
+
+static const struct key_entry dell_wmi_aio_keymap[] = {
+        { KE_KEY, 0xc0, { KEY_VOLUMEUP } },
+        { KE_KEY, 0xc1, { KEY_VOLUMEDOWN } },
+        { KE_END, 0 }
+};
+
+static struct input_dev *dell_wmi_aio_input_dev;
+
+static void dell_wmi_aio_notify(u32 value, void *context)
+{
+        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = wmi_get_event_data(value, &response);
+        if (status != AE_OK) {
+                pr_info("bad event status 0x%x\n", status);
+                return;
+        }
+
+        obj = (union acpi_object *)response.pointer;
+        if (obj) {
+                unsigned int scancode;
+
+                switch (obj->type) {
+                case ACPI_TYPE_INTEGER:
+                        /* Most All-In-One correctly return integer scancode */
+                        scancode = obj->integer.value;
+                        sparse_keymap_report_event(dell_wmi_aio_input_dev,
+                                scancode, 1, true);
+                        break;
+                case ACPI_TYPE_BUFFER:
+                        /* Broken machines return the scancode in a buffer */
+                        if (obj->buffer.pointer && obj->buffer.length > 0) {
+                                scancode = obj->buffer.pointer[0];
+                                sparse_keymap_report_event(
+                                        dell_wmi_aio_input_dev,
+                                        scancode, 1, true);
+                        }
+                        break;
+                }
+        }
+        kfree(obj);
+}
+
+static int __init dell_wmi_aio_input_setup(void)
+{
+        int err;
+
+        dell_wmi_aio_input_dev = input_allocate_device();
+
+        if (!dell_wmi_aio_input_dev)
+                return -ENOMEM;
+
+        dell_wmi_aio_input_dev->name = "Dell AIO WMI hotkeys";
+        dell_wmi_aio_input_dev->phys = "wmi/input0";
+        dell_wmi_aio_input_dev->id.bustype = BUS_HOST;
+
+        err = sparse_keymap_setup(dell_wmi_aio_input_dev,
+                        dell_wmi_aio_keymap, NULL);
+        if (err) {
+                pr_err("Unable to setup input device keymap\n");
+                goto err_free_dev;
+        }
+        err = input_register_device(dell_wmi_aio_input_dev);
+        if (err) {
+                pr_info("Unable to register input device\n");
+                goto err_free_keymap;
+        }
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(dell_wmi_aio_input_dev);
+err_free_dev:
+        input_free_device(dell_wmi_aio_input_dev);
+        return err;
+}
+
+static const char *dell_wmi_aio_find(void)
+{
+        int i;
+
+        for (i = 0; dell_wmi_aio_guids[i] != NULL; i++)
+                if (wmi_has_guid(dell_wmi_aio_guids[i]))
+                        return dell_wmi_aio_guids[i];
+
+        return NULL;
+}
+
+static int __init dell_wmi_aio_init(void)
+{
+        int err;
+        const char *guid;
+
+        guid = dell_wmi_aio_find();
+        if (!guid) {
+                pr_warn("No known WMI GUID found\n");
+                return -ENXIO;
+        }
+
+        err = dell_wmi_aio_input_setup();
+        if (err)
+                return err;
+
+        err = wmi_install_notify_handler(guid, dell_wmi_aio_notify, NULL);
+        if (err) {
+                pr_err("Unable to register notify handler - %d\n", err);
+                sparse_keymap_free(dell_wmi_aio_input_dev);
+                input_unregister_device(dell_wmi_aio_input_dev);
+                return err;
+        }
+
+        return 0;
+}
+
+static void __exit dell_wmi_aio_exit(void)
+{
+        const char *guid;
+
+        guid = dell_wmi_aio_find();
+        wmi_remove_notify_handler(guid);
+        sparse_keymap_free(dell_wmi_aio_input_dev);
+        input_unregister_device(dell_wmi_aio_input_dev);
+}
+
+module_init(dell_wmi_aio_init);
+module_exit(dell_wmi_aio_exit);
diff --git a/drivers/platform/x86/dell-wmi.c b/drivers/platform/x86/dell-wmi.c
index 08fb70f6d9bf..ce790827e199 100644
--- a/drivers/platform/x86/dell-wmi.c
+++ b/drivers/platform/x86/dell-wmi.c
@@ -23,12 +23,15 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 #include <acpi/acpi_drivers.h>
 #include <linux/acpi.h>
 #include <linux/string.h>
@@ -44,78 +47,70 @@ static int acpi_video;
 
 MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
 
-struct key_entry {
-        char type;              /* See KE_* below */
-        u16 code;
-        u16 keycode;
-};
-
-enum { KE_KEY, KE_SW, KE_IGNORE, KE_END };
-
 /*
  * Certain keys are flagged as KE_IGNORE. All of these are either
  * notifications (rather than requests for change) or are also sent
  * via the keyboard controller so should not be sent again.
  */
 
-static struct key_entry dell_legacy_wmi_keymap[] = {
-        {KE_KEY, 0xe045, KEY_PROG1},
-        {KE_KEY, 0xe009, KEY_EJECTCD},
+static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
+        { KE_KEY, 0xe045, { KEY_PROG1 } },
+        { KE_KEY, 0xe009, { KEY_EJECTCD } },
 
         /* These also contain the brightness level at offset 6 */
-        {KE_KEY, 0xe006, KEY_BRIGHTNESSUP},
-        {KE_KEY, 0xe005, KEY_BRIGHTNESSDOWN},
+        { KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },
 
         /* Battery health status button */
-        {KE_KEY, 0xe007, KEY_BATTERY},
+        { KE_KEY, 0xe007, { KEY_BATTERY } },
 
         /* This is actually for all radios. Although physically a
          * switch, the notification does not provide an indication of
          * state and so it should be reported as a key */
-        {KE_KEY, 0xe008, KEY_WLAN},
+        { KE_KEY, 0xe008, { KEY_WLAN } },
 
         /* The next device is at offset 6, the active devices are at
            offset 8 and the attached devices at offset 10 */
-        {KE_KEY, 0xe00b, KEY_SWITCHVIDEOMODE},
+        { KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },
 
-        {KE_IGNORE, 0xe00c, KEY_KBDILLUMTOGGLE},
+        { KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },
 
         /* BIOS error detected */
-        {KE_IGNORE, 0xe00d, KEY_RESERVED},
+        { KE_IGNORE, 0xe00d, { KEY_RESERVED } },
 
         /* Wifi Catcher */
-        {KE_KEY, 0xe011, KEY_PROG2},
+        { KE_KEY, 0xe011, {KEY_PROG2 } },
 
         /* Ambient light sensor toggle */
-        {KE_IGNORE, 0xe013, KEY_RESERVED},
-
-        {KE_IGNORE, 0xe020, KEY_MUTE},
-        {KE_IGNORE, 0xe02e, KEY_VOLUMEDOWN},
-        {KE_IGNORE, 0xe030, KEY_VOLUMEUP},
-        {KE_IGNORE, 0xe033, KEY_KBDILLUMUP},
-        {KE_IGNORE, 0xe034, KEY_KBDILLUMDOWN},
-        {KE_IGNORE, 0xe03a, KEY_CAPSLOCK},
-        {KE_IGNORE, 0xe045, KEY_NUMLOCK},
-        {KE_IGNORE, 0xe046, KEY_SCROLLLOCK},
-        {KE_END, 0}
+        { KE_IGNORE, 0xe013, { KEY_RESERVED } },
+
+        { KE_IGNORE, 0xe020, { KEY_MUTE } },
+        { KE_IGNORE, 0xe02e, { KEY_VOLUMEDOWN } },
+        { KE_IGNORE, 0xe030, { KEY_VOLUMEUP } },
+        { KE_IGNORE, 0xe033, { KEY_KBDILLUMUP } },
+        { KE_IGNORE, 0xe034, { KEY_KBDILLUMDOWN } },
+        { KE_IGNORE, 0xe03a, { KEY_CAPSLOCK } },
+        { KE_IGNORE, 0xe045, { KEY_NUMLOCK } },
+        { KE_IGNORE, 0xe046, { KEY_SCROLLLOCK } },
+        { KE_END, 0 }
 };
 
 static bool dell_new_hk_type;
 
-struct dell_new_keymap_entry {
+struct dell_bios_keymap_entry {
         u16 scancode;
         u16 keycode;
 };
 
-struct dell_hotkey_table {
+struct dell_bios_hotkey_table {
         struct dmi_header header;
-        struct dell_new_keymap_entry keymap[];
+        struct dell_bios_keymap_entry keymap[];
 
 };
 
-static struct key_entry *dell_new_wmi_keymap;
+static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;
 
-static u16 bios_to_linux_keycode[256] = {
+static const u16 bios_to_linux_keycode[256] __initconst = {
 
         KEY_MEDIA,      KEY_NEXTSONG,   KEY_PLAYPAUSE, KEY_PREVIOUSSONG,
         KEY_STOPCD,     KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_UNKNOWN,
@@ -138,85 +133,30 @@ static u16 bios_to_linux_keycode[256] = {
         KEY_PROG3
 };
 
-
-static struct key_entry *dell_wmi_keymap = dell_legacy_wmi_keymap;
-
 static struct input_dev *dell_wmi_input_dev;
 
-static struct key_entry *dell_wmi_get_entry_by_scancode(unsigned int code)
-{
-        struct key_entry *key;
-
-        for (key = dell_wmi_keymap; key->type != KE_END; key++)
-                if (code == key->code)
-                        return key;
-
-        return NULL;
-}
-
-static struct key_entry *dell_wmi_get_entry_by_keycode(unsigned int keycode)
-{
-        struct key_entry *key;
-
-        for (key = dell_wmi_keymap; key->type != KE_END; key++)
-                if (key->type == KE_KEY && keycode == key->keycode)
-                        return key;
-
-        return NULL;
-}
-
-static int dell_wmi_getkeycode(struct input_dev *dev,
-                                unsigned int scancode, unsigned int *keycode)
-{
-        struct key_entry *key = dell_wmi_get_entry_by_scancode(scancode);
-
-        if (key && key->type == KE_KEY) {
-                *keycode = key->keycode;
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
-static int dell_wmi_setkeycode(struct input_dev *dev,
-                                unsigned int scancode, unsigned int keycode)
-{
-        struct key_entry *key;
-        unsigned int old_keycode;
-
-        key = dell_wmi_get_entry_by_scancode(scancode);
-        if (key && key->type == KE_KEY) {
-                old_keycode = key->keycode;
-                key->keycode = keycode;
-                set_bit(keycode, dev->keybit);
-                if (!dell_wmi_get_entry_by_keycode(old_keycode))
-                        clear_bit(old_keycode, dev->keybit);
-                return 0;
-        }
-        return -EINVAL;
-}
-
 static void dell_wmi_notify(u32 value, void *context)
 {
         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
-        static struct key_entry *key;
         union acpi_object *obj;
         acpi_status status;
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO "dell-wmi: bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
         obj = (union acpi_object *)response.pointer;
 
         if (obj && obj->type == ACPI_TYPE_BUFFER) {
+                const struct key_entry *key;
                 int reported_key;
                 u16 *buffer_entry = (u16 *)obj->buffer.pointer;
+
                 if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
-                        printk(KERN_INFO "dell-wmi: Received unknown WMI event"
-                                         " (0x%x)\n", buffer_entry[1]);
+                        pr_info("Received unknown WMI event (0x%x)\n",
+                                buffer_entry[1]);
                         kfree(obj);
                         return;
                 }
@@ -226,103 +166,108 @@ static void dell_wmi_notify(u32 value, void *context)
                 else
                         reported_key = (int)buffer_entry[1] & 0xffff;
 
-                key = dell_wmi_get_entry_by_scancode(reported_key);
-
+                key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
+                                                        reported_key);
                 if (!key) {
-                        printk(KERN_INFO "dell-wmi: Unknown key %x pressed\n",
-                                reported_key);
+                        pr_info("Unknown key %x pressed\n", reported_key);
                 } else if ((key->keycode == KEY_BRIGHTNESSUP ||
                             key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
                         /* Don't report brightness notifications that will also
                          * come via ACPI */
                         ;
                 } else {
-                        input_report_key(dell_wmi_input_dev, key->keycode, 1);
-                        input_sync(dell_wmi_input_dev);
-                        input_report_key(dell_wmi_input_dev, key->keycode, 0);
-                        input_sync(dell_wmi_input_dev);
+                        sparse_keymap_report_entry(dell_wmi_input_dev, key,
+                                                   1, true);
                 }
         }
         kfree(obj);
 }
 
-
-static void setup_new_hk_map(const struct dmi_header *dm)
+static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
 {
-
+        int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
+                                sizeof(struct dell_bios_keymap_entry);
+        struct key_entry *keymap;
         int i;
-        int hotkey_num = (dm->length-4)/sizeof(struct dell_new_keymap_entry);
-        struct dell_hotkey_table *table =
-                container_of(dm, struct dell_hotkey_table, header);
 
-        dell_new_wmi_keymap = kzalloc((hotkey_num+1) *
-                                      sizeof(struct key_entry), GFP_KERNEL);
+        keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
+        if (!keymap)
+                return NULL;
 
         for (i = 0; i < hotkey_num; i++) {
-                dell_new_wmi_keymap[i].type = KE_KEY;
-                dell_new_wmi_keymap[i].code = table->keymap[i].scancode;
-                dell_new_wmi_keymap[i].keycode =
-                        (table->keymap[i].keycode > 255) ? 0 :
-                        bios_to_linux_keycode[table->keymap[i].keycode];
+                const struct dell_bios_keymap_entry *bios_entry =
+                                        &dell_bios_hotkey_table->keymap[i];
+                keymap[i].type = KE_KEY;
+                keymap[i].code = bios_entry->scancode;
+                keymap[i].keycode = bios_entry->keycode < 256 ?
+                                    bios_to_linux_keycode[bios_entry->keycode] :
+                                    KEY_RESERVED;
         }
 
-        dell_new_wmi_keymap[i].type = KE_END;
-        dell_new_wmi_keymap[i].code = 0;
-        dell_new_wmi_keymap[i].keycode = 0;
-
-        dell_wmi_keymap = dell_new_wmi_keymap;
+        keymap[hotkey_num].type = KE_END;
 
+        return keymap;
 }
 
-
-static void find_hk_type(const struct dmi_header *dm, void *dummy)
-{
-
-        if ((dm->type == 0xb2) && (dm->length > 6)) {
-                dell_new_hk_type = true;
-                setup_new_hk_map(dm);
-        }
-
-}
-
-
 static int __init dell_wmi_input_setup(void)
 {
-        struct key_entry *key;
         int err;
 
         dell_wmi_input_dev = input_allocate_device();
-
         if (!dell_wmi_input_dev)
                 return -ENOMEM;
 
         dell_wmi_input_dev->name = "Dell WMI hotkeys";
         dell_wmi_input_dev->phys = "wmi/input0";
         dell_wmi_input_dev->id.bustype = BUS_HOST;
-        dell_wmi_input_dev->getkeycode = dell_wmi_getkeycode;
-        dell_wmi_input_dev->setkeycode = dell_wmi_setkeycode;
-
-        for (key = dell_wmi_keymap; key->type != KE_END; key++) {
-                switch (key->type) {
-                case KE_KEY:
-                        set_bit(EV_KEY, dell_wmi_input_dev->evbit);
-                        set_bit(key->keycode, dell_wmi_input_dev->keybit);
-                        break;
-                case KE_SW:
-                        set_bit(EV_SW, dell_wmi_input_dev->evbit);
-                        set_bit(key->keycode, dell_wmi_input_dev->swbit);
-                        break;
+
+        if (dell_new_hk_type) {
+                const struct key_entry *keymap = dell_wmi_prepare_new_keymap();
+                if (!keymap) {
+                        err = -ENOMEM;
+                        goto err_free_dev;
                 }
-        }
 
-        err = input_register_device(dell_wmi_input_dev);
+                err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);
 
-        if (err) {
-                input_free_device(dell_wmi_input_dev);
-                return err;
+                /*
+                 * Sparse keymap library makes a copy of keymap so we
+                 * don't need the original one that was allocated.
+                 */
+                kfree(keymap);
+        } else {
+                err = sparse_keymap_setup(dell_wmi_input_dev,
+                                          dell_wmi_legacy_keymap, NULL);
         }
+        if (err)
+                goto err_free_dev;
+
+        err = input_register_device(dell_wmi_input_dev);
+        if (err)
+                goto err_free_keymap;
 
         return 0;
+
+ err_free_keymap:
+        sparse_keymap_free(dell_wmi_input_dev);
+ err_free_dev:
+        input_free_device(dell_wmi_input_dev);
+        return err;
+}
+
+static void dell_wmi_input_destroy(void)
+{
+        sparse_keymap_free(dell_wmi_input_dev);
+        input_unregister_device(dell_wmi_input_dev);
+}
+
+static void __init find_hk_type(const struct dmi_header *dm, void *dummy)
+{
+        if (dm->type == 0xb2 && dm->length > 6) {
+                dell_new_hk_type = true;
+                dell_bios_hotkey_table =
+                        container_of(dm, struct dell_bios_hotkey_table, header);
+        }
 }
 
 static int __init dell_wmi_init(void)
@@ -331,7 +276,7 @@ static int __init dell_wmi_init(void)
         acpi_status status;
 
         if (!wmi_has_guid(DELL_EVENT_GUID)) {
-                printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
+                pr_warn("No known WMI GUID found\n");
                 return -ENODEV;
         }
 
@@ -339,34 +284,24 @@ static int __init dell_wmi_init(void)
         acpi_video = acpi_video_backlight_support();
 
         err = dell_wmi_input_setup();
-        if (err) {
-                if (dell_new_hk_type)
-                        kfree(dell_wmi_keymap);
+        if (err)
                 return err;
-        }
 
         status = wmi_install_notify_handler(DELL_EVENT_GUID,
                                          dell_wmi_notify, NULL);
         if (ACPI_FAILURE(status)) {
-                input_unregister_device(dell_wmi_input_dev);
-                if (dell_new_hk_type)
-                        kfree(dell_wmi_keymap);
-                printk(KERN_ERR
-                        "dell-wmi: Unable to register notify handler - %d\n",
-                        status);
+                dell_wmi_input_destroy();
+                pr_err("Unable to register notify handler - %d\n", status);
                 return -ENODEV;
         }
 
         return 0;
 }
+module_init(dell_wmi_init);
 
 static void __exit dell_wmi_exit(void)
 {
         wmi_remove_notify_handler(DELL_EVENT_GUID);
-        input_unregister_device(dell_wmi_input_dev);
-        if (dell_new_hk_type)
-                kfree(dell_wmi_keymap);
+        dell_wmi_input_destroy();
 }
-
-module_init(dell_wmi_init);
 module_exit(dell_wmi_exit);
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 6b8e06206c46..1c45d92e2163 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -165,6 +165,7 @@ struct eeepc_laptop {
         u16 event_count[128];           /* count for each event */
 
         struct platform_device *platform_device;
+        struct acpi_device *device;             /* the device we are in */
         struct device *hwmon_device;
         struct backlight_device *backlight_device;
 
@@ -227,7 +228,7 @@ static int set_acpi(struct eeepc_laptop *eeepc, int cm, int value)
                 return -ENODEV;
 
         if (write_acpi_int(eeepc->handle, method, value))
-                pr_warning("Error writing %s\n", method);
+                pr_warn("Error writing %s\n", method);
         return 0;
 }
 
@@ -242,7 +243,7 @@ static int get_acpi(struct eeepc_laptop *eeepc, int cm)
                 return -ENODEV;
 
         if (read_acpi_int(eeepc->handle, method, &value))
-                pr_warning("Error reading %s\n", method);
+                pr_warn("Error reading %s\n", method);
         return value;
 }
 
@@ -260,7 +261,7 @@ static int acpi_setter_handle(struct eeepc_laptop *eeepc, int cm,
         status = acpi_get_handle(eeepc->handle, (char *)method,
                                  handle);
         if (status != AE_OK) {
-                pr_warning("Error finding %s\n", method);
+                pr_warn("Error finding %s\n", method);
                 return -ENODEV;
         }
         return 0;
@@ -416,7 +417,7 @@ static ssize_t store_cpufv_disabled(struct device *dev,
         switch (value) {
         case 0:
                 if (eeepc->cpufv_disabled)
-                        pr_warning("cpufv enabled (not officially supported "
+                        pr_warn("cpufv enabled (not officially supported "
                                 "on this model)\n");
                 eeepc->cpufv_disabled = false;
                 return rv;
@@ -528,6 +529,15 @@ static void tpd_led_set(struct led_classdev *led_cdev,
         queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
 }
 
+static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
+{
+        struct eeepc_laptop *eeepc;
+
+        eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
+
+        return get_acpi(eeepc, CM_ASL_TPD);
+}
+
 static int eeepc_led_init(struct eeepc_laptop *eeepc)
 {
         int rv;
@@ -542,6 +552,8 @@ static int eeepc_led_init(struct eeepc_laptop *eeepc)
 
         eeepc->tpd_led.name = "eeepc::touchpad";
         eeepc->tpd_led.brightness_set = tpd_led_set;
+        if (get_acpi(eeepc, CM_ASL_TPD) >= 0) /* if method is available */
+          eeepc->tpd_led.brightness_get = tpd_led_get;
         eeepc->tpd_led.max_brightness = 1;
 
         rv = led_classdev_register(&eeepc->platform_device->dev,
@@ -573,8 +585,9 @@ static bool eeepc_wlan_rfkill_blocked(struct eeepc_laptop *eeepc)
         return true;
 }
 
-static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc)
+static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
 {
+        struct pci_dev *port;
         struct pci_dev *dev;
         struct pci_bus *bus;
         bool blocked = eeepc_wlan_rfkill_blocked(eeepc);
@@ -587,9 +600,16 @@ static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc)
         mutex_lock(&eeepc->hotplug_lock);
 
         if (eeepc->hotplug_slot) {
-                bus = pci_find_bus(0, 1);
+                port = acpi_get_pci_dev(handle);
+                if (!port) {
+                        pr_warning("Unable to find port\n");
+                        goto out_unlock;
+                }
+
+                bus = port->subordinate;
+
                 if (!bus) {
-                        pr_warning("Unable to find PCI bus 1?\n");
+                        pr_warn("Unable to find PCI bus 1?\n");
                         goto out_unlock;
                 }
 
@@ -597,15 +617,16 @@ static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc)
                         pr_err("Unable to read PCI config space?\n");
                         goto out_unlock;
                 }
+
                 absent = (l == 0xffffffff);
 
                 if (blocked != absent) {
-                        pr_warning("BIOS says wireless lan is %s, "
-                                        "but the pci device is %s\n",
+                        pr_warn("BIOS says wireless lan is %s, "
+                                "but the pci device is %s\n",
                                 blocked ? "blocked" : "unblocked",
                                 absent ? "absent" : "present");
-                        pr_warning("skipped wireless hotplug as probably "
-                                        "inappropriate for this model\n");
+                        pr_warn("skipped wireless hotplug as probably "
+                                "inappropriate for this model\n");
                         goto out_unlock;
                 }
 
@@ -635,6 +656,17 @@ out_unlock:
         mutex_unlock(&eeepc->hotplug_lock);
 }
 
+static void eeepc_rfkill_hotplug_update(struct eeepc_laptop *eeepc, char *node)
+{
+        acpi_status status = AE_OK;
+        acpi_handle handle;
+
+        status = acpi_get_handle(NULL, node, &handle);
+
+        if (ACPI_SUCCESS(status))
+                eeepc_rfkill_hotplug(eeepc, handle);
+}
+
 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
 {
         struct eeepc_laptop *eeepc = data;
@@ -642,7 +674,7 @@ static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
         if (event != ACPI_NOTIFY_BUS_CHECK)
                 return;
 
-        eeepc_rfkill_hotplug(eeepc);
+        eeepc_rfkill_hotplug(eeepc, handle);
 }
 
 static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
@@ -659,7 +691,13 @@ static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
                                                      eeepc_rfkill_notify,
                                                      eeepc);
                 if (ACPI_FAILURE(status))
-                        pr_warning("Failed to register notify on %s\n", node);
+                        pr_warn("Failed to register notify on %s\n", node);
+
+                /*
+                 * Refresh pci hotplug in case the rfkill state was
+                 * changed during setup.
+                 */
+                eeepc_rfkill_hotplug(eeepc, handle);
         } else
                 return -ENODEV;
 
@@ -681,6 +719,12 @@ static void eeepc_unregister_rfkill_notifier(struct eeepc_laptop *eeepc,
                 if (ACPI_FAILURE(status))
                         pr_err("Error removing rfkill notify handler %s\n",
                                 node);
+                        /*
+                         * Refresh pci hotplug in case the rfkill
+                         * state was changed after
+                         * eeepc_unregister_rfkill_notifier()
+                         */
+                eeepc_rfkill_hotplug(eeepc, handle);
         }
 }
 
@@ -804,11 +848,7 @@ static void eeepc_rfkill_exit(struct eeepc_laptop *eeepc)
                 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);
 
@@ -877,11 +917,6 @@ static int eeepc_rfkill_init(struct eeepc_laptop *eeepc)
         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)
@@ -916,8 +951,11 @@ 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->wlan_rfkill) {
+                eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P5");
+                eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P6");
+                eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P7");
+        }
 
         if (eeepc->bluetooth_rfkill)
                 rfkill_set_sw_state(eeepc->bluetooth_rfkill,
@@ -1114,7 +1152,7 @@ static int update_bl_status(struct backlight_device *bd)
         return set_brightness(bd, bd->props.brightness);
 }
 
-static struct backlight_ops eeepcbl_ops = {
+static const struct backlight_ops eeepcbl_ops = {
         .get_brightness = read_brightness,
         .update_status = update_bl_status,
 };
@@ -1135,6 +1173,7 @@ static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
         struct backlight_device *bd;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = 15;
         bd = backlight_device_register(EEEPC_LAPTOP_FILE,
                                        &eeepc->platform_device->dev, eeepc,
@@ -1193,9 +1232,9 @@ static int eeepc_input_init(struct eeepc_laptop *eeepc)
         eeepc->inputdev = input;
         return 0;
 
- err_free_keymap:
+err_free_keymap:
         sparse_keymap_free(input);
- err_free_dev:
+err_free_dev:
         input_free_device(input);
         return error;
 }
@@ -1206,6 +1245,7 @@ static void eeepc_input_exit(struct eeepc_laptop *eeepc)
                 sparse_keymap_free(eeepc->inputdev);
                 input_unregister_device(eeepc->inputdev);
         }
+        eeepc->inputdev = NULL;
 }
 
 /*
@@ -1308,7 +1348,7 @@ 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.
+        /* Some BIOSes do not report cm although it is available.
            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)) {
@@ -1326,16 +1366,15 @@ static void cmsg_quirks(struct eeepc_laptop *eeepc)
         cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
 }
 
-static int eeepc_acpi_init(struct eeepc_laptop *eeepc,
-                           struct acpi_device *device)
+static int __devinit eeepc_acpi_init(struct eeepc_laptop *eeepc)
 {
         unsigned int init_flags;
         int result;
 
-        result = acpi_bus_get_status(device);
+        result = acpi_bus_get_status(eeepc->device);
         if (result)
                 return result;
-        if (!device->status.present) {
+        if (!eeepc->device->status.present) {
                 pr_err("Hotkey device not present, aborting\n");
                 return -ENODEV;
         }
@@ -1384,12 +1423,13 @@ static int __devinit eeepc_acpi_add(struct acpi_device *device)
         strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
         strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
         device->driver_data = eeepc;
+        eeepc->device = device;
 
         eeepc->hotplug_disabled = hotplug_disabled;
 
         eeepc_dmi_check(eeepc);
 
-        result = eeepc_acpi_init(eeepc, device);
+        result = eeepc_acpi_init(eeepc);
         if (result)
                 goto fail_platform;
         eeepc_enable_camera(eeepc);
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index 9dc50fbf3d0b..4aa867a9b88b 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -2,6 +2,7 @@
  * Eee PC WMI hotkey driver
  *
  * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
  *
  * Portions based on wistron_btns.c:
  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
@@ -28,385 +29,141 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/input/sparse-keymap.h>
-#include <linux/fb.h>
-#include <linux/backlight.h>
-#include <linux/platform_device.h>
+#include <linux/dmi.h>
 #include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
+
+#include "asus-wmi.h"
 
 #define EEEPC_WMI_FILE  "eeepc-wmi"
 
-MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
 MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
 MODULE_LICENSE("GPL");
 
+#define EEEPC_ACPI_HID          "ASUS010" /* old _HID used in eeepc-laptop */
+
 #define EEEPC_WMI_EVENT_GUID    "ABBC0F72-8EA1-11D1-00A0-C90629100000"
-#define EEEPC_WMI_MGMT_GUID     "97845ED0-4E6D-11DE-8A39-0800200C9A66"
 
 MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID);
-MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID);
 
-#define NOTIFY_BRNUP_MIN        0x11
-#define NOTIFY_BRNUP_MAX        0x1f
-#define NOTIFY_BRNDOWN_MIN      0x20
-#define NOTIFY_BRNDOWN_MAX      0x2e
+static bool hotplug_wireless;
 
-#define EEEPC_WMI_METHODID_DEVS 0x53564544
-#define EEEPC_WMI_METHODID_DSTS 0x53544344
-
-#define EEEPC_WMI_DEVID_BACKLIGHT       0x00050012
+module_param(hotplug_wireless, bool, 0444);
+MODULE_PARM_DESC(hotplug_wireless,
+                 "Enable hotplug for wireless device. "
+                 "If your laptop needs that, please report to "
+                 "acpi4asus-user@lists.sourceforge.net.");
 
 static const struct key_entry eeepc_wmi_keymap[] = {
         /* Sleep already handled via generic ACPI code */
-        { KE_KEY, 0x5d, { KEY_WLAN } },
-        { KE_KEY, 0x32, { KEY_MUTE } },
-        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
         { KE_KEY, 0x30, { KEY_VOLUMEUP } },
-        { KE_IGNORE, NOTIFY_BRNDOWN_MIN, { KEY_BRIGHTNESSDOWN } },
-        { KE_IGNORE, NOTIFY_BRNUP_MIN, { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 0x32, { KEY_MUTE } },
+        { KE_KEY, 0x5c, { KEY_F15 } }, /* Power Gear key */
+        { KE_KEY, 0x5d, { KEY_WLAN } },
+        { KE_KEY, 0x6b, { KEY_TOUCHPAD_TOGGLE } }, /* Toggle Touchpad */
+        { KE_KEY, 0x82, { KEY_CAMERA } },
+        { KE_KEY, 0x83, { KEY_CAMERA_ZOOMIN } },
+        { KE_KEY, 0x88, { KEY_WLAN } },
+        { KE_KEY, 0xbd, { KEY_CAMERA } },
         { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
+        { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
+        { KE_KEY, 0xe8, { KEY_SCREENLOCK } },
+        { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
+        { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
+        { KE_KEY, 0xec, { KEY_CAMERA_UP } },
+        { KE_KEY, 0xed, { KEY_CAMERA_DOWN } },
+        { KE_KEY, 0xee, { KEY_CAMERA_LEFT } },
+        { KE_KEY, 0xef, { KEY_CAMERA_RIGHT } },
         { KE_END, 0},
 };
 
-struct bios_args {
-        u32     dev_id;
-        u32     ctrl_param;
-};
-
-struct eeepc_wmi {
-        struct input_dev *inputdev;
-        struct backlight_device *backlight_device;
-};
-
-static struct platform_device *platform_device;
-
-static int eeepc_wmi_input_init(struct eeepc_wmi *eeepc)
+static acpi_status eeepc_wmi_parse_device(acpi_handle handle, u32 level,
+                                                 void *context, void **retval)
 {
-        int err;
-
-        eeepc->inputdev = input_allocate_device();
-        if (!eeepc->inputdev)
-                return -ENOMEM;
-
-        eeepc->inputdev->name = "Eee PC WMI hotkeys";
-        eeepc->inputdev->phys = EEEPC_WMI_FILE "/input0";
-        eeepc->inputdev->id.bustype = BUS_HOST;
-        eeepc->inputdev->dev.parent = &platform_device->dev;
-
-        err = sparse_keymap_setup(eeepc->inputdev, eeepc_wmi_keymap, NULL);
-        if (err)
-                goto err_free_dev;
-
-        err = input_register_device(eeepc->inputdev);
-        if (err)
-                goto err_free_keymap;
-
-        return 0;
-
-err_free_keymap:
-        sparse_keymap_free(eeepc->inputdev);
-err_free_dev:
-        input_free_device(eeepc->inputdev);
-        return err;
+        pr_warn("Found legacy ATKD device (%s)\n", EEEPC_ACPI_HID);
+        *(bool *)context = true;
+        return AE_CTRL_TERMINATE;
 }
 
-static void eeepc_wmi_input_exit(struct eeepc_wmi *eeepc)
+static int eeepc_wmi_check_atkd(void)
 {
-        if (eeepc->inputdev) {
-                sparse_keymap_free(eeepc->inputdev);
-                input_unregister_device(eeepc->inputdev);
-        }
-
-        eeepc->inputdev = NULL;
-}
-
-static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *ctrl_param)
-{
-        struct acpi_buffer input = { (acpi_size)sizeof(u32), &dev_id };
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
         acpi_status status;
-        u32 tmp;
-
-        status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
-                        1, EEEPC_WMI_METHODID_DSTS, &input, &output);
+        bool found = false;
 
-        if (ACPI_FAILURE(status))
-                return status;
+        status = acpi_get_devices(EEEPC_ACPI_HID, eeepc_wmi_parse_device,
+                                  &found, NULL);
 
-        obj = (union acpi_object *)output.pointer;
-        if (obj && obj->type == ACPI_TYPE_INTEGER)
-                tmp = (u32)obj->integer.value;
-        else
-                tmp = 0;
-
-        if (ctrl_param)
-                *ctrl_param = tmp;
-
-        kfree(obj);
-
-        return status;
-
-}
-
-static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param)
-{
-        struct bios_args args = {
-                .dev_id = dev_id,
-                .ctrl_param = ctrl_param,
-        };
-        struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
-        acpi_status status;
-
-        status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
-                        1, EEEPC_WMI_METHODID_DEVS, &input, NULL);
-
-        return status;
-}
-
-static int read_brightness(struct backlight_device *bd)
-{
-        static u32 ctrl_param;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_BACKLIGHT, &ctrl_param);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else
-                return ctrl_param & 0xFF;
-}
-
-static int update_bl_status(struct backlight_device *bd)
-{
-
-        static u32 ctrl_param;
-        acpi_status status;
-
-        ctrl_param = bd->props.brightness;
-
-        status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BACKLIGHT, ctrl_param);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else
+        if (ACPI_FAILURE(status) || !found)
                 return 0;
+        return -1;
 }
 
-static const struct backlight_ops eeepc_wmi_bl_ops = {
-        .get_brightness = read_brightness,
-        .update_status = update_bl_status,
-};
-
-static int eeepc_wmi_backlight_notify(struct eeepc_wmi *eeepc, int code)
+static int eeepc_wmi_probe(struct platform_device *pdev)
 {
-        struct backlight_device *bd = eeepc->backlight_device;
-        int old = bd->props.brightness;
-        int new = old;
-
-        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
-                new = code - NOTIFY_BRNUP_MIN + 1;
-        else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
-                new = code - NOTIFY_BRNDOWN_MIN;
-
-        bd->props.brightness = new;
-        backlight_update_status(bd);
-        backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
-
-        return old;
-}
-
-static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
-{
-        struct backlight_device *bd;
-        struct backlight_properties props;
-
-        memset(&props, 0, sizeof(struct backlight_properties));
-        props.max_brightness = 15;
-        bd = backlight_device_register(EEEPC_WMI_FILE,
-                                       &platform_device->dev, eeepc,
-                                       &eeepc_wmi_bl_ops, &props);
-        if (IS_ERR(bd)) {
-                pr_err("Could not register backlight device\n");
-                return PTR_ERR(bd);
+        if (eeepc_wmi_check_atkd()) {
+                pr_warn("WMI device present, but legacy ATKD device is also "
+                        "present and enabled\n");
+                pr_warn("You probably booted with acpi_osi=\"Linux\" or "
+                        "acpi_osi=\"!Windows 2009\"\n");
+                pr_warn("Can't load eeepc-wmi, use default acpi_osi "
+                        "(preferred) or eeepc-laptop\n");
+                return -EBUSY;
         }
-
-        eeepc->backlight_device = bd;
-
-        bd->props.brightness = read_brightness(bd);
-        bd->props.power = FB_BLANK_UNBLANK;
-        backlight_update_status(bd);
-
         return 0;
 }
 
-static void eeepc_wmi_backlight_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->backlight_device)
-                backlight_device_unregister(eeepc->backlight_device);
-
-        eeepc->backlight_device = NULL;
-}
-
-static void eeepc_wmi_notify(u32 value, void *context)
+static void eeepc_dmi_check(struct asus_wmi_driver *driver)
 {
-        struct eeepc_wmi *eeepc = context;
-        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_status status;
-        int code;
-        int orig_code;
+        const char *model;
 
-        status = wmi_get_event_data(value, &response);
-        if (status != AE_OK) {
-                pr_err("bad event status 0x%x\n", status);
+        model = dmi_get_system_info(DMI_PRODUCT_NAME);
+        if (!model)
                 return;
-        }
-
-        obj = (union acpi_object *)response.pointer;
-
-        if (obj && obj->type == ACPI_TYPE_INTEGER) {
-                code = obj->integer.value;
-                orig_code = code;
-
-                if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
-                        code = NOTIFY_BRNUP_MIN;
-                else if (code >= NOTIFY_BRNDOWN_MIN &&
-                         code <= NOTIFY_BRNDOWN_MAX)
-                        code = NOTIFY_BRNDOWN_MIN;
-
-                if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
-                        if (!acpi_video_backlight_support())
-                                eeepc_wmi_backlight_notify(eeepc, orig_code);
-                }
-
-                if (!sparse_keymap_report_event(eeepc->inputdev,
-                                                code, 1, true))
-                        pr_info("Unknown key %x pressed\n", code);
-        }
-
-        kfree(obj);
-}
-
-static int __devinit eeepc_wmi_platform_probe(struct platform_device *device)
-{
-        struct eeepc_wmi *eeepc;
-        int err;
-        acpi_status status;
-
-        eeepc = platform_get_drvdata(device);
-
-        err = eeepc_wmi_input_init(eeepc);
-        if (err)
-                goto error_input;
-
-        if (!acpi_video_backlight_support()) {
-                err = eeepc_wmi_backlight_init(eeepc);
-                if (err)
-                        goto error_backlight;
-        } else
-                pr_info("Backlight controlled by ACPI video driver\n");
 
-        status = wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID,
-                                        eeepc_wmi_notify, eeepc);
-        if (ACPI_FAILURE(status)) {
-                pr_err("Unable to register notify handler - %d\n",
-                        status);
-                err = -ENODEV;
-                goto error_wmi;
+        /*
+         * Whitelist for wlan hotplug
+         *
+         * Asus 1000H needs the current hotplug code to handle
+         * Fn+F2 correctly. We may add other Asus here later, but
+         * it seems that most of the laptops supported by asus-wmi
+         * don't need to be on this list
+         */
+        if (strcmp(model, "1000H") == 0) {
+                driver->hotplug_wireless = true;
+                pr_info("wlan hotplug enabled\n");
         }
-
-        return 0;
-
-error_wmi:
-        eeepc_wmi_backlight_exit(eeepc);
-error_backlight:
-        eeepc_wmi_input_exit(eeepc);
-error_input:
-        return err;
 }
 
-static int __devexit eeepc_wmi_platform_remove(struct platform_device *device)
+static void eeepc_wmi_quirks(struct asus_wmi_driver *driver)
 {
-        struct eeepc_wmi *eeepc;
-
-        eeepc = platform_get_drvdata(device);
-        wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
-        eeepc_wmi_backlight_exit(eeepc);
-        eeepc_wmi_input_exit(eeepc);
-
-        return 0;
+        driver->hotplug_wireless = hotplug_wireless;
+        eeepc_dmi_check(driver);
 }
 
-static struct platform_driver platform_driver = {
-        .driver = {
-                .name = EEEPC_WMI_FILE,
-                .owner = THIS_MODULE,
-        },
-        .probe = eeepc_wmi_platform_probe,
-        .remove = __devexit_p(eeepc_wmi_platform_remove),
+static struct asus_wmi_driver asus_wmi_driver = {
+        .name = EEEPC_WMI_FILE,
+        .owner = THIS_MODULE,
+        .event_guid = EEEPC_WMI_EVENT_GUID,
+        .keymap = eeepc_wmi_keymap,
+        .input_name = "Eee PC WMI hotkeys",
+        .input_phys = EEEPC_WMI_FILE "/input0",
+        .probe = eeepc_wmi_probe,
+        .quirks = eeepc_wmi_quirks,
 };
 
+
 static int __init eeepc_wmi_init(void)
 {
-        struct eeepc_wmi *eeepc;
-        int err;
-
-        if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID) ||
-            !wmi_has_guid(EEEPC_WMI_MGMT_GUID)) {
-                pr_warning("No known WMI GUID found\n");
-                return -ENODEV;
-        }
-
-        eeepc = kzalloc(sizeof(struct eeepc_wmi), GFP_KERNEL);
-        if (!eeepc)
-                return -ENOMEM;
-
-        platform_device = platform_device_alloc(EEEPC_WMI_FILE, -1);
-        if (!platform_device) {
-                pr_warning("Unable to allocate platform device\n");
-                err = -ENOMEM;
-                goto fail_platform;
-        }
-
-        err = platform_device_add(platform_device);
-        if (err) {
-                pr_warning("Unable to add platform device\n");
-                goto put_dev;
-        }
-
-        platform_set_drvdata(platform_device, eeepc);
-
-        err = platform_driver_register(&platform_driver);
-        if (err) {
-                pr_warning("Unable to register platform driver\n");
-                goto del_dev;
-        }
-
-        return 0;
-
-del_dev:
-        platform_device_del(platform_device);
-put_dev:
-        platform_device_put(platform_device);
-fail_platform:
-        kfree(eeepc);
-
-        return err;
+        return asus_wmi_register_driver(&asus_wmi_driver);
 }
 
 static void __exit eeepc_wmi_exit(void)
 {
-        struct eeepc_wmi *eeepc;
-
-        eeepc = platform_get_drvdata(platform_device);
-        platform_driver_unregister(&platform_driver);
-        platform_device_unregister(platform_device);
-        kfree(eeepc);
+        asus_wmi_unregister_driver(&asus_wmi_driver);
 }
 
 module_init(eeepc_wmi_init);
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index f44cd2620ff9..6b26666b37f2 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -56,6 +56,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -437,7 +439,7 @@ static int bl_update_status(struct backlight_device *b)
         return ret;
 }
 
-static struct backlight_ops fujitsubl_ops = {
+static const struct backlight_ops fujitsubl_ops = {
         .get_brightness = bl_get_brightness,
         .update_status = bl_update_status,
 };
@@ -585,8 +587,7 @@ static struct platform_driver fujitsupf_driver = {
 static void dmi_check_cb_common(const struct dmi_system_id *id)
 {
         acpi_handle handle;
-        printk(KERN_INFO "fujitsu-laptop: Identified laptop model '%s'.\n",
-               id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         if (use_alt_lcd_levels == -1) {
                 if (ACPI_SUCCESS(acpi_get_handle(NULL,
                                 "\\_SB.PCI0.LPCB.FJEX.SBL2", &handle)))
@@ -689,13 +690,13 @@ static int acpi_fujitsu_add(struct acpi_device *device)
         if (error)
                 goto err_free_input_dev;
 
-        result = acpi_bus_get_power(fujitsu->acpi_handle, &state);
+        result = acpi_bus_update_power(fujitsu->acpi_handle, &state);
         if (result) {
-                printk(KERN_ERR "Error reading power state\n");
+                pr_err("Error reading power state\n");
                 goto err_unregister_input_dev;
         }
 
-        printk(KERN_INFO "ACPI: %s [%s] (%s)\n",
+        pr_info("ACPI: %s [%s] (%s)\n",
                acpi_device_name(device), acpi_device_bid(device),
                !device->power.state ? "on" : "off");
 
@@ -707,7 +708,7 @@ static int acpi_fujitsu_add(struct acpi_device *device)
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
-                        printk(KERN_ERR "_INI Method failed\n");
+                        pr_err("_INI Method failed\n");
         }
 
         /* do config (detect defaults) */
@@ -827,7 +828,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
         error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int),
                         GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 goto err_stop;
         }
 
@@ -857,15 +858,15 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
         if (error)
                 goto err_free_input_dev;
 
-        result = acpi_bus_get_power(fujitsu_hotkey->acpi_handle, &state);
+        result = acpi_bus_update_power(fujitsu_hotkey->acpi_handle, &state);
         if (result) {
-                printk(KERN_ERR "Error reading power state\n");
+                pr_err("Error reading power state\n");
                 goto err_unregister_input_dev;
         }
 
-        printk(KERN_INFO "ACPI: %s [%s] (%s)\n",
-               acpi_device_name(device), acpi_device_bid(device),
-               !device->power.state ? "on" : "off");
+        pr_info("ACPI: %s [%s] (%s)\n",
+                acpi_device_name(device), acpi_device_bid(device),
+                !device->power.state ? "on" : "off");
 
         fujitsu_hotkey->dev = device;
 
@@ -875,7 +876,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
-                        printk(KERN_ERR "_INI Method failed\n");
+                        pr_err("_INI Method failed\n");
         }
 
         i = 0;
@@ -897,8 +898,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                         call_fext_func(FUNC_RFKILL, 0x4, 0x0, 0x0);
 
         /* Suspect this is a keymap of the application panel, print it */
-        printk(KERN_INFO "fujitsu-laptop: BTNI: [0x%x]\n",
-                call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0));
+        pr_info("BTNI: [0x%x]\n", call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0));
 
 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
         if (call_fext_func(FUNC_LEDS, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON) {
@@ -907,8 +907,8 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (result == 0) {
                         fujitsu_hotkey->logolamp_registered = 1;
                 } else {
-                        printk(KERN_ERR "fujitsu-laptop: Could not register "
-                        "LED handler for logo lamp, error %i\n", result);
+                        pr_err("Could not register LED handler for logo lamp, error %i\n",
+                               result);
                 }
         }
 
@@ -919,8 +919,8 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (result == 0) {
                         fujitsu_hotkey->kblamps_registered = 1;
                 } else {
-                        printk(KERN_ERR "fujitsu-laptop: Could not register "
-                        "LED handler for keyboard lamps, error %i\n", result);
+                        pr_err("Could not register LED handler for keyboard lamps, error %i\n",
+                               result);
                 }
         }
 #endif
@@ -1128,6 +1128,7 @@ static int __init fujitsu_init(void)
 
                 memset(&props, 0, sizeof(struct backlight_properties));
                 max_brightness = fujitsu->max_brightness;
+                props.type = BACKLIGHT_PLATFORM;
                 props.max_brightness = max_brightness - 1;
                 fujitsu->bl_device = backlight_device_register("fujitsu-laptop",
                                                                NULL, NULL,
@@ -1168,8 +1169,7 @@ static int __init fujitsu_init(void)
                         fujitsu->bl_device->props.power = 0;
         }
 
-        printk(KERN_INFO "fujitsu-laptop: driver " FUJITSU_DRIVER_VERSION
-               " successfully loaded.\n");
+        pr_info("driver " FUJITSU_DRIVER_VERSION " successfully loaded\n");
 
         return 0;
 
@@ -1215,7 +1215,7 @@ static void __exit fujitsu_cleanup(void)
 
         kfree(fujitsu);
 
-        printk(KERN_INFO "fujitsu-laptop: driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(fujitsu_init);
@@ -1240,7 +1240,7 @@ MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1D3:*:cvrS6410:*");
 MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1E6:*:cvrS6420:*");
 MODULE_ALIAS("dmi:*:svnFUJITSU:*:pvr:rvnFUJITSU:rnFJNB19C:*:cvrS7020:*");
 
-static struct pnp_device_id pnp_ids[] = {
+static struct pnp_device_id pnp_ids[] __used = {
         {.id = "FUJ02bf"},
         {.id = "FUJ02B1"},
         {.id = "FUJ02E3"},
diff --git a/drivers/platform/x86/hdaps.c b/drivers/platform/x86/hdaps.c
new file mode 100644
index 000000000000..5a34973dc164
--- /dev/null
+++ b/drivers/platform/x86/hdaps.c
@@ -0,0 +1,638 @@
+/*
+ * hdaps.c - driver for IBM's Hard Drive Active Protection System
+ *
+ * Copyright (C) 2005 Robert Love <rml@novell.com>
+ * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
+ *
+ * The HardDisk Active Protection System (hdaps) is present in IBM ThinkPads
+ * starting with the R40, T41, and X40.  It provides a basic two-axis
+ * accelerometer and other data, such as the device's temperature.
+ *
+ * This driver is based on the document by Mark A. Smith available at
+ * http://www.almaden.ibm.com/cs/people/marksmith/tpaps.html and a lot of trial
+ * and error.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License v2 as published by the
+ * Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/input-polldev.h>
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/timer.h>
+#include <linux/dmi.h>
+#include <linux/jiffies.h>
+#include <linux/io.h>
+
+#define HDAPS_LOW_PORT          0x1600  /* first port used by hdaps */
+#define HDAPS_NR_PORTS          0x30    /* number of ports: 0x1600 - 0x162f */
+
+#define HDAPS_PORT_STATE        0x1611  /* device state */
+#define HDAPS_PORT_YPOS         0x1612  /* y-axis position */
+#define HDAPS_PORT_XPOS         0x1614  /* x-axis position */
+#define HDAPS_PORT_TEMP1        0x1616  /* device temperature, in Celsius */
+#define HDAPS_PORT_YVAR         0x1617  /* y-axis variance (what is this?) */
+#define HDAPS_PORT_XVAR         0x1619  /* x-axis variance (what is this?) */
+#define HDAPS_PORT_TEMP2        0x161b  /* device temperature (again?) */
+#define HDAPS_PORT_UNKNOWN      0x161c  /* what is this? */
+#define HDAPS_PORT_KMACT        0x161d  /* keyboard or mouse activity */
+
+#define STATE_FRESH             0x50    /* accelerometer data is fresh */
+
+#define KEYBD_MASK              0x20    /* set if keyboard activity */
+#define MOUSE_MASK              0x40    /* set if mouse activity */
+#define KEYBD_ISSET(n)          (!! (n & KEYBD_MASK))   /* keyboard used? */
+#define MOUSE_ISSET(n)          (!! (n & MOUSE_MASK))   /* mouse used? */
+
+#define INIT_TIMEOUT_MSECS      4000    /* wait up to 4s for device init ... */
+#define INIT_WAIT_MSECS         200     /* ... in 200ms increments */
+
+#define HDAPS_POLL_INTERVAL     50      /* poll for input every 1/20s (50 ms)*/
+#define HDAPS_INPUT_FUZZ        4       /* input event threshold */
+#define HDAPS_INPUT_FLAT        4
+
+#define HDAPS_X_AXIS            (1 << 0)
+#define HDAPS_Y_AXIS            (1 << 1)
+#define HDAPS_BOTH_AXES         (HDAPS_X_AXIS | HDAPS_Y_AXIS)
+
+static struct platform_device *pdev;
+static struct input_polled_dev *hdaps_idev;
+static unsigned int hdaps_invert;
+static u8 km_activity;
+static int rest_x;
+static int rest_y;
+
+static DEFINE_MUTEX(hdaps_mtx);
+
+/*
+ * __get_latch - Get the value from a given port.  Callers must hold hdaps_mtx.
+ */
+static inline u8 __get_latch(u16 port)
+{
+        return inb(port) & 0xff;
+}
+
+/*
+ * __check_latch - Check a port latch for a given value.  Returns zero if the
+ * port contains the given value.  Callers must hold hdaps_mtx.
+ */
+static inline int __check_latch(u16 port, u8 val)
+{
+        if (__get_latch(port) == val)
+                return 0;
+        return -EINVAL;
+}
+
+/*
+ * __wait_latch - Wait up to 100us for a port latch to get a certain value,
+ * returning zero if the value is obtained.  Callers must hold hdaps_mtx.
+ */
+static int __wait_latch(u16 port, u8 val)
+{
+        unsigned int i;
+
+        for (i = 0; i < 20; i++) {
+                if (!__check_latch(port, val))
+                        return 0;
+                udelay(5);
+        }
+
+        return -EIO;
+}
+
+/*
+ * __device_refresh - request a refresh from the accelerometer.  Does not wait
+ * for refresh to complete.  Callers must hold hdaps_mtx.
+ */
+static void __device_refresh(void)
+{
+        udelay(200);
+        if (inb(0x1604) != STATE_FRESH) {
+                outb(0x11, 0x1610);
+                outb(0x01, 0x161f);
+        }
+}
+
+/*
+ * __device_refresh_sync - request a synchronous refresh from the
+ * accelerometer.  We wait for the refresh to complete.  Returns zero if
+ * successful and nonzero on error.  Callers must hold hdaps_mtx.
+ */
+static int __device_refresh_sync(void)
+{
+        __device_refresh();
+        return __wait_latch(0x1604, STATE_FRESH);
+}
+
+/*
+ * __device_complete - indicate to the accelerometer that we are done reading
+ * data, and then initiate an async refresh.  Callers must hold hdaps_mtx.
+ */
+static inline void __device_complete(void)
+{
+        inb(0x161f);
+        inb(0x1604);
+        __device_refresh();
+}
+
+/*
+ * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
+ * the given pointer.  Returns zero on success or a negative error on failure.
+ * Can sleep.
+ */
+static int hdaps_readb_one(unsigned int port, u8 *val)
+{
+        int ret;
+
+        mutex_lock(&hdaps_mtx);
+
+        /* do a sync refresh -- we need to be sure that we read fresh data */
+        ret = __device_refresh_sync();
+        if (ret)
+                goto out;
+
+        *val = inb(port);
+        __device_complete();
+
+out:
+        mutex_unlock(&hdaps_mtx);
+        return ret;
+}
+
+/* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
+static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
+                             int *x, int *y)
+{
+        /* do a sync refresh -- we need to be sure that we read fresh data */
+        if (__device_refresh_sync())
+                return -EIO;
+
+        *y = inw(port2);
+        *x = inw(port1);
+        km_activity = inb(HDAPS_PORT_KMACT);
+        __device_complete();
+
+        /* hdaps_invert is a bitvector to negate the axes */
+        if (hdaps_invert & HDAPS_X_AXIS)
+                *x = -*x;
+        if (hdaps_invert & HDAPS_Y_AXIS)
+                *y = -*y;
+
+        return 0;
+}
+
+/*
+ * hdaps_read_pair - reads the values from a pair of ports, placing the values
+ * in the given pointers.  Returns zero on success.  Can sleep.
+ */
+static int hdaps_read_pair(unsigned int port1, unsigned int port2,
+                           int *val1, int *val2)
+{
+        int ret;
+
+        mutex_lock(&hdaps_mtx);
+        ret = __hdaps_read_pair(port1, port2, val1, val2);
+        mutex_unlock(&hdaps_mtx);
+
+        return ret;
+}
+
+/*
+ * hdaps_device_init - initialize the accelerometer.  Returns zero on success
+ * and negative error code on failure.  Can sleep.
+ */
+static int hdaps_device_init(void)
+{
+        int total, ret = -ENXIO;
+
+        mutex_lock(&hdaps_mtx);
+
+        outb(0x13, 0x1610);
+        outb(0x01, 0x161f);
+        if (__wait_latch(0x161f, 0x00))
+                goto out;
+
+        /*
+         * Most ThinkPads return 0x01.
+         *
+         * Others--namely the R50p, T41p, and T42p--return 0x03.  These laptops
+         * have "inverted" axises.
+         *
+         * The 0x02 value occurs when the chip has been previously initialized.
+         */
+        if (__check_latch(0x1611, 0x03) &&
+                     __check_latch(0x1611, 0x02) &&
+                     __check_latch(0x1611, 0x01))
+                goto out;
+
+        printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x)\n",
+               __get_latch(0x1611));
+
+        outb(0x17, 0x1610);
+        outb(0x81, 0x1611);
+        outb(0x01, 0x161f);
+        if (__wait_latch(0x161f, 0x00))
+                goto out;
+        if (__wait_latch(0x1611, 0x00))
+                goto out;
+        if (__wait_latch(0x1612, 0x60))
+                goto out;
+        if (__wait_latch(0x1613, 0x00))
+                goto out;
+        outb(0x14, 0x1610);
+        outb(0x01, 0x1611);
+        outb(0x01, 0x161f);
+        if (__wait_latch(0x161f, 0x00))
+                goto out;
+        outb(0x10, 0x1610);
+        outb(0xc8, 0x1611);
+        outb(0x00, 0x1612);
+        outb(0x02, 0x1613);
+        outb(0x01, 0x161f);
+        if (__wait_latch(0x161f, 0x00))
+                goto out;
+        if (__device_refresh_sync())
+                goto out;
+        if (__wait_latch(0x1611, 0x00))
+                goto out;
+
+        /* we have done our dance, now let's wait for the applause */
+        for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
+                int x, y;
+
+                /* a read of the device helps push it into action */
+                __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
+                if (!__wait_latch(0x1611, 0x02)) {
+                        ret = 0;
+                        break;
+                }
+
+                msleep(INIT_WAIT_MSECS);
+        }
+
+out:
+        mutex_unlock(&hdaps_mtx);
+        return ret;
+}
+
+
+/* Device model stuff */
+
+static int hdaps_probe(struct platform_device *dev)
+{
+        int ret;
+
+        ret = hdaps_device_init();
+        if (ret)
+                return ret;
+
+        pr_info("device successfully initialized\n");
+        return 0;
+}
+
+static int hdaps_resume(struct platform_device *dev)
+{
+        return hdaps_device_init();
+}
+
+static struct platform_driver hdaps_driver = {
+        .probe = hdaps_probe,
+        .resume = hdaps_resume,
+        .driver = {
+                .name = "hdaps",
+                .owner = THIS_MODULE,
+        },
+};
+
+/*
+ * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_mtx.
+ */
+static void hdaps_calibrate(void)
+{
+        __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
+}
+
+static void hdaps_mousedev_poll(struct input_polled_dev *dev)
+{
+        struct input_dev *input_dev = dev->input;
+        int x, y;
+
+        mutex_lock(&hdaps_mtx);
+
+        if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
+                goto out;
+
+        input_report_abs(input_dev, ABS_X, x - rest_x);
+        input_report_abs(input_dev, ABS_Y, y - rest_y);
+        input_sync(input_dev);
+
+out:
+        mutex_unlock(&hdaps_mtx);
+}
+
+
+/* Sysfs Files */
+
+static ssize_t hdaps_position_show(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        int ret, x, y;
+
+        ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
+        if (ret)
+                return ret;
+
+        return sprintf(buf, "(%d,%d)\n", x, y);
+}
+
+static ssize_t hdaps_variance_show(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        int ret, x, y;
+
+        ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
+        if (ret)
+                return ret;
+
+        return sprintf(buf, "(%d,%d)\n", x, y);
+}
+
+static ssize_t hdaps_temp1_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        u8 temp;
+        int ret;
+
+        ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%u\n", temp);
+}
+
+static ssize_t hdaps_temp2_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        u8 temp;
+        int ret;
+
+        ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%u\n", temp);
+}
+
+static ssize_t hdaps_keyboard_activity_show(struct device *dev,
+                                            struct device_attribute *attr,
+                                            char *buf)
+{
+        return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
+}
+
+static ssize_t hdaps_mouse_activity_show(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
+{
+        return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
+}
+
+static ssize_t hdaps_calibrate_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
+}
+
+static ssize_t hdaps_calibrate_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        mutex_lock(&hdaps_mtx);
+        hdaps_calibrate();
+        mutex_unlock(&hdaps_mtx);
+
+        return count;
+}
+
+static ssize_t hdaps_invert_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%u\n", hdaps_invert);
+}
+
+static ssize_t hdaps_invert_store(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
+{
+        int invert;
+
+        if (sscanf(buf, "%d", &invert) != 1 ||
+            invert < 0 || invert > HDAPS_BOTH_AXES)
+                return -EINVAL;
+
+        hdaps_invert = invert;
+        hdaps_calibrate();
+
+        return count;
+}
+
+static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
+static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
+static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
+static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
+static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
+static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
+static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
+static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
+
+static struct attribute *hdaps_attributes[] = {
+        &dev_attr_position.attr,
+        &dev_attr_variance.attr,
+        &dev_attr_temp1.attr,
+        &dev_attr_temp2.attr,
+        &dev_attr_keyboard_activity.attr,
+        &dev_attr_mouse_activity.attr,
+        &dev_attr_calibrate.attr,
+        &dev_attr_invert.attr,
+        NULL,
+};
+
+static struct attribute_group hdaps_attribute_group = {
+        .attrs = hdaps_attributes,
+};
+
+
+/* Module stuff */
+
+/* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
+static int __init hdaps_dmi_match(const struct dmi_system_id *id)
+{
+        pr_info("%s detected\n", id->ident);
+        return 1;
+}
+
+/* hdaps_dmi_match_invert - found an inverted match. */
+static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
+{
+        hdaps_invert = (unsigned long)id->driver_data;
+        pr_info("inverting axis (%u) readings\n", hdaps_invert);
+        return hdaps_dmi_match(id);
+}
+
+#define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) {   \
+        .ident = vendor " " model,                      \
+        .callback = hdaps_dmi_match_invert,             \
+        .driver_data = (void *)axes,                    \
+        .matches = {                                    \
+                DMI_MATCH(DMI_BOARD_VENDOR, vendor),    \
+                DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
+        }                                               \
+}
+
+#define HDAPS_DMI_MATCH_NORMAL(vendor, model)           \
+        HDAPS_DMI_MATCH_INVERT(vendor, model, 0)
+
+/* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
+   "ThinkPad T42p", so the order of the entries matters.
+   If your ThinkPad is not recognized, please update to latest
+   BIOS. This is especially the case for some R52 ThinkPads. */
+static struct dmi_system_id __initdata hdaps_whitelist[] = {
+        HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61i", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
+        HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
+        HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
+        HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
+        { .ident = NULL }
+};
+
+static int __init hdaps_init(void)
+{
+        struct input_dev *idev;
+        int ret;
+
+        if (!dmi_check_system(hdaps_whitelist)) {
+                pr_warn("supported laptop not found!\n");
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
+                ret = -ENXIO;
+                goto out;
+        }
+
+        ret = platform_driver_register(&hdaps_driver);
+        if (ret)
+                goto out_region;
+
+        pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
+        if (IS_ERR(pdev)) {
+                ret = PTR_ERR(pdev);
+                goto out_driver;
+        }
+
+        ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
+        if (ret)
+                goto out_device;
+
+        hdaps_idev = input_allocate_polled_device();
+        if (!hdaps_idev) {
+                ret = -ENOMEM;
+                goto out_group;
+        }
+
+        hdaps_idev->poll = hdaps_mousedev_poll;
+        hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;
+
+        /* initial calibrate for the input device */
+        hdaps_calibrate();
+
+        /* initialize the input class */
+        idev = hdaps_idev->input;
+        idev->name = "hdaps";
+        idev->phys = "isa1600/input0";
+        idev->id.bustype = BUS_ISA;
+        idev->dev.parent = &pdev->dev;
+        idev->evbit[0] = BIT_MASK(EV_ABS);
+        input_set_abs_params(idev, ABS_X,
+                        -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
+        input_set_abs_params(idev, ABS_Y,
+                        -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
+
+        ret = input_register_polled_device(hdaps_idev);
+        if (ret)
+                goto out_idev;
+
+        pr_info("driver successfully loaded\n");
+        return 0;
+
+out_idev:
+        input_free_polled_device(hdaps_idev);
+out_group:
+        sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
+out_device:
+        platform_device_unregister(pdev);
+out_driver:
+        platform_driver_unregister(&hdaps_driver);
+out_region:
+        release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
+out:
+        pr_warn("driver init failed (ret=%d)!\n", ret);
+        return ret;
+}
+
+static void __exit hdaps_exit(void)
+{
+        input_unregister_polled_device(hdaps_idev);
+        input_free_polled_device(hdaps_idev);
+        sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&hdaps_driver);
+        release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
+
+        pr_info("driver unloaded\n");
+}
+
+module_init(hdaps_init);
+module_exit(hdaps_exit);
+
+module_param_named(invert, hdaps_invert, int, 0);
+MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
+                 "2 invert y-axis, 3 invert both axes.");
+
+MODULE_AUTHOR("Robert Love");
+MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index c1741142a4cb..e2faa3cbb792 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -2,6 +2,7 @@
  * HP WMI hotkeys
  *
  * Copyright (C) 2008 Red Hat <mjg@redhat.com>
+ * Copyright (C) 2010, 2011 Anssi Hannula <anssi.hannula@iki.fi>
  *
  * Portions based on wistron_btns.c:
  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
@@ -23,12 +24,15 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 #include <linux/platform_device.h>
 #include <linux/acpi.h>
 #include <linux/rfkill.h>
@@ -50,9 +54,7 @@ MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
 #define HPWMI_HARDWARE_QUERY 0x4
 #define HPWMI_WIRELESS_QUERY 0x5
 #define HPWMI_HOTKEY_QUERY 0xc
-
-#define PREFIX "HP WMI: "
-#define UNIMP "Unimplemented "
+#define HPWMI_WIRELESS2_QUERY 0x1b
 
 enum hp_wmi_radio {
         HPWMI_WIFI = 0,
@@ -85,27 +87,58 @@ struct bios_args {
 struct bios_return {
         u32 sigpass;
         u32 return_code;
-        u32 value;
 };
 
-struct key_entry {
-        char type;              /* See KE_* below */
-        u16 code;
-        u16 keycode;
+enum hp_return_value {
+        HPWMI_RET_WRONG_SIGNATURE       = 0x02,
+        HPWMI_RET_UNKNOWN_COMMAND       = 0x03,
+        HPWMI_RET_UNKNOWN_CMDTYPE       = 0x04,
+        HPWMI_RET_INVALID_PARAMETERS    = 0x05,
+};
+
+enum hp_wireless2_bits {
+        HPWMI_POWER_STATE       = 0x01,
+        HPWMI_POWER_SOFT        = 0x02,
+        HPWMI_POWER_BIOS        = 0x04,
+        HPWMI_POWER_HARD        = 0x08,
 };
 
-enum { KE_KEY, KE_END };
-
-static struct key_entry hp_wmi_keymap[] = {
-        {KE_KEY, 0x02, KEY_BRIGHTNESSUP},
-        {KE_KEY, 0x03, KEY_BRIGHTNESSDOWN},
-        {KE_KEY, 0x20e6, KEY_PROG1},
-        {KE_KEY, 0x20e8, KEY_MEDIA},
-        {KE_KEY, 0x2142, KEY_MEDIA},
-        {KE_KEY, 0x213b, KEY_INFO},
-        {KE_KEY, 0x2169, KEY_DIRECTION},
-        {KE_KEY, 0x231b, KEY_HELP},
-        {KE_END, 0}
+#define IS_HWBLOCKED(x) ((x & (HPWMI_POWER_BIOS | HPWMI_POWER_HARD)) \
+                         != (HPWMI_POWER_BIOS | HPWMI_POWER_HARD))
+#define IS_SWBLOCKED(x) !(x & HPWMI_POWER_SOFT)
+
+struct bios_rfkill2_device_state {
+        u8 radio_type;
+        u8 bus_type;
+        u16 vendor_id;
+        u16 product_id;
+        u16 subsys_vendor_id;
+        u16 subsys_product_id;
+        u8 rfkill_id;
+        u8 power;
+        u8 unknown[4];
+};
+
+/* 7 devices fit into the 128 byte buffer */
+#define HPWMI_MAX_RFKILL2_DEVICES       7
+
+struct bios_rfkill2_state {
+        u8 unknown[7];
+        u8 count;
+        u8 pad[8];
+        struct bios_rfkill2_device_state device[HPWMI_MAX_RFKILL2_DEVICES];
+};
+
+static const struct key_entry hp_wmi_keymap[] = {
+        { KE_KEY, 0x02,   { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 0x03,   { KEY_BRIGHTNESSDOWN } },
+        { KE_KEY, 0x20e6, { KEY_PROG1 } },
+        { KE_KEY, 0x20e8, { KEY_MEDIA } },
+        { KE_KEY, 0x2142, { KEY_MEDIA } },
+        { KE_KEY, 0x213b, { KEY_INFO } },
+        { KE_KEY, 0x2169, { KEY_DIRECTION } },
+        { KE_KEY, 0x231b, { KEY_HELP } },
+        { KE_END, 0 }
 };
 
 static struct input_dev *hp_wmi_input_dev;
@@ -115,6 +148,15 @@ static struct rfkill *wifi_rfkill;
 static struct rfkill *bluetooth_rfkill;
 static struct rfkill *wwan_rfkill;
 
+struct rfkill2_device {
+        u8 id;
+        int num;
+        struct rfkill *rfkill;
+};
+
+static int rfkill2_count;
+static struct rfkill2_device rfkill2[HPWMI_MAX_RFKILL2_DEVICES];
+
 static const struct dev_pm_ops hp_wmi_pm_ops = {
         .resume  = hp_wmi_resume_handler,
         .restore  = hp_wmi_resume_handler,
@@ -136,7 +178,8 @@ static struct platform_driver hp_wmi_driver = {
  * query:       The commandtype -> What should be queried
  * write:       The command -> 0 read, 1 write, 3 ODM specific
  * buffer:      Buffer used as input and/or output
- * buffersize:  Size of buffer
+ * insize:      Size of input buffer
+ * outsize:     Size of output buffer
  *
  * returns zero on success
  *         an HP WMI query specific error code (which is positive)
@@ -147,25 +190,30 @@ static struct platform_driver hp_wmi_driver = {
  *       size. E.g. Battery info query (0x7) is defined to have 1 byte input
  *       and 128 byte output. The caller would do:
  *       buffer = kzalloc(128, GFP_KERNEL);
- *       ret = hp_wmi_perform_query(0x7, 0, buffer, 128)
+ *       ret = hp_wmi_perform_query(0x7, 0, buffer, 1, 128)
  */
-static int hp_wmi_perform_query(int query, int write, u32 *buffer,
-                                int buffersize)
+static int hp_wmi_perform_query(int query, int write, void *buffer,
+                                int insize, int outsize)
 {
-        struct bios_return bios_return;
-        acpi_status status;
+        struct bios_return *bios_return;
+        int actual_outsize;
         union acpi_object *obj;
         struct bios_args args = {
                 .signature = 0x55434553,
                 .command = write ? 0x2 : 0x1,
                 .commandtype = query,
-                .datasize = buffersize,
-                .data = *buffer,
+                .datasize = insize,
+                .data = 0,
         };
         struct acpi_buffer input = { sizeof(struct bios_args), &args };
         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        u32 rc;
+
+        if (WARN_ON(insize > sizeof(args.data)))
+                return -EINVAL;
+        memcpy(&args.data, buffer, insize);
 
-        status = wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
+        wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
 
         obj = output.pointer;
 
@@ -176,9 +224,26 @@ static int hp_wmi_perform_query(int query, int write, u32 *buffer,
                 return -EINVAL;
         }
 
-        bios_return = *((struct bios_return *)obj->buffer.pointer);
+        bios_return = (struct bios_return *)obj->buffer.pointer;
+        rc = bios_return->return_code;
+
+        if (rc) {
+                if (rc != HPWMI_RET_UNKNOWN_CMDTYPE)
+                        pr_warn("query 0x%x returned error 0x%x\n", query, rc);
+                kfree(obj);
+                return rc;
+        }
+
+        if (!outsize) {
+                /* ignore output data */
+                kfree(obj);
+                return 0;
+        }
 
-        memcpy(buffer, &bios_return.value, sizeof(bios_return.value));
+        actual_outsize = min(outsize, (int)(obj->buffer.length - sizeof(*bios_return)));
+        memcpy(buffer, obj->buffer.pointer + sizeof(*bios_return), actual_outsize);
+        memset(buffer + actual_outsize, 0, outsize - actual_outsize);
+        kfree(obj);
         return 0;
 }
 
@@ -186,7 +251,7 @@ static int hp_wmi_display_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_DISPLAY_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -196,7 +261,7 @@ static int hp_wmi_hddtemp_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HDDTEMP_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -206,7 +271,7 @@ static int hp_wmi_als_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -216,7 +281,7 @@ static int hp_wmi_dock_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
 
         if (ret)
                 return -EINVAL;
@@ -228,7 +293,7 @@ static int hp_wmi_tablet_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return ret;
 
@@ -242,7 +307,7 @@ static int hp_wmi_set_block(void *data, bool blocked)
         int ret;
 
         ret = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1,
-                                   &query, sizeof(query));
+                                   &query, sizeof(query), 0);
         if (ret)
                 return -EINVAL;
         return 0;
@@ -257,7 +322,8 @@ static bool hp_wmi_get_sw_state(enum hp_wmi_radio r)
         int wireless = 0;
         int mask;
         hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
-                             &wireless, sizeof(wireless));
+                             &wireless, sizeof(wireless),
+                             sizeof(wireless));
         /* TBD: Pass error */
 
         mask = 0x200 << (r * 8);
@@ -273,7 +339,8 @@ static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
         int wireless = 0;
         int mask;
         hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
-                             &wireless, sizeof(wireless));
+                             &wireless, sizeof(wireless),
+                             sizeof(wireless));
         /* TBD: Pass error */
 
         mask = 0x800 << (r * 8);
@@ -284,6 +351,50 @@ static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
                 return true;
 }
 
+static int hp_wmi_rfkill2_set_block(void *data, bool blocked)
+{
+        int rfkill_id = (int)(long)data;
+        char buffer[4] = { 0x01, 0x00, rfkill_id, !blocked };
+
+        if (hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 1,
+                                   buffer, sizeof(buffer), 0))
+                return -EINVAL;
+        return 0;
+}
+
+static const struct rfkill_ops hp_wmi_rfkill2_ops = {
+        .set_block = hp_wmi_rfkill2_set_block,
+};
+
+static int hp_wmi_rfkill2_refresh(void)
+{
+        int err, i;
+        struct bios_rfkill2_state state;
+
+        err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
+                                   0, sizeof(state));
+        if (err)
+                return err;
+
+        for (i = 0; i < rfkill2_count; i++) {
+                int num = rfkill2[i].num;
+                struct bios_rfkill2_device_state *devstate;
+                devstate = &state.device[num];
+
+                if (num >= state.count ||
+                    devstate->rfkill_id != rfkill2[i].id) {
+                        pr_warn("power configuration of the wireless devices unexpectedly changed\n");
+                        continue;
+                }
+
+                rfkill_set_states(rfkill2[i].rfkill,
+                                  IS_SWBLOCKED(devstate->power),
+                                  IS_HWBLOCKED(devstate->power));
+        }
+
+        return 0;
+}
+
 static ssize_t show_display(struct device *dev, struct device_attribute *attr,
                             char *buf)
 {
@@ -334,7 +445,7 @@ static ssize_t set_als(struct device *dev, struct device_attribute *attr,
 {
         u32 tmp = simple_strtoul(buf, NULL, 10);
         int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 1, &tmp,
-                                       sizeof(tmp));
+                                       sizeof(tmp), sizeof(tmp));
         if (ret)
                 return -EINVAL;
 
@@ -347,64 +458,9 @@ static DEVICE_ATTR(als, S_IRUGO | S_IWUSR, show_als, set_als);
 static DEVICE_ATTR(dock, S_IRUGO, show_dock, NULL);
 static DEVICE_ATTR(tablet, S_IRUGO, show_tablet, NULL);
 
-static struct key_entry *hp_wmi_get_entry_by_scancode(unsigned int code)
-{
-        struct key_entry *key;
-
-        for (key = hp_wmi_keymap; key->type != KE_END; key++)
-                if (code == key->code)
-                        return key;
-
-        return NULL;
-}
-
-static struct key_entry *hp_wmi_get_entry_by_keycode(unsigned int keycode)
-{
-        struct key_entry *key;
-
-        for (key = hp_wmi_keymap; key->type != KE_END; key++)
-                if (key->type == KE_KEY && keycode == key->keycode)
-                        return key;
-
-        return NULL;
-}
-
-static int hp_wmi_getkeycode(struct input_dev *dev,
-                             unsigned int scancode, unsigned int *keycode)
-{
-        struct key_entry *key = hp_wmi_get_entry_by_scancode(scancode);
-
-        if (key && key->type == KE_KEY) {
-                *keycode = key->keycode;
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
-static int hp_wmi_setkeycode(struct input_dev *dev,
-                             unsigned int scancode, unsigned int keycode)
-{
-        struct key_entry *key;
-        unsigned int old_keycode;
-
-        key = hp_wmi_get_entry_by_scancode(scancode);
-        if (key && key->type == KE_KEY) {
-                old_keycode = key->keycode;
-                key->keycode = keycode;
-                set_bit(keycode, dev->keybit);
-                if (!hp_wmi_get_entry_by_keycode(old_keycode))
-                        clear_bit(old_keycode, dev->keybit);
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
 static void hp_wmi_notify(u32 value, void *context)
 {
         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
-        static struct key_entry *key;
         union acpi_object *obj;
         u32 event_id, event_data;
         int key_code = 0, ret;
@@ -413,7 +469,7 @@ static void hp_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO PREFIX "bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -422,8 +478,7 @@ static void hp_wmi_notify(u32 value, void *context)
         if (!obj)
                 return;
         if (obj->type != ACPI_TYPE_BUFFER) {
-                printk(KERN_INFO "hp-wmi: Unknown response received %d\n",
-                       obj->type);
+                pr_info("Unknown response received %d\n", obj->type);
                 kfree(obj);
                 return;
         }
@@ -440,8 +495,7 @@ static void hp_wmi_notify(u32 value, void *context)
                 event_id = *location;
                 event_data = *(location + 2);
         } else {
-                printk(KERN_INFO "hp-wmi: Unknown buffer length %d\n",
-                       obj->buffer.length);
+                pr_info("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return;
         }
@@ -462,26 +516,21 @@ static void hp_wmi_notify(u32 value, void *context)
         case HPWMI_BEZEL_BUTTON:
                 ret = hp_wmi_perform_query(HPWMI_HOTKEY_QUERY, 0,
                                            &key_code,
+                                           sizeof(key_code),
                                            sizeof(key_code));
                 if (ret)
                         break;
-                key = hp_wmi_get_entry_by_scancode(key_code);
-                if (key) {
-                        switch (key->type) {
-                        case KE_KEY:
-                                input_report_key(hp_wmi_input_dev,
-                                                 key->keycode, 1);
-                                input_sync(hp_wmi_input_dev);
-                                input_report_key(hp_wmi_input_dev,
-                                                 key->keycode, 0);
-                                input_sync(hp_wmi_input_dev);
-                                break;
-                        }
-                } else
-                        printk(KERN_INFO PREFIX "Unknown key code - 0x%x\n",
-                               key_code);
+
+                if (!sparse_keymap_report_event(hp_wmi_input_dev,
+                                                key_code, 1, true))
+                        pr_info("Unknown key code - 0x%x\n", key_code);
                 break;
         case HPWMI_WIRELESS:
+                if (rfkill2_count) {
+                        hp_wmi_rfkill2_refresh();
+                        break;
+                }
+
                 if (wifi_rfkill)
                         rfkill_set_states(wifi_rfkill,
                                           hp_wmi_get_sw_state(HPWMI_WIFI),
@@ -496,21 +545,19 @@ static void hp_wmi_notify(u32 value, void *context)
                                           hp_wmi_get_hw_state(HPWMI_WWAN));
                 break;
         case HPWMI_CPU_BATTERY_THROTTLE:
-                printk(KERN_INFO PREFIX UNIMP "CPU throttle because of 3 Cell"
-                       " battery event detected\n");
+                pr_info("Unimplemented CPU throttle because of 3 Cell battery event detected\n");
                 break;
         case HPWMI_LOCK_SWITCH:
                 break;
         default:
-                printk(KERN_INFO PREFIX "Unknown event_id - %d - 0x%x\n",
-                       event_id, event_data);
+                pr_info("Unknown event_id - %d - 0x%x\n", event_id, event_data);
                 break;
         }
 }
 
 static int __init hp_wmi_input_setup(void)
 {
-        struct key_entry *key;
+        acpi_status status;
         int err;
 
         hp_wmi_input_dev = input_allocate_device();
@@ -520,21 +567,14 @@ static int __init hp_wmi_input_setup(void)
         hp_wmi_input_dev->name = "HP WMI hotkeys";
         hp_wmi_input_dev->phys = "wmi/input0";
         hp_wmi_input_dev->id.bustype = BUS_HOST;
-        hp_wmi_input_dev->getkeycode = hp_wmi_getkeycode;
-        hp_wmi_input_dev->setkeycode = hp_wmi_setkeycode;
-
-        for (key = hp_wmi_keymap; key->type != KE_END; key++) {
-                switch (key->type) {
-                case KE_KEY:
-                        set_bit(EV_KEY, hp_wmi_input_dev->evbit);
-                        set_bit(key->keycode, hp_wmi_input_dev->keybit);
-                        break;
-                }
-        }
 
-        set_bit(EV_SW, hp_wmi_input_dev->evbit);
-        set_bit(SW_DOCK, hp_wmi_input_dev->swbit);
-        set_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit);
+        __set_bit(EV_SW, hp_wmi_input_dev->evbit);
+        __set_bit(SW_DOCK, hp_wmi_input_dev->swbit);
+        __set_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit);
+
+        err = sparse_keymap_setup(hp_wmi_input_dev, hp_wmi_keymap, NULL);
+        if (err)
+                goto err_free_dev;
 
         /* Set initial hardware state */
         input_report_switch(hp_wmi_input_dev, SW_DOCK, hp_wmi_dock_state());
@@ -542,14 +582,32 @@ static int __init hp_wmi_input_setup(void)
                             hp_wmi_tablet_state());
         input_sync(hp_wmi_input_dev);
 
-        err = input_register_device(hp_wmi_input_dev);
-
-        if (err) {
-                input_free_device(hp_wmi_input_dev);
-                return err;
+        status = wmi_install_notify_handler(HPWMI_EVENT_GUID, hp_wmi_notify, NULL);
+        if (ACPI_FAILURE(status)) {
+                err = -EIO;
+                goto err_free_keymap;
         }
 
+        err = input_register_device(hp_wmi_input_dev);
+        if (err)
+                goto err_uninstall_notifier;
+
         return 0;
+
+ err_uninstall_notifier:
+        wmi_remove_notify_handler(HPWMI_EVENT_GUID);
+ err_free_keymap:
+        sparse_keymap_free(hp_wmi_input_dev);
+ err_free_dev:
+        input_free_device(hp_wmi_input_dev);
+        return err;
+}
+
+static void hp_wmi_input_destroy(void)
+{
+        wmi_remove_notify_handler(HPWMI_EVENT_GUID);
+        sparse_keymap_free(hp_wmi_input_dev);
+        input_unregister_device(hp_wmi_input_dev);
 }
 
 static void cleanup_sysfs(struct platform_device *device)
@@ -561,32 +619,16 @@ static void cleanup_sysfs(struct platform_device *device)
         device_remove_file(&device->dev, &dev_attr_tablet);
 }
 
-static int __devinit hp_wmi_bios_setup(struct platform_device *device)
+static int __devinit hp_wmi_rfkill_setup(struct platform_device *device)
 {
         int err;
         int wireless = 0;
 
         err = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0, &wireless,
-                                   sizeof(wireless));
+                                   sizeof(wireless), sizeof(wireless));
         if (err)
                 return err;
 
-        err = device_create_file(&device->dev, &dev_attr_display);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_hddtemp);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_als);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_dock);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_tablet);
-        if (err)
-                goto add_sysfs_error;
-
         if (wireless & 0x1) {
                 wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
                                            RFKILL_TYPE_WLAN,
@@ -632,14 +674,130 @@ static int __devinit hp_wmi_bios_setup(struct platform_device *device)
         return 0;
 register_wwan_err:
         rfkill_destroy(wwan_rfkill);
+        wwan_rfkill = NULL;
         if (bluetooth_rfkill)
                 rfkill_unregister(bluetooth_rfkill);
 register_bluetooth_error:
         rfkill_destroy(bluetooth_rfkill);
+        bluetooth_rfkill = NULL;
         if (wifi_rfkill)
                 rfkill_unregister(wifi_rfkill);
 register_wifi_error:
         rfkill_destroy(wifi_rfkill);
+        wifi_rfkill = NULL;
+        return err;
+}
+
+static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
+{
+        int err, i;
+        struct bios_rfkill2_state state;
+        err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
+                                   0, sizeof(state));
+        if (err)
+                return err;
+
+        if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
+                pr_warn("unable to parse 0x1b query output\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < state.count; i++) {
+                struct rfkill *rfkill;
+                enum rfkill_type type;
+                char *name;
+                switch (state.device[i].radio_type) {
+                case HPWMI_WIFI:
+                        type = RFKILL_TYPE_WLAN;
+                        name = "hp-wifi";
+                        break;
+                case HPWMI_BLUETOOTH:
+                        type = RFKILL_TYPE_BLUETOOTH;
+                        name = "hp-bluetooth";
+                        break;
+                case HPWMI_WWAN:
+                        type = RFKILL_TYPE_WWAN;
+                        name = "hp-wwan";
+                        break;
+                default:
+                        pr_warn("unknown device type 0x%x\n",
+                                state.device[i].radio_type);
+                        continue;
+                }
+
+                if (!state.device[i].vendor_id) {
+                        pr_warn("zero device %d while %d reported\n",
+                                i, state.count);
+                        continue;
+                }
+
+                rfkill = rfkill_alloc(name, &device->dev, type,
+                                      &hp_wmi_rfkill2_ops, (void *)(long)i);
+                if (!rfkill) {
+                        err = -ENOMEM;
+                        goto fail;
+                }
+
+                rfkill2[rfkill2_count].id = state.device[i].rfkill_id;
+                rfkill2[rfkill2_count].num = i;
+                rfkill2[rfkill2_count].rfkill = rfkill;
+
+                rfkill_init_sw_state(rfkill,
+                                     IS_SWBLOCKED(state.device[i].power));
+                rfkill_set_hw_state(rfkill,
+                                    IS_HWBLOCKED(state.device[i].power));
+
+                if (!(state.device[i].power & HPWMI_POWER_BIOS))
+                        pr_info("device %s blocked by BIOS\n", name);
+
+                err = rfkill_register(rfkill);
+                if (err) {
+                        rfkill_destroy(rfkill);
+                        goto fail;
+                }
+
+                rfkill2_count++;
+        }
+
+        return 0;
+fail:
+        for (; rfkill2_count > 0; rfkill2_count--) {
+                rfkill_unregister(rfkill2[rfkill2_count - 1].rfkill);
+                rfkill_destroy(rfkill2[rfkill2_count - 1].rfkill);
+        }
+        return err;
+}
+
+static int __devinit hp_wmi_bios_setup(struct platform_device *device)
+{
+        int err;
+
+        /* clear detected rfkill devices */
+        wifi_rfkill = NULL;
+        bluetooth_rfkill = NULL;
+        wwan_rfkill = NULL;
+        rfkill2_count = 0;
+
+        if (hp_wmi_rfkill_setup(device))
+                hp_wmi_rfkill2_setup(device);
+
+        err = device_create_file(&device->dev, &dev_attr_display);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_hddtemp);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_als);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_dock);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_tablet);
+        if (err)
+                goto add_sysfs_error;
+        return 0;
+
 add_sysfs_error:
         cleanup_sysfs(device);
         return err;
@@ -647,8 +805,14 @@ add_sysfs_error:
 
 static int __exit hp_wmi_bios_remove(struct platform_device *device)
 {
+        int i;
         cleanup_sysfs(device);
 
+        for (i = 0; i < rfkill2_count; i++) {
+                rfkill_unregister(rfkill2[i].rfkill);
+                rfkill_destroy(rfkill2[i].rfkill);
+        }
+
         if (wifi_rfkill) {
                 rfkill_unregister(wifi_rfkill);
                 rfkill_destroy(wifi_rfkill);
@@ -681,6 +845,9 @@ static int hp_wmi_resume_handler(struct device *device)
                 input_sync(hp_wmi_input_dev);
         }
 
+        if (rfkill2_count)
+                hp_wmi_rfkill2_refresh();
+
         if (wifi_rfkill)
                 rfkill_set_states(wifi_rfkill,
                                   hp_wmi_get_sw_state(HPWMI_WIFI),
@@ -704,15 +871,9 @@ static int __init hp_wmi_init(void)
         int bios_capable = wmi_has_guid(HPWMI_BIOS_GUID);
 
         if (event_capable) {
-                err = wmi_install_notify_handler(HPWMI_EVENT_GUID,
-                                                 hp_wmi_notify, NULL);
-                if (ACPI_FAILURE(err))
-                        return -EINVAL;
                 err = hp_wmi_input_setup();
-                if (err) {
-                        wmi_remove_notify_handler(HPWMI_EVENT_GUID);
+                if (err)
                         return err;
-                }
         }
 
         if (bios_capable) {
@@ -739,20 +900,17 @@ err_device_add:
 err_device_alloc:
         platform_driver_unregister(&hp_wmi_driver);
 err_driver_reg:
-        if (wmi_has_guid(HPWMI_EVENT_GUID)) {
-                input_unregister_device(hp_wmi_input_dev);
-                wmi_remove_notify_handler(HPWMI_EVENT_GUID);
-        }
+        if (event_capable)
+                hp_wmi_input_destroy();
 
         return err;
 }
 
 static void __exit hp_wmi_exit(void)
 {
-        if (wmi_has_guid(HPWMI_EVENT_GUID)) {
-                wmi_remove_notify_handler(HPWMI_EVENT_GUID);
-                input_unregister_device(hp_wmi_input_dev);
-        }
+        if (wmi_has_guid(HPWMI_EVENT_GUID))
+                hp_wmi_input_destroy();
+
         if (hp_wmi_platform_dev) {
                 platform_device_unregister(hp_wmi_platform_dev);
                 platform_driver_unregister(&hp_wmi_driver);
diff --git a/drivers/platform/x86/hp_accel.c b/drivers/platform/x86/hp_accel.c
new file mode 100644
index 000000000000..1b52d00e2f90
--- /dev/null
+++ b/drivers/platform/x86/hp_accel.c
@@ -0,0 +1,404 @@
+/*
+ *  hp_accel.c - Interface between LIS3LV02DL driver and HP ACPI BIOS
+ *
+ *  Copyright (C) 2007-2008 Yan Burman
+ *  Copyright (C) 2008 Eric Piel
+ *  Copyright (C) 2008-2009 Pavel Machek
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/dmi.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/wait.h>
+#include <linux/poll.h>
+#include <linux/freezer.h>
+#include <linux/uaccess.h>
+#include <linux/leds.h>
+#include <linux/atomic.h>
+#include <acpi/acpi_drivers.h>
+#include "../../misc/lis3lv02d/lis3lv02d.h"
+
+#define DRIVER_NAME     "hp_accel"
+#define ACPI_MDPS_CLASS "accelerometer"
+
+/* Delayed LEDs infrastructure ------------------------------------ */
+
+/* Special LED class that can defer work */
+struct delayed_led_classdev {
+        struct led_classdev led_classdev;
+        struct work_struct work;
+        enum led_brightness new_brightness;
+
+        unsigned int led;               /* For driver */
+        void (*set_brightness)(struct delayed_led_classdev *data, enum led_brightness value);
+};
+
+static inline void delayed_set_status_worker(struct work_struct *work)
+{
+        struct delayed_led_classdev *data =
+                        container_of(work, struct delayed_led_classdev, work);
+
+        data->set_brightness(data, data->new_brightness);
+}
+
+static inline void delayed_sysfs_set(struct led_classdev *led_cdev,
+                              enum led_brightness brightness)
+{
+        struct delayed_led_classdev *data = container_of(led_cdev,
+                             struct delayed_led_classdev, led_classdev);
+        data->new_brightness = brightness;
+        schedule_work(&data->work);
+}
+
+/* HP-specific accelerometer driver ------------------------------------ */
+
+/* For automatic insertion of the module */
+static struct acpi_device_id lis3lv02d_device_ids[] = {
+        {"HPQ0004", 0}, /* HP Mobile Data Protection System PNP */
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, lis3lv02d_device_ids);
+
+
+/**
+ * lis3lv02d_acpi_init - ACPI _INI method: initialize the device.
+ * @lis3: pointer to the device struct
+ *
+ * Returns 0 on success.
+ */
+int lis3lv02d_acpi_init(struct lis3lv02d *lis3)
+{
+        struct acpi_device *dev = lis3->bus_priv;
+        if (acpi_evaluate_object(dev->handle, METHOD_NAME__INI,
+                                 NULL, NULL) != AE_OK)
+                return -EINVAL;
+
+        return 0;
+}
+
+/**
+ * lis3lv02d_acpi_read - ACPI ALRD method: read a register
+ * @lis3: pointer to the device struct
+ * @reg:    the register to read
+ * @ret:    result of the operation
+ *
+ * Returns 0 on success.
+ */
+int lis3lv02d_acpi_read(struct lis3lv02d *lis3, int reg, u8 *ret)
+{
+        struct acpi_device *dev = lis3->bus_priv;
+        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
+        struct acpi_object_list args = { 1, &arg0 };
+        unsigned long long lret;
+        acpi_status status;
+
+        arg0.integer.value = reg;
+
+        status = acpi_evaluate_integer(dev->handle, "ALRD", &args, &lret);
+        *ret = lret;
+        return (status != AE_OK) ? -EINVAL : 0;
+}
+
+/**
+ * lis3lv02d_acpi_write - ACPI ALWR method: write to a register
+ * @lis3: pointer to the device struct
+ * @reg:    the register to write to
+ * @val:    the value to write
+ *
+ * Returns 0 on success.
+ */
+int lis3lv02d_acpi_write(struct lis3lv02d *lis3, int reg, u8 val)
+{
+        struct acpi_device *dev = lis3->bus_priv;
+        unsigned long long ret; /* Not used when writting */
+        union acpi_object in_obj[2];
+        struct acpi_object_list args = { 2, in_obj };
+
+        in_obj[0].type          = ACPI_TYPE_INTEGER;
+        in_obj[0].integer.value = reg;
+        in_obj[1].type          = ACPI_TYPE_INTEGER;
+        in_obj[1].integer.value = val;
+
+        if (acpi_evaluate_integer(dev->handle, "ALWR", &args, &ret) != AE_OK)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int lis3lv02d_dmi_matched(const struct dmi_system_id *dmi)
+{
+        lis3_dev.ac = *((union axis_conversion *)dmi->driver_data);
+        pr_info("hardware type %s found\n", dmi->ident);
+
+        return 1;
+}
+
+/* Represents, for each axis seen by userspace, the corresponding hw axis (+1).
+ * If the value is negative, the opposite of the hw value is used. */
+#define DEFINE_CONV(name, x, y, z)                            \
+        static union axis_conversion lis3lv02d_axis_##name = \
+                { .as_array = { x, y, z } }
+DEFINE_CONV(normal, 1, 2, 3);
+DEFINE_CONV(y_inverted, 1, -2, 3);
+DEFINE_CONV(x_inverted, -1, 2, 3);
+DEFINE_CONV(z_inverted, 1, 2, -3);
+DEFINE_CONV(xy_swap, 2, 1, 3);
+DEFINE_CONV(xy_rotated_left, -2, 1, 3);
+DEFINE_CONV(xy_rotated_left_usd, -2, 1, -3);
+DEFINE_CONV(xy_swap_inverted, -2, -1, 3);
+DEFINE_CONV(xy_rotated_right, 2, -1, 3);
+DEFINE_CONV(xy_swap_yz_inverted, 2, -1, -3);
+
+#define AXIS_DMI_MATCH(_ident, _name, _axis) {          \
+        .ident = _ident,                                \
+        .callback = lis3lv02d_dmi_matched,              \
+        .matches = {                                    \
+                DMI_MATCH(DMI_PRODUCT_NAME, _name)      \
+        },                                              \
+        .driver_data = &lis3lv02d_axis_##_axis          \
+}
+
+#define AXIS_DMI_MATCH2(_ident, _class1, _name1,        \
+                                _class2, _name2,        \
+                                _axis) {                \
+        .ident = _ident,                                \
+        .callback = lis3lv02d_dmi_matched,              \
+        .matches = {                                    \
+                DMI_MATCH(DMI_##_class1, _name1),       \
+                DMI_MATCH(DMI_##_class2, _name2),       \
+        },                                              \
+        .driver_data = &lis3lv02d_axis_##_axis          \
+}
+static struct dmi_system_id lis3lv02d_dmi_ids[] = {
+        /* product names are truncated to match all kinds of a same model */
+        AXIS_DMI_MATCH("NC64x0", "HP Compaq nc64", x_inverted),
+        AXIS_DMI_MATCH("NC84x0", "HP Compaq nc84", z_inverted),
+        AXIS_DMI_MATCH("NX9420", "HP Compaq nx9420", x_inverted),
+        AXIS_DMI_MATCH("NW9440", "HP Compaq nw9440", x_inverted),
+        AXIS_DMI_MATCH("NC2510", "HP Compaq 2510", y_inverted),
+        AXIS_DMI_MATCH("NC2710", "HP Compaq 2710", xy_swap),
+        AXIS_DMI_MATCH("NC8510", "HP Compaq 8510", xy_swap_inverted),
+        AXIS_DMI_MATCH("HP2133", "HP 2133", xy_rotated_left),
+        AXIS_DMI_MATCH("HP2140", "HP 2140", xy_swap_inverted),
+        AXIS_DMI_MATCH("NC653x", "HP Compaq 653", xy_rotated_left_usd),
+        AXIS_DMI_MATCH("NC6730b", "HP Compaq 6730b", xy_rotated_left_usd),
+        AXIS_DMI_MATCH("NC6730s", "HP Compaq 6730s", xy_swap),
+        AXIS_DMI_MATCH("NC651xx", "HP Compaq 651", xy_rotated_right),
+        AXIS_DMI_MATCH("NC6710x", "HP Compaq 6710", xy_swap_yz_inverted),
+        AXIS_DMI_MATCH("NC6715x", "HP Compaq 6715", y_inverted),
+        AXIS_DMI_MATCH("NC693xx", "HP EliteBook 693", xy_rotated_right),
+        AXIS_DMI_MATCH("NC693xx", "HP EliteBook 853", xy_swap),
+        /* Intel-based HP Pavilion dv5 */
+        AXIS_DMI_MATCH2("HPDV5_I",
+                        PRODUCT_NAME, "HP Pavilion dv5",
+                        BOARD_NAME, "3603",
+                        x_inverted),
+        /* AMD-based HP Pavilion dv5 */
+        AXIS_DMI_MATCH2("HPDV5_A",
+                        PRODUCT_NAME, "HP Pavilion dv5",
+                        BOARD_NAME, "3600",
+                        y_inverted),
+        AXIS_DMI_MATCH("DV7", "HP Pavilion dv7", x_inverted),
+        AXIS_DMI_MATCH("HP8710", "HP Compaq 8710", y_inverted),
+        AXIS_DMI_MATCH("HDX18", "HP HDX 18", x_inverted),
+        AXIS_DMI_MATCH("HPB432x", "HP ProBook 432", xy_rotated_left),
+        AXIS_DMI_MATCH("HPB442x", "HP ProBook 442", xy_rotated_left),
+        AXIS_DMI_MATCH("HPB452x", "HP ProBook 452", y_inverted),
+        AXIS_DMI_MATCH("HPB522x", "HP ProBook 522", xy_swap),
+        AXIS_DMI_MATCH("HPB532x", "HP ProBook 532", y_inverted),
+        AXIS_DMI_MATCH("Mini510x", "HP Mini 510", xy_rotated_left_usd),
+        { NULL, }
+/* Laptop models without axis info (yet):
+ * "NC6910" "HP Compaq 6910"
+ * "NC2400" "HP Compaq nc2400"
+ * "NX74x0" "HP Compaq nx74"
+ * "NX6325" "HP Compaq nx6325"
+ * "NC4400" "HP Compaq nc4400"
+ */
+};
+
+static void hpled_set(struct delayed_led_classdev *led_cdev, enum led_brightness value)
+{
+        struct acpi_device *dev = lis3_dev.bus_priv;
+        unsigned long long ret; /* Not used when writing */
+        union acpi_object in_obj[1];
+        struct acpi_object_list args = { 1, in_obj };
+
+        in_obj[0].type          = ACPI_TYPE_INTEGER;
+        in_obj[0].integer.value = !!value;
+
+        acpi_evaluate_integer(dev->handle, "ALED", &args, &ret);
+}
+
+static struct delayed_led_classdev hpled_led = {
+        .led_classdev = {
+                .name                   = "hp::hddprotect",
+                .default_trigger        = "none",
+                .brightness_set         = delayed_sysfs_set,
+                .flags                  = LED_CORE_SUSPENDRESUME,
+        },
+        .set_brightness = hpled_set,
+};
+
+static acpi_status
+lis3lv02d_get_resource(struct acpi_resource *resource, void *context)
+{
+        if (resource->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
+                struct acpi_resource_extended_irq *irq;
+                u32 *device_irq = context;
+
+                irq = &resource->data.extended_irq;
+                *device_irq = irq->interrupts[0];
+        }
+
+        return AE_OK;
+}
+
+static void lis3lv02d_enum_resources(struct acpi_device *device)
+{
+        acpi_status status;
+
+        status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
+                                        lis3lv02d_get_resource, &lis3_dev.irq);
+        if (ACPI_FAILURE(status))
+                printk(KERN_DEBUG DRIVER_NAME ": Error getting resources\n");
+}
+
+static int lis3lv02d_add(struct acpi_device *device)
+{
+        int ret;
+
+        if (!device)
+                return -EINVAL;
+
+        lis3_dev.bus_priv = device;
+        lis3_dev.init = lis3lv02d_acpi_init;
+        lis3_dev.read = lis3lv02d_acpi_read;
+        lis3_dev.write = lis3lv02d_acpi_write;
+        strcpy(acpi_device_name(device), DRIVER_NAME);
+        strcpy(acpi_device_class(device), ACPI_MDPS_CLASS);
+        device->driver_data = &lis3_dev;
+
+        /* obtain IRQ number of our device from ACPI */
+        lis3lv02d_enum_resources(device);
+
+        /* If possible use a "standard" axes order */
+        if (lis3_dev.ac.x && lis3_dev.ac.y && lis3_dev.ac.z) {
+                pr_info("Using custom axes %d,%d,%d\n",
+                        lis3_dev.ac.x, lis3_dev.ac.y, lis3_dev.ac.z);
+        } else if (dmi_check_system(lis3lv02d_dmi_ids) == 0) {
+                pr_info("laptop model unknown, using default axes configuration\n");
+                lis3_dev.ac = lis3lv02d_axis_normal;
+        }
+
+        /* call the core layer do its init */
+        ret = lis3lv02d_init_device(&lis3_dev);
+        if (ret)
+                return ret;
+
+        INIT_WORK(&hpled_led.work, delayed_set_status_worker);
+        ret = led_classdev_register(NULL, &hpled_led.led_classdev);
+        if (ret) {
+                lis3lv02d_joystick_disable();
+                lis3lv02d_poweroff(&lis3_dev);
+                flush_work(&hpled_led.work);
+                return ret;
+        }
+
+        return ret;
+}
+
+static int lis3lv02d_remove(struct acpi_device *device, int type)
+{
+        if (!device)
+                return -EINVAL;
+
+        lis3lv02d_joystick_disable();
+        lis3lv02d_poweroff(&lis3_dev);
+
+        led_classdev_unregister(&hpled_led.led_classdev);
+        flush_work(&hpled_led.work);
+
+        return lis3lv02d_remove_fs(&lis3_dev);
+}
+
+
+#ifdef CONFIG_PM
+static int lis3lv02d_suspend(struct acpi_device *device, pm_message_t state)
+{
+        /* make sure the device is off when we suspend */
+        lis3lv02d_poweroff(&lis3_dev);
+        return 0;
+}
+
+static int lis3lv02d_resume(struct acpi_device *device)
+{
+        lis3lv02d_poweron(&lis3_dev);
+        return 0;
+}
+#else
+#define lis3lv02d_suspend NULL
+#define lis3lv02d_resume NULL
+#endif
+
+/* For the HP MDPS aka 3D Driveguard */
+static struct acpi_driver lis3lv02d_driver = {
+        .name  = DRIVER_NAME,
+        .class = ACPI_MDPS_CLASS,
+        .ids   = lis3lv02d_device_ids,
+        .ops = {
+                .add     = lis3lv02d_add,
+                .remove  = lis3lv02d_remove,
+                .suspend = lis3lv02d_suspend,
+                .resume  = lis3lv02d_resume,
+        }
+};
+
+static int __init lis3lv02d_init_module(void)
+{
+        int ret;
+
+        if (acpi_disabled)
+                return -ENODEV;
+
+        ret = acpi_bus_register_driver(&lis3lv02d_driver);
+        if (ret < 0)
+                return ret;
+
+        pr_info("driver loaded\n");
+
+        return 0;
+}
+
+static void __exit lis3lv02d_exit_module(void)
+{
+        acpi_bus_unregister_driver(&lis3lv02d_driver);
+}
+
+MODULE_DESCRIPTION("Glue between LIS3LV02Dx and HP ACPI BIOS and support for disk protection LED.");
+MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
+MODULE_LICENSE("GPL");
+
+module_init(lis3lv02d_init_module);
+module_exit(lis3lv02d_exit_module);
diff --git a/drivers/platform/x86/ibm_rtl.c b/drivers/platform/x86/ibm_rtl.c
new file mode 100644
index 000000000000..811d436cd677
--- /dev/null
+++ b/drivers/platform/x86/ibm_rtl.c
@@ -0,0 +1,339 @@
+/*
+ * IBM Real-Time Linux driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright (C) IBM Corporation, 2010
+ *
+ * Author: Keith Mannthey <kmannth@us.ibm.com>
+ *         Vernon Mauery <vernux@us.ibm.com>
+ *
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/sysdev.h>
+#include <linux/dmi.h>
+#include <linux/efi.h>
+#include <linux/mutex.h>
+#include <asm/bios_ebda.h>
+
+static bool force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
+
+static bool debug;
+module_param(debug, bool, 0644);
+MODULE_PARM_DESC(debug, "Show debug output");
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Keith Mannthey <kmmanth@us.ibm.com>");
+MODULE_AUTHOR("Vernon Mauery <vernux@us.ibm.com>");
+
+#define RTL_ADDR_TYPE_IO    1
+#define RTL_ADDR_TYPE_MMIO  2
+
+#define RTL_CMD_ENTER_PRTM  1
+#define RTL_CMD_EXIT_PRTM   2
+
+/* The RTL table as presented by the EBDA: */
+struct ibm_rtl_table {
+        char signature[5]; /* signature should be "_RTL_" */
+        u8 version;
+        u8 rt_status;
+        u8 command;
+        u8 command_status;
+        u8 cmd_address_type;
+        u8 cmd_granularity;
+        u8 cmd_offset;
+        u16 reserve1;
+        u32 cmd_port_address; /* platform dependent address */
+        u32 cmd_port_value;   /* platform dependent value */
+} __attribute__((packed));
+
+/* to locate "_RTL_" signature do a masked 5-byte integer compare */
+#define RTL_SIGNATURE 0x0000005f4c54525fULL
+#define RTL_MASK      0x000000ffffffffffULL
+
+#define RTL_DEBUG(fmt, ...)                             \
+do {                                                    \
+        if (debug)                                      \
+                pr_info(fmt, ##__VA_ARGS__);            \
+} while (0)
+
+static DEFINE_MUTEX(rtl_lock);
+static struct ibm_rtl_table __iomem *rtl_table;
+static void __iomem *ebda_map;
+static void __iomem *rtl_cmd_addr;
+static u8 rtl_cmd_type;
+static u8 rtl_cmd_width;
+
+#ifndef readq
+static inline __u64 readq(const volatile void __iomem *addr)
+{
+        const volatile u32 __iomem *p = addr;
+        u32 low, high;
+
+        low = readl(p);
+        high = readl(p + 1);
+
+        return low + ((u64)high << 32);
+}
+#endif
+
+static void __iomem *rtl_port_map(phys_addr_t addr, unsigned long len)
+{
+        if (rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
+                return ioremap(addr, len);
+        return ioport_map(addr, len);
+}
+
+static void rtl_port_unmap(void __iomem *addr)
+{
+        if (addr && rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
+                iounmap(addr);
+        else
+                ioport_unmap(addr);
+}
+
+static int ibm_rtl_write(u8 value)
+{
+        int ret = 0, count = 0;
+        static u32 cmd_port_val;
+
+        RTL_DEBUG("%s(%d)\n", __func__, value);
+
+        value = value == 1 ? RTL_CMD_ENTER_PRTM : RTL_CMD_EXIT_PRTM;
+
+        mutex_lock(&rtl_lock);
+
+        if (ioread8(&rtl_table->rt_status) != value) {
+                iowrite8(value, &rtl_table->command);
+
+                switch (rtl_cmd_width) {
+                case 8:
+                        cmd_port_val = ioread8(&rtl_table->cmd_port_value);
+                        RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
+                        iowrite8((u8)cmd_port_val, rtl_cmd_addr);
+                        break;
+                case 16:
+                        cmd_port_val = ioread16(&rtl_table->cmd_port_value);
+                        RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
+                        iowrite16((u16)cmd_port_val, rtl_cmd_addr);
+                        break;
+                case 32:
+                        cmd_port_val = ioread32(&rtl_table->cmd_port_value);
+                        RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
+                        iowrite32(cmd_port_val, rtl_cmd_addr);
+                        break;
+                }
+
+                while (ioread8(&rtl_table->command)) {
+                        msleep(10);
+                        if (count++ > 500) {
+                                pr_err("Hardware not responding to "
+                                       "mode switch request\n");
+                                ret = -EIO;
+                                break;
+                        }
+
+                }
+
+                if (ioread8(&rtl_table->command_status)) {
+                        RTL_DEBUG("command_status reports failed command\n");
+                        ret = -EIO;
+                }
+        }
+
+        mutex_unlock(&rtl_lock);
+        return ret;
+}
+
+static ssize_t rtl_show_version(struct sysdev_class * dev,
+                                struct sysdev_class_attribute *attr,
+                                char *buf)
+{
+        return sprintf(buf, "%d\n", (int)ioread8(&rtl_table->version));
+}
+
+static ssize_t rtl_show_state(struct sysdev_class *dev,
+                              struct sysdev_class_attribute *attr,
+                              char *buf)
+{
+        return sprintf(buf, "%d\n", ioread8(&rtl_table->rt_status));
+}
+
+static ssize_t rtl_set_state(struct sysdev_class *dev,
+                             struct sysdev_class_attribute *attr,
+                             const char *buf,
+                             size_t count)
+{
+        ssize_t ret;
+
+        if (count < 1 || count > 2)
+                return -EINVAL;
+
+        switch (buf[0]) {
+        case '0':
+                ret = ibm_rtl_write(0);
+                break;
+        case '1':
+                ret = ibm_rtl_write(1);
+                break;
+        default:
+                ret = -EINVAL;
+        }
+        if (ret >= 0)
+                ret = count;
+
+        return ret;
+}
+
+static struct sysdev_class class_rtl = {
+        .name = "ibm_rtl",
+};
+
+static SYSDEV_CLASS_ATTR(version, S_IRUGO, rtl_show_version, NULL);
+static SYSDEV_CLASS_ATTR(state, 0600, rtl_show_state, rtl_set_state);
+
+static struct sysdev_class_attribute *rtl_attributes[] = {
+        &attr_version,
+        &attr_state,
+        NULL
+};
+
+
+static int rtl_setup_sysfs(void) {
+        int ret, i;
+        ret = sysdev_class_register(&class_rtl);
+
+        if (!ret) {
+                for (i = 0; rtl_attributes[i]; i ++)
+                        sysdev_class_create_file(&class_rtl, rtl_attributes[i]);
+        }
+        return ret;
+}
+
+static void rtl_teardown_sysfs(void) {
+        int i;
+        for (i = 0; rtl_attributes[i]; i ++)
+                sysdev_class_remove_file(&class_rtl, rtl_attributes[i]);
+        sysdev_class_unregister(&class_rtl);
+}
+
+
+static struct dmi_system_id __initdata ibm_rtl_dmi_table[] = {
+        {                                                  \
+                .matches = {                               \
+                        DMI_MATCH(DMI_SYS_VENDOR, "IBM"),  \
+                },                                         \
+        },
+        { }
+};
+
+static int __init ibm_rtl_init(void) {
+        unsigned long ebda_addr, ebda_size;
+        unsigned int ebda_kb;
+        int ret = -ENODEV, i;
+
+        if (force)
+                pr_warn("module loaded by force\n");
+        /* first ensure that we are running on IBM HW */
+        else if (efi_enabled || !dmi_check_system(ibm_rtl_dmi_table))
+                return -ENODEV;
+
+        /* Get the address for the Extended BIOS Data Area */
+        ebda_addr = get_bios_ebda();
+        if (!ebda_addr) {
+                RTL_DEBUG("no BIOS EBDA found\n");
+                return -ENODEV;
+        }
+
+        ebda_map = ioremap(ebda_addr, 4);
+        if (!ebda_map)
+                return -ENOMEM;
+
+        /* First word in the EDBA is the Size in KB */
+        ebda_kb = ioread16(ebda_map);
+        RTL_DEBUG("EBDA is %d kB\n", ebda_kb);
+
+        if (ebda_kb == 0)
+                goto out;
+
+        iounmap(ebda_map);
+        ebda_size = ebda_kb*1024;
+
+        /* Remap the whole table */
+        ebda_map = ioremap(ebda_addr, ebda_size);
+        if (!ebda_map)
+                return -ENOMEM;
+
+        /* search for the _RTL_ signature at the start of the table */
+        for (i = 0 ; i < ebda_size/sizeof(unsigned int); i++) {
+                struct ibm_rtl_table __iomem * tmp;
+                tmp = (struct ibm_rtl_table __iomem *) (ebda_map+i);
+                if ((readq(&tmp->signature) & RTL_MASK) == RTL_SIGNATURE) {
+                        phys_addr_t addr;
+                        unsigned int plen;
+                        RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp);
+                        rtl_table = tmp;
+                        /* The address, value, width and offset are platform
+                         * dependent and found in the ibm_rtl_table */
+                        rtl_cmd_width = ioread8(&rtl_table->cmd_granularity);
+                        rtl_cmd_type = ioread8(&rtl_table->cmd_address_type);
+                        RTL_DEBUG("rtl_cmd_width = %u, rtl_cmd_type = %u\n",
+                                  rtl_cmd_width, rtl_cmd_type);
+                        addr = ioread32(&rtl_table->cmd_port_address);
+                        RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr);
+                        plen = rtl_cmd_width/sizeof(char);
+                        rtl_cmd_addr = rtl_port_map(addr, plen);
+                        RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr);
+                        if (!rtl_cmd_addr) {
+                                ret = -ENOMEM;
+                                break;
+                        }
+                        ret = rtl_setup_sysfs();
+                        break;
+                }
+        }
+
+out:
+        if (ret) {
+                iounmap(ebda_map);
+                rtl_port_unmap(rtl_cmd_addr);
+        }
+
+        return ret;
+}
+
+static void __exit ibm_rtl_exit(void)
+{
+        if (rtl_table) {
+                RTL_DEBUG("cleaning up");
+                /* do not leave the machine in SMI-free mode */
+                ibm_rtl_write(0);
+                /* unmap, unlink and remove all traces */
+                rtl_teardown_sysfs();
+                iounmap(ebda_map);
+                rtl_port_unmap(rtl_cmd_addr);
+        }
+}
+
+module_init(ibm_rtl_init);
+module_exit(ibm_rtl_exit);
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
new file mode 100644
index 000000000000..bfdda33feb26
--- /dev/null
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -0,0 +1,497 @@
+/*
+ *  ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
+ *
+ *  Copyright © 2010 Intel Corporation
+ *  Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ *  02110-1301, USA.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+#include <linux/rfkill.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+
+#define IDEAPAD_RFKILL_DEV_NUM  (3)
+
+struct ideapad_private {
+        struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
+        struct platform_device *platform_device;
+        struct input_dev *inputdev;
+};
+
+static acpi_handle ideapad_handle;
+static bool no_bt_rfkill;
+module_param(no_bt_rfkill, bool, 0444);
+MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");
+
+/*
+ * ACPI Helpers
+ */
+#define IDEAPAD_EC_TIMEOUT (100) /* in ms */
+
+static int read_method_int(acpi_handle handle, const char *method, int *val)
+{
+        acpi_status status;
+        unsigned long long result;
+
+        status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
+        if (ACPI_FAILURE(status)) {
+                *val = -1;
+                return -1;
+        } else {
+                *val = result;
+                return 0;
+        }
+}
+
+static int method_vpcr(acpi_handle handle, int cmd, int *ret)
+{
+        acpi_status status;
+        unsigned long long result;
+        struct acpi_object_list params;
+        union acpi_object in_obj;
+
+        params.count = 1;
+        params.pointer = &in_obj;
+        in_obj.type = ACPI_TYPE_INTEGER;
+        in_obj.integer.value = cmd;
+
+        status = acpi_evaluate_integer(handle, "VPCR", &params, &result);
+
+        if (ACPI_FAILURE(status)) {
+                *ret = -1;
+                return -1;
+        } else {
+                *ret = result;
+                return 0;
+        }
+}
+
+static int method_vpcw(acpi_handle handle, int cmd, int data)
+{
+        struct acpi_object_list params;
+        union acpi_object in_obj[2];
+        acpi_status status;
+
+        params.count = 2;
+        params.pointer = in_obj;
+        in_obj[0].type = ACPI_TYPE_INTEGER;
+        in_obj[0].integer.value = cmd;
+        in_obj[1].type = ACPI_TYPE_INTEGER;
+        in_obj[1].integer.value = data;
+
+        status = acpi_evaluate_object(handle, "VPCW", &params, NULL);
+        if (status != AE_OK)
+                return -1;
+        return 0;
+}
+
+static int read_ec_data(acpi_handle handle, int cmd, unsigned long *data)
+{
+        int val;
+        unsigned long int end_jiffies;
+
+        if (method_vpcw(handle, 1, cmd))
+                return -1;
+
+        for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
+             time_before(jiffies, end_jiffies);) {
+                schedule();
+                if (method_vpcr(handle, 1, &val))
+                        return -1;
+                if (val == 0) {
+                        if (method_vpcr(handle, 0, &val))
+                                return -1;
+                        *data = val;
+                        return 0;
+                }
+        }
+        pr_err("timeout in read_ec_cmd\n");
+        return -1;
+}
+
+static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
+{
+        int val;
+        unsigned long int end_jiffies;
+
+        if (method_vpcw(handle, 0, data))
+                return -1;
+        if (method_vpcw(handle, 1, cmd))
+                return -1;
+
+        for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
+             time_before(jiffies, end_jiffies);) {
+                schedule();
+                if (method_vpcr(handle, 1, &val))
+                        return -1;
+                if (val == 0)
+                        return 0;
+        }
+        pr_err("timeout in write_ec_cmd\n");
+        return -1;
+}
+
+/*
+ * camera power
+ */
+static ssize_t show_ideapad_cam(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        unsigned long result;
+
+        if (read_ec_data(ideapad_handle, 0x1D, &result))
+                return sprintf(buf, "-1\n");
+        return sprintf(buf, "%lu\n", result);
+}
+
+static ssize_t store_ideapad_cam(struct device *dev,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t count)
+{
+        int ret, state;
+
+        if (!count)
+                return 0;
+        if (sscanf(buf, "%i", &state) != 1)
+                return -EINVAL;
+        ret = write_ec_cmd(ideapad_handle, 0x1E, state);
+        if (ret < 0)
+                return ret;
+        return count;
+}
+
+static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
+
+/*
+ * Rfkill
+ */
+struct ideapad_rfk_data {
+        char *name;
+        int cfgbit;
+        int opcode;
+        int type;
+};
+
+const struct ideapad_rfk_data ideapad_rfk_data[] = {
+        { "ideapad_wlan",       18, 0x15, RFKILL_TYPE_WLAN },
+        { "ideapad_bluetooth",  16, 0x17, RFKILL_TYPE_BLUETOOTH },
+        { "ideapad_3g",         17, 0x20, RFKILL_TYPE_WWAN },
+};
+
+static int ideapad_rfk_set(void *data, bool blocked)
+{
+        unsigned long opcode = (unsigned long)data;
+
+        return write_ec_cmd(ideapad_handle, opcode, !blocked);
+}
+
+static struct rfkill_ops ideapad_rfk_ops = {
+        .set_block = ideapad_rfk_set,
+};
+
+static void ideapad_sync_rfk_state(struct acpi_device *adevice)
+{
+        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+        unsigned long hw_blocked;
+        int i;
+
+        if (read_ec_data(ideapad_handle, 0x23, &hw_blocked))
+                return;
+        hw_blocked = !hw_blocked;
+
+        for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
+                if (priv->rfk[i])
+                        rfkill_set_hw_state(priv->rfk[i], hw_blocked);
+}
+
+static int __devinit ideapad_register_rfkill(struct acpi_device *adevice,
+                                             int dev)
+{
+        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+        int ret;
+        unsigned long sw_blocked;
+
+        if (no_bt_rfkill &&
+            (ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH)) {
+                /* Force to enable bluetooth when no_bt_rfkill=1 */
+                write_ec_cmd(ideapad_handle,
+                             ideapad_rfk_data[dev].opcode, 1);
+                return 0;
+        }
+
+        priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name, &adevice->dev,
+                                      ideapad_rfk_data[dev].type, &ideapad_rfk_ops,
+                                      (void *)(long)dev);
+        if (!priv->rfk[dev])
+                return -ENOMEM;
+
+        if (read_ec_data(ideapad_handle, ideapad_rfk_data[dev].opcode-1,
+                         &sw_blocked)) {
+                rfkill_init_sw_state(priv->rfk[dev], 0);
+        } else {
+                sw_blocked = !sw_blocked;
+                rfkill_init_sw_state(priv->rfk[dev], sw_blocked);
+        }
+
+        ret = rfkill_register(priv->rfk[dev]);
+        if (ret) {
+                rfkill_destroy(priv->rfk[dev]);
+                return ret;
+        }
+        return 0;
+}
+
+static void __devexit ideapad_unregister_rfkill(struct acpi_device *adevice,
+                                                int dev)
+{
+        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+
+        if (!priv->rfk[dev])
+                return;
+
+        rfkill_unregister(priv->rfk[dev]);
+        rfkill_destroy(priv->rfk[dev]);
+}
+
+/*
+ * Platform device
+ */
+static struct attribute *ideapad_attributes[] = {
+        &dev_attr_camera_power.attr,
+        NULL
+};
+
+static struct attribute_group ideapad_attribute_group = {
+        .attrs = ideapad_attributes
+};
+
+static int __devinit ideapad_platform_init(struct ideapad_private *priv)
+{
+        int result;
+
+        priv->platform_device = platform_device_alloc("ideapad", -1);
+        if (!priv->platform_device)
+                return -ENOMEM;
+        platform_set_drvdata(priv->platform_device, priv);
+
+        result = platform_device_add(priv->platform_device);
+        if (result)
+                goto fail_platform_device;
+
+        result = sysfs_create_group(&priv->platform_device->dev.kobj,
+                                    &ideapad_attribute_group);
+        if (result)
+                goto fail_sysfs;
+        return 0;
+
+fail_sysfs:
+        platform_device_del(priv->platform_device);
+fail_platform_device:
+        platform_device_put(priv->platform_device);
+        return result;
+}
+
+static void ideapad_platform_exit(struct ideapad_private *priv)
+{
+        sysfs_remove_group(&priv->platform_device->dev.kobj,
+                           &ideapad_attribute_group);
+        platform_device_unregister(priv->platform_device);
+}
+
+/*
+ * input device
+ */
+static const struct key_entry ideapad_keymap[] = {
+        { KE_KEY, 0x06, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x0D, { KEY_WLAN } },
+        { KE_END, 0 },
+};
+
+static int __devinit ideapad_input_init(struct ideapad_private *priv)
+{
+        struct input_dev *inputdev;
+        int error;
+
+        inputdev = input_allocate_device();
+        if (!inputdev) {
+                pr_info("Unable to allocate input device\n");
+                return -ENOMEM;
+        }
+
+        inputdev->name = "Ideapad extra buttons";
+        inputdev->phys = "ideapad/input0";
+        inputdev->id.bustype = BUS_HOST;
+        inputdev->dev.parent = &priv->platform_device->dev;
+
+        error = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
+        if (error) {
+                pr_err("Unable to setup input device keymap\n");
+                goto err_free_dev;
+        }
+
+        error = input_register_device(inputdev);
+        if (error) {
+                pr_err("Unable to register input device\n");
+                goto err_free_keymap;
+        }
+
+        priv->inputdev = inputdev;
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(inputdev);
+err_free_dev:
+        input_free_device(inputdev);
+        return error;
+}
+
+static void __devexit ideapad_input_exit(struct ideapad_private *priv)
+{
+        sparse_keymap_free(priv->inputdev);
+        input_unregister_device(priv->inputdev);
+        priv->inputdev = NULL;
+}
+
+static void ideapad_input_report(struct ideapad_private *priv,
+                                 unsigned long scancode)
+{
+        sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
+}
+
+/*
+ * module init/exit
+ */
+static const struct acpi_device_id ideapad_device_ids[] = {
+        { "VPC2004", 0},
+        { "", 0},
+};
+MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
+
+static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
+{
+        int ret, i, cfg;
+        struct ideapad_private *priv;
+
+        if (read_method_int(adevice->handle, "_CFG", &cfg))
+                return -ENODEV;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+        dev_set_drvdata(&adevice->dev, priv);
+        ideapad_handle = adevice->handle;
+
+        ret = ideapad_platform_init(priv);
+        if (ret)
+                goto platform_failed;
+
+        ret = ideapad_input_init(priv);
+        if (ret)
+                goto input_failed;
+
+        for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) {
+                if (test_bit(ideapad_rfk_data[i].cfgbit, (unsigned long *)&cfg))
+                        ideapad_register_rfkill(adevice, i);
+                else
+                        priv->rfk[i] = NULL;
+        }
+        ideapad_sync_rfk_state(adevice);
+
+        return 0;
+
+input_failed:
+        ideapad_platform_exit(priv);
+platform_failed:
+        kfree(priv);
+        return ret;
+}
+
+static int __devexit ideapad_acpi_remove(struct acpi_device *adevice, int type)
+{
+        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+        int i;
+
+        for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
+                ideapad_unregister_rfkill(adevice, i);
+        ideapad_input_exit(priv);
+        ideapad_platform_exit(priv);
+        dev_set_drvdata(&adevice->dev, NULL);
+        kfree(priv);
+
+        return 0;
+}
+
+static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
+{
+        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+        acpi_handle handle = adevice->handle;
+        unsigned long vpc1, vpc2, vpc_bit;
+
+        if (read_ec_data(handle, 0x10, &vpc1))
+                return;
+        if (read_ec_data(handle, 0x1A, &vpc2))
+                return;
+
+        vpc1 = (vpc2 << 8) | vpc1;
+        for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
+                if (test_bit(vpc_bit, &vpc1)) {
+                        if (vpc_bit == 9)
+                                ideapad_sync_rfk_state(adevice);
+                        else if (vpc_bit == 4)
+                                read_ec_data(handle, 0x12, &vpc2);
+                        else
+                                ideapad_input_report(priv, vpc_bit);
+                }
+        }
+}
+
+static struct acpi_driver ideapad_acpi_driver = {
+        .name = "ideapad_acpi",
+        .class = "IdeaPad",
+        .ids = ideapad_device_ids,
+        .ops.add = ideapad_acpi_add,
+        .ops.remove = ideapad_acpi_remove,
+        .ops.notify = ideapad_acpi_notify,
+        .owner = THIS_MODULE,
+};
+
+static int __init ideapad_acpi_module_init(void)
+{
+        return acpi_bus_register_driver(&ideapad_acpi_driver);
+}
+
+static void __exit ideapad_acpi_module_exit(void)
+{
+        acpi_bus_unregister_driver(&ideapad_acpi_driver);
+}
+
+MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
+MODULE_DESCRIPTION("IdeaPad ACPI Extras");
+MODULE_LICENSE("GPL");
+
+module_init(ideapad_acpi_module_init);
+module_exit(ideapad_acpi_module_exit);
diff --git a/drivers/platform/x86/ideapad_acpi.c b/drivers/platform/x86/ideapad_acpi.c
deleted file mode 100644
index 798496353e8c..000000000000
--- a/drivers/platform/x86/ideapad_acpi.c
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- *  ideapad_acpi.c - Lenovo IdeaPad ACPI Extras
- *
- *  Copyright © 2010 Intel Corporation
- *  Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- *  02110-1301, USA.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
-#include <linux/rfkill.h>
-
-#define IDEAPAD_DEV_CAMERA      0
-#define IDEAPAD_DEV_WLAN        1
-#define IDEAPAD_DEV_BLUETOOTH   2
-#define IDEAPAD_DEV_3G          3
-#define IDEAPAD_DEV_KILLSW      4
-
-struct ideapad_private {
-        struct rfkill *rfk[5];
-};
-
-static struct {
-        char *name;
-        int type;
-} ideapad_rfk_data[] = {
-        /* camera has no rfkill */
-        { "ideapad_wlan",       RFKILL_TYPE_WLAN },
-        { "ideapad_bluetooth",  RFKILL_TYPE_BLUETOOTH },
-        { "ideapad_3g",         RFKILL_TYPE_WWAN },
-        { "ideapad_killsw",     RFKILL_TYPE_WLAN }
-};
-
-static int ideapad_dev_exists(int device)
-{
-        acpi_status status;
-        union acpi_object in_param;
-        struct acpi_object_list input = { 1, &in_param };
-        struct acpi_buffer output;
-        union acpi_object out_obj;
-
-        output.length = sizeof(out_obj);
-        output.pointer = &out_obj;
-
-        in_param.type = ACPI_TYPE_INTEGER;
-        in_param.integer.value = device + 1;
-
-        status = acpi_evaluate_object(NULL, "\\_SB_.DECN", &input, &output);
-        if (ACPI_FAILURE(status)) {
-                printk(KERN_WARNING "IdeaPAD \\_SB_.DECN method failed %d. Is this an IdeaPAD?\n", status);
-                return -ENODEV;
-        }
-        if (out_obj.type != ACPI_TYPE_INTEGER) {
-                printk(KERN_WARNING "IdeaPAD \\_SB_.DECN method returned unexpected type\n");
-                return -ENODEV;
-        }
-        return out_obj.integer.value;
-}
-
-static int ideapad_dev_get_state(int device)
-{
-        acpi_status status;
-        union acpi_object in_param;
-        struct acpi_object_list input = { 1, &in_param };
-        struct acpi_buffer output;
-        union acpi_object out_obj;
-
-        output.length = sizeof(out_obj);
-        output.pointer = &out_obj;
-
-        in_param.type = ACPI_TYPE_INTEGER;
-        in_param.integer.value = device + 1;
-
-        status = acpi_evaluate_object(NULL, "\\_SB_.GECN", &input, &output);
-        if (ACPI_FAILURE(status)) {
-                printk(KERN_WARNING "IdeaPAD \\_SB_.GECN method failed %d\n", status);
-                return -ENODEV;
-        }
-        if (out_obj.type != ACPI_TYPE_INTEGER) {
-                printk(KERN_WARNING "IdeaPAD \\_SB_.GECN method returned unexpected type\n");
-                return -ENODEV;
-        }
-        return out_obj.integer.value;
-}
-
-static int ideapad_dev_set_state(int device, int state)
-{
-        acpi_status status;
-        union acpi_object in_params[2];
-        struct acpi_object_list input = { 2, in_params };
-
-        in_params[0].type = ACPI_TYPE_INTEGER;
-        in_params[0].integer.value = device + 1;
-        in_params[1].type = ACPI_TYPE_INTEGER;
-        in_params[1].integer.value = state;
-
-        status = acpi_evaluate_object(NULL, "\\_SB_.SECN", &input, NULL);
-        if (ACPI_FAILURE(status)) {
-                printk(KERN_WARNING "IdeaPAD \\_SB_.SECN method failed %d\n", status);
-                return -ENODEV;
-        }
-        return 0;
-}
-static ssize_t show_ideapad_cam(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
-{
-        int state = ideapad_dev_get_state(IDEAPAD_DEV_CAMERA);
-        if (state < 0)
-                return state;
-
-        return sprintf(buf, "%d\n", state);
-}
-
-static ssize_t store_ideapad_cam(struct device *dev,
-                                 struct device_attribute *attr,
-                                 const char *buf, size_t count)
-{
-        int ret, state;
-
-        if (!count)
-                return 0;
-        if (sscanf(buf, "%i", &state) != 1)
-                return -EINVAL;
-        ret = ideapad_dev_set_state(IDEAPAD_DEV_CAMERA, !!state);
-        if (ret < 0)
-                return ret;
-        return count;
-}
-
-static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
-
-static int ideapad_rfk_set(void *data, bool blocked)
-{
-        int device = (unsigned long)data;
-
-        if (device == IDEAPAD_DEV_KILLSW)
-                return -EINVAL;
-        return ideapad_dev_set_state(device, !blocked);
-}
-
-static struct rfkill_ops ideapad_rfk_ops = {
-        .set_block = ideapad_rfk_set,
-};
-
-static void ideapad_sync_rfk_state(struct acpi_device *adevice)
-{
-        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
-        int hw_blocked = !ideapad_dev_get_state(IDEAPAD_DEV_KILLSW);
-        int i;
-
-        rfkill_set_hw_state(priv->rfk[IDEAPAD_DEV_KILLSW], hw_blocked);
-        for (i = IDEAPAD_DEV_WLAN; i < IDEAPAD_DEV_KILLSW; i++)
-                if (priv->rfk[i])
-                        rfkill_set_hw_state(priv->rfk[i], hw_blocked);
-        if (hw_blocked)
-                return;
-
-        for (i = IDEAPAD_DEV_WLAN; i < IDEAPAD_DEV_KILLSW; i++)
-                if (priv->rfk[i])
-                        rfkill_set_sw_state(priv->rfk[i], !ideapad_dev_get_state(i));
-}
-
-static int ideapad_register_rfkill(struct acpi_device *adevice, int dev)
-{
-        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
-        int ret;
-
-        priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev-1].name, &adevice->dev,
-                                      ideapad_rfk_data[dev-1].type, &ideapad_rfk_ops,
-                                      (void *)(long)dev);
-        if (!priv->rfk[dev])
-                return -ENOMEM;
-
-        ret = rfkill_register(priv->rfk[dev]);
-        if (ret) {
-                rfkill_destroy(priv->rfk[dev]);
-                return ret;
-        }
-        return 0;
-}
-
-static void ideapad_unregister_rfkill(struct acpi_device *adevice, int dev)
-{
-        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
-
-        if (!priv->rfk[dev])
-                return;
-
-        rfkill_unregister(priv->rfk[dev]);
-        rfkill_destroy(priv->rfk[dev]);
-}
-
-static const struct acpi_device_id ideapad_device_ids[] = {
-        { "VPC2004", 0},
-        { "", 0},
-};
-MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
-
-static int ideapad_acpi_add(struct acpi_device *adevice)
-{
-        int i;
-        int devs_present[5];
-        struct ideapad_private *priv;
-
-        for (i = IDEAPAD_DEV_CAMERA; i < IDEAPAD_DEV_KILLSW; i++) {
-                devs_present[i] = ideapad_dev_exists(i);
-                if (devs_present[i] < 0)
-                        return devs_present[i];
-        }
-
-        /* The hardware switch is always present */
-        devs_present[IDEAPAD_DEV_KILLSW] = 1;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        if (devs_present[IDEAPAD_DEV_CAMERA]) {
-                int ret = device_create_file(&adevice->dev, &dev_attr_camera_power);
-                if (ret) {
-                        kfree(priv);
-                        return ret;
-                }
-        }
-
-        dev_set_drvdata(&adevice->dev, priv);
-        for (i = IDEAPAD_DEV_WLAN; i <= IDEAPAD_DEV_KILLSW; i++) {
-                if (!devs_present[i])
-                        continue;
-
-                ideapad_register_rfkill(adevice, i);
-        }
-        ideapad_sync_rfk_state(adevice);
-        return 0;
-}
-
-static int ideapad_acpi_remove(struct acpi_device *adevice, int type)
-{
-        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
-        int i;
-
-        device_remove_file(&adevice->dev, &dev_attr_camera_power);
-
-        for (i = IDEAPAD_DEV_WLAN; i <= IDEAPAD_DEV_KILLSW; i++)
-                ideapad_unregister_rfkill(adevice, i);
-
-        dev_set_drvdata(&adevice->dev, NULL);
-        kfree(priv);
-        return 0;
-}
-
-static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
-{
-        ideapad_sync_rfk_state(adevice);
-}
-
-static struct acpi_driver ideapad_acpi_driver = {
-        .name = "ideapad_acpi",
-        .class = "IdeaPad",
-        .ids = ideapad_device_ids,
-        .ops.add = ideapad_acpi_add,
-        .ops.remove = ideapad_acpi_remove,
-        .ops.notify = ideapad_acpi_notify,
-        .owner = THIS_MODULE,
-};
-
-
-static int __init ideapad_acpi_module_init(void)
-{
-        acpi_bus_register_driver(&ideapad_acpi_driver);
-
-        return 0;
-}
-
-
-static void __exit ideapad_acpi_module_exit(void)
-{
-        acpi_bus_unregister_driver(&ideapad_acpi_driver);
-
-}
-
-MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
-MODULE_DESCRIPTION("IdeaPad ACPI Extras");
-MODULE_LICENSE("GPL");
-
-module_init(ideapad_acpi_module_init);
-module_exit(ideapad_acpi_module_exit);
diff --git a/drivers/platform/x86/intel_ips.c b/drivers/platform/x86/intel_ips.c
index c44a5e8b8b82..5ffe7c398148 100644
--- a/drivers/platform/x86/intel_ips.c
+++ b/drivers/platform/x86/intel_ips.c
@@ -75,6 +75,7 @@
 #include <drm/i915_drm.h>
 #include <asm/msr.h>
 #include <asm/processor.h>
+#include "intel_ips.h"
 
 #define PCI_DEVICE_ID_INTEL_THERMAL_SENSOR 0x3b32
 
@@ -245,6 +246,7 @@
 #define thm_writel(off, val) writel((val), ips->regmap + (off))
 
 static const int IPS_ADJUST_PERIOD = 5000; /* ms */
+static bool late_i915_load = false;
 
 /* For initial average collection */
 static const int IPS_SAMPLE_PERIOD = 200; /* ms */
@@ -339,6 +341,22 @@ struct ips_driver {
         u64 orig_turbo_ratios;
 };
 
+static bool
+ips_gpu_turbo_enabled(struct ips_driver *ips);
+
+#ifndef readq
+static inline __u64 readq(const volatile void __iomem *addr)
+{
+        const volatile u32 __iomem *p = addr;
+        u32 low, high;
+
+        low = readl(p);
+        high = readl(p + 1);
+
+        return low + ((u64)high << 32);
+}
+#endif
+
 /**
  * ips_cpu_busy - is CPU busy?
  * @ips: IPS driver struct
@@ -517,7 +535,7 @@ static void ips_disable_cpu_turbo(struct ips_driver *ips)
  */
 static bool ips_gpu_busy(struct ips_driver *ips)
 {
-        if (!ips->gpu_turbo_enabled)
+        if (!ips_gpu_turbo_enabled(ips))
                 return false;
 
         return ips->gpu_busy();
@@ -532,7 +550,7 @@ static bool ips_gpu_busy(struct ips_driver *ips)
  */
 static void ips_gpu_raise(struct ips_driver *ips)
 {
-        if (!ips->gpu_turbo_enabled)
+        if (!ips_gpu_turbo_enabled(ips))
                 return;
 
         if (!ips->gpu_raise())
@@ -549,7 +567,7 @@ static void ips_gpu_raise(struct ips_driver *ips)
  */
 static void ips_gpu_lower(struct ips_driver *ips)
 {
-        if (!ips->gpu_turbo_enabled)
+        if (!ips_gpu_turbo_enabled(ips))
                 return;
 
         if (!ips->gpu_lower())
@@ -1106,7 +1124,7 @@ static int ips_monitor(void *data)
                 last_msecs = jiffies_to_msecs(jiffies);
                 expire = jiffies + msecs_to_jiffies(IPS_SAMPLE_PERIOD);
 
-                __set_current_state(TASK_UNINTERRUPTIBLE);
+                __set_current_state(TASK_INTERRUPTIBLE);
                 mod_timer(&timer, expire);
                 schedule();
 
@@ -1454,6 +1472,31 @@ out_err:
         return false;
 }
 
+static bool
+ips_gpu_turbo_enabled(struct ips_driver *ips)
+{
+        if (!ips->gpu_busy && late_i915_load) {
+                if (ips_get_i915_syms(ips)) {
+                        dev_info(&ips->dev->dev,
+                                 "i915 driver attached, reenabling gpu turbo\n");
+                        ips->gpu_turbo_enabled = !(thm_readl(THM_HTS) & HTS_GTD_DIS);
+                }
+        }
+
+        return ips->gpu_turbo_enabled;
+}
+
+void
+ips_link_to_i915_driver(void)
+{
+        /* We can't cleanly get at the various ips_driver structs from
+         * this caller (the i915 driver), so just set a flag saying
+         * that it's time to try getting the symbols again.
+         */
+        late_i915_load = true;
+}
+EXPORT_SYMBOL_GPL(ips_link_to_i915_driver);
+
 static DEFINE_PCI_DEVICE_TABLE(ips_id_table) = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL,
                      PCI_DEVICE_ID_INTEL_THERMAL_SENSOR), },
diff --git a/drivers/platform/x86/intel_ips.h b/drivers/platform/x86/intel_ips.h
new file mode 100644
index 000000000000..73299beff5b3
--- /dev/null
+++ b/drivers/platform/x86/intel_ips.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2010 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ */
+
+void ips_link_to_i915_driver(void);
diff --git a/drivers/platform/x86/intel_menlow.c b/drivers/platform/x86/intel_menlow.c
index eacd5da7dd24..809adea4965f 100644
--- a/drivers/platform/x86/intel_menlow.c
+++ b/drivers/platform/x86/intel_menlow.c
@@ -27,6 +27,8 @@
  *  to get/set bandwidth.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -135,8 +137,7 @@ static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
             acpi_evaluate_integer(handle, MEMORY_SET_BANDWIDTH, &arg_list,
                                   &temp);
 
-        printk(KERN_INFO
-               "Bandwidth value was %ld: status is %d\n", state, status);
+        pr_info("Bandwidth value was %ld: status is %d\n", state, status);
         if (ACPI_FAILURE(status))
                 return -EFAULT;
 
diff --git a/drivers/platform/x86/intel_mid_powerbtn.c b/drivers/platform/x86/intel_mid_powerbtn.c
new file mode 100644
index 000000000000..f1ae5078b7ec
--- /dev/null
+++ b/drivers/platform/x86/intel_mid_powerbtn.c
@@ -0,0 +1,136 @@
+/*
+ * Power button driver for Medfield.
+ *
+ * Copyright (C) 2010 Intel Corp
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+
+#include <asm/intel_scu_ipc.h>
+
+#define DRIVER_NAME "msic_power_btn"
+
+#define MSIC_PB_STATUS  0x3f
+#define MSIC_PB_LEVEL   (1 << 3) /* 1 - release, 0 - press */
+
+static irqreturn_t mfld_pb_isr(int irq, void *dev_id)
+{
+        struct input_dev *input = dev_id;
+        int ret;
+        u8 pbstat;
+
+        ret = intel_scu_ipc_ioread8(MSIC_PB_STATUS, &pbstat);
+        if (ret < 0) {
+                dev_err(input->dev.parent, "Read error %d while reading"
+                               " MSIC_PB_STATUS\n", ret);
+        } else {
+                input_event(input, EV_KEY, KEY_POWER,
+                               !(pbstat & MSIC_PB_LEVEL));
+                input_sync(input);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit mfld_pb_probe(struct platform_device *pdev)
+{
+        struct input_dev *input;
+        int irq = platform_get_irq(pdev, 0);
+        int error;
+
+        if (irq < 0)
+                return -EINVAL;
+
+        input = input_allocate_device();
+        if (!input) {
+                dev_err(&pdev->dev, "Input device allocation error\n");
+                return -ENOMEM;
+        }
+
+        input->name = pdev->name;
+        input->phys = "power-button/input0";
+        input->id.bustype = BUS_HOST;
+        input->dev.parent = &pdev->dev;
+
+        input_set_capability(input, EV_KEY, KEY_POWER);
+
+        error = request_threaded_irq(irq, NULL, mfld_pb_isr, 0,
+                        DRIVER_NAME, input);
+        if (error) {
+                dev_err(&pdev->dev, "Unable to request irq %d for mfld power"
+                                "button\n", irq);
+                goto err_free_input;
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev, "Unable to register input dev, error "
+                                "%d\n", error);
+                goto err_free_irq;
+        }
+
+        platform_set_drvdata(pdev, input);
+        return 0;
+
+err_free_irq:
+        free_irq(irq, input);
+err_free_input:
+        input_free_device(input);
+        return error;
+}
+
+static int __devexit mfld_pb_remove(struct platform_device *pdev)
+{
+        struct input_dev *input = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        free_irq(irq, input);
+        input_unregister_device(input);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver mfld_pb_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe  = mfld_pb_probe,
+        .remove = __devexit_p(mfld_pb_remove),
+};
+
+static int __init mfld_pb_init(void)
+{
+        return platform_driver_register(&mfld_pb_driver);
+}
+module_init(mfld_pb_init);
+
+static void __exit mfld_pb_exit(void)
+{
+        platform_driver_unregister(&mfld_pb_driver);
+}
+module_exit(mfld_pb_exit);
+
+MODULE_AUTHOR("Hong Liu <hong.liu@intel.com>");
+MODULE_DESCRIPTION("Intel Medfield Power Button Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
new file mode 100644
index 000000000000..3a578323122b
--- /dev/null
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -0,0 +1,571 @@
+/*
+ * intel_mid_thermal.c - Intel MID platform thermal driver
+ *
+ * Copyright (C) 2011 Intel Corporation
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.        See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * Author: Durgadoss R <durgadoss.r@intel.com>
+ */
+
+#define pr_fmt(fmt) "intel_mid_thermal: " fmt
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/param.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/pm.h>
+#include <linux/thermal.h>
+
+#include <asm/intel_scu_ipc.h>
+
+/* Number of thermal sensors */
+#define MSIC_THERMAL_SENSORS    4
+
+/* ADC1 - thermal registers */
+#define MSIC_THERM_ADC1CNTL1    0x1C0
+#define MSIC_ADC_ENBL           0x10
+#define MSIC_ADC_START          0x08
+
+#define MSIC_THERM_ADC1CNTL3    0x1C2
+#define MSIC_ADCTHERM_ENBL      0x04
+#define MSIC_ADCRRDATA_ENBL     0x05
+#define MSIC_CHANL_MASK_VAL     0x0F
+
+#define MSIC_STOPBIT_MASK       16
+#define MSIC_ADCTHERM_MASK      4
+/* Number of ADC channels */
+#define ADC_CHANLS_MAX          15
+#define ADC_LOOP_MAX            (ADC_CHANLS_MAX - MSIC_THERMAL_SENSORS)
+
+/* ADC channel code values */
+#define SKIN_SENSOR0_CODE       0x08
+#define SKIN_SENSOR1_CODE       0x09
+#define SYS_SENSOR_CODE         0x0A
+#define MSIC_DIE_SENSOR_CODE    0x03
+
+#define SKIN_THERM_SENSOR0      0
+#define SKIN_THERM_SENSOR1      1
+#define SYS_THERM_SENSOR2       2
+#define MSIC_DIE_THERM_SENSOR3  3
+
+/* ADC code range */
+#define ADC_MAX                 977
+#define ADC_MIN                 162
+#define ADC_VAL0C               887
+#define ADC_VAL20C              720
+#define ADC_VAL40C              508
+#define ADC_VAL60C              315
+
+/* ADC base addresses */
+#define ADC_CHNL_START_ADDR     0x1C5   /* increments by 1 */
+#define ADC_DATA_START_ADDR     0x1D4   /* increments by 2 */
+
+/* MSIC die attributes */
+#define MSIC_DIE_ADC_MIN        488
+#define MSIC_DIE_ADC_MAX        1004
+
+/* This holds the address of the first free ADC channel,
+ * among the 15 channels
+ */
+static int channel_index;
+
+struct platform_info {
+        struct platform_device *pdev;
+        struct thermal_zone_device *tzd[MSIC_THERMAL_SENSORS];
+};
+
+struct thermal_device_info {
+        unsigned int chnl_addr;
+        int direct;
+        /* This holds the current temperature in millidegree celsius */
+        long curr_temp;
+};
+
+/**
+ * to_msic_die_temp - converts adc_val to msic_die temperature
+ * @adc_val: ADC value to be converted
+ *
+ * Can sleep
+ */
+static int to_msic_die_temp(uint16_t adc_val)
+{
+        return (368 * (adc_val) / 1000) - 220;
+}
+
+/**
+ * is_valid_adc - checks whether the adc code is within the defined range
+ * @min: minimum value for the sensor
+ * @max: maximum value for the sensor
+ *
+ * Can sleep
+ */
+static int is_valid_adc(uint16_t adc_val, uint16_t min, uint16_t max)
+{
+        return (adc_val >= min) && (adc_val <= max);
+}
+
+/**
+ * adc_to_temp - converts the ADC code to temperature in C
+ * @direct: true if ths channel is direct index
+ * @adc_val: the adc_val that needs to be converted
+ * @tp: temperature return value
+ *
+ * Linear approximation is used to covert the skin adc value into temperature.
+ * This technique is used to avoid very long look-up table to get
+ * the appropriate temp value from ADC value.
+ * The adc code vs sensor temp curve is split into five parts
+ * to achieve very close approximate temp value with less than
+ * 0.5C error
+ */
+static int adc_to_temp(int direct, uint16_t adc_val, unsigned long *tp)
+{
+        int temp;
+
+        /* Direct conversion for die temperature */
+        if (direct) {
+                if (is_valid_adc(adc_val, MSIC_DIE_ADC_MIN, MSIC_DIE_ADC_MAX)) {
+                        *tp = to_msic_die_temp(adc_val) * 1000;
+                        return 0;
+                }
+                return -ERANGE;
+        }
+
+        if (!is_valid_adc(adc_val, ADC_MIN, ADC_MAX))
+                return -ERANGE;
+
+        /* Linear approximation for skin temperature */
+        if (adc_val > ADC_VAL0C)
+                temp = 177 - (adc_val/5);
+        else if ((adc_val <= ADC_VAL0C) && (adc_val > ADC_VAL20C))
+                temp = 111 - (adc_val/8);
+        else if ((adc_val <= ADC_VAL20C) && (adc_val > ADC_VAL40C))
+                temp = 92 - (adc_val/10);
+        else if ((adc_val <= ADC_VAL40C) && (adc_val > ADC_VAL60C))
+                temp = 91 - (adc_val/10);
+        else
+                temp = 112 - (adc_val/6);
+
+        /* Convert temperature in celsius to milli degree celsius */
+        *tp = temp * 1000;
+        return 0;
+}
+
+/**
+ * mid_read_temp - read sensors for temperature
+ * @temp: holds the current temperature for the sensor after reading
+ *
+ * reads the adc_code from the channel and converts it to real
+ * temperature. The converted value is stored in temp.
+ *
+ * Can sleep
+ */
+static int mid_read_temp(struct thermal_zone_device *tzd, unsigned long *temp)
+{
+        struct thermal_device_info *td_info = tzd->devdata;
+        uint16_t adc_val, addr;
+        uint8_t data = 0;
+        int ret;
+        unsigned long curr_temp;
+
+
+        addr = td_info->chnl_addr;
+
+        /* Enable the msic for conversion before reading */
+        ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCRRDATA_ENBL);
+        if (ret)
+                return ret;
+
+        /* Re-toggle the RRDATARD bit (temporary workaround) */
+        ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCTHERM_ENBL);
+        if (ret)
+                return ret;
+
+        /* Read the higher bits of data */
+        ret = intel_scu_ipc_ioread8(addr, &data);
+        if (ret)
+                return ret;
+
+        /* Shift bits to accommodate the lower two data bits */
+        adc_val = (data << 2);
+        addr++;
+
+        ret = intel_scu_ipc_ioread8(addr, &data);/* Read lower bits */
+        if (ret)
+                return ret;
+
+        /* Adding lower two bits to the higher bits */
+        data &= 03;
+        adc_val += data;
+
+        /* Convert ADC value to temperature */
+        ret = adc_to_temp(td_info->direct, adc_val, &curr_temp);
+        if (ret == 0)
+                *temp = td_info->curr_temp = curr_temp;
+        return ret;
+}
+
+/**
+ * configure_adc - enables/disables the ADC for conversion
+ * @val: zero: disables the ADC non-zero:enables the ADC
+ *
+ * Enable/Disable the ADC depending on the argument
+ *
+ * Can sleep
+ */
+static int configure_adc(int val)
+{
+        int ret;
+        uint8_t data;
+
+        ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+        if (ret)
+                return ret;
+
+        if (val) {
+                /* Enable and start the ADC */
+                data |= (MSIC_ADC_ENBL | MSIC_ADC_START);
+        } else {
+                /* Just stop the ADC */
+                data &= (~MSIC_ADC_START);
+        }
+        return intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL1, data);
+}
+
+/**
+ * set_up_therm_channel - enable thermal channel for conversion
+ * @base_addr: index of free msic ADC channel
+ *
+ * Enable all the three channels for conversion
+ *
+ * Can sleep
+ */
+static int set_up_therm_channel(u16 base_addr)
+{
+        int ret;
+
+        /* Enable all the sensor channels */
+        ret = intel_scu_ipc_iowrite8(base_addr, SKIN_SENSOR0_CODE);
+        if (ret)
+                return ret;
+
+        ret = intel_scu_ipc_iowrite8(base_addr + 1, SKIN_SENSOR1_CODE);
+        if (ret)
+                return ret;
+
+        ret = intel_scu_ipc_iowrite8(base_addr + 2, SYS_SENSOR_CODE);
+        if (ret)
+                return ret;
+
+        /* Since this is the last channel, set the stop bit
+         * to 1 by ORing the DIE_SENSOR_CODE with 0x10 */
+        ret = intel_scu_ipc_iowrite8(base_addr + 3,
+                        (MSIC_DIE_SENSOR_CODE | 0x10));
+        if (ret)
+                return ret;
+
+        /* Enable ADC and start it */
+        return configure_adc(1);
+}
+
+/**
+ * reset_stopbit - sets the stop bit to 0 on the given channel
+ * @addr: address of the channel
+ *
+ * Can sleep
+ */
+static int reset_stopbit(uint16_t addr)
+{
+        int ret;
+        uint8_t data;
+        ret = intel_scu_ipc_ioread8(addr, &data);
+        if (ret)
+                return ret;
+        /* Set the stop bit to zero */
+        return intel_scu_ipc_iowrite8(addr, (data & 0xEF));
+}
+
+/**
+ * find_free_channel - finds an empty channel for conversion
+ *
+ * If the ADC is not enabled then start using 0th channel
+ * itself. Otherwise find an empty channel by looking for a
+ * channel in which the stopbit is set to 1. returns the index
+ * of the first free channel if succeeds or an error code.
+ *
+ * Context: can sleep
+ *
+ * FIXME: Ultimately the channel allocator will move into the intel_scu_ipc
+ * code.
+ */
+static int find_free_channel(void)
+{
+        int ret;
+        int i;
+        uint8_t data;
+
+        /* check whether ADC is enabled */
+        ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+        if (ret)
+                return ret;
+
+        if ((data & MSIC_ADC_ENBL) == 0)
+                return 0;
+
+        /* ADC is already enabled; Looking for an empty channel */
+        for (i = 0; i < ADC_CHANLS_MAX; i++) {
+                ret = intel_scu_ipc_ioread8(ADC_CHNL_START_ADDR + i, &data);
+                if (ret)
+                        return ret;
+
+                if (data & MSIC_STOPBIT_MASK) {
+                        ret = i;
+                        break;
+                }
+        }
+        return (ret > ADC_LOOP_MAX) ? (-EINVAL) : ret;
+}
+
+/**
+ * mid_initialize_adc - initializing the ADC
+ * @dev: our device structure
+ *
+ * Initialize the ADC for reading thermistor values. Can sleep.
+ */
+static int mid_initialize_adc(struct device *dev)
+{
+        u8  data;
+        u16 base_addr;
+        int ret;
+
+        /*
+         * Ensure that adctherm is disabled before we
+         * initialize the ADC
+         */
+        ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL3, &data);
+        if (ret)
+                return ret;
+
+        if (data & MSIC_ADCTHERM_MASK)
+                dev_warn(dev, "ADCTHERM already set");
+
+        /* Index of the first channel in which the stop bit is set */
+        channel_index = find_free_channel();
+        if (channel_index < 0) {
+                dev_err(dev, "No free ADC channels");
+                return channel_index;
+        }
+
+        base_addr = ADC_CHNL_START_ADDR + channel_index;
+
+        if (!(channel_index == 0 || channel_index == ADC_LOOP_MAX)) {
+                /* Reset stop bit for channels other than 0 and 12 */
+                ret = reset_stopbit(base_addr);
+                if (ret)
+                        return ret;
+
+                /* Index of the first free channel */
+                base_addr++;
+                channel_index++;
+        }
+
+        ret = set_up_therm_channel(base_addr);
+        if (ret) {
+                dev_err(dev, "unable to enable ADC");
+                return ret;
+        }
+        dev_dbg(dev, "ADC initialization successful");
+        return ret;
+}
+
+/**
+ * initialize_sensor - sets default temp and timer ranges
+ * @index: index of the sensor
+ *
+ * Context: can sleep
+ */
+static struct thermal_device_info *initialize_sensor(int index)
+{
+        struct thermal_device_info *td_info =
+                kzalloc(sizeof(struct thermal_device_info), GFP_KERNEL);
+
+        if (!td_info)
+                return NULL;
+
+        /* Set the base addr of the channel for this sensor */
+        td_info->chnl_addr = ADC_DATA_START_ADDR + 2 * (channel_index + index);
+        /* Sensor 3 is direct conversion */
+        if (index == 3)
+                td_info->direct = 1;
+        return td_info;
+}
+
+/**
+ * mid_thermal_resume - resume routine
+ * @pdev: platform device structure
+ *
+ * mid thermal resume: re-initializes the adc. Can sleep.
+ */
+static int mid_thermal_resume(struct platform_device *pdev)
+{
+        return mid_initialize_adc(&pdev->dev);
+}
+
+/**
+ * mid_thermal_suspend - suspend routine
+ * @pdev: platform device structure
+ *
+ * mid thermal suspend implements the suspend functionality
+ * by stopping the ADC. Can sleep.
+ */
+static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
+{
+        /*
+         * This just stops the ADC and does not disable it.
+         * temporary workaround until we have a generic ADC driver.
+         * If 0 is passed, it disables the ADC.
+         */
+        return configure_adc(0);
+}
+
+/**
+ * read_curr_temp - reads the current temperature and stores in temp
+ * @temp: holds the current temperature value after reading
+ *
+ * Can sleep
+ */
+static int read_curr_temp(struct thermal_zone_device *tzd, unsigned long *temp)
+{
+        WARN_ON(tzd == NULL);
+        return mid_read_temp(tzd, temp);
+}
+
+/* Can't be const */
+static struct thermal_zone_device_ops tzd_ops = {
+        .get_temp = read_curr_temp,
+};
+
+/**
+ * mid_thermal_probe - mfld thermal initialize
+ * @pdev: platform device structure
+ *
+ * mid thermal probe initializes the hardware and registers
+ * all the sensors with the generic thermal framework. Can sleep.
+ */
+static int mid_thermal_probe(struct platform_device *pdev)
+{
+        static char *name[MSIC_THERMAL_SENSORS] = {
+                "skin0", "skin1", "sys", "msicdie"
+        };
+
+        int ret;
+        int i;
+        struct platform_info *pinfo;
+
+        pinfo = kzalloc(sizeof(struct platform_info), GFP_KERNEL);
+        if (!pinfo)
+                return -ENOMEM;
+
+        /* Initializing the hardware */
+        ret = mid_initialize_adc(&pdev->dev);
+        if (ret) {
+                dev_err(&pdev->dev, "ADC init failed");
+                kfree(pinfo);
+                return ret;
+        }
+
+        /* Register each sensor with the generic thermal framework*/
+        for (i = 0; i < MSIC_THERMAL_SENSORS; i++) {
+                pinfo->tzd[i] = thermal_zone_device_register(name[i],
+                                0, initialize_sensor(i), &tzd_ops, 0, 0, 0, 0);
+                if (IS_ERR(pinfo->tzd[i]))
+                        goto reg_fail;
+        }
+
+        pinfo->pdev = pdev;
+        platform_set_drvdata(pdev, pinfo);
+        return 0;
+
+reg_fail:
+        ret = PTR_ERR(pinfo->tzd[i]);
+        while (--i >= 0)
+                thermal_zone_device_unregister(pinfo->tzd[i]);
+        configure_adc(0);
+        kfree(pinfo);
+        return ret;
+}
+
+/**
+ * mid_thermal_remove - mfld thermal finalize
+ * @dev: platform device structure
+ *
+ * MLFD thermal remove unregisters all the sensors from the generic
+ * thermal framework. Can sleep.
+ */
+static int mid_thermal_remove(struct platform_device *pdev)
+{
+        int i;
+        struct platform_info *pinfo = platform_get_drvdata(pdev);
+
+        for (i = 0; i < MSIC_THERMAL_SENSORS; i++)
+                thermal_zone_device_unregister(pinfo->tzd[i]);
+
+        kfree(pinfo);
+        platform_set_drvdata(pdev, NULL);
+
+        /* Stop the ADC */
+        return configure_adc(0);
+}
+
+#define DRIVER_NAME "msic_sensor"
+
+static const struct platform_device_id therm_id_table[] = {
+        { DRIVER_NAME, 1 },
+        { }
+};
+
+static struct platform_driver mid_thermal_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe = mid_thermal_probe,
+        .suspend = mid_thermal_suspend,
+        .resume = mid_thermal_resume,
+        .remove = __devexit_p(mid_thermal_remove),
+        .id_table = therm_id_table,
+};
+
+static int __init mid_thermal_module_init(void)
+{
+        return platform_driver_register(&mid_thermal_driver);
+}
+
+static void __exit mid_thermal_module_exit(void)
+{
+        platform_driver_unregister(&mid_thermal_driver);
+}
+
+module_init(mid_thermal_module_init);
+module_exit(mid_thermal_module_exit);
+
+MODULE_AUTHOR("Durgadoss R <durgadoss.r@intel.com>");
+MODULE_DESCRIPTION("Intel Medfield Platform Thermal Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/intel_oaktrail.c b/drivers/platform/x86/intel_oaktrail.c
new file mode 100644
index 000000000000..7f88c7923fc6
--- /dev/null
+++ b/drivers/platform/x86/intel_oaktrail.c
@@ -0,0 +1,397 @@
+/*
+ * intel_oaktrail.c - Intel OakTrail Platform support.
+ *
+ * Copyright (C) 2010-2011 Intel Corporation
+ * Author: Yin Kangkai (kangkai.yin@intel.com)
+ *
+ * based on Compal driver, Copyright (C) 2008 Cezary Jackiewicz
+ * <cezary.jackiewicz (at) gmail.com>, based on MSI driver
+ * Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ *  02110-1301, USA.
+ *
+ * This driver does below things:
+ * 1. registers itself in the Linux backlight control in
+ *    /sys/class/backlight/intel_oaktrail/
+ *
+ * 2. registers in the rfkill subsystem here: /sys/class/rfkill/rfkillX/
+ *    for these components: wifi, bluetooth, wwan (3g), gps
+ *
+ * This driver might work on other products based on Oaktrail. If you
+ * want to try it you can pass force=1 as argument to the module which
+ * will force it to load even when the DMI data doesn't identify the
+ * product as compatible.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/fb.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/backlight.h>
+#include <linux/platform_device.h>
+#include <linux/dmi.h>
+#include <linux/rfkill.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+
+#define DRIVER_NAME     "intel_oaktrail"
+#define DRIVER_VERSION  "0.4ac1"
+
+/*
+ * This is the devices status address in EC space, and the control bits
+ * definition:
+ *
+ * (1 << 0):    Camera enable/disable, RW.
+ * (1 << 1):    Bluetooth enable/disable, RW.
+ * (1 << 2):    GPS enable/disable, RW.
+ * (1 << 3):    WiFi enable/disable, RW.
+ * (1 << 4):    WWAN (3G) enable/disalbe, RW.
+ * (1 << 5):    Touchscreen enable/disable, Read Only.
+ */
+#define OT_EC_DEVICE_STATE_ADDRESS      0xD6
+
+#define OT_EC_CAMERA_MASK       (1 << 0)
+#define OT_EC_BT_MASK           (1 << 1)
+#define OT_EC_GPS_MASK          (1 << 2)
+#define OT_EC_WIFI_MASK         (1 << 3)
+#define OT_EC_WWAN_MASK         (1 << 4)
+#define OT_EC_TS_MASK           (1 << 5)
+
+/*
+ * This is the address in EC space and commands used to control LCD backlight:
+ *
+ * Two steps needed to change the LCD backlight:
+ *   1. write the backlight percentage into OT_EC_BL_BRIGHTNESS_ADDRESS;
+ *   2. write OT_EC_BL_CONTROL_ON_DATA into OT_EC_BL_CONTROL_ADDRESS.
+ *
+ * To read the LCD back light, just read out the value from
+ * OT_EC_BL_BRIGHTNESS_ADDRESS.
+ *
+ * LCD backlight brightness range: 0 - 100 (OT_EC_BL_BRIGHTNESS_MAX)
+ */
+#define OT_EC_BL_BRIGHTNESS_ADDRESS     0x44
+#define OT_EC_BL_BRIGHTNESS_MAX         100
+#define OT_EC_BL_CONTROL_ADDRESS        0x3A
+#define OT_EC_BL_CONTROL_ON_DATA        0x1A
+
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
+
+static struct platform_device *oaktrail_device;
+static struct backlight_device *oaktrail_bl_device;
+static struct rfkill *bt_rfkill;
+static struct rfkill *gps_rfkill;
+static struct rfkill *wifi_rfkill;
+static struct rfkill *wwan_rfkill;
+
+
+/* rfkill */
+static int oaktrail_rfkill_set(void *data, bool blocked)
+{
+        u8 value;
+        u8 result;
+        unsigned long radio = (unsigned long) data;
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &result);
+
+        if (!blocked)
+                value = (u8) (result | radio);
+        else
+                value = (u8) (result & ~radio);
+
+        ec_write(OT_EC_DEVICE_STATE_ADDRESS, value);
+
+        return 0;
+}
+
+static const struct rfkill_ops oaktrail_rfkill_ops = {
+        .set_block = oaktrail_rfkill_set,
+};
+
+static struct rfkill *oaktrail_rfkill_new(char *name, enum rfkill_type type,
+                                          unsigned long mask)
+{
+        struct rfkill *rfkill_dev;
+        u8 value;
+        int err;
+
+        rfkill_dev = rfkill_alloc(name, &oaktrail_device->dev, type,
+                                  &oaktrail_rfkill_ops, (void *)mask);
+        if (!rfkill_dev)
+                return ERR_PTR(-ENOMEM);
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &value);
+        rfkill_init_sw_state(rfkill_dev, (value & mask) != 1);
+
+        err = rfkill_register(rfkill_dev);
+        if (err) {
+                rfkill_destroy(rfkill_dev);
+                return ERR_PTR(err);
+        }
+
+        return rfkill_dev;
+}
+
+static inline void __oaktrail_rfkill_cleanup(struct rfkill *rf)
+{
+        if (rf) {
+                rfkill_unregister(rf);
+                rfkill_destroy(rf);
+        }
+}
+
+static void oaktrail_rfkill_cleanup(void)
+{
+        __oaktrail_rfkill_cleanup(wifi_rfkill);
+        __oaktrail_rfkill_cleanup(bt_rfkill);
+        __oaktrail_rfkill_cleanup(gps_rfkill);
+        __oaktrail_rfkill_cleanup(wwan_rfkill);
+}
+
+static int oaktrail_rfkill_init(void)
+{
+        int ret;
+
+        wifi_rfkill = oaktrail_rfkill_new("oaktrail-wifi",
+                                          RFKILL_TYPE_WLAN,
+                                          OT_EC_WIFI_MASK);
+        if (IS_ERR(wifi_rfkill)) {
+                ret = PTR_ERR(wifi_rfkill);
+                wifi_rfkill = NULL;
+                goto cleanup;
+        }
+
+        bt_rfkill = oaktrail_rfkill_new("oaktrail-bluetooth",
+                                        RFKILL_TYPE_BLUETOOTH,
+                                        OT_EC_BT_MASK);
+        if (IS_ERR(bt_rfkill)) {
+                ret = PTR_ERR(bt_rfkill);
+                bt_rfkill = NULL;
+                goto cleanup;
+        }
+
+        gps_rfkill = oaktrail_rfkill_new("oaktrail-gps",
+                                         RFKILL_TYPE_GPS,
+                                         OT_EC_GPS_MASK);
+        if (IS_ERR(gps_rfkill)) {
+                ret = PTR_ERR(gps_rfkill);
+                gps_rfkill = NULL;
+                goto cleanup;
+        }
+
+        wwan_rfkill = oaktrail_rfkill_new("oaktrail-wwan",
+                                          RFKILL_TYPE_WWAN,
+                                          OT_EC_WWAN_MASK);
+        if (IS_ERR(wwan_rfkill)) {
+                ret = PTR_ERR(wwan_rfkill);
+                wwan_rfkill = NULL;
+                goto cleanup;
+        }
+
+        return 0;
+
+cleanup:
+        oaktrail_rfkill_cleanup();
+        return ret;
+}
+
+
+/* backlight */
+static int get_backlight_brightness(struct backlight_device *b)
+{
+        u8 value;
+        ec_read(OT_EC_BL_BRIGHTNESS_ADDRESS, &value);
+
+        return value;
+}
+
+static int set_backlight_brightness(struct backlight_device *b)
+{
+        u8 percent = (u8) b->props.brightness;
+        if (percent < 0 || percent > OT_EC_BL_BRIGHTNESS_MAX)
+                return -EINVAL;
+
+        ec_write(OT_EC_BL_BRIGHTNESS_ADDRESS, percent);
+        ec_write(OT_EC_BL_CONTROL_ADDRESS, OT_EC_BL_CONTROL_ON_DATA);
+
+        return 0;
+}
+
+static const struct backlight_ops oaktrail_bl_ops = {
+        .get_brightness = get_backlight_brightness,
+        .update_status  = set_backlight_brightness,
+};
+
+static int oaktrail_backlight_init(void)
+{
+        struct backlight_device *bd;
+        struct backlight_properties props;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = OT_EC_BL_BRIGHTNESS_MAX;
+        bd = backlight_device_register(DRIVER_NAME,
+                                       &oaktrail_device->dev, NULL,
+                                       &oaktrail_bl_ops,
+                                       &props);
+
+        if (IS_ERR(bd)) {
+                oaktrail_bl_device = NULL;
+                pr_warning("Unable to register backlight device\n");
+                return PTR_ERR(bd);
+        }
+
+        oaktrail_bl_device = bd;
+
+        bd->props.brightness = get_backlight_brightness(bd);
+        bd->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(bd);
+
+        return 0;
+}
+
+static void oaktrail_backlight_exit(void)
+{
+        if (oaktrail_bl_device)
+                backlight_device_unregister(oaktrail_bl_device);
+}
+
+static int __devinit oaktrail_probe(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static int __devexit oaktrail_remove(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static struct platform_driver oaktrail_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe  = oaktrail_probe,
+        .remove = __devexit_p(oaktrail_remove)
+};
+
+static int dmi_check_cb(const struct dmi_system_id *id)
+{
+        pr_info("Identified model '%s'\n", id->ident);
+        return 0;
+}
+
+static struct dmi_system_id __initdata oaktrail_dmi_table[] = {
+        {
+                .ident = "OakTrail platform",
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OakTrail platform"),
+                },
+                .callback = dmi_check_cb
+        },
+        { }
+};
+
+static int __init oaktrail_init(void)
+{
+        int ret;
+
+        if (acpi_disabled) {
+                pr_err("ACPI needs to be enabled for this driver to work!\n");
+                return -ENODEV;
+        }
+
+        if (!force && !dmi_check_system(oaktrail_dmi_table)) {
+                pr_err("Platform not recognized (You could try the module's force-parameter)");
+                return -ENODEV;
+        }
+
+        ret = platform_driver_register(&oaktrail_driver);
+        if (ret) {
+                pr_warning("Unable to register platform driver\n");
+                goto err_driver_reg;
+        }
+
+        oaktrail_device = platform_device_alloc(DRIVER_NAME, -1);
+        if (!oaktrail_device) {
+                pr_warning("Unable to allocate platform device\n");
+                ret = -ENOMEM;
+                goto err_device_alloc;
+        }
+
+        ret = platform_device_add(oaktrail_device);
+        if (ret) {
+                pr_warning("Unable to add platform device\n");
+                goto err_device_add;
+        }
+
+        if (!acpi_video_backlight_support()) {
+                ret = oaktrail_backlight_init();
+                if (ret)
+                        goto err_backlight;
+
+        } else
+                pr_info("Backlight controlled by ACPI video driver\n");
+
+        ret = oaktrail_rfkill_init();
+        if (ret) {
+                pr_warning("Setup rfkill failed\n");
+                goto err_rfkill;
+        }
+
+        pr_info("Driver "DRIVER_VERSION" successfully loaded\n");
+        return 0;
+
+err_rfkill:
+        oaktrail_backlight_exit();
+err_backlight:
+        platform_device_del(oaktrail_device);
+err_device_add:
+        platform_device_put(oaktrail_device);
+err_device_alloc:
+        platform_driver_unregister(&oaktrail_driver);
+err_driver_reg:
+
+        return ret;
+}
+
+static void __exit oaktrail_cleanup(void)
+{
+        oaktrail_backlight_exit();
+        oaktrail_rfkill_cleanup();
+        platform_device_unregister(oaktrail_device);
+        platform_driver_unregister(&oaktrail_driver);
+
+        pr_info("Driver unloaded\n");
+}
+
+module_init(oaktrail_init);
+module_exit(oaktrail_cleanup);
+
+MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)");
+MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("dmi:*:svnIntelCorporation:pnOakTrailplatform:*");
diff --git a/drivers/platform/x86/intel_pmic_gpio.c b/drivers/platform/x86/intel_pmic_gpio.c
index 5cdcff653918..1686c1e07d5d 100644
--- a/drivers/platform/x86/intel_pmic_gpio.c
+++ b/drivers/platform/x86/intel_pmic_gpio.c
@@ -19,6 +19,8 @@
  * Moorestown platform PMIC chip
  */
 
+#define pr_fmt(fmt) "%s: " fmt, __func__
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
@@ -29,7 +31,6 @@
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
-#include <linux/interrupt.h>
 #include <asm/intel_scu_ipc.h>
 #include <linux/device.h>
 #include <linux/intel_pmic_gpio.h>
@@ -61,23 +62,18 @@ enum pmic_gpio_register {
 #define GPOSW_DOU 0x08
 #define GPOSW_RDRV 0x30
 
+#define GPIO_UPDATE_TYPE        0x80000000
 
 #define NUM_GPIO 24
 
-struct pmic_gpio_irq {
-        spinlock_t lock;
-        u32 trigger[NUM_GPIO];
-        u32 dirty;
-        struct work_struct work;
-};
-
-
 struct pmic_gpio {
+        struct mutex            buslock;
         struct gpio_chip        chip;
-        struct pmic_gpio_irq    irqtypes;
         void                    *gpiointr;
         int                     irq;
         unsigned                irq_base;
+        unsigned int            update_type;
+        u32                     trigger_type;
 };
 
 static void pmic_program_irqtype(int gpio, int type)
@@ -93,42 +89,10 @@ static void pmic_program_irqtype(int gpio, int type)
                 intel_scu_ipc_update_register(GPIO0 + gpio, 0x00, 0x10);
 };
 
-static void pmic_irqtype_work(struct work_struct *work)
-{
-        struct pmic_gpio_irq *t =
-                container_of(work, struct pmic_gpio_irq, work);
-        unsigned long flags;
-        int i;
-        u16 type;
-
-        spin_lock_irqsave(&t->lock, flags);
-        /* As we drop the lock, we may need multiple scans if we race the
-           pmic_irq_type function */
-        while (t->dirty) {
-                /*
-                 *      For each pin that has the dirty bit set send an IPC
-                 *      message to configure the hardware via the PMIC
-                 */
-                for (i = 0; i < NUM_GPIO; i++) {
-                        if (!(t->dirty & (1 << i)))
-                                continue;
-                        t->dirty &= ~(1 << i);
-                        /* We can't trust the array entry or dirty
-                           once the lock is dropped */
-                        type = t->trigger[i];
-                        spin_unlock_irqrestore(&t->lock, flags);
-                        pmic_program_irqtype(i, type);
-                        spin_lock_irqsave(&t->lock, flags);
-                }
-        }
-        spin_unlock_irqrestore(&t->lock, flags);
-}
-
 static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
         if (offset > 8) {
-                printk(KERN_ERR
-                        "%s: only pin 0-7 support input\n", __func__);
+                pr_err("only pin 0-7 support input\n");
                 return -1;/* we only have 8 GPIO can use as input */
         }
         return intel_scu_ipc_update_register(GPIO0 + offset,
@@ -142,19 +106,18 @@ static int pmic_gpio_direction_output(struct gpio_chip *chip,
 
         if (offset < 8)/* it is GPIO */
                 rc = intel_scu_ipc_update_register(GPIO0 + offset,
-                                GPIO_DRV | GPIO_DOU | GPIO_DIR,
-                                GPIO_DRV | (value ? GPIO_DOU : 0));
+                                GPIO_DRV | (value ? GPIO_DOU : 0),
+                                GPIO_DRV | GPIO_DOU | GPIO_DIR);
         else if (offset < 16)/* it is GPOSW */
                 rc = intel_scu_ipc_update_register(GPOSWCTL0 + offset - 8,
-                                GPOSW_DRV | GPOSW_DOU | GPOSW_RDRV,
-                                GPOSW_DRV | (value ? GPOSW_DOU : 0));
+                                GPOSW_DRV | (value ? GPOSW_DOU : 0),
+                                GPOSW_DRV | GPOSW_DOU | GPOSW_RDRV);
         else if (offset > 15 && offset < 24)/* it is GPO */
                 rc = intel_scu_ipc_update_register(GPO,
-                                1 << (offset - 16),
-                                value ? 1 << (offset - 16) : 0);
+                                value ? 1 << (offset - 16) : 0,
+                                1 << (offset - 16));
         else {
-                printk(KERN_ERR
-                        "%s: invalid PMIC GPIO pin %d!\n", __func__, offset);
+                pr_err("invalid PMIC GPIO pin %d!\n", offset);
                 WARN_ON(1);
         }
 
@@ -179,37 +142,36 @@ static void pmic_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
         if (offset < 8)/* it is GPIO */
                 intel_scu_ipc_update_register(GPIO0 + offset,
-                        GPIO_DRV | GPIO_DOU,
-                        GPIO_DRV | (value ? GPIO_DOU : 0));
+                        GPIO_DRV | (value ? GPIO_DOU : 0),
+                        GPIO_DRV | GPIO_DOU);
         else if (offset < 16)/* it is GPOSW */
                 intel_scu_ipc_update_register(GPOSWCTL0 + offset - 8,
-                        GPOSW_DRV | GPOSW_DOU | GPOSW_RDRV,
-                        GPOSW_DRV | (value ? GPOSW_DOU : 0));
+                        GPOSW_DRV | (value ? GPOSW_DOU : 0),
+                        GPOSW_DRV | GPOSW_DOU | GPOSW_RDRV);
         else if (offset > 15 && offset < 24) /* it is GPO */
                 intel_scu_ipc_update_register(GPO,
-                        1 << (offset - 16),
-                        value ? 1 << (offset - 16) : 0);
+                        value ? 1 << (offset - 16) : 0,
+                        1 << (offset - 16));
 }
 
-static int pmic_irq_type(unsigned irq, unsigned type)
+/*
+ * This is called from genirq with pg->buslock locked and
+ * irq_desc->lock held. We can not access the scu bus here, so we
+ * store the change and update in the bus_sync_unlock() function below
+ */
+static int pmic_irq_type(struct irq_data *data, unsigned type)
 {
-        struct pmic_gpio *pg = get_irq_chip_data(irq);
-        u32 gpio = irq - pg->irq_base;
-        unsigned long flags;
+        struct pmic_gpio *pg = irq_data_get_irq_chip_data(data);
+        u32 gpio = data->irq - pg->irq_base;
 
-        if (gpio > pg->chip.ngpio)
+        if (gpio >= pg->chip.ngpio)
                 return -EINVAL;
 
-        spin_lock_irqsave(&pg->irqtypes.lock, flags);
-        pg->irqtypes.trigger[gpio] = type;
-        pg->irqtypes.dirty |=  (1 << gpio);
-        spin_unlock_irqrestore(&pg->irqtypes.lock, flags);
-        schedule_work(&pg->irqtypes.work);
+        pg->trigger_type = type;
+        pg->update_type = gpio | GPIO_UPDATE_TYPE;
         return 0;
 }
 
-
-
 static int pmic_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
         struct pmic_gpio *pg = container_of(chip, struct pmic_gpio, chip);
@@ -217,35 +179,55 @@ static int pmic_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
         return pg->irq_base + offset;
 }
 
-/* the gpiointr register is read-clear, so just do nothing. */
-static void pmic_irq_unmask(unsigned irq)
+static void pmic_bus_lock(struct irq_data *data)
 {
-};
+        struct pmic_gpio *pg = irq_data_get_irq_chip_data(data);
 
-static void pmic_irq_mask(unsigned irq)
+        mutex_lock(&pg->buslock);
+}
+
+static void pmic_bus_sync_unlock(struct irq_data *data)
 {
-};
+        struct pmic_gpio *pg = irq_data_get_irq_chip_data(data);
+
+        if (pg->update_type) {
+                unsigned int gpio = pg->update_type & ~GPIO_UPDATE_TYPE;
+
+                pmic_program_irqtype(gpio, pg->trigger_type);
+                pg->update_type = 0;
+        }
+        mutex_unlock(&pg->buslock);
+}
+
+/* the gpiointr register is read-clear, so just do nothing. */
+static void pmic_irq_unmask(struct irq_data *data) { }
+
+static void pmic_irq_mask(struct irq_data *data) { }
 
 static struct irq_chip pmic_irqchip = {
-        .name           = "PMIC-GPIO",
-        .mask           = pmic_irq_mask,
-        .unmask         = pmic_irq_unmask,
-        .set_type       = pmic_irq_type,
+        .name                   = "PMIC-GPIO",
+        .irq_mask               = pmic_irq_mask,
+        .irq_unmask             = pmic_irq_unmask,
+        .irq_set_type           = pmic_irq_type,
+        .irq_bus_lock           = pmic_bus_lock,
+        .irq_bus_sync_unlock    = pmic_bus_sync_unlock,
 };
 
-static void pmic_irq_handler(unsigned irq, struct irq_desc *desc)
+static irqreturn_t pmic_irq_handler(int irq, void *data)
 {
-        struct pmic_gpio *pg = (struct pmic_gpio *)get_irq_data(irq);
+        struct pmic_gpio *pg = data;
         u8 intsts = *((u8 *)pg->gpiointr + 4);
         int gpio;
+        irqreturn_t ret = IRQ_NONE;
 
         for (gpio = 0; gpio < 8; gpio++) {
                 if (intsts & (1 << gpio)) {
                         pr_debug("pmic pin %d triggered\n", gpio);
                         generic_handle_irq(pg->irq_base + gpio);
+                        ret = IRQ_HANDLED;
                 }
         }
-        desc->chip->eoi(irq);
+        return ret;
 }
 
 static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
@@ -278,7 +260,7 @@ static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
         /* setting up SRAM mapping for GPIOINT register */
         pg->gpiointr = ioremap_nocache(pdata->gpiointr, 8);
         if (!pg->gpiointr) {
-                printk(KERN_ERR "%s: Can not map GPIOINT.\n", __func__);
+                pr_err("Can not map GPIOINT\n");
                 retval = -EINVAL;
                 goto err2;
         }
@@ -294,21 +276,27 @@ static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
         pg->chip.can_sleep = 1;
         pg->chip.dev = dev;
 
-        INIT_WORK(&pg->irqtypes.work, pmic_irqtype_work);
-        spin_lock_init(&pg->irqtypes.lock);
+        mutex_init(&pg->buslock);
 
         pg->chip.dev = dev;
         retval = gpiochip_add(&pg->chip);
         if (retval) {
-                printk(KERN_ERR "%s: Can not add pmic gpio chip.\n", __func__);
+                pr_err("Can not add pmic gpio chip\n");
                 goto err;
         }
-        set_irq_data(pg->irq, pg);
-        set_irq_chained_handler(pg->irq, pmic_irq_handler);
+
+        retval = request_irq(pg->irq, pmic_irq_handler, 0, "pmic", pg);
+        if (retval) {
+                pr_warn("Interrupt request failed\n");
+                goto err;
+        }
+
         for (i = 0; i < 8; i++) {
-                set_irq_chip_and_handler_name(i + pg->irq_base, &pmic_irqchip,
-                                        handle_simple_irq, "demux");
-                set_irq_chip_data(i + pg->irq_base, pg);
+                irq_set_chip_and_handler_name(i + pg->irq_base,
+                                              &pmic_irqchip,
+                                              handle_simple_irq,
+                                              "demux");
+                irq_set_chip_data(i + pg->irq_base, pg);
         }
         return 0;
 err:
diff --git a/drivers/platform/x86/intel_rar_register.c b/drivers/platform/x86/intel_rar_register.c
index 2b11a33325e6..bde47e9080cd 100644
--- a/drivers/platform/x86/intel_rar_register.c
+++ b/drivers/platform/x86/intel_rar_register.c
@@ -485,7 +485,7 @@ EXPORT_SYMBOL(rar_lock);
  *
  *      The register_rar function is to used by other device drivers
  *      to ensure that this driver is ready. As we cannot be sure of
- *      the compile/execute order of drivers in ther kernel, it is
+ *      the compile/execute order of drivers in the kernel, it is
  *      best to give this driver a callback function to call when
  *      it is ready to give out addresses. The callback function
  *      would have those steps that continue the initialization of
diff --git a/drivers/platform/x86/intel_scu_ipc.c b/drivers/platform/x86/intel_scu_ipc.c
index 6abe18e638e9..940accbe28d3 100644
--- a/drivers/platform/x86/intel_scu_ipc.c
+++ b/drivers/platform/x86/intel_scu_ipc.c
@@ -9,7 +9,7 @@
  * as published by the Free Software Foundation; version 2
  * of the License.
  *
- * SCU runing in ARC processor communicates with other entity running in IA
+ * SCU running in ARC processor communicates with other entity running in IA
  * core through IPC mechanism which in turn messaging between IA core ad SCU.
  * SCU has two IPC mechanism IPC-1 and IPC-2. IPC-1 is used between IA32 and
  * SCU where IPC-2 is used between P-Unit and SCU. This driver delas with
@@ -23,6 +23,7 @@
 #include <linux/pm.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
+#include <linux/sfi.h>
 #include <asm/mrst.h>
 #include <asm/intel_scu_ipc.h>
 
@@ -159,7 +160,7 @@ static int pwr_reg_rdwr(u16 *addr, u8 *data, u32 count, u32 op, u32 id)
 {
         int i, nc, bytes, d;
         u32 offset = 0;
-        u32 err = 0;
+        int err;
         u8 cbuf[IPC_WWBUF_SIZE] = { };
         u32 *wbuf = (u32 *)&cbuf;
 
@@ -402,7 +403,7 @@ EXPORT_SYMBOL(intel_scu_ipc_update_register);
  */
 int intel_scu_ipc_simple_command(int cmd, int sub)
 {
-        u32 err = 0;
+        int err;
 
         mutex_lock(&ipclock);
         if (ipcdev.pdev == NULL) {
@@ -432,8 +433,7 @@ EXPORT_SYMBOL(intel_scu_ipc_simple_command);
 int intel_scu_ipc_command(int cmd, int sub, u32 *in, int inlen,
                                                         u32 *out, int outlen)
 {
-        u32 err = 0;
-        int i = 0;
+        int i, err;
 
         mutex_lock(&ipclock);
         if (ipcdev.pdev == NULL) {
@@ -495,7 +495,7 @@ int intel_scu_ipc_i2c_cntrl(u32 addr, u32 *data)
                         "intel_scu_ipc: I2C INVALID_CMD = 0x%x\n", cmd);
 
                 mutex_unlock(&ipclock);
-                return -1;
+                return -EIO;
         }
         mutex_unlock(&ipclock);
         return 0;
@@ -640,7 +640,7 @@ update_end:
 
         if (status == IPC_FW_UPDATE_SUCCESS)
                 return 0;
-        return -1;
+        return -EIO;
 }
 EXPORT_SYMBOL(intel_scu_ipc_fw_update);
 
@@ -698,6 +698,9 @@ static int ipc_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 iounmap(ipcdev.ipc_base);
                 return -ENOMEM;
         }
+
+        intel_scu_devices_create();
+
         return 0;
 }
 
@@ -719,6 +722,7 @@ static void ipc_remove(struct pci_dev *pdev)
         iounmap(ipcdev.ipc_base);
         iounmap(ipcdev.i2c_base);
         ipcdev.pdev = NULL;
+        intel_scu_devices_destroy();
 }
 
 static const struct pci_device_id pci_ids[] = {
diff --git a/drivers/platform/x86/intel_scu_ipcutil.c b/drivers/platform/x86/intel_scu_ipcutil.c
new file mode 100644
index 000000000000..b93a03259c16
--- /dev/null
+++ b/drivers/platform/x86/intel_scu_ipcutil.c
@@ -0,0 +1,133 @@
+/*
+ * intel_scu_ipc.c: Driver for the Intel SCU IPC mechanism
+ *
+ * (C) Copyright 2008-2010 Intel Corporation
+ * Author: Sreedhara DS (sreedhara.ds@intel.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ *
+ * This driver provides ioctl interfaces to call intel scu ipc driver api
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/fcntl.h>
+#include <linux/sched.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <asm/intel_scu_ipc.h>
+
+static u32 major;
+
+#define MAX_FW_SIZE 264192
+
+/* ioctl commnds */
+#define INTE_SCU_IPC_REGISTER_READ      0
+#define INTE_SCU_IPC_REGISTER_WRITE     1
+#define INTE_SCU_IPC_REGISTER_UPDATE    2
+#define INTE_SCU_IPC_FW_UPDATE          0xA2
+
+struct scu_ipc_data {
+        u32     count;  /* No. of registers */
+        u16     addr[5]; /* Register addresses */
+        u8      data[5]; /* Register data */
+        u8      mask; /* Valid for read-modify-write */
+};
+
+/**
+ *      scu_reg_access          -       implement register access ioctls
+ *      @cmd: command we are doing (read/write/update)
+ *      @data: kernel copy of ioctl data
+ *
+ *      Allow the user to perform register accesses on the SCU via the
+ *      kernel interface
+ */
+
+static int scu_reg_access(u32 cmd, struct scu_ipc_data  *data)
+{
+        int count = data->count;
+
+        if (count == 0 || count == 3 || count > 4)
+                return -EINVAL;
+
+        switch (cmd) {
+        case INTE_SCU_IPC_REGISTER_READ:
+                return intel_scu_ipc_readv(data->addr, data->data, count);
+        case INTE_SCU_IPC_REGISTER_WRITE:
+                return intel_scu_ipc_writev(data->addr, data->data, count);
+        case INTE_SCU_IPC_REGISTER_UPDATE:
+                return intel_scu_ipc_update_register(data->addr[0],
+                                                    data->data[0], data->mask);
+        default:
+                return -ENOTTY;
+        }
+}
+
+/**
+ *      scu_ipc_ioctl           -       control ioctls for the SCU
+ *      @fp: file handle of the SCU device
+ *      @cmd: ioctl coce
+ *      @arg: pointer to user passed structure
+ *
+ *      Support the I/O and firmware flashing interfaces of the SCU
+ */
+static long scu_ipc_ioctl(struct file *fp, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        int ret;
+        struct scu_ipc_data  data;
+        void __user *argp = (void __user *)arg;
+
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
+
+        if (cmd == INTE_SCU_IPC_FW_UPDATE) {
+                        u8 *fwbuf = kmalloc(MAX_FW_SIZE, GFP_KERNEL);
+                        if (fwbuf == NULL)
+                                return -ENOMEM;
+                        if (copy_from_user(fwbuf, (u8 *)arg, MAX_FW_SIZE)) {
+                                kfree(fwbuf);
+                                return -EFAULT;
+                        }
+                        ret = intel_scu_ipc_fw_update(fwbuf, MAX_FW_SIZE);
+                        kfree(fwbuf);
+                        return ret;
+        } else {
+                if (copy_from_user(&data, argp, sizeof(struct scu_ipc_data)))
+                        return -EFAULT;
+                ret = scu_reg_access(cmd, &data);
+                if (ret < 0)
+                        return ret;
+                if (copy_to_user(argp, &data, sizeof(struct scu_ipc_data)))
+                        return -EFAULT;
+                return 0;
+        }
+}
+
+static const struct file_operations scu_ipc_fops = {
+        .unlocked_ioctl = scu_ipc_ioctl,
+};
+
+static int __init ipc_module_init(void)
+{
+        return register_chrdev(0, "intel_mid_scu", &scu_ipc_fops);
+}
+
+static void __exit ipc_module_exit(void)
+{
+        unregister_chrdev(major, "intel_mid_scu");
+}
+
+module_init(ipc_module_init);
+module_exit(ipc_module_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Utility driver for intel scu ipc");
+MODULE_AUTHOR("Sreedhara <sreedhara.ds@intel.com>");
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index 7e9bb6df9d39..3ff629df9f01 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -51,6 +51,8 @@
  * laptop as MSI S270. YMMV.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -60,6 +62,8 @@
 #include <linux/platform_device.h>
 #include <linux/rfkill.h>
 #include <linux/i8042.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 
 #define MSI_DRIVER_VERSION "0.5"
 
@@ -78,6 +82,9 @@
 #define MSI_STANDARD_EC_SCM_LOAD_ADDRESS        0x2d
 #define MSI_STANDARD_EC_SCM_LOAD_MASK           (1 << 0)
 
+#define MSI_STANDARD_EC_TOUCHPAD_ADDRESS        0xe4
+#define MSI_STANDARD_EC_TOUCHPAD_MASK           (1 << 4)
+
 static int msi_laptop_resume(struct platform_device *device);
 
 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS  0x2f
@@ -90,6 +97,14 @@ static int auto_brightness;
 module_param(auto_brightness, int, 0);
 MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)");
 
+static const struct key_entry msi_laptop_keymap[] = {
+        {KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} },  /* Touch Pad On */
+        {KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} },/* Touch Pad On */
+        {KE_END, 0}
+};
+
+static struct input_dev *msi_laptop_input_dev;
+
 static bool old_ec_model;
 static int wlan_s, bluetooth_s, threeg_s;
 static int threeg_exists;
@@ -120,7 +135,7 @@ static int set_lcd_level(int level)
         buf[1] = (u8) (level*31);
 
         return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, buf, sizeof(buf),
-                              NULL, 0, 1);
+                              NULL, 0);
 }
 
 static int get_lcd_level(void)
@@ -129,7 +144,7 @@ static int get_lcd_level(void)
         int result;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -142,7 +157,7 @@ static int get_auto_brightness(void)
         int result;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -157,7 +172,7 @@ static int set_auto_brightness(int enable)
         wdata[0] = 4;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -165,7 +180,7 @@ static int set_auto_brightness(int enable)
         wdata[1] = (rdata & 0xF7) | (enable ? 8 : 0);
 
         return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 2,
-                              NULL, 0, 1);
+                              NULL, 0);
 }
 
 static ssize_t set_device_state(const char *buf, size_t count, u8 mask)
@@ -202,7 +217,7 @@ static int get_wireless_state(int *wlan, int *bluetooth)
         u8 wdata = 0, rdata;
         int result;
 
-        result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1, 1);
+        result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1);
         if (result < 0)
                 return -1;
 
@@ -432,8 +447,7 @@ static struct platform_device *msipf_device;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO "msi-laptop: Identified laptop model '%s'.\n",
-               id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         return 1;
 }
 
@@ -605,6 +619,21 @@ static void msi_update_rfkill(struct work_struct *ignored)
 }
 static DECLARE_DELAYED_WORK(msi_rfkill_work, msi_update_rfkill);
 
+static void msi_send_touchpad_key(struct work_struct *ignored)
+{
+        u8 rdata;
+        int result;
+
+        result = ec_read(MSI_STANDARD_EC_TOUCHPAD_ADDRESS, &rdata);
+        if (result < 0)
+                return;
+
+        sparse_keymap_report_event(msi_laptop_input_dev,
+                (rdata & MSI_STANDARD_EC_TOUCHPAD_MASK) ?
+                KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF, 1, true);
+}
+static DECLARE_DELAYED_WORK(msi_touchpad_work, msi_send_touchpad_key);
+
 static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
                                 struct serio *port)
 {
@@ -613,12 +642,17 @@ static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
         if (str & 0x20)
                 return false;
 
-        /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan*/
+        /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan, 0xE4 touchpad toggle*/
         if (unlikely(data == 0xe0)) {
                 extended = true;
                 return false;
         } else if (unlikely(extended)) {
+                extended = false;
                 switch (data) {
+                case 0xE4:
+                        schedule_delayed_work(&msi_touchpad_work,
+                                round_jiffies_relative(0.5 * HZ));
+                        break;
                 case 0x54:
                 case 0x62:
                 case 0x76:
@@ -626,7 +660,6 @@ static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
                                 round_jiffies_relative(0.5 * HZ));
                         break;
                 }
-                extended = false;
         }
 
         return false;
@@ -731,7 +764,43 @@ static int msi_laptop_resume(struct platform_device *device)
         return 0;
 }
 
-static int load_scm_model_init(struct platform_device *sdev)
+static int __init msi_laptop_input_setup(void)
+{
+        int err;
+
+        msi_laptop_input_dev = input_allocate_device();
+        if (!msi_laptop_input_dev)
+                return -ENOMEM;
+
+        msi_laptop_input_dev->name = "MSI Laptop hotkeys";
+        msi_laptop_input_dev->phys = "msi-laptop/input0";
+        msi_laptop_input_dev->id.bustype = BUS_HOST;
+
+        err = sparse_keymap_setup(msi_laptop_input_dev,
+                msi_laptop_keymap, NULL);
+        if (err)
+                goto err_free_dev;
+
+        err = input_register_device(msi_laptop_input_dev);
+        if (err)
+                goto err_free_keymap;
+
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(msi_laptop_input_dev);
+err_free_dev:
+        input_free_device(msi_laptop_input_dev);
+        return err;
+}
+
+static void msi_laptop_input_destroy(void)
+{
+        sparse_keymap_free(msi_laptop_input_dev);
+        input_unregister_device(msi_laptop_input_dev);
+}
+
+static int __init load_scm_model_init(struct platform_device *sdev)
 {
         u8 data;
         int result;
@@ -759,16 +828,23 @@ static int load_scm_model_init(struct platform_device *sdev)
         if (result < 0)
                 goto fail_rfkill;
 
+        /* setup input device */
+        result = msi_laptop_input_setup();
+        if (result)
+                goto fail_input;
+
         result = i8042_install_filter(msi_laptop_i8042_filter);
         if (result) {
-                printk(KERN_ERR
-                        "msi-laptop: Unable to install key filter\n");
+                pr_err("Unable to install key filter\n");
                 goto fail_filter;
         }
 
         return 0;
 
 fail_filter:
+        msi_laptop_input_destroy();
+
+fail_input:
         rfkill_cleanup();
 
 fail_rfkill:
@@ -799,11 +875,11 @@ static int __init msi_init(void)
         /* Register backlight stuff */
 
         if (acpi_video_backlight_support()) {
-                printk(KERN_INFO "MSI: Brightness ignored, must be controlled "
-                       "by ACPI video driver\n");
+                pr_info("Brightness ignored, must be controlled by ACPI video driver\n");
         } else {
                 struct backlight_properties props;
                 memset(&props, 0, sizeof(struct backlight_properties));
+                props.type = BACKLIGHT_PLATFORM;
                 props.max_brightness = MSI_LCD_LEVEL_MAX - 1;
                 msibl_device = backlight_device_register("msi-laptop-bl", NULL,
                                                          NULL, &msibl_ops,
@@ -853,7 +929,7 @@ static int __init msi_init(void)
         if (auto_brightness != 2)
                 set_auto_brightness(auto_brightness);
 
-        printk(KERN_INFO "msi-laptop: driver "MSI_DRIVER_VERSION" successfully loaded.\n");
+        pr_info("driver " MSI_DRIVER_VERSION " successfully loaded\n");
 
         return 0;
 
@@ -885,6 +961,7 @@ static void __exit msi_cleanup(void)
 {
         if (load_scm_model) {
                 i8042_remove_filter(msi_laptop_i8042_filter);
+                msi_laptop_input_destroy();
                 cancel_delayed_work_sync(&msi_rfkill_work);
                 rfkill_cleanup();
         }
@@ -900,7 +977,7 @@ static void __exit msi_cleanup(void)
         if (auto_brightness != 2)
                 set_auto_brightness(1);
 
-        printk(KERN_INFO "msi-laptop: driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(msi_init);
diff --git a/drivers/platform/x86/msi-wmi.c b/drivers/platform/x86/msi-wmi.c
index 42a5469a2459..c832e3356cd6 100644
--- a/drivers/platform/x86/msi-wmi.c
+++ b/drivers/platform/x86/msi-wmi.c
@@ -20,6 +20,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/input.h>
@@ -36,23 +37,22 @@ MODULE_ALIAS("wmi:551A1F84-FBDD-4125-91DB-3EA8F44F1D45");
 MODULE_ALIAS("wmi:B6F3EEF2-3D2F-49DC-9DE3-85BCE18C62F2");
 
 #define DRV_NAME "msi-wmi"
-#define DRV_PFX DRV_NAME ": "
 
 #define MSIWMI_BIOS_GUID "551A1F84-FBDD-4125-91DB-3EA8F44F1D45"
 #define MSIWMI_EVENT_GUID "B6F3EEF2-3D2F-49DC-9DE3-85BCE18C62F2"
 
-#define dprintk(msg...) pr_debug(DRV_PFX msg)
-
-#define KEYCODE_BASE 0xD0
-#define MSI_WMI_BRIGHTNESSUP   KEYCODE_BASE
-#define MSI_WMI_BRIGHTNESSDOWN (KEYCODE_BASE + 1)
-#define MSI_WMI_VOLUMEUP       (KEYCODE_BASE + 2)
-#define MSI_WMI_VOLUMEDOWN     (KEYCODE_BASE + 3)
+#define SCANCODE_BASE 0xD0
+#define MSI_WMI_BRIGHTNESSUP   SCANCODE_BASE
+#define MSI_WMI_BRIGHTNESSDOWN (SCANCODE_BASE + 1)
+#define MSI_WMI_VOLUMEUP       (SCANCODE_BASE + 2)
+#define MSI_WMI_VOLUMEDOWN     (SCANCODE_BASE + 3)
+#define MSI_WMI_MUTE           (SCANCODE_BASE + 4)
 static struct key_entry msi_wmi_keymap[] = {
         { KE_KEY, MSI_WMI_BRIGHTNESSUP,   {KEY_BRIGHTNESSUP} },
         { KE_KEY, MSI_WMI_BRIGHTNESSDOWN, {KEY_BRIGHTNESSDOWN} },
         { KE_KEY, MSI_WMI_VOLUMEUP,       {KEY_VOLUMEUP} },
         { KE_KEY, MSI_WMI_VOLUMEDOWN,     {KEY_VOLUMEDOWN} },
+        { KE_KEY, MSI_WMI_MUTE,           {KEY_MUTE} },
         { KE_END, 0}
 };
 static ktime_t last_pressed[ARRAY_SIZE(msi_wmi_keymap) - 1];
@@ -76,7 +76,7 @@ static int msi_wmi_query_block(int instance, int *ret)
 
         if (!obj || obj->type != ACPI_TYPE_INTEGER) {
                 if (obj) {
-                        printk(KERN_ERR DRV_PFX "query block returned object "
+                        pr_err("query block returned object "
                                "type: %d - buffer length:%d\n", obj->type,
                                obj->type == ACPI_TYPE_BUFFER ?
                                obj->buffer.length : 0);
@@ -95,8 +95,8 @@ static int msi_wmi_set_block(int instance, int value)
 
         struct acpi_buffer input = { sizeof(int), &value };
 
-        dprintk("Going to set block of instance: %d - value: %d\n",
-                instance, value);
+        pr_debug("Going to set block of instance: %d - value: %d\n",
+                 instance, value);
 
         status = wmi_set_block(MSIWMI_BIOS_GUID, instance, &input);
 
@@ -110,20 +110,19 @@ static int bl_get(struct backlight_device *bd)
         /* Instance 1 is "get backlight", cmp with DSDT */
         err = msi_wmi_query_block(1, &ret);
         if (err) {
-                printk(KERN_ERR DRV_PFX "Could not query backlight: %d\n", err);
+                pr_err("Could not query backlight: %d\n", err);
                 return -EINVAL;
         }
-        dprintk("Get: Query block returned: %d\n", ret);
+        pr_debug("Get: Query block returned: %d\n", ret);
         for (level = 0; level < ARRAY_SIZE(backlight_map); level++) {
                 if (backlight_map[level] == ret) {
-                        dprintk("Current backlight level: 0x%X - index: %d\n",
-                                backlight_map[level], level);
+                        pr_debug("Current backlight level: 0x%X - index: %d\n",
+                                 backlight_map[level], level);
                         break;
                 }
         }
         if (level == ARRAY_SIZE(backlight_map)) {
-                printk(KERN_ERR DRV_PFX "get: Invalid brightness value: 0x%X\n",
-                       ret);
+                pr_err("get: Invalid brightness value: 0x%X\n", ret);
                 return -EINVAL;
         }
         return level;
@@ -154,7 +153,7 @@ static void msi_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO DRV_PFX "bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -162,40 +161,39 @@ static void msi_wmi_notify(u32 value, void *context)
 
         if (obj && obj->type == ACPI_TYPE_INTEGER) {
                 int eventcode = obj->integer.value;
-                dprintk("Eventcode: 0x%x\n", eventcode);
+                pr_debug("Eventcode: 0x%x\n", eventcode);
                 key = sparse_keymap_entry_from_scancode(msi_wmi_input_dev,
                                 eventcode);
                 if (key) {
                         ktime_t diff;
                         cur = ktime_get_real();
                         diff = ktime_sub(cur, last_pressed[key->code -
-                                        KEYCODE_BASE]);
+                                        SCANCODE_BASE]);
                         /* Ignore event if the same event happened in a 50 ms
                            timeframe -> Key press may result in 10-20 GPEs */
                         if (ktime_to_us(diff) < 1000 * 50) {
-                                dprintk("Suppressed key event 0x%X - "
-                                        "Last press was %lld us ago\n",
+                                pr_debug("Suppressed key event 0x%X - "
+                                         "Last press was %lld us ago\n",
                                          key->code, ktime_to_us(diff));
                                 return;
                         }
-                        last_pressed[key->code - KEYCODE_BASE] = cur;
+                        last_pressed[key->code - SCANCODE_BASE] = cur;
 
                         if (key->type == KE_KEY &&
                         /* Brightness is served via acpi video driver */
                         (!acpi_video_backlight_support() ||
                         (key->code != MSI_WMI_BRIGHTNESSUP &&
                         key->code != MSI_WMI_BRIGHTNESSDOWN))) {
-                                dprintk("Send key: 0x%X - "
-                                        "Input layer keycode: %d\n", key->code,
-                                         key->keycode);
+                                pr_debug("Send key: 0x%X - "
+                                         "Input layer keycode: %d\n",
+                                         key->code, key->keycode);
                                 sparse_keymap_report_entry(msi_wmi_input_dev,
                                                 key, 1, true);
                         }
                 } else
-                        printk(KERN_INFO "Unknown key pressed - %x\n",
-                               eventcode);
+                        pr_info("Unknown key pressed - %x\n", eventcode);
         } else
-                printk(KERN_INFO DRV_PFX "Unknown event received\n");
+                pr_info("Unknown event received\n");
         kfree(response.pointer);
 }
 
@@ -236,8 +234,7 @@ static int __init msi_wmi_init(void)
         int err;
 
         if (!wmi_has_guid(MSIWMI_EVENT_GUID)) {
-                printk(KERN_ERR
-                       "This machine doesn't have MSI-hotkeys through WMI\n");
+                pr_err("This machine doesn't have MSI-hotkeys through WMI\n");
                 return -ENODEV;
         }
         err = wmi_install_notify_handler(MSIWMI_EVENT_GUID,
@@ -252,6 +249,7 @@ static int __init msi_wmi_init(void)
         if (!acpi_video_backlight_support()) {
                 struct backlight_properties props;
                 memset(&props, 0, sizeof(struct backlight_properties));
+                props.type = BACKLIGHT_PLATFORM;
                 props.max_brightness = ARRAY_SIZE(backlight_map) - 1;
                 backlight = backlight_device_register(DRV_NAME, NULL, NULL,
                                                       &msi_backlight_ops,
@@ -267,7 +265,7 @@ static int __init msi_wmi_init(void)
 
                 backlight->props.brightness = err;
         }
-        dprintk("Event handler installed\n");
+        pr_debug("Event handler installed\n");
 
         return 0;
 
diff --git a/drivers/platform/x86/mxm-wmi.c b/drivers/platform/x86/mxm-wmi.c
new file mode 100644
index 000000000000..0aea63b3729a
--- /dev/null
+++ b/drivers/platform/x86/mxm-wmi.c
@@ -0,0 +1,111 @@
+/*
+ * MXM WMI driver
+ *
+ * Copyright(C) 2010 Red Hat.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+MODULE_AUTHOR("Dave Airlie");
+MODULE_DESCRIPTION("MXM WMI Driver");
+MODULE_LICENSE("GPL");
+
+#define MXM_WMMX_GUID "F6CB5C3C-9CAE-4EBD-B577-931EA32A2CC0"
+
+MODULE_ALIAS("wmi:"MXM_WMMX_GUID);
+
+#define MXM_WMMX_FUNC_MXDS 0x5344584D /* "MXDS" */
+#define MXM_WMMX_FUNC_MXMX 0x53445344 /* "MXMX" */
+
+struct mxds_args {
+        u32 func;
+        u32 args;
+        u32 xarg;
+};
+
+int mxm_wmi_call_mxds(int adapter)
+{
+        struct mxds_args args = {
+                .func = MXM_WMMX_FUNC_MXDS,
+                .args = 0,
+                .xarg = 1,
+        };
+        struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        acpi_status status;
+
+        printk("calling mux switch %d\n", adapter);
+
+        status = wmi_evaluate_method(MXM_WMMX_GUID, 0x1, adapter, &input,
+                                     &output);
+
+        if (ACPI_FAILURE(status))
+                return status;
+
+        printk("mux switched %d\n", status);
+        return 0;
+                            
+}
+EXPORT_SYMBOL_GPL(mxm_wmi_call_mxds);
+
+int mxm_wmi_call_mxmx(int adapter)
+{
+        struct mxds_args args = {
+                .func = MXM_WMMX_FUNC_MXMX,
+                .args = 0,
+                .xarg = 1,
+        };
+        struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        acpi_status status;
+
+        printk("calling mux switch %d\n", adapter);
+
+        status = wmi_evaluate_method(MXM_WMMX_GUID, 0x1, adapter, &input,
+                                     &output);
+
+        if (ACPI_FAILURE(status))
+                return status;
+
+        printk("mux mutex set switched %d\n", status);
+        return 0;
+                            
+}
+EXPORT_SYMBOL_GPL(mxm_wmi_call_mxmx);
+
+bool mxm_wmi_supported(void)
+{
+        bool guid_valid;
+        guid_valid = wmi_has_guid(MXM_WMMX_GUID);
+        return guid_valid;
+}
+EXPORT_SYMBOL_GPL(mxm_wmi_supported);
+
+static int __init mxm_wmi_init(void)
+{
+        return 0;
+}
+
+static void __exit mxm_wmi_exit(void)
+{
+}
+
+module_init(mxm_wmi_init);
+module_exit(mxm_wmi_exit);
diff --git a/drivers/platform/x86/panasonic-laptop.c b/drivers/platform/x86/panasonic-laptop.c
index ec01c3d8fc5a..05be30ee158b 100644
--- a/drivers/platform/x86/panasonic-laptop.c
+++ b/drivers/platform/x86/panasonic-laptop.c
@@ -128,6 +128,7 @@
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 #include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 
 
 #ifndef ACPI_HOTKEY_COMPONENT
@@ -200,30 +201,29 @@ static struct acpi_driver acpi_pcc_driver = {
                         },
 };
 
-#define KEYMAP_SIZE             11
-static const unsigned int initial_keymap[KEYMAP_SIZE] = {
-        /*  0 */ KEY_RESERVED,
-        /*  1 */ KEY_BRIGHTNESSDOWN,
-        /*  2 */ KEY_BRIGHTNESSUP,
-        /*  3 */ KEY_DISPLAYTOGGLE,
-        /*  4 */ KEY_MUTE,
-        /*  5 */ KEY_VOLUMEDOWN,
-        /*  6 */ KEY_VOLUMEUP,
-        /*  7 */ KEY_SLEEP,
-        /*  8 */ KEY_PROG1, /* Change CPU boost */
-        /*  9 */ KEY_BATTERY,
-        /* 10 */ KEY_SUSPEND,
+static const struct key_entry panasonic_keymap[] = {
+        { KE_KEY, 0, { KEY_RESERVED } },
+        { KE_KEY, 1, { KEY_BRIGHTNESSDOWN } },
+        { KE_KEY, 2, { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 3, { KEY_DISPLAYTOGGLE } },
+        { KE_KEY, 4, { KEY_MUTE } },
+        { KE_KEY, 5, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 6, { KEY_VOLUMEUP } },
+        { KE_KEY, 7, { KEY_SLEEP } },
+        { KE_KEY, 8, { KEY_PROG1 } }, /* Change CPU boost */
+        { KE_KEY, 9, { KEY_BATTERY } },
+        { KE_KEY, 10, { KEY_SUSPEND } },
+        { KE_END, 0 }
 };
 
 struct pcc_acpi {
         acpi_handle             handle;
         unsigned long           num_sifr;
         int                     sticky_mode;
-        u32                     *sinf;
+        u32                     *sinf;
         struct acpi_device      *device;
         struct input_dev        *input_dev;
         struct backlight_device *backlight;
-        unsigned int            keymap[KEYMAP_SIZE];
 };
 
 struct pcc_keyinput {
@@ -267,7 +267,7 @@ static inline int acpi_pcc_get_sqty(struct acpi_device *device)
         }
 }
 
-static int acpi_pcc_retrieve_biosdata(struct pcc_acpi *pcc, u32 *sinf)
+static int acpi_pcc_retrieve_biosdata(struct pcc_acpi *pcc)
 {
         acpi_status status;
         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
@@ -285,6 +285,7 @@ static int acpi_pcc_retrieve_biosdata(struct pcc_acpi *pcc, u32 *sinf)
         hkey = buffer.pointer;
         if (!hkey || (hkey->type != ACPI_TYPE_PACKAGE)) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid HKEY.SINF\n"));
+                status = AE_ERROR;
                 goto end;
         }
 
@@ -298,12 +299,12 @@ static int acpi_pcc_retrieve_biosdata(struct pcc_acpi *pcc, u32 *sinf)
         for (i = 0; i < hkey->package.count; i++) {
                 union acpi_object *element = &(hkey->package.elements[i]);
                 if (likely(element->type == ACPI_TYPE_INTEGER)) {
-                        sinf[i] = element->integer.value;
+                        pcc->sinf[i] = element->integer.value;
                 } else
                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                                          "Invalid HKEY.SINF data\n"));
         }
-        sinf[hkey->package.count] = -1;
+        pcc->sinf[hkey->package.count] = -1;
 
 end:
         kfree(buffer.pointer);
@@ -321,7 +322,7 @@ static int bl_get(struct backlight_device *bd)
 {
         struct pcc_acpi *pcc = bl_get_data(bd);
 
-        if (!acpi_pcc_retrieve_biosdata(pcc, pcc->sinf))
+        if (!acpi_pcc_retrieve_biosdata(pcc))
                 return -EIO;
 
         return pcc->sinf[SINF_AC_CUR_BRIGHT];
@@ -333,7 +334,7 @@ static int bl_set_status(struct backlight_device *bd)
         int bright = bd->props.brightness;
         int rc;
 
-        if (!acpi_pcc_retrieve_biosdata(pcc, pcc->sinf))
+        if (!acpi_pcc_retrieve_biosdata(pcc))
                 return -EIO;
 
         if (bright < pcc->sinf[SINF_AC_MIN_BRIGHT])
@@ -367,7 +368,7 @@ static ssize_t show_numbatt(struct device *dev, struct device_attribute *attr,
         struct acpi_device *acpi = to_acpi_device(dev);
         struct pcc_acpi *pcc = acpi_driver_data(acpi);
 
-        if (!acpi_pcc_retrieve_biosdata(pcc, pcc->sinf))
+        if (!acpi_pcc_retrieve_biosdata(pcc))
                 return -EIO;
 
         return snprintf(buf, PAGE_SIZE, "%u\n", pcc->sinf[SINF_NUM_BATTERIES]);
@@ -379,7 +380,7 @@ static ssize_t show_lcdtype(struct device *dev, struct device_attribute *attr,
         struct acpi_device *acpi = to_acpi_device(dev);
         struct pcc_acpi *pcc = acpi_driver_data(acpi);
 
-        if (!acpi_pcc_retrieve_biosdata(pcc, pcc->sinf))
+        if (!acpi_pcc_retrieve_biosdata(pcc))
                 return -EIO;
 
         return snprintf(buf, PAGE_SIZE, "%u\n", pcc->sinf[SINF_LCD_TYPE]);
@@ -391,7 +392,7 @@ static ssize_t show_mute(struct device *dev, struct device_attribute *attr,
         struct acpi_device *acpi = to_acpi_device(dev);
         struct pcc_acpi *pcc = acpi_driver_data(acpi);
 
-        if (!acpi_pcc_retrieve_biosdata(pcc, pcc->sinf))
+        if (!acpi_pcc_retrieve_biosdata(pcc))
                 return -EIO;
 
         return snprintf(buf, PAGE_SIZE, "%u\n", pcc->sinf[SINF_MUTE]);
@@ -403,7 +404,7 @@ static ssize_t show_sticky(struct device *dev, struct device_attribute *attr,
         struct acpi_device *acpi = to_acpi_device(dev);
         struct pcc_acpi *pcc = acpi_driver_data(acpi);
 
-        if (!acpi_pcc_retrieve_biosdata(pcc, pcc->sinf))
+        if (!acpi_pcc_retrieve_biosdata(pcc))
                 return -EIO;
 
         return snprintf(buf, PAGE_SIZE, "%u\n", pcc->sinf[SINF_STICKY_KEY]);
@@ -446,56 +447,10 @@ static struct attribute_group pcc_attr_group = {
 
 /* hotkey input device driver */
 
-static int pcc_getkeycode(struct input_dev *dev,
-                          unsigned int scancode, unsigned int *keycode)
-{
-        struct pcc_acpi *pcc = input_get_drvdata(dev);
-
-        if (scancode >= ARRAY_SIZE(pcc->keymap))
-                return -EINVAL;
-
-        *keycode = pcc->keymap[scancode];
-
-        return 0;
-}
-
-static int keymap_get_by_keycode(struct pcc_acpi *pcc, unsigned int keycode)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(pcc->keymap); i++) {
-                if (pcc->keymap[i] == keycode)
-                        return i+1;
-        }
-
-        return 0;
-}
-
-static int pcc_setkeycode(struct input_dev *dev,
-                          unsigned int scancode, unsigned int keycode)
-{
-        struct pcc_acpi *pcc = input_get_drvdata(dev);
-        int oldkeycode;
-
-        if (scancode >= ARRAY_SIZE(pcc->keymap))
-                return -EINVAL;
-
-        oldkeycode = pcc->keymap[scancode];
-        pcc->keymap[scancode] = keycode;
-
-        set_bit(keycode, dev->keybit);
-
-        if (!keymap_get_by_keycode(pcc, oldkeycode))
-                clear_bit(oldkeycode, dev->keybit);
-
-        return 0;
-}
-
 static void acpi_pcc_generate_keyinput(struct pcc_acpi *pcc)
 {
         struct input_dev *hotk_input_dev = pcc->input_dev;
         int rc;
-        int key_code, hkey_num;
         unsigned long long result;
 
         rc = acpi_evaluate_integer(pcc->handle, METHOD_HKEY_QUERY,
@@ -508,25 +463,10 @@ static void acpi_pcc_generate_keyinput(struct pcc_acpi *pcc)
 
         acpi_bus_generate_proc_event(pcc->device, HKEY_NOTIFY, result);
 
-        hkey_num = result & 0xf;
-
-        if (hkey_num < 0 || hkey_num >= ARRAY_SIZE(pcc->keymap)) {
+        if (!sparse_keymap_report_event(hotk_input_dev,
+                                        result & 0xf, result & 0x80, false))
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "hotkey number out of range: %d\n",
-                                  hkey_num));
-                return;
-        }
-
-        key_code = pcc->keymap[hkey_num];
-
-        if (key_code != KEY_RESERVED) {
-                int pushed = (result & 0x80) ? TRUE : FALSE;
-
-                input_report_key(hotk_input_dev, key_code, pushed);
-                input_sync(hotk_input_dev);
-        }
-
-        return;
+                                  "Unknown hotkey event: %d\n", result));
 }
 
 static void acpi_pcc_hotkey_notify(struct acpi_device *device, u32 event)
@@ -545,40 +485,55 @@ static void acpi_pcc_hotkey_notify(struct acpi_device *device, u32 event)
 
 static int acpi_pcc_init_input(struct pcc_acpi *pcc)
 {
-        int i, rc;
+        struct input_dev *input_dev;
+        int error;
 
-        pcc->input_dev = input_allocate_device();
-        if (!pcc->input_dev) {
+        input_dev = input_allocate_device();
+        if (!input_dev) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                                   "Couldn't allocate input device for hotkey"));
                 return -ENOMEM;
         }
 
-        pcc->input_dev->evbit[0] = BIT(EV_KEY);
-
-        pcc->input_dev->name = ACPI_PCC_DRIVER_NAME;
-        pcc->input_dev->phys = ACPI_PCC_INPUT_PHYS;
-        pcc->input_dev->id.bustype = BUS_HOST;
-        pcc->input_dev->id.vendor = 0x0001;
-        pcc->input_dev->id.product = 0x0001;
-        pcc->input_dev->id.version = 0x0100;
-        pcc->input_dev->getkeycode = pcc_getkeycode;
-        pcc->input_dev->setkeycode = pcc_setkeycode;
+        input_dev->name = ACPI_PCC_DRIVER_NAME;
+        input_dev->phys = ACPI_PCC_INPUT_PHYS;
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->id.vendor = 0x0001;
+        input_dev->id.product = 0x0001;
+        input_dev->id.version = 0x0100;
 
-        /* load initial keymap */
-        memcpy(pcc->keymap, initial_keymap, sizeof(pcc->keymap));
+        error = sparse_keymap_setup(input_dev, panasonic_keymap, NULL);
+        if (error) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "Unable to setup input device keymap\n"));
+                goto err_free_dev;
+        }
 
-        for (i = 0; i < ARRAY_SIZE(pcc->keymap); i++)
-                __set_bit(pcc->keymap[i], pcc->input_dev->keybit);
-        __clear_bit(KEY_RESERVED, pcc->input_dev->keybit);
+        error = input_register_device(input_dev);
+        if (error) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "Unable to register input device\n"));
+                goto err_free_keymap;
+        }
 
-        input_set_drvdata(pcc->input_dev, pcc);
+        pcc->input_dev = input_dev;
+        return 0;
 
-        rc = input_register_device(pcc->input_dev);
-        if (rc < 0)
-                input_free_device(pcc->input_dev);
+ err_free_keymap:
+        sparse_keymap_free(input_dev);
+ err_free_dev:
+        input_free_device(input_dev);
+        return error;
+}
 
-        return rc;
+static void acpi_pcc_destroy_input(struct pcc_acpi *pcc)
+{
+        sparse_keymap_free(pcc->input_dev);
+        input_unregister_device(pcc->input_dev);
+        /*
+         * No need to input_free_device() since core input API refcounts
+         * and free()s the device.
+         */
 }
 
 /* kernel module interface */
@@ -636,22 +591,24 @@ static int acpi_pcc_hotkey_add(struct acpi_device *device)
         if (result) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                                   "Error installing keyinput handler\n"));
-                goto out_hotkey;
+                goto out_sinf;
         }
 
-        if (!acpi_pcc_retrieve_biosdata(pcc, pcc->sinf)) {
+        if (!acpi_pcc_retrieve_biosdata(pcc)) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
                                  "Couldn't retrieve BIOS data\n"));
+                result = -EIO;
                 goto out_input;
         }
         /* initialize backlight */
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = pcc->sinf[SINF_AC_MAX_BRIGHT];
         pcc->backlight = backlight_device_register("panasonic", NULL, pcc,
                                                    &pcc_backlight_ops, &props);
         if (IS_ERR(pcc->backlight)) {
                 result = PTR_ERR(pcc->backlight);
-                goto out_sinf;
+                goto out_input;
         }
 
         /* read the initial brightness setting from the hardware */
@@ -669,12 +626,10 @@ static int acpi_pcc_hotkey_add(struct acpi_device *device)
 
 out_backlight:
         backlight_device_unregister(pcc->backlight);
+out_input:
+        acpi_pcc_destroy_input(pcc);
 out_sinf:
         kfree(pcc->sinf);
-out_input:
-        input_unregister_device(pcc->input_dev);
-        /* no need to input_free_device() since core input API refcount and
-         * free()s the device */
 out_hotkey:
         kfree(pcc);
 
@@ -709,9 +664,7 @@ static int acpi_pcc_hotkey_remove(struct acpi_device *device, int type)
 
         backlight_device_unregister(pcc->backlight);
 
-        input_unregister_device(pcc->input_dev);
-        /* no need to input_free_device() since core input API refcount and
-         * free()s the device */
+        acpi_pcc_destroy_input(pcc);
 
         kfree(pcc->sinf);
         kfree(pcc);
diff --git a/drivers/platform/x86/samsung-laptop.c b/drivers/platform/x86/samsung-laptop.c
new file mode 100644
index 000000000000..d347116d150e
--- /dev/null
+++ b/drivers/platform/x86/samsung-laptop.c
@@ -0,0 +1,843 @@
+/*
+ * Samsung Laptop driver
+ *
+ * Copyright (C) 2009,2011 Greg Kroah-Hartman (gregkh@suse.de)
+ * Copyright (C) 2009,2011 Novell Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/backlight.h>
+#include <linux/fb.h>
+#include <linux/dmi.h>
+#include <linux/platform_device.h>
+#include <linux/rfkill.h>
+
+/*
+ * This driver is needed because a number of Samsung laptops do not hook
+ * their control settings through ACPI.  So we have to poke around in the
+ * BIOS to do things like brightness values, and "special" key controls.
+ */
+
+/*
+ * We have 0 - 8 as valid brightness levels.  The specs say that level 0 should
+ * be reserved by the BIOS (which really doesn't make much sense), we tell
+ * userspace that the value is 0 - 7 and then just tell the hardware 1 - 8
+ */
+#define MAX_BRIGHT      0x07
+
+
+#define SABI_IFACE_MAIN                 0x00
+#define SABI_IFACE_SUB                  0x02
+#define SABI_IFACE_COMPLETE             0x04
+#define SABI_IFACE_DATA                 0x05
+
+/* Structure to get data back to the calling function */
+struct sabi_retval {
+        u8 retval[20];
+};
+
+struct sabi_header_offsets {
+        u8 port;
+        u8 re_mem;
+        u8 iface_func;
+        u8 en_mem;
+        u8 data_offset;
+        u8 data_segment;
+};
+
+struct sabi_commands {
+        /*
+         * Brightness is 0 - 8, as described above.
+         * Value 0 is for the BIOS to use
+         */
+        u8 get_brightness;
+        u8 set_brightness;
+
+        /*
+         * first byte:
+         * 0x00 - wireless is off
+         * 0x01 - wireless is on
+         * second byte:
+         * 0x02 - 3G is off
+         * 0x03 - 3G is on
+         * TODO, verify 3G is correct, that doesn't seem right...
+         */
+        u8 get_wireless_button;
+        u8 set_wireless_button;
+
+        /* 0 is off, 1 is on */
+        u8 get_backlight;
+        u8 set_backlight;
+
+        /*
+         * 0x80 or 0x00 - no action
+         * 0x81 - recovery key pressed
+         */
+        u8 get_recovery_mode;
+        u8 set_recovery_mode;
+
+        /*
+         * on seclinux: 0 is low, 1 is high,
+         * on swsmi: 0 is normal, 1 is silent, 2 is turbo
+         */
+        u8 get_performance_level;
+        u8 set_performance_level;
+
+        /*
+         * Tell the BIOS that Linux is running on this machine.
+         * 81 is on, 80 is off
+         */
+        u8 set_linux;
+};
+
+struct sabi_performance_level {
+        const char *name;
+        u8 value;
+};
+
+struct sabi_config {
+        const char *test_string;
+        u16 main_function;
+        const struct sabi_header_offsets header_offsets;
+        const struct sabi_commands commands;
+        const struct sabi_performance_level performance_levels[4];
+        u8 min_brightness;
+        u8 max_brightness;
+};
+
+static const struct sabi_config sabi_configs[] = {
+        {
+                .test_string = "SECLINUX",
+
+                .main_function = 0x4c49,
+
+                .header_offsets = {
+                        .port = 0x00,
+                        .re_mem = 0x02,
+                        .iface_func = 0x03,
+                        .en_mem = 0x04,
+                        .data_offset = 0x05,
+                        .data_segment = 0x07,
+                },
+
+                .commands = {
+                        .get_brightness = 0x00,
+                        .set_brightness = 0x01,
+
+                        .get_wireless_button = 0x02,
+                        .set_wireless_button = 0x03,
+
+                        .get_backlight = 0x04,
+                        .set_backlight = 0x05,
+
+                        .get_recovery_mode = 0x06,
+                        .set_recovery_mode = 0x07,
+
+                        .get_performance_level = 0x08,
+                        .set_performance_level = 0x09,
+
+                        .set_linux = 0x0a,
+                },
+
+                .performance_levels = {
+                        {
+                                .name = "silent",
+                                .value = 0,
+                        },
+                        {
+                                .name = "normal",
+                                .value = 1,
+                        },
+                        { },
+                },
+                .min_brightness = 1,
+                .max_brightness = 8,
+        },
+        {
+                .test_string = "SwSmi@",
+
+                .main_function = 0x5843,
+
+                .header_offsets = {
+                        .port = 0x00,
+                        .re_mem = 0x04,
+                        .iface_func = 0x02,
+                        .en_mem = 0x03,
+                        .data_offset = 0x05,
+                        .data_segment = 0x07,
+                },
+
+                .commands = {
+                        .get_brightness = 0x10,
+                        .set_brightness = 0x11,
+
+                        .get_wireless_button = 0x12,
+                        .set_wireless_button = 0x13,
+
+                        .get_backlight = 0x2d,
+                        .set_backlight = 0x2e,
+
+                        .get_recovery_mode = 0xff,
+                        .set_recovery_mode = 0xff,
+
+                        .get_performance_level = 0x31,
+                        .set_performance_level = 0x32,
+
+                        .set_linux = 0xff,
+                },
+
+                .performance_levels = {
+                        {
+                                .name = "normal",
+                                .value = 0,
+                        },
+                        {
+                                .name = "silent",
+                                .value = 1,
+                        },
+                        {
+                                .name = "overclock",
+                                .value = 2,
+                        },
+                        { },
+                },
+                .min_brightness = 0,
+                .max_brightness = 8,
+        },
+        { },
+};
+
+static const struct sabi_config *sabi_config;
+
+static void __iomem *sabi;
+static void __iomem *sabi_iface;
+static void __iomem *f0000_segment;
+static struct backlight_device *backlight_device;
+static struct mutex sabi_mutex;
+static struct platform_device *sdev;
+static struct rfkill *rfk;
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force,
+                "Disable the DMI check and forces the driver to be loaded");
+
+static int debug;
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
+
+static int sabi_get_command(u8 command, struct sabi_retval *sretval)
+{
+        int retval = 0;
+        u16 port = readw(sabi + sabi_config->header_offsets.port);
+        u8 complete, iface_data;
+
+        mutex_lock(&sabi_mutex);
+
+        /* enable memory to be able to write to it */
+        outb(readb(sabi + sabi_config->header_offsets.en_mem), port);
+
+        /* write out the command */
+        writew(sabi_config->main_function, sabi_iface + SABI_IFACE_MAIN);
+        writew(command, sabi_iface + SABI_IFACE_SUB);
+        writeb(0, sabi_iface + SABI_IFACE_COMPLETE);
+        outb(readb(sabi + sabi_config->header_offsets.iface_func), port);
+
+        /* write protect memory to make it safe */
+        outb(readb(sabi + sabi_config->header_offsets.re_mem), port);
+
+        /* see if the command actually succeeded */
+        complete = readb(sabi_iface + SABI_IFACE_COMPLETE);
+        iface_data = readb(sabi_iface + SABI_IFACE_DATA);
+        if (complete != 0xaa || iface_data == 0xff) {
+                pr_warn("SABI get command 0x%02x failed with completion flag 0x%02x and data 0x%02x\n",
+                        command, complete, iface_data);
+                retval = -EINVAL;
+                goto exit;
+        }
+        /*
+         * Save off the data into a structure so the caller use it.
+         * Right now we only want the first 4 bytes,
+         * There are commands that need more, but not for the ones we
+         * currently care about.
+         */
+        sretval->retval[0] = readb(sabi_iface + SABI_IFACE_DATA);
+        sretval->retval[1] = readb(sabi_iface + SABI_IFACE_DATA + 1);
+        sretval->retval[2] = readb(sabi_iface + SABI_IFACE_DATA + 2);
+        sretval->retval[3] = readb(sabi_iface + SABI_IFACE_DATA + 3);
+
+exit:
+        mutex_unlock(&sabi_mutex);
+        return retval;
+
+}
+
+static int sabi_set_command(u8 command, u8 data)
+{
+        int retval = 0;
+        u16 port = readw(sabi + sabi_config->header_offsets.port);
+        u8 complete, iface_data;
+
+        mutex_lock(&sabi_mutex);
+
+        /* enable memory to be able to write to it */
+        outb(readb(sabi + sabi_config->header_offsets.en_mem), port);
+
+        /* write out the command */
+        writew(sabi_config->main_function, sabi_iface + SABI_IFACE_MAIN);
+        writew(command, sabi_iface + SABI_IFACE_SUB);
+        writeb(0, sabi_iface + SABI_IFACE_COMPLETE);
+        writeb(data, sabi_iface + SABI_IFACE_DATA);
+        outb(readb(sabi + sabi_config->header_offsets.iface_func), port);
+
+        /* write protect memory to make it safe */
+        outb(readb(sabi + sabi_config->header_offsets.re_mem), port);
+
+        /* see if the command actually succeeded */
+        complete = readb(sabi_iface + SABI_IFACE_COMPLETE);
+        iface_data = readb(sabi_iface + SABI_IFACE_DATA);
+        if (complete != 0xaa || iface_data == 0xff) {
+                pr_warn("SABI set command 0x%02x failed with completion flag 0x%02x and data 0x%02x\n",
+                       command, complete, iface_data);
+                retval = -EINVAL;
+        }
+
+        mutex_unlock(&sabi_mutex);
+        return retval;
+}
+
+static void test_backlight(void)
+{
+        struct sabi_retval sretval;
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+
+        sabi_set_command(sabi_config->commands.set_backlight, 0);
+        printk(KERN_DEBUG "backlight should be off\n");
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+
+        msleep(1000);
+
+        sabi_set_command(sabi_config->commands.set_backlight, 1);
+        printk(KERN_DEBUG "backlight should be on\n");
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+}
+
+static void test_wireless(void)
+{
+        struct sabi_retval sretval;
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+
+        sabi_set_command(sabi_config->commands.set_wireless_button, 0);
+        printk(KERN_DEBUG "wireless led should be off\n");
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+
+        msleep(1000);
+
+        sabi_set_command(sabi_config->commands.set_wireless_button, 1);
+        printk(KERN_DEBUG "wireless led should be on\n");
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+}
+
+static u8 read_brightness(void)
+{
+        struct sabi_retval sretval;
+        int user_brightness = 0;
+        int retval;
+
+        retval = sabi_get_command(sabi_config->commands.get_brightness,
+                                  &sretval);
+        if (!retval) {
+                user_brightness = sretval.retval[0];
+                if (user_brightness != 0)
+                        user_brightness -= sabi_config->min_brightness;
+        }
+        return user_brightness;
+}
+
+static void set_brightness(u8 user_brightness)
+{
+        u8 user_level = user_brightness - sabi_config->min_brightness;
+
+        sabi_set_command(sabi_config->commands.set_brightness, user_level);
+}
+
+static int get_brightness(struct backlight_device *bd)
+{
+        return (int)read_brightness();
+}
+
+static int update_status(struct backlight_device *bd)
+{
+        set_brightness(bd->props.brightness);
+
+        if (bd->props.power == FB_BLANK_UNBLANK)
+                sabi_set_command(sabi_config->commands.set_backlight, 1);
+        else
+                sabi_set_command(sabi_config->commands.set_backlight, 0);
+        return 0;
+}
+
+static const struct backlight_ops backlight_ops = {
+        .get_brightness = get_brightness,
+        .update_status  = update_status,
+};
+
+static int rfkill_set(void *data, bool blocked)
+{
+        /* Do something with blocked...*/
+        /*
+         * blocked == false is on
+         * blocked == true is off
+         */
+        if (blocked)
+                sabi_set_command(sabi_config->commands.set_wireless_button, 0);
+        else
+                sabi_set_command(sabi_config->commands.set_wireless_button, 1);
+
+        return 0;
+}
+
+static struct rfkill_ops rfkill_ops = {
+        .set_block = rfkill_set,
+};
+
+static int init_wireless(struct platform_device *sdev)
+{
+        int retval;
+
+        rfk = rfkill_alloc("samsung-wifi", &sdev->dev, RFKILL_TYPE_WLAN,
+                           &rfkill_ops, NULL);
+        if (!rfk)
+                return -ENOMEM;
+
+        retval = rfkill_register(rfk);
+        if (retval) {
+                rfkill_destroy(rfk);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void destroy_wireless(void)
+{
+        rfkill_unregister(rfk);
+        rfkill_destroy(rfk);
+}
+
+static ssize_t get_performance_level(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct sabi_retval sretval;
+        int retval;
+        int i;
+
+        /* Read the state */
+        retval = sabi_get_command(sabi_config->commands.get_performance_level,
+                                  &sretval);
+        if (retval)
+                return retval;
+
+        /* The logic is backwards, yeah, lots of fun... */
+        for (i = 0; sabi_config->performance_levels[i].name; ++i) {
+                if (sretval.retval[0] == sabi_config->performance_levels[i].value)
+                        return sprintf(buf, "%s\n", sabi_config->performance_levels[i].name);
+        }
+        return sprintf(buf, "%s\n", "unknown");
+}
+
+static ssize_t set_performance_level(struct device *dev,
+                                struct device_attribute *attr, const char *buf,
+                                size_t count)
+{
+        if (count >= 1) {
+                int i;
+                for (i = 0; sabi_config->performance_levels[i].name; ++i) {
+                        const struct sabi_performance_level *level =
+                                &sabi_config->performance_levels[i];
+                        if (!strncasecmp(level->name, buf, strlen(level->name))) {
+                                sabi_set_command(sabi_config->commands.set_performance_level,
+                                                 level->value);
+                                break;
+                        }
+                }
+                if (!sabi_config->performance_levels[i].name)
+                        return -EINVAL;
+        }
+        return count;
+}
+static DEVICE_ATTR(performance_level, S_IWUSR | S_IRUGO,
+                   get_performance_level, set_performance_level);
+
+
+static int __init dmi_check_cb(const struct dmi_system_id *id)
+{
+        pr_info("found laptop model '%s'\n",
+                id->ident);
+        return 1;
+}
+
+static struct dmi_system_id __initdata samsung_dmi_table[] = {
+        {
+                .ident = "N128",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N128"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N128"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N130",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N130"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N130"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "X125",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X125"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X125"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "X120/X170",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X120/X170"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X120/X170"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "NC10",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
+                        DMI_MATCH(DMI_BOARD_NAME, "NC10"),
+                },
+                .callback = dmi_check_cb,
+        },
+                {
+                .ident = "NP-Q45",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
+                        DMI_MATCH(DMI_BOARD_NAME, "SQ45S70S"),
+                },
+                .callback = dmi_check_cb,
+                },
+        {
+                .ident = "X360",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X360"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X360"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R410 Plus",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R410P"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R460"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R518",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R518"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R518"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R519/R719",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R519/R719"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R519/R719"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N150/N210/N220/N230",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N150/N210/N220/N230"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N150/N210/N220/N230"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N150P/N210P/N220P",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N150P/N210P/N220P"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N150P/N210P/N220P"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R530/R730",
+                .matches = {
+                      DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                      DMI_MATCH(DMI_PRODUCT_NAME, "R530/R730"),
+                      DMI_MATCH(DMI_BOARD_NAME, "R530/R730"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "NF110/NF210/NF310",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NF110/NF210/NF310"),
+                        DMI_MATCH(DMI_BOARD_NAME, "NF110/NF210/NF310"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N145P/N250P/N260P",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N145P/N250P/N260P"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N145P/N250P/N260P"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R70/R71",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R70/R71"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R70/R71"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "P460",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "P460"),
+                        DMI_MATCH(DMI_BOARD_NAME, "P460"),
+                },
+                .callback = dmi_check_cb,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(dmi, samsung_dmi_table);
+
+static int find_signature(void __iomem *memcheck, const char *testStr)
+{
+        int i = 0;
+        int loca;
+
+        for (loca = 0; loca < 0xffff; loca++) {
+                char temp = readb(memcheck + loca);
+
+                if (temp == testStr[i]) {
+                        if (i == strlen(testStr)-1)
+                                break;
+                        ++i;
+                } else {
+                        i = 0;
+                }
+        }
+        return loca;
+}
+
+static int __init samsung_init(void)
+{
+        struct backlight_properties props;
+        struct sabi_retval sretval;
+        unsigned int ifaceP;
+        int i;
+        int loca;
+        int retval;
+
+        mutex_init(&sabi_mutex);
+
+        if (!force && !dmi_check_system(samsung_dmi_table))
+                return -ENODEV;
+
+        f0000_segment = ioremap_nocache(0xf0000, 0xffff);
+        if (!f0000_segment) {
+                pr_err("Can't map the segment at 0xf0000\n");
+                return -EINVAL;
+        }
+
+        /* Try to find one of the signatures in memory to find the header */
+        for (i = 0; sabi_configs[i].test_string != 0; ++i) {
+                sabi_config = &sabi_configs[i];
+                loca = find_signature(f0000_segment, sabi_config->test_string);
+                if (loca != 0xffff)
+                        break;
+        }
+
+        if (loca == 0xffff) {
+                pr_err("This computer does not support SABI\n");
+                goto error_no_signature;
+        }
+
+        /* point to the SMI port Number */
+        loca += 1;
+        sabi = (f0000_segment + loca);
+
+        if (debug) {
+                printk(KERN_DEBUG "This computer supports SABI==%x\n",
+                        loca + 0xf0000 - 6);
+                printk(KERN_DEBUG "SABI header:\n");
+                printk(KERN_DEBUG " SMI Port Number = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.port));
+                printk(KERN_DEBUG " SMI Interface Function = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.iface_func));
+                printk(KERN_DEBUG " SMI enable memory buffer = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.en_mem));
+                printk(KERN_DEBUG " SMI restore memory buffer = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.re_mem));
+                printk(KERN_DEBUG " SABI data offset = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.data_offset));
+                printk(KERN_DEBUG " SABI data segment = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.data_segment));
+        }
+
+        /* Get a pointer to the SABI Interface */
+        ifaceP = (readw(sabi + sabi_config->header_offsets.data_segment) & 0x0ffff) << 4;
+        ifaceP += readw(sabi + sabi_config->header_offsets.data_offset) & 0x0ffff;
+        sabi_iface = ioremap_nocache(ifaceP, 16);
+        if (!sabi_iface) {
+                pr_err("Can't remap %x\n", ifaceP);
+                goto exit;
+        }
+        if (debug) {
+                printk(KERN_DEBUG "ifaceP = 0x%08x\n", ifaceP);
+                printk(KERN_DEBUG "sabi_iface = %p\n", sabi_iface);
+
+                test_backlight();
+                test_wireless();
+
+                retval = sabi_get_command(sabi_config->commands.get_brightness,
+                                          &sretval);
+                printk(KERN_DEBUG "brightness = 0x%02x\n", sretval.retval[0]);
+        }
+
+        /* Turn on "Linux" mode in the BIOS */
+        if (sabi_config->commands.set_linux != 0xff) {
+                retval = sabi_set_command(sabi_config->commands.set_linux,
+                                          0x81);
+                if (retval) {
+                        pr_warn("Linux mode was not set!\n");
+                        goto error_no_platform;
+                }
+        }
+
+        /* knock up a platform device to hang stuff off of */
+        sdev = platform_device_register_simple("samsung", -1, NULL, 0);
+        if (IS_ERR(sdev))
+                goto error_no_platform;
+
+        /* create a backlight device to talk to this one */
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = sabi_config->max_brightness;
+        backlight_device = backlight_device_register("samsung", &sdev->dev,
+                                                     NULL, &backlight_ops,
+                                                     &props);
+        if (IS_ERR(backlight_device))
+                goto error_no_backlight;
+
+        backlight_device->props.brightness = read_brightness();
+        backlight_device->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(backlight_device);
+
+        retval = init_wireless(sdev);
+        if (retval)
+                goto error_no_rfk;
+
+        retval = device_create_file(&sdev->dev, &dev_attr_performance_level);
+        if (retval)
+                goto error_file_create;
+
+exit:
+        return 0;
+
+error_file_create:
+        destroy_wireless();
+
+error_no_rfk:
+        backlight_device_unregister(backlight_device);
+
+error_no_backlight:
+        platform_device_unregister(sdev);
+
+error_no_platform:
+        iounmap(sabi_iface);
+
+error_no_signature:
+        iounmap(f0000_segment);
+        return -EINVAL;
+}
+
+static void __exit samsung_exit(void)
+{
+        /* Turn off "Linux" mode in the BIOS */
+        if (sabi_config->commands.set_linux != 0xff)
+                sabi_set_command(sabi_config->commands.set_linux, 0x80);
+
+        device_remove_file(&sdev->dev, &dev_attr_performance_level);
+        backlight_device_unregister(backlight_device);
+        destroy_wireless();
+        iounmap(sabi_iface);
+        iounmap(f0000_segment);
+        platform_device_unregister(sdev);
+}
+
+module_init(samsung_init);
+module_exit(samsung_exit);
+
+MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@suse.de>");
+MODULE_DESCRIPTION("Samsung Backlight driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index e3154ff7a39f..bbd182e178cb 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -42,6 +42,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
@@ -70,9 +72,10 @@
 #include <linux/miscdevice.h>
 #endif
 
-#define DRV_PFX                 "sony-laptop: "
-#define dprintk(msg...)         do {                    \
-        if (debug) printk(KERN_WARNING DRV_PFX  msg);   \
+#define dprintk(fmt, ...)                       \
+do {                                            \
+        if (debug)                              \
+                pr_warn(fmt, ##__VA_ARGS__);    \
 } while (0)
 
 #define SONY_LAPTOP_DRIVER_VERSION      "0.6"
@@ -124,6 +127,21 @@ MODULE_PARM_DESC(minor,
                  "default is -1 (automatic)");
 #endif
 
+static int kbd_backlight;       /* = 1 */
+module_param(kbd_backlight, int, 0444);
+MODULE_PARM_DESC(kbd_backlight,
+                 "set this to 0 to disable keyboard backlight, "
+                 "1 to enable it (default: 0)");
+
+static int kbd_backlight_timeout;       /* = 0 */
+module_param(kbd_backlight_timeout, int, 0444);
+MODULE_PARM_DESC(kbd_backlight_timeout,
+                 "set this to 0 to set the default 10 seconds timeout, "
+                 "1 for 30 seconds, 2 for 60 seconds and 3 to disable timeout "
+                 "(default: 0)");
+
+static void sony_nc_kbd_backlight_resume(void);
+
 enum sony_nc_rfkill {
         SONY_WIFI,
         SONY_BLUETOOTH,
@@ -235,6 +253,7 @@ static int sony_laptop_input_index[] = {
         57,     /* 70 SONYPI_EVENT_VOLUME_DEC_PRESSED */
         -1,     /* 71 SONYPI_EVENT_BRIGHTNESS_PRESSED */
         58,     /* 72 SONYPI_EVENT_MEDIA_PRESSED */
+        59,     /* 72 SONYPI_EVENT_VENDOR_PRESSED */
 };
 
 static int sony_laptop_input_keycode_map[] = {
@@ -297,6 +316,7 @@ static int sony_laptop_input_keycode_map[] = {
         KEY_VOLUMEUP,   /* 56 SONYPI_EVENT_VOLUME_INC_PRESSED */
         KEY_VOLUMEDOWN, /* 57 SONYPI_EVENT_VOLUME_DEC_PRESSED */
         KEY_MEDIA,      /* 58 SONYPI_EVENT_MEDIA_PRESSED */
+        KEY_VENDOR,     /* 59 SONYPI_EVENT_VENDOR_PRESSED */
 };
 
 /* release buttons after a short delay if pressed */
@@ -400,7 +420,7 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
         error = kfifo_alloc(&sony_laptop_input.fifo,
                             SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 goto err_dec_users;
         }
 
@@ -589,7 +609,7 @@ struct sony_nc_value {
         int value;              /* current setting */
         int valid;              /* Has ever been set */
         int debug;              /* active only in debug mode ? */
-        struct device_attribute devattr;        /* sysfs atribute */
+        struct device_attribute devattr;        /* sysfs attribute */
 };
 
 #define SNC_HANDLE_NAMES(_name, _values...) \
@@ -684,7 +704,7 @@ static int acpi_callgetfunc(acpi_handle handle, char *name, int *result)
                 return 0;
         }
 
-        printk(KERN_WARNING DRV_PFX "acpi_callreadfunc failed\n");
+        pr_warn("acpi_callreadfunc failed\n");
 
         return -1;
 }
@@ -710,8 +730,7 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
         if (status == AE_OK) {
                 if (result != NULL) {
                         if (out_obj.type != ACPI_TYPE_INTEGER) {
-                                printk(KERN_WARNING DRV_PFX "acpi_evaluate_object bad "
-                                       "return type\n");
+                                pr_warn("acpi_evaluate_object bad return type\n");
                                 return -1;
                         }
                         *result = out_obj.integer.value;
@@ -719,34 +738,111 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
                 return 0;
         }
 
-        printk(KERN_WARNING DRV_PFX "acpi_evaluate_object failed\n");
+        pr_warn("acpi_evaluate_object failed\n");
 
         return -1;
 }
 
-static int sony_find_snc_handle(int handle)
+struct sony_nc_handles {
+        u16 cap[0x10];
+        struct device_attribute devattr;
+};
+
+static struct sony_nc_handles *handles;
+
+static ssize_t sony_nc_handles_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t len = 0;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
+                len += snprintf(buffer + len, PAGE_SIZE - len, "0x%.4x ",
+                                handles->cap[i]);
+        }
+        len += snprintf(buffer + len, PAGE_SIZE - len, "\n");
+
+        return len;
+}
+
+static int sony_nc_handles_setup(struct platform_device *pd)
 {
         int i;
         int result;
 
-        for (i = 0x20; i < 0x30; i++) {
-                acpi_callsetfunc(sony_nc_acpi_handle, "SN00", i, &result);
-                if (result == handle)
-                        return i-0x20;
+        handles = kzalloc(sizeof(*handles), GFP_KERNEL);
+        if (!handles)
+                return -ENOMEM;
+
+        for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
+                if (!acpi_callsetfunc(sony_nc_acpi_handle,
+                                        "SN00", i + 0x20, &result)) {
+                        dprintk("caching handle 0x%.4x (offset: 0x%.2x)\n",
+                                        result, i);
+                        handles->cap[i] = result;
+                }
+        }
+
+        if (debug) {
+                sysfs_attr_init(&handles->devattr.attr);
+                handles->devattr.attr.name = "handles";
+                handles->devattr.attr.mode = S_IRUGO;
+                handles->devattr.show = sony_nc_handles_show;
+
+                /* allow reading capabilities via sysfs */
+                if (device_create_file(&pd->dev, &handles->devattr)) {
+                        kfree(handles);
+                        handles = NULL;
+                        return -1;
+                }
+        }
+
+        return 0;
+}
+
+static int sony_nc_handles_cleanup(struct platform_device *pd)
+{
+        if (handles) {
+                if (debug)
+                        device_remove_file(&pd->dev, &handles->devattr);
+                kfree(handles);
+                handles = NULL;
         }
+        return 0;
+}
+
+static int sony_find_snc_handle(int handle)
+{
+        int i;
+
+        /* not initialized yet, return early */
+        if (!handles)
+                return -1;
 
+        for (i = 0; i < 0x10; i++) {
+                if (handles->cap[i] == handle) {
+                        dprintk("found handle 0x%.4x (offset: 0x%.2x)\n",
+                                        handle, i);
+                        return i;
+                }
+        }
+        dprintk("handle 0x%.4x not found\n", handle);
         return -1;
 }
 
 static int sony_call_snc_handle(int handle, int argument, int *result)
 {
+        int ret = 0;
         int offset = sony_find_snc_handle(handle);
 
         if (offset < 0)
                 return -1;
 
-        return acpi_callsetfunc(sony_nc_acpi_handle, "SN07", offset | argument,
-                                result);
+        ret = acpi_callsetfunc(sony_nc_acpi_handle, "SN07", offset | argument,
+                        result);
+        dprintk("called SN07 with 0x%.4x (result: 0x%.4x)\n", offset | argument,
+                        *result);
+        return ret;
 }
 
 /*
@@ -839,6 +935,14 @@ static ssize_t sony_nc_sysfs_store(struct device *dev,
 /*
  * Backlight device
  */
+struct sony_backlight_props {
+        struct backlight_device *dev;
+        int                     handle;
+        u8                      offset;
+        u8                      maxlvl;
+};
+struct sony_backlight_props sony_bl_props;
+
 static int sony_backlight_update_status(struct backlight_device *bd)
 {
         return acpi_callsetfunc(sony_nc_acpi_handle, "SBRT",
@@ -855,11 +959,40 @@ static int sony_backlight_get_brightness(struct backlight_device *bd)
         return value - 1;
 }
 
-static struct backlight_device *sony_backlight_device;
-static struct backlight_ops sony_backlight_ops = {
+static int sony_nc_get_brightness_ng(struct backlight_device *bd)
+{
+        int result;
+        struct sony_backlight_props *sdev =
+                (struct sony_backlight_props *)bl_get_data(bd);
+
+        sony_call_snc_handle(sdev->handle, 0x0200, &result);
+
+        return (result & 0xff) - sdev->offset;
+}
+
+static int sony_nc_update_status_ng(struct backlight_device *bd)
+{
+        int value, result;
+        struct sony_backlight_props *sdev =
+                (struct sony_backlight_props *)bl_get_data(bd);
+
+        value = bd->props.brightness + sdev->offset;
+        if (sony_call_snc_handle(sdev->handle, 0x0100 | (value << 16), &result))
+                return -EIO;
+
+        return value;
+}
+
+static const struct backlight_ops sony_backlight_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
         .update_status = sony_backlight_update_status,
         .get_brightness = sony_backlight_get_brightness,
 };
+static const struct backlight_ops sony_backlight_ng_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .update_status = sony_nc_update_status_ng,
+        .get_brightness = sony_nc_get_brightness_ng,
+};
 
 /*
  * New SNC-only Vaios event mapping to driver known keys
@@ -894,10 +1027,18 @@ static struct sony_nc_event sony_100_events[] = {
         { 0x0A, SONYPI_EVENT_FNKEY_RELEASED },
         { 0x8C, SONYPI_EVENT_FNKEY_F12 },
         { 0x0C, SONYPI_EVENT_FNKEY_RELEASED },
+        { 0x9d, SONYPI_EVENT_ZOOM_PRESSED },
+        { 0x1d, SONYPI_EVENT_ANYBUTTON_RELEASED },
         { 0x9f, SONYPI_EVENT_CD_EJECT_PRESSED },
         { 0x1f, SONYPI_EVENT_ANYBUTTON_RELEASED },
         { 0xa1, SONYPI_EVENT_MEDIA_PRESSED },
         { 0x21, SONYPI_EVENT_ANYBUTTON_RELEASED },
+        { 0xa4, SONYPI_EVENT_CD_EJECT_PRESSED },
+        { 0x24, SONYPI_EVENT_ANYBUTTON_RELEASED },
+        { 0xa5, SONYPI_EVENT_VENDOR_PRESSED },
+        { 0x25, SONYPI_EVENT_ANYBUTTON_RELEASED },
+        { 0xa6, SONYPI_EVENT_HELP_PRESSED },
+        { 0x26, SONYPI_EVENT_ANYBUTTON_RELEASED },
         { 0, 0 },
 };
 
@@ -962,10 +1103,8 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                                 }
 
                                 if (!key_event->data)
-                                        printk(KERN_INFO DRV_PFX
-                                                        "Unknown event: 0x%x 0x%x\n",
-                                                        key_handle,
-                                                        ev);
+                                        pr_info("Unknown event: 0x%x 0x%x\n",
+                                                key_handle, ev);
                                 else
                                         sony_laptop_report_input_event(ev);
                         }
@@ -986,7 +1125,7 @@ static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
         struct acpi_device_info *info;
 
         if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
-                printk(KERN_WARNING DRV_PFX "method: name: %4.4s, args %X\n",
+                pr_warn("method: name: %4.4s, args %X\n",
                         (char *)&info->name, info->param_count);
 
                 kfree(info);
@@ -1027,7 +1166,7 @@ static int sony_nc_resume(struct acpi_device *device)
                 ret = acpi_callsetfunc(sony_nc_acpi_handle, *item->acpiset,
                                        item->value, NULL);
                 if (ret < 0) {
-                        printk("%s: %d\n", __func__, ret);
+                        pr_err("%s: %d\n", __func__, ret);
                         break;
                 }
         }
@@ -1044,14 +1183,12 @@ static int sony_nc_resume(struct acpi_device *device)
                 sony_nc_function_setup(device);
         }
 
-        /* set the last requested brightness level */
-        if (sony_backlight_device &&
-                        sony_backlight_update_status(sony_backlight_device) < 0)
-                printk(KERN_WARNING DRV_PFX "unable to restore brightness level\n");
-
         /* re-read rfkill state */
         sony_nc_rfkill_update();
 
+        /* restore kbd backlight states */
+        sony_nc_kbd_backlight_resume();
+
         return 0;
 }
 
@@ -1131,7 +1268,7 @@ static int sony_nc_setup_rfkill(struct acpi_device *device,
         return err;
 }
 
-static void sony_nc_rfkill_update()
+static void sony_nc_rfkill_update(void)
 {
         enum sony_nc_rfkill i;
         int result;
@@ -1196,11 +1333,11 @@ static void sony_nc_rfkill_setup(struct acpi_device *device)
 
         device_enum = (union acpi_object *) buffer.pointer;
         if (!device_enum) {
-                pr_err("Invalid SN06 return object\n");
+                pr_err("No SN06 return object\n");
                 goto out_no_enum;
         }
         if (device_enum->type != ACPI_TYPE_BUFFER) {
-                pr_err("Invalid SN06 return object type 0x%.2x\n",
+                pr_err("Invalid SN06 return object 0x%.2x\n",
                        device_enum->type);
                 goto out_no_enum;
         }
@@ -1235,6 +1372,306 @@ out_no_enum:
         return;
 }
 
+/* Keyboard backlight feature */
+#define KBDBL_HANDLER   0x137
+#define KBDBL_PRESENT   0xB00
+#define SET_MODE        0xC00
+#define SET_STATE       0xD00
+#define SET_TIMEOUT     0xE00
+
+struct kbd_backlight {
+        int mode;
+        int timeout;
+        struct device_attribute mode_attr;
+        struct device_attribute timeout_attr;
+};
+
+static struct kbd_backlight *kbdbl_handle;
+
+static ssize_t __sony_nc_kbd_backlight_mode_set(u8 value)
+{
+        int result;
+
+        if (value > 1)
+                return -EINVAL;
+
+        if (sony_call_snc_handle(KBDBL_HANDLER,
+                                (value << 0x10) | SET_MODE, &result))
+                return -EIO;
+
+        /* Try to turn the light on/off immediately */
+        sony_call_snc_handle(KBDBL_HANDLER, (value << 0x10) | SET_STATE,
+                        &result);
+
+        kbdbl_handle->mode = value;
+
+        return 0;
+}
+
+static ssize_t sony_nc_kbd_backlight_mode_store(struct device *dev,
+                struct device_attribute *attr,
+                const char *buffer, size_t count)
+{
+        int ret = 0;
+        unsigned long value;
+
+        if (count > 31)
+                return -EINVAL;
+
+        if (strict_strtoul(buffer, 10, &value))
+                return -EINVAL;
+
+        ret = __sony_nc_kbd_backlight_mode_set(value);
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static ssize_t sony_nc_kbd_backlight_mode_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t count = 0;
+        count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_handle->mode);
+        return count;
+}
+
+static int __sony_nc_kbd_backlight_timeout_set(u8 value)
+{
+        int result;
+
+        if (value > 3)
+                return -EINVAL;
+
+        if (sony_call_snc_handle(KBDBL_HANDLER,
+                                (value << 0x10) | SET_TIMEOUT, &result))
+                return -EIO;
+
+        kbdbl_handle->timeout = value;
+
+        return 0;
+}
+
+static ssize_t sony_nc_kbd_backlight_timeout_store(struct device *dev,
+                struct device_attribute *attr,
+                const char *buffer, size_t count)
+{
+        int ret = 0;
+        unsigned long value;
+
+        if (count > 31)
+                return -EINVAL;
+
+        if (strict_strtoul(buffer, 10, &value))
+                return -EINVAL;
+
+        ret = __sony_nc_kbd_backlight_timeout_set(value);
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static ssize_t sony_nc_kbd_backlight_timeout_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t count = 0;
+        count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_handle->timeout);
+        return count;
+}
+
+static int sony_nc_kbd_backlight_setup(struct platform_device *pd)
+{
+        int result;
+
+        if (sony_call_snc_handle(KBDBL_HANDLER, KBDBL_PRESENT, &result))
+                return 0;
+        if (!(result & 0x02))
+                return 0;
+
+        kbdbl_handle = kzalloc(sizeof(*kbdbl_handle), GFP_KERNEL);
+        if (!kbdbl_handle)
+                return -ENOMEM;
+
+        sysfs_attr_init(&kbdbl_handle->mode_attr.attr);
+        kbdbl_handle->mode_attr.attr.name = "kbd_backlight";
+        kbdbl_handle->mode_attr.attr.mode = S_IRUGO | S_IWUSR;
+        kbdbl_handle->mode_attr.show = sony_nc_kbd_backlight_mode_show;
+        kbdbl_handle->mode_attr.store = sony_nc_kbd_backlight_mode_store;
+
+        sysfs_attr_init(&kbdbl_handle->timeout_attr.attr);
+        kbdbl_handle->timeout_attr.attr.name = "kbd_backlight_timeout";
+        kbdbl_handle->timeout_attr.attr.mode = S_IRUGO | S_IWUSR;
+        kbdbl_handle->timeout_attr.show = sony_nc_kbd_backlight_timeout_show;
+        kbdbl_handle->timeout_attr.store = sony_nc_kbd_backlight_timeout_store;
+
+        if (device_create_file(&pd->dev, &kbdbl_handle->mode_attr))
+                goto outkzalloc;
+
+        if (device_create_file(&pd->dev, &kbdbl_handle->timeout_attr))
+                goto outmode;
+
+        __sony_nc_kbd_backlight_mode_set(kbd_backlight);
+        __sony_nc_kbd_backlight_timeout_set(kbd_backlight_timeout);
+
+        return 0;
+
+outmode:
+        device_remove_file(&pd->dev, &kbdbl_handle->mode_attr);
+outkzalloc:
+        kfree(kbdbl_handle);
+        kbdbl_handle = NULL;
+        return -1;
+}
+
+static int sony_nc_kbd_backlight_cleanup(struct platform_device *pd)
+{
+        if (kbdbl_handle) {
+                int result;
+
+                device_remove_file(&pd->dev, &kbdbl_handle->mode_attr);
+                device_remove_file(&pd->dev, &kbdbl_handle->timeout_attr);
+
+                /* restore the default hw behaviour */
+                sony_call_snc_handle(KBDBL_HANDLER, 0x1000 | SET_MODE, &result);
+                sony_call_snc_handle(KBDBL_HANDLER, SET_TIMEOUT, &result);
+
+                kfree(kbdbl_handle);
+        }
+        return 0;
+}
+
+static void sony_nc_kbd_backlight_resume(void)
+{
+        int ignore = 0;
+
+        if (!kbdbl_handle)
+                return;
+
+        if (kbdbl_handle->mode == 0)
+                sony_call_snc_handle(KBDBL_HANDLER, SET_MODE, &ignore);
+
+        if (kbdbl_handle->timeout != 0)
+                sony_call_snc_handle(KBDBL_HANDLER,
+                                (kbdbl_handle->timeout << 0x10) | SET_TIMEOUT,
+                                &ignore);
+}
+
+static void sony_nc_backlight_ng_read_limits(int handle,
+                struct sony_backlight_props *props)
+{
+        int offset;
+        acpi_status status;
+        u8 brlvl, i;
+        u8 min = 0xff, max = 0x00;
+        struct acpi_object_list params;
+        union acpi_object in_obj;
+        union acpi_object *lvl_enum;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        props->handle = handle;
+        props->offset = 0;
+        props->maxlvl = 0xff;
+
+        offset = sony_find_snc_handle(handle);
+        if (offset < 0)
+                return;
+
+        /* try to read the boundaries from ACPI tables, if we fail the above
+         * defaults should be reasonable
+         */
+        params.count = 1;
+        params.pointer = &in_obj;
+        in_obj.type = ACPI_TYPE_INTEGER;
+        in_obj.integer.value = offset;
+        status = acpi_evaluate_object(sony_nc_acpi_handle, "SN06", &params,
+                        &buffer);
+        if (ACPI_FAILURE(status))
+                return;
+
+        lvl_enum = (union acpi_object *) buffer.pointer;
+        if (!lvl_enum) {
+                pr_err("No SN06 return object.");
+                return;
+        }
+        if (lvl_enum->type != ACPI_TYPE_BUFFER) {
+                pr_err("Invalid SN06 return object 0x%.2x\n",
+                       lvl_enum->type);
+                goto out_invalid;
+        }
+
+        /* the buffer lists brightness levels available, brightness levels are
+         * from 0 to 8 in the array, other values are used by ALS control.
+         */
+        for (i = 0; i < 9 && i < lvl_enum->buffer.length; i++) {
+
+                brlvl = *(lvl_enum->buffer.pointer + i);
+                dprintk("Brightness level: %d\n", brlvl);
+
+                if (!brlvl)
+                        break;
+
+                if (brlvl > max)
+                        max = brlvl;
+                if (brlvl < min)
+                        min = brlvl;
+        }
+        props->offset = min;
+        props->maxlvl = max;
+        dprintk("Brightness levels: min=%d max=%d\n", props->offset,
+                        props->maxlvl);
+
+out_invalid:
+        kfree(buffer.pointer);
+        return;
+}
+
+static void sony_nc_backlight_setup(void)
+{
+        acpi_handle unused;
+        int max_brightness = 0;
+        const struct backlight_ops *ops = NULL;
+        struct backlight_properties props;
+
+        if (sony_find_snc_handle(0x12f) != -1) {
+                ops = &sony_backlight_ng_ops;
+                sony_nc_backlight_ng_read_limits(0x12f, &sony_bl_props);
+                max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
+
+        } else if (sony_find_snc_handle(0x137) != -1) {
+                ops = &sony_backlight_ng_ops;
+                sony_nc_backlight_ng_read_limits(0x137, &sony_bl_props);
+                max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
+
+        } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
+                                                &unused))) {
+                ops = &sony_backlight_ops;
+                max_brightness = SONY_MAX_BRIGHTNESS - 1;
+
+        } else
+                return;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = max_brightness;
+        sony_bl_props.dev = backlight_device_register("sony", NULL,
+                                                      &sony_bl_props,
+                                                      ops, &props);
+
+        if (IS_ERR(sony_bl_props.dev)) {
+                pr_warn("unable to register backlight device\n");
+                sony_bl_props.dev = NULL;
+        } else
+                sony_bl_props.dev->props.brightness =
+                        ops->get_brightness(sony_bl_props.dev);
+}
+
+static void sony_nc_backlight_cleanup(void)
+{
+        if (sony_bl_props.dev)
+                backlight_device_unregister(sony_bl_props.dev);
+}
+
 static int sony_nc_add(struct acpi_device *device)
 {
         acpi_status status;
@@ -1242,8 +1679,7 @@ static int sony_nc_add(struct acpi_device *device)
         acpi_handle handle;
         struct sony_nc_value *item;
 
-        printk(KERN_INFO DRV_PFX "%s v%s.\n",
-                SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
+        pr_info("%s v%s\n", SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
 
         sony_nc_acpi_device = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -1259,13 +1695,18 @@ static int sony_nc_add(struct acpi_device *device)
                 goto outwalk;
         }
 
+        result = sony_pf_add();
+        if (result)
+                goto outpresent;
+
         if (debug) {
-                status = acpi_walk_namespace(ACPI_TYPE_METHOD, sony_nc_acpi_handle,
-                                             1, sony_walk_callback, NULL, NULL, NULL);
+                status = acpi_walk_namespace(ACPI_TYPE_METHOD,
+                                sony_nc_acpi_handle, 1, sony_walk_callback,
+                                NULL, NULL, NULL);
                 if (ACPI_FAILURE(status)) {
-                        printk(KERN_WARNING DRV_PFX "unable to walk acpi resources\n");
+                        pr_warn("unable to walk acpi resources\n");
                         result = -ENODEV;
-                        goto outwalk;
+                        goto outpresent;
                 }
         }
 
@@ -1278,6 +1719,12 @@ static int sony_nc_add(struct acpi_device *device)
         if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "SN00",
                                          &handle))) {
                 dprintk("Doing SNC setup\n");
+                result = sony_nc_handles_setup(sony_pf_device);
+                if (result)
+                        goto outpresent;
+                result = sony_nc_kbd_backlight_setup(sony_pf_device);
+                if (result)
+                        goto outsnc;
                 sony_nc_function_setup(device);
                 sony_nc_rfkill_setup(device);
         }
@@ -1285,39 +1732,16 @@ static int sony_nc_add(struct acpi_device *device)
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to create input devices.\n");
-                goto outwalk;
+                pr_err("Unable to create input devices\n");
+                goto outkbdbacklight;
         }
 
         if (acpi_video_backlight_support()) {
-                printk(KERN_INFO DRV_PFX "brightness ignored, must be "
-                       "controlled by ACPI video driver\n");
-        } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
-                                                &handle))) {
-                                                        struct backlight_properties props;
-                memset(&props, 0, sizeof(struct backlight_properties));
-                props.max_brightness = SONY_MAX_BRIGHTNESS - 1;
-                sony_backlight_device = backlight_device_register("sony", NULL,
-                                                                  NULL,
-                                                                  &sony_backlight_ops,
-                                                                  &props);
-
-                if (IS_ERR(sony_backlight_device)) {
-                        printk(KERN_WARNING DRV_PFX "unable to register backlight device\n");
-                        sony_backlight_device = NULL;
-                } else {
-                        sony_backlight_device->props.brightness =
-                            sony_backlight_get_brightness
-                            (sony_backlight_device);
-                }
-
+                pr_info("brightness ignored, must be controlled by ACPI video driver\n");
+        } else {
+                sony_nc_backlight_setup();
         }
 
-        result = sony_pf_add();
-        if (result)
-                goto outbacklight;
-
         /* create sony_pf sysfs attributes related to the SNC device */
         for (item = sony_nc_values; item->name; ++item) {
 
@@ -1363,14 +1787,19 @@ static int sony_nc_add(struct acpi_device *device)
         for (item = sony_nc_values; item->name; ++item) {
                 device_remove_file(&sony_pf_device->dev, &item->devattr);
         }
-        sony_pf_remove();
-
-      outbacklight:
-        if (sony_backlight_device)
-                backlight_device_unregister(sony_backlight_device);
+        sony_nc_backlight_cleanup();
 
         sony_laptop_remove_input();
 
+      outkbdbacklight:
+        sony_nc_kbd_backlight_cleanup(sony_pf_device);
+
+      outsnc:
+        sony_nc_handles_cleanup(sony_pf_device);
+
+      outpresent:
+        sony_pf_remove();
+
       outwalk:
         sony_nc_rfkill_cleanup();
         return result;
@@ -1380,8 +1809,7 @@ static int sony_nc_remove(struct acpi_device *device, int type)
 {
         struct sony_nc_value *item;
 
-        if (sony_backlight_device)
-                backlight_device_unregister(sony_backlight_device);
+        sony_nc_backlight_cleanup();
 
         sony_nc_acpi_device = NULL;
 
@@ -1389,6 +1817,8 @@ static int sony_nc_remove(struct acpi_device *device, int type)
                 device_remove_file(&sony_pf_device->dev, &item->devattr);
         }
 
+        sony_nc_kbd_backlight_cleanup(sony_pf_device);
+        sony_nc_handles_cleanup(sony_pf_device);
         sony_pf_remove();
         sony_laptop_remove_input();
         sony_nc_rfkill_cleanup();
@@ -1427,7 +1857,6 @@ static struct acpi_driver sony_nc_driver = {
 #define SONYPI_DEVICE_TYPE1     0x00000001
 #define SONYPI_DEVICE_TYPE2     0x00000002
 #define SONYPI_DEVICE_TYPE3     0x00000004
-#define SONYPI_DEVICE_TYPE4     0x00000008
 
 #define SONYPI_TYPE1_OFFSET     0x04
 #define SONYPI_TYPE2_OFFSET     0x12
@@ -1573,8 +2002,8 @@ static struct sonypi_event sonypi_blueev[] = {
 
 /* The set of possible wireless events */
 static struct sonypi_event sonypi_wlessev[] = {
-        { 0x59, SONYPI_EVENT_WIRELESS_ON },
-        { 0x5a, SONYPI_EVENT_WIRELESS_OFF },
+        { 0x59, SONYPI_EVENT_IGNORE },
+        { 0x5a, SONYPI_EVENT_IGNORE },
         { 0, 0 }
 };
 
@@ -1831,9 +2260,9 @@ out:
         if (pcidev)
                 pci_dev_put(pcidev);
 
-        printk(KERN_INFO DRV_PFX "detected Type%d model\n",
-                        dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
-                        dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
+        pr_info("detected Type%d model\n",
+                dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
+                dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
 }
 
 /* camera tests and poweron/poweroff */
@@ -1879,7 +2308,7 @@ static int __sony_pic_camera_ready(void)
 static int __sony_pic_camera_off(void)
 {
         if (!camera) {
-                printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
+                pr_warn("camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -1899,7 +2328,7 @@ static int __sony_pic_camera_on(void)
         int i, j, x;
 
         if (!camera) {
-                printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
+                pr_warn("camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -1922,7 +2351,7 @@ static int __sony_pic_camera_on(void)
         }
 
         if (j == 0) {
-                printk(KERN_WARNING DRV_PFX "failed to power on camera\n");
+                pr_warn("failed to power on camera\n");
                 return -ENODEV;
         }
 
@@ -1978,8 +2407,7 @@ int sony_pic_camera_command(int command, u8 value)
                                 ITERATIONS_SHORT);
                 break;
         default:
-                printk(KERN_ERR DRV_PFX "sony_pic_camera_command invalid: %d\n",
-                       command);
+                pr_err("sony_pic_camera_command invalid: %d\n", command);
                 break;
         }
         mutex_unlock(&spic_dev.lock);
@@ -2236,7 +2664,7 @@ static long sonypi_misc_ioctl(struct file *fp, unsigned int cmd,
         mutex_lock(&spic_dev.lock);
         switch (cmd) {
         case SONYPI_IOCGBRT:
-                if (sony_backlight_device == NULL) {
+                if (sony_bl_props.dev == NULL) {
                         ret = -EIO;
                         break;
                 }
@@ -2249,7 +2677,7 @@ static long sonypi_misc_ioctl(struct file *fp, unsigned int cmd,
                                 ret = -EFAULT;
                 break;
         case SONYPI_IOCSBRT:
-                if (sony_backlight_device == NULL) {
+                if (sony_bl_props.dev == NULL) {
                         ret = -EIO;
                         break;
                 }
@@ -2263,8 +2691,8 @@ static long sonypi_misc_ioctl(struct file *fp, unsigned int cmd,
                         break;
                 }
                 /* sync the backlight device status */
-                sony_backlight_device->props.brightness =
-                    sony_backlight_get_brightness(sony_backlight_device);
+                sony_bl_props.dev->props.brightness =
+                    sony_backlight_get_brightness(sony_bl_props.dev);
                 break;
         case SONYPI_IOCGBAT1CAP:
                 if (ec_read16(SONYPI_BAT1_FULL, &val16)) {
@@ -2360,6 +2788,7 @@ static const struct file_operations sonypi_misc_fops = {
         .release        = sonypi_misc_release,
         .fasync         = sonypi_misc_fasync,
         .unlocked_ioctl = sonypi_misc_ioctl,
+        .llseek         = noop_llseek,
 };
 
 static struct miscdevice sonypi_misc_device = {
@@ -2384,7 +2813,7 @@ static int sonypi_compat_init(void)
         error =
          kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 return error;
         }
 
@@ -2394,12 +2823,12 @@ static int sonypi_compat_init(void)
                 sonypi_misc_device.minor = minor;
         error = misc_register(&sonypi_misc_device);
         if (error) {
-                printk(KERN_ERR DRV_PFX "misc_register failed\n");
+                pr_err("misc_register failed\n");
                 goto err_free_kfifo;
         }
         if (minor == -1)
-                printk(KERN_INFO DRV_PFX "device allocated minor is %d\n",
-                       sonypi_misc_device.minor);
+                pr_info("device allocated minor is %d\n",
+                        sonypi_misc_device.minor);
 
         return 0;
 
@@ -2458,9 +2887,8 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                         }
                         for (i = 0; i < p->interrupt_count; i++) {
                                 if (!p->interrupts[i]) {
-                                        printk(KERN_WARNING DRV_PFX
-                                                        "Invalid IRQ %d\n",
-                                                        p->interrupts[i]);
+                                        pr_warn("Invalid IRQ %d\n",
+                                                p->interrupts[i]);
                                         continue;
                                 }
                                 interrupt = kzalloc(sizeof(*interrupt),
@@ -2498,14 +2926,14 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                                                 ioport->io2.address_length);
                         }
                         else {
-                                printk(KERN_ERR DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
+                                pr_err("Unknown SPIC Type, more than 2 IO Ports\n");
                                 return AE_ERROR;
                         }
                         return AE_OK;
                 }
         default:
                 dprintk("Resource %d isn't an IRQ nor an IO port\n",
-                                resource->type);
+                        resource->type);
 
         case ACPI_RESOURCE_TYPE_END_TAG:
                 return AE_OK;
@@ -2526,7 +2954,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         dprintk("Evaluating _STA\n");
         result = acpi_bus_get_status(device);
         if (result) {
-                printk(KERN_WARNING DRV_PFX "Unable to read status\n");
+                pr_warn("Unable to read status\n");
                 goto end;
         }
 
@@ -2542,9 +2970,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         status = acpi_walk_resources(device->handle, METHOD_NAME__PRS,
                         sony_pic_read_possible_resource, &spic_dev);
         if (ACPI_FAILURE(status)) {
-                printk(KERN_WARNING DRV_PFX
-                                "Failure evaluating %s\n",
-                                METHOD_NAME__PRS);
+                pr_warn("Failure evaluating %s\n", METHOD_NAME__PRS);
                 result = -ENODEV;
         }
 end:
@@ -2657,7 +3083,7 @@ static int sony_pic_enable(struct acpi_device *device,
 
         /* check for total failure */
         if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR DRV_PFX "Error evaluating _SRS\n");
+                pr_err("Error evaluating _SRS\n");
                 result = -ENODEV;
                 goto end;
         }
@@ -2713,6 +3139,9 @@ static irqreturn_t sony_pic_irq(int irq, void *dev_id)
                         if (ev == dev->event_types[i].events[j].data) {
                                 device_event =
                                         dev->event_types[i].events[j].event;
+                                /* some events may require ignoring */
+                                if (!device_event)
+                                        return IRQ_HANDLED;
                                 goto found;
                         }
                 }
@@ -2732,7 +3161,6 @@ found:
         sony_laptop_report_input_event(device_event);
         acpi_bus_generate_proc_event(dev->acpi_dev, 1, device_event);
         sonypi_compat_report_event(device_event);
-
         return IRQ_HANDLED;
 }
 
@@ -2747,7 +3175,7 @@ static int sony_pic_remove(struct acpi_device *device, int type)
         struct sony_pic_irq *irq, *tmp_irq;
 
         if (sony_pic_disable(device)) {
-                printk(KERN_ERR DRV_PFX "Couldn't disable device.\n");
+                pr_err("Couldn't disable device\n");
                 return -ENXIO;
         }
 
@@ -2787,8 +3215,7 @@ static int sony_pic_add(struct acpi_device *device)
         struct sony_pic_ioport *io, *tmp_io;
         struct sony_pic_irq *irq, *tmp_irq;
 
-        printk(KERN_INFO DRV_PFX "%s v%s.\n",
-                SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
+        pr_info("%s v%s\n", SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
 
         spic_dev.acpi_dev = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -2798,16 +3225,14 @@ static int sony_pic_add(struct acpi_device *device)
         /* read _PRS resources */
         result = sony_pic_possible_resources(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to read possible resources.\n");
+                pr_err("Unable to read possible resources\n");
                 goto err_free_resources;
         }
 
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to create input devices.\n");
+                pr_err("Unable to create input devices\n");
                 goto err_free_resources;
         }
 
@@ -2817,7 +3242,7 @@ static int sony_pic_add(struct acpi_device *device)
         /* request io port */
         list_for_each_entry_reverse(io, &spic_dev.ioports, list) {
                 if (request_region(io->io1.minimum, io->io1.address_length,
-                                        "Sony Programable I/O Device")) {
+                                        "Sony Programmable I/O Device")) {
                         dprintk("I/O port1: 0x%.4x (0x%.4x) + 0x%.2x\n",
                                         io->io1.minimum, io->io1.maximum,
                                         io->io1.address_length);
@@ -2825,7 +3250,7 @@ static int sony_pic_add(struct acpi_device *device)
                         if (io->io2.minimum) {
                                 if (request_region(io->io2.minimum,
                                                 io->io2.address_length,
-                                                "Sony Programable I/O Device")) {
+                                                "Sony Programmable I/O Device")) {
                                         dprintk("I/O port2: 0x%.4x (0x%.4x) + 0x%.2x\n",
                                                         io->io2.minimum, io->io2.maximum,
                                                         io->io2.address_length);
@@ -2848,7 +3273,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_ioport) {
-                printk(KERN_ERR DRV_PFX "Failed to request_region.\n");
+                pr_err("Failed to request_region\n");
                 result = -ENODEV;
                 goto err_remove_compat;
         }
@@ -2868,7 +3293,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_irq) {
-                printk(KERN_ERR DRV_PFX "Failed to request_irq.\n");
+                pr_err("Failed to request_irq\n");
                 result = -ENODEV;
                 goto err_release_region;
         }
@@ -2876,7 +3301,7 @@ static int sony_pic_add(struct acpi_device *device)
         /* set resource status _SRS */
         result = sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
         if (result) {
-                printk(KERN_ERR DRV_PFX "Couldn't enable device.\n");
+                pr_err("Couldn't enable device\n");
                 goto err_free_irq;
         }
 
@@ -2985,8 +3410,7 @@ static int __init sony_laptop_init(void)
         if (!no_spic && dmi_check_system(sonypi_dmi_table)) {
                 result = acpi_bus_register_driver(&sony_pic_driver);
                 if (result) {
-                        printk(KERN_ERR DRV_PFX
-                                        "Unable to register SPIC driver.");
+                        pr_err("Unable to register SPIC driver\n");
                         goto out;
                 }
                 spic_drv_registered = 1;
@@ -2994,7 +3418,7 @@ static int __init sony_laptop_init(void)
 
         result = acpi_bus_register_driver(&sony_nc_driver);
         if (result) {
-                printk(KERN_ERR DRV_PFX "Unable to register SNC driver.");
+                pr_err("Unable to register SNC driver\n");
                 goto out_unregister_pic;
         }
 
diff --git a/drivers/platform/x86/tc1100-wmi.c b/drivers/platform/x86/tc1100-wmi.c
index 1fe0f1feff71..e24f5ae475af 100644
--- a/drivers/platform/x86/tc1100-wmi.c
+++ b/drivers/platform/x86/tc1100-wmi.c
@@ -25,6 +25,8 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -40,9 +42,6 @@
 #define TC1100_INSTANCE_WIRELESS                1
 #define TC1100_INSTANCE_JOGDIAL         2
 
-#define TC1100_LOGPREFIX "tc1100-wmi: "
-#define TC1100_INFO KERN_INFO TC1100_LOGPREFIX
-
 MODULE_AUTHOR("Jamey Hicks, Carlos Corbacho");
 MODULE_DESCRIPTION("HP Compaq TC1100 Tablet WMI Extras");
 MODULE_LICENSE("GPL");
@@ -162,7 +161,7 @@ set_bool_##value(struct device *dev, struct device_attribute *attr, \
                         return -EINVAL; \
         return count; \
 } \
-static DEVICE_ATTR(value, S_IWUGO | S_IRUGO | S_IWUSR, \
+static DEVICE_ATTR(value, S_IRUGO | S_IWUSR, \
         show_bool_##value, set_bool_##value);
 
 show_set_bool(wireless, TC1100_INSTANCE_WIRELESS);
@@ -264,7 +263,7 @@ static int __init tc1100_init(void)
         if (error)
                 goto err_device_del;
 
-        printk(TC1100_INFO "HP Compaq TC1100 Tablet WMI Extras loaded\n");
+        pr_info("HP Compaq TC1100 Tablet WMI Extras loaded\n");
         return 0;
 
  err_device_del:
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 2d61186ad5a2..26c5b117df22 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -21,6 +21,8 @@
  *  02110-1301, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define TPACPI_VERSION "0.24"
 #define TPACPI_SYSFS_VERSION 0x020700
 
@@ -128,7 +130,8 @@ enum {
 };
 
 /* ACPI HIDs */
-#define TPACPI_ACPI_HKEY_HID            "IBM0068"
+#define TPACPI_ACPI_IBM_HKEY_HID        "IBM0068"
+#define TPACPI_ACPI_LENOVO_HKEY_HID     "LEN0068"
 #define TPACPI_ACPI_EC_HID              "PNP0C09"
 
 /* Input IDs */
@@ -181,6 +184,10 @@ enum tpacpi_hkey_event_t {
 
         /* Misc bay events */
         TP_HKEY_EV_OPTDRV_EJ            = 0x3006, /* opt. drive tray ejected */
+        TP_HKEY_EV_HOTPLUG_DOCK         = 0x4010, /* docked into hotplug dock
+                                                     or port replicator */
+        TP_HKEY_EV_HOTPLUG_UNDOCK       = 0x4011, /* undocked from hotplug
+                                                     dock or port replicator */
 
         /* User-interface events */
         TP_HKEY_EV_LID_CLOSE            = 0x5001, /* laptop lid closed */
@@ -191,6 +198,10 @@ enum tpacpi_hkey_event_t {
         TP_HKEY_EV_PEN_REMOVED          = 0x500c, /* tablet pen removed */
         TP_HKEY_EV_BRGHT_CHANGED        = 0x5010, /* backlight control event */
 
+        /* Key-related user-interface events */
+        TP_HKEY_EV_KEY_NUMLOCK          = 0x6000, /* NumLock key pressed */
+        TP_HKEY_EV_KEY_FN               = 0x6005, /* Fn key pressed? E420 */
+
         /* Thermal events */
         TP_HKEY_EV_ALARM_BAT_HOT        = 0x6011, /* battery too hot */
         TP_HKEY_EV_ALARM_BAT_XHOT       = 0x6012, /* battery critically hot */
@@ -198,6 +209,10 @@ enum tpacpi_hkey_event_t {
         TP_HKEY_EV_ALARM_SENSOR_XHOT    = 0x6022, /* sensor critically hot */
         TP_HKEY_EV_THM_TABLE_CHANGED    = 0x6030, /* thermal table changed */
 
+        TP_HKEY_EV_UNK_6040             = 0x6040, /* Related to AC change?
+                                                     some sort of APM hint,
+                                                     W520 */
+
         /* Misc */
         TP_HKEY_EV_RFKILL_CHANGED       = 0x7000, /* rfkill switch changed */
 };
@@ -223,17 +238,6 @@ enum tpacpi_hkey_event_t {
 
 #define TPACPI_MAX_ACPI_ARGS 3
 
-/* printk headers */
-#define TPACPI_LOG TPACPI_FILE ": "
-#define TPACPI_EMERG    KERN_EMERG      TPACPI_LOG
-#define TPACPI_ALERT    KERN_ALERT      TPACPI_LOG
-#define TPACPI_CRIT     KERN_CRIT       TPACPI_LOG
-#define TPACPI_ERR      KERN_ERR        TPACPI_LOG
-#define TPACPI_WARN     KERN_WARNING    TPACPI_LOG
-#define TPACPI_NOTICE   KERN_NOTICE     TPACPI_LOG
-#define TPACPI_INFO     KERN_INFO       TPACPI_LOG
-#define TPACPI_DEBUG    KERN_DEBUG      TPACPI_LOG
-
 /* Debugging printk groups */
 #define TPACPI_DBG_ALL          0xffff
 #define TPACPI_DBG_DISCLOSETASK 0x8000
@@ -388,34 +392,36 @@ static int tpacpi_uwb_emulstate;
  *  Debugging helpers
  */
 
-#define dbg_printk(a_dbg_level, format, arg...) \
-        do { if (dbg_level & (a_dbg_level)) \
-                printk(TPACPI_DEBUG "%s: " format, __func__ , ## arg); \
-        } while (0)
+#define dbg_printk(a_dbg_level, format, arg...)                         \
+do {                                                                    \
+        if (dbg_level & (a_dbg_level))                                  \
+                printk(KERN_DEBUG pr_fmt("%s: " format),                \
+                       __func__, ##arg);                                \
+} while (0)
 
 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
 #define vdbg_printk dbg_printk
 static const char *str_supported(int is_supported);
 #else
-#define vdbg_printk(a_dbg_level, format, arg...) \
-        do { } while (0)
+static inline const char *str_supported(int is_supported) { return ""; }
+#define vdbg_printk(a_dbg_level, format, arg...)        \
+        no_printk(format, ##arg)
 #endif
 
 static void tpacpi_log_usertask(const char * const what)
 {
-        printk(TPACPI_DEBUG "%s: access by process with PID %d\n",
-                what, task_tgid_vnr(current));
+        printk(KERN_DEBUG pr_fmt("%s: access by process with PID %d\n"),
+               what, task_tgid_vnr(current));
 }
 
-#define tpacpi_disclose_usertask(what, format, arg...) \
-        do { \
-                if (unlikely( \
-                    (dbg_level & TPACPI_DBG_DISCLOSETASK) && \
-                    (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) { \
-                        printk(TPACPI_DEBUG "%s: PID %d: " format, \
-                                what, task_tgid_vnr(current), ## arg); \
-                } \
-        } while (0)
+#define tpacpi_disclose_usertask(what, format, arg...)                  \
+do {                                                                    \
+        if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) &&           \
+                     (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) {      \
+                printk(KERN_DEBUG pr_fmt("%s: PID %d: " format),        \
+                       what, task_tgid_vnr(current), ## arg);           \
+        }                                                               \
+} while (0)
 
 /*
  * Quirk handling helpers
@@ -534,15 +540,6 @@ TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",	/* 600e/x, 770e, 770x */
            "HKEY",              /* all others */
            );                   /* 570 */
 
-TPACPI_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA",   /* 570 */
-           "\\_SB.PCI0.AGP0.VID0",      /* 600e/x, 770x */
-           "\\_SB.PCI0.VID0",   /* 770e */
-           "\\_SB.PCI0.VID",    /* A21e, G4x, R50e, X30, X40 */
-           "\\_SB.PCI0.AGP.VGA",        /* X100e and a few others */
-           "\\_SB.PCI0.AGP.VID",        /* all others */
-           );                           /* R30, R31 */
-
-
 /*************************************************************************
  * ACPI helpers
  */
@@ -562,7 +559,7 @@ static int acpi_evalf(acpi_handle handle,
         int quiet;
 
         if (!*fmt) {
-                printk(TPACPI_ERR "acpi_evalf() called with empty format\n");
+                pr_err("acpi_evalf() called with empty format\n");
                 return 0;
         }
 
@@ -587,8 +584,9 @@ static int acpi_evalf(acpi_handle handle,
                         break;
                         /* add more types as needed */
                 default:
-                        printk(TPACPI_ERR "acpi_evalf() called "
+                        pr_err("acpi_evalf() called "
                                "with invalid format character '%c'\n", c);
+                        va_end(ap);
                         return 0;
                 }
         }
@@ -615,13 +613,13 @@ static int acpi_evalf(acpi_handle handle,
                 break;
                 /* add more types as needed */
         default:
-                printk(TPACPI_ERR "acpi_evalf() called "
+                pr_err("acpi_evalf() called "
                        "with invalid format character '%c'\n", res_type);
                 return 0;
         }
 
         if (!success && !quiet)
-                printk(TPACPI_ERR "acpi_evalf(%s, %s, ...) failed: %s\n",
+                pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
                        method, fmt0, acpi_format_exception(status));
 
         return success;
@@ -765,8 +763,7 @@ static int __init setup_acpi_notify(struct ibm_struct *ibm)
 
         rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
         if (rc < 0) {
-                printk(TPACPI_ERR "acpi_bus_get_device(%s) failed: %d\n",
-                        ibm->name, rc);
+                pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm->name, rc);
                 return -ENODEV;
         }
 
@@ -779,12 +776,10 @@ static int __init setup_acpi_notify(struct ibm_struct *ibm)
                         ibm->acpi->type, dispatch_acpi_notify, ibm);
         if (ACPI_FAILURE(status)) {
                 if (status == AE_ALREADY_EXISTS) {
-                        printk(TPACPI_NOTICE
-                               "another device driver is already "
-                               "handling %s events\n", ibm->name);
+                        pr_notice("another device driver is already "
+                                  "handling %s events\n", ibm->name);
                 } else {
-                        printk(TPACPI_ERR
-                               "acpi_install_notify_handler(%s) failed: %s\n",
+                        pr_err("acpi_install_notify_handler(%s) failed: %s\n",
                                ibm->name, acpi_format_exception(status));
                 }
                 return -ENODEV;
@@ -809,8 +804,7 @@ static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 
         ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
         if (!ibm->acpi->driver) {
-                printk(TPACPI_ERR
-                       "failed to allocate memory for ibm->acpi->driver\n");
+                pr_err("failed to allocate memory for ibm->acpi->driver\n");
                 return -ENOMEM;
         }
 
@@ -821,7 +815,7 @@ static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 
         rc = acpi_bus_register_driver(ibm->acpi->driver);
         if (rc < 0) {
-                printk(TPACPI_ERR "acpi_bus_register_driver(%s) failed: %d\n",
+                pr_err("acpi_bus_register_driver(%s) failed: %d\n",
                        ibm->name, rc);
                 kfree(ibm->acpi->driver);
                 ibm->acpi->driver = NULL;
@@ -1079,15 +1073,14 @@ static int parse_strtoul(const char *buf,
 static void tpacpi_disable_brightness_delay(void)
 {
         if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
-                printk(TPACPI_NOTICE
-                        "ACPI backlight control delay disabled\n");
+                pr_notice("ACPI backlight control delay disabled\n");
 }
 
 static void printk_deprecated_attribute(const char * const what,
                                         const char * const details)
 {
         tpacpi_log_usertask("deprecated sysfs attribute");
-        printk(TPACPI_WARN "WARNING: sysfs attribute %s is deprecated and "
+        pr_warn("WARNING: sysfs attribute %s is deprecated and "
                 "will be removed. %s\n",
                 what, details);
 }
@@ -1262,8 +1255,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
                                                 &tpacpi_rfk_rfkill_ops,
                                                 atp_rfk);
         if (!atp_rfk || !atp_rfk->rfkill) {
-                printk(TPACPI_ERR
-                        "failed to allocate memory for rfkill class\n");
+                pr_err("failed to allocate memory for rfkill class\n");
                 kfree(atp_rfk);
                 return -ENOMEM;
         }
@@ -1273,9 +1265,8 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         sw_status = (tp_rfkops->get_status)();
         if (sw_status < 0) {
-                printk(TPACPI_ERR
-                        "failed to read initial state for %s, error %d\n",
-                        name, sw_status);
+                pr_err("failed to read initial state for %s, error %d\n",
+                       name, sw_status);
         } else {
                 sw_state = (sw_status == TPACPI_RFK_RADIO_OFF);
                 if (set_default) {
@@ -1289,9 +1280,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         res = rfkill_register(atp_rfk->rfkill);
         if (res < 0) {
-                printk(TPACPI_ERR
-                        "failed to register %s rfkill switch: %d\n",
-                        name, res);
+                pr_err("failed to register %s rfkill switch: %d\n", name, res);
                 rfkill_destroy(atp_rfk->rfkill);
                 kfree(atp_rfk);
                 return res;
@@ -1299,7 +1288,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         tpacpi_rfkill_switches[id] = atp_rfk;
 
-        printk(TPACPI_INFO "rfkill switch %s: radio is %sblocked\n",
+        pr_info("rfkill switch %s: radio is %sblocked\n",
                 name, (sw_state || hw_state) ? "" : "un");
         return 0;
 }
@@ -1823,10 +1812,8 @@ static void __init tpacpi_check_outdated_fw(void)
                  * broken, or really stable to begin with, so it is
                  * best if the user upgrades the firmware anyway.
                  */
-                printk(TPACPI_WARN
-                        "WARNING: Outdated ThinkPad BIOS/EC firmware\n");
-                printk(TPACPI_WARN
-                        "WARNING: This firmware may be missing critical bug "
+                pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
+                pr_warn("WARNING: This firmware may be missing critical bug "
                         "fixes and/or important features\n");
         }
 }
@@ -2115,9 +2102,7 @@ void static hotkey_mask_warn_incomplete_mask(void)
                 (hotkey_all_mask | TPACPI_HKEY_NVRAM_KNOWN_MASK);
 
         if (wantedmask)
-                printk(TPACPI_NOTICE
-                        "required events 0x%08x not enabled!\n",
-                        wantedmask);
+                pr_notice("required events 0x%08x not enabled!\n", wantedmask);
 }
 
 /*
@@ -2155,10 +2140,9 @@ static int hotkey_mask_set(u32 mask)
          * a given event.
          */
         if (!hotkey_mask_get() && !rc && (fwmask & ~hotkey_acpi_mask)) {
-                printk(TPACPI_NOTICE
-                       "asked for hotkey mask 0x%08x, but "
-                       "firmware forced it to 0x%08x\n",
-                       fwmask, hotkey_acpi_mask);
+                pr_notice("asked for hotkey mask 0x%08x, but "
+                          "firmware forced it to 0x%08x\n",
+                          fwmask, hotkey_acpi_mask);
         }
 
         if (tpacpi_lifecycle != TPACPI_LIFE_EXITING)
@@ -2182,13 +2166,11 @@ static int hotkey_user_mask_set(const u32 mask)
             (mask == 0xffff || mask == 0xffffff ||
              mask == 0xffffffff)) {
                 tp_warned.hotkey_mask_ff = 1;
-                printk(TPACPI_NOTICE
-                       "setting the hotkey mask to 0x%08x is likely "
-                       "not the best way to go about it\n", mask);
-                printk(TPACPI_NOTICE
-                       "please consider using the driver defaults, "
-                       "and refer to up-to-date thinkpad-acpi "
-                       "documentation\n");
+                pr_notice("setting the hotkey mask to 0x%08x is likely "
+                          "not the best way to go about it\n", mask);
+                pr_notice("please consider using the driver defaults, "
+                          "and refer to up-to-date thinkpad-acpi "
+                          "documentation\n");
         }
 
         /* Try to enable what the user asked for, plus whatever we need.
@@ -2274,16 +2256,12 @@ static void tpacpi_input_send_key(const unsigned int scancode)
         if (keycode != KEY_RESERVED) {
                 mutex_lock(&tpacpi_inputdev_send_mutex);
 
+                input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
                 input_report_key(tpacpi_inputdev, keycode, 1);
-                if (keycode == KEY_UNKNOWN)
-                        input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
-                                    scancode);
                 input_sync(tpacpi_inputdev);
 
+                input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
                 input_report_key(tpacpi_inputdev, keycode, 0);
-                if (keycode == KEY_UNKNOWN)
-                        input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
-                                    scancode);
                 input_sync(tpacpi_inputdev);
 
                 mutex_unlock(&tpacpi_inputdev_send_mutex);
@@ -2410,7 +2388,7 @@ static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
          * This code is supposed to duplicate the IBM firmware behaviour:
          * - Pressing MUTE issues mute hotkey message, even when already mute
          * - Pressing Volume up/down issues volume up/down hotkey messages,
-         *   even when already at maximum or minumum volume
+         *   even when already at maximum or minimum volume
          * - The act of unmuting issues volume up/down notification,
          *   depending which key was used to unmute
          *
@@ -2576,8 +2554,7 @@ static void hotkey_poll_setup(const bool may_warn)
                                         NULL, TPACPI_NVRAM_KTHREAD_NAME);
                         if (IS_ERR(tpacpi_hotkey_task)) {
                                 tpacpi_hotkey_task = NULL;
-                                printk(TPACPI_ERR
-                                       "could not create kernel thread "
+                                pr_err("could not create kernel thread "
                                        "for hotkey polling\n");
                         }
                 }
@@ -2585,11 +2562,10 @@ static void hotkey_poll_setup(const bool may_warn)
                 hotkey_poll_stop_sync();
                 if (may_warn && (poll_driver_mask || poll_user_mask) &&
                     hotkey_poll_freq == 0) {
-                        printk(TPACPI_NOTICE
-                                "hot keys 0x%08x and/or events 0x%08x "
-                                "require polling, which is currently "
-                                "disabled\n",
-                                poll_user_mask, poll_driver_mask);
+                        pr_notice("hot keys 0x%08x and/or events 0x%08x "
+                                  "require polling, which is currently "
+                                  "disabled\n",
+                                  poll_user_mask, poll_driver_mask);
                 }
         }
 }
@@ -2813,13 +2789,13 @@ static ssize_t hotkey_source_mask_store(struct device *dev,
         mutex_unlock(&hotkey_mutex);
 
         if (rc < 0)
-                printk(TPACPI_ERR "hotkey_source_mask: failed to update the"
-                        "firmware event mask!\n");
+                pr_err("hotkey_source_mask: "
+                       "failed to update the firmware event mask!\n");
 
         if (r_ev)
-                printk(TPACPI_NOTICE "hotkey_source_mask: "
-                        "some important events were disabled: "
-                        "0x%04x\n", r_ev);
+                pr_notice("hotkey_source_mask: "
+                          "some important events were disabled: 0x%04x\n",
+                          r_ev);
 
         tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t);
 
@@ -2993,7 +2969,7 @@ static void tpacpi_send_radiosw_update(void)
          * rfkill input events, or we will race the rfkill core input
          * handler.
          *
-         * tpacpi_inputdev_send_mutex works as a syncronization point
+         * tpacpi_inputdev_send_mutex works as a synchronization point
          * for the above.
          *
          * We optimize to avoid numerous calls to hotkey_get_wlsw.
@@ -3050,8 +3026,7 @@ static void hotkey_exit(void)
         if (((tp_features.hotkey_mask &&
               hotkey_mask_set(hotkey_orig_mask)) |
              hotkey_status_set(false)) != 0)
-                printk(TPACPI_ERR
-                       "failed to restore hot key mask "
+                pr_err("failed to restore hot key mask "
                        "to BIOS defaults\n");
 }
 
@@ -3290,10 +3265,9 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
            for HKEY interface version 0x100 */
         if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
                 if ((hkeyv >> 8) != 1) {
-                        printk(TPACPI_ERR "unknown version of the "
-                               "HKEY interface: 0x%x\n", hkeyv);
-                        printk(TPACPI_ERR "please report this to %s\n",
-                               TPACPI_MAIL);
+                        pr_err("unknown version of the HKEY interface: 0x%x\n",
+                               hkeyv);
+                        pr_err("please report this to %s\n", TPACPI_MAIL);
                 } else {
                         /*
                          * MHKV 0x100 in A31, R40, R40e,
@@ -3306,8 +3280,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                         /* Paranoia check AND init hotkey_all_mask */
                         if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
                                         "MHKA", "qd")) {
-                                printk(TPACPI_ERR
-                                       "missing MHKA handler, "
+                                pr_err("missing MHKA handler, "
                                        "please report this to %s\n",
                                        TPACPI_MAIL);
                                 /* Fallback: pre-init for FN+F3,F4,F12 */
@@ -3345,16 +3318,14 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         if (dbg_wlswemul) {
                 tp_features.hotkey_wlsw = 1;
                 radiosw_state = !!tpacpi_wlsw_emulstate;
-                printk(TPACPI_INFO
-                        "radio switch emulation enabled\n");
+                pr_info("radio switch emulation enabled\n");
         } else
 #endif
         /* Not all thinkpads have a hardware radio switch */
         if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
                 tp_features.hotkey_wlsw = 1;
                 radiosw_state = !!status;
-                printk(TPACPI_INFO
-                        "radio switch found; radios are %s\n",
+                pr_info("radio switch found; radios are %s\n",
                         enabled(status, 0));
         }
         if (tp_features.hotkey_wlsw)
@@ -3365,8 +3336,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         if (!res && acpi_evalf(hkey_handle, &status, "MHKG", "qd")) {
                 tp_features.hotkey_tablet = 1;
                 tabletsw_state = !!(status & TP_HOTKEY_TABLET_MASK);
-                printk(TPACPI_INFO
-                        "possible tablet mode switch found; "
+                pr_info("possible tablet mode switch found; "
                         "ThinkPad in %s mode\n",
                         (tabletsw_state) ? "tablet" : "laptop");
                 res = add_to_attr_set(hotkey_dev_attributes,
@@ -3384,8 +3354,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE,
                                         GFP_KERNEL);
         if (!hotkey_keycode_map) {
-                printk(TPACPI_ERR
-                        "failed to allocate memory for key map\n");
+                pr_err("failed to allocate memory for key map\n");
                 res = -ENOMEM;
                 goto err_exit;
         }
@@ -3428,13 +3397,11 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
          * userspace. tpacpi_detect_brightness_capabilities() must have
          * been called before this point  */
         if (tp_features.bright_acpimode && acpi_video_backlight_support()) {
-                printk(TPACPI_INFO
-                       "This ThinkPad has standard ACPI backlight "
-                       "brightness control, supported by the ACPI "
-                       "video driver\n");
-                printk(TPACPI_NOTICE
-                       "Disabling thinkpad-acpi brightness events "
-                       "by default...\n");
+                pr_info("This ThinkPad has standard ACPI backlight "
+                        "brightness control, supported by the ACPI "
+                        "video driver\n");
+                pr_notice("Disabling thinkpad-acpi brightness events "
+                          "by default...\n");
 
                 /* Disable brightness up/down on Lenovo thinkpads when
                  * ACPI is handling them, otherwise it is plain impossible
@@ -3541,8 +3508,7 @@ static bool hotkey_notify_wakeup(const u32 hkey,
 
         case TP_HKEY_EV_WKUP_S3_BATLOW: /* Battery on critical low level/S3 */
         case TP_HKEY_EV_WKUP_S4_BATLOW: /* Battery on critical low level/S4 */
-                printk(TPACPI_ALERT
-                        "EMERGENCY WAKEUP: battery almost empty\n");
+                pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
                 /* how to auto-heal: */
                 /* 2313: woke up from S3, go to S4/S5 */
                 /* 2413: woke up from S4, go to S5 */
@@ -3553,14 +3519,40 @@ static bool hotkey_notify_wakeup(const u32 hkey,
         }
 
         if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
-                printk(TPACPI_INFO
-                       "woke up due to a hot-unplug "
-                       "request...\n");
+                pr_info("woke up due to a hot-unplug request...\n");
                 hotkey_wakeup_reason_notify_change();
         }
         return true;
 }
 
+static bool hotkey_notify_dockevent(const u32 hkey,
+                                 bool *send_acpi_ev,
+                                 bool *ignore_acpi_ev)
+{
+        /* 0x4000-0x4FFF: dock-related events */
+        *send_acpi_ev = true;
+        *ignore_acpi_ev = false;
+
+        switch (hkey) {
+        case TP_HKEY_EV_UNDOCK_ACK:
+                /* ACPI undock operation completed after wakeup */
+                hotkey_autosleep_ack = 1;
+                pr_info("undocked\n");
+                hotkey_wakeup_hotunplug_complete_notify_change();
+                return true;
+
+        case TP_HKEY_EV_HOTPLUG_DOCK: /* docked to port replicator */
+                pr_info("docked into hotplug port replicator\n");
+                return true;
+        case TP_HKEY_EV_HOTPLUG_UNDOCK: /* undocked from port replicator */
+                pr_info("undocked from hotplug port replicator\n");
+                return true;
+
+        default:
+                return false;
+        }
+}
+
 static bool hotkey_notify_usrevent(const u32 hkey,
                                  bool *send_acpi_ev,
                                  bool *ignore_acpi_ev)
@@ -3595,49 +3587,52 @@ static bool hotkey_notify_usrevent(const u32 hkey,
 
 static void thermal_dump_all_sensors(void);
 
-static bool hotkey_notify_thermal(const u32 hkey,
+static bool hotkey_notify_6xxx(const u32 hkey,
                                  bool *send_acpi_ev,
                                  bool *ignore_acpi_ev)
 {
         bool known = true;
 
-        /* 0x6000-0x6FFF: thermal alarms */
+        /* 0x6000-0x6FFF: thermal alarms/notices and keyboard events */
         *send_acpi_ev = true;
         *ignore_acpi_ev = false;
 
         switch (hkey) {
         case TP_HKEY_EV_THM_TABLE_CHANGED:
-                printk(TPACPI_INFO
-                        "EC reports that Thermal Table has changed\n");
+                pr_info("EC reports that Thermal Table has changed\n");
                 /* recommended action: do nothing, we don't have
                  * Lenovo ATM information */
                 return true;
         case TP_HKEY_EV_ALARM_BAT_HOT:
-                printk(TPACPI_CRIT
-                        "THERMAL ALARM: battery is too hot!\n");
+                pr_crit("THERMAL ALARM: battery is too hot!\n");
                 /* recommended action: warn user through gui */
                 break;
         case TP_HKEY_EV_ALARM_BAT_XHOT:
-                printk(TPACPI_ALERT
-                        "THERMAL EMERGENCY: battery is extremely hot!\n");
+                pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
                 /* recommended action: immediate sleep/hibernate */
                 break;
         case TP_HKEY_EV_ALARM_SENSOR_HOT:
-                printk(TPACPI_CRIT
-                        "THERMAL ALARM: "
+                pr_crit("THERMAL ALARM: "
                         "a sensor reports something is too hot!\n");
                 /* recommended action: warn user through gui, that */
                 /* some internal component is too hot */
                 break;
         case TP_HKEY_EV_ALARM_SENSOR_XHOT:
-                printk(TPACPI_ALERT
-                        "THERMAL EMERGENCY: "
-                        "a sensor reports something is extremely hot!\n");
+                pr_alert("THERMAL EMERGENCY: "
+                         "a sensor reports something is extremely hot!\n");
                 /* recommended action: immediate sleep/hibernate */
                 break;
+
+        case TP_HKEY_EV_KEY_NUMLOCK:
+        case TP_HKEY_EV_KEY_FN:
+                /* key press events, we just ignore them as long as the EC
+                 * is still reporting them in the normal keyboard stream */
+                *send_acpi_ev = false;
+                *ignore_acpi_ev = true;
+                return true;
+
         default:
-                printk(TPACPI_ALERT
-                         "THERMAL ALERT: unknown thermal alarm received\n");
+                pr_warn("unknown possible thermal alarm or keyboard event received\n");
                 known = false;
         }
 
@@ -3654,8 +3649,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
         bool known_ev;
 
         if (event != 0x80) {
-                printk(TPACPI_ERR
-                       "unknown HKEY notification event %d\n", event);
+                pr_err("unknown HKEY notification event %d\n", event);
                 /* forward it to userspace, maybe it knows how to handle it */
                 acpi_bus_generate_netlink_event(
                                         ibm->acpi->device->pnp.device_class,
@@ -3666,7 +3660,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
 
         while (1) {
                 if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
-                        printk(TPACPI_ERR "failed to retrieve HKEY event\n");
+                        pr_err("failed to retrieve HKEY event\n");
                         return;
                 }
 
@@ -3694,8 +3688,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         switch (hkey) {
                         case TP_HKEY_EV_BAYEJ_ACK:
                                 hotkey_autosleep_ack = 1;
-                                printk(TPACPI_INFO
-                                       "bay ejected\n");
+                                pr_info("bay ejected\n");
                                 hotkey_wakeup_hotunplug_complete_notify_change();
                                 known_ev = true;
                                 break;
@@ -3708,16 +3701,9 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         }
                         break;
                 case 4:
-                        /* 0x4000-0x4FFF: dock-related wakeups */
-                        if (hkey == TP_HKEY_EV_UNDOCK_ACK) {
-                                hotkey_autosleep_ack = 1;
-                                printk(TPACPI_INFO
-                                       "undocked\n");
-                                hotkey_wakeup_hotunplug_complete_notify_change();
-                                known_ev = true;
-                        } else {
-                                known_ev = false;
-                        }
+                        /* 0x4000-0x4FFF: dock-related events */
+                        known_ev = hotkey_notify_dockevent(hkey, &send_acpi_ev,
+                                                &ignore_acpi_ev);
                         break;
                 case 5:
                         /* 0x5000-0x5FFF: human interface helpers */
@@ -3725,8 +3711,9 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                                                  &ignore_acpi_ev);
                         break;
                 case 6:
-                        /* 0x6000-0x6FFF: thermal alarms */
-                        known_ev = hotkey_notify_thermal(hkey, &send_acpi_ev,
+                        /* 0x6000-0x6FFF: thermal alarms/notices and
+                         *                keyboard events */
+                        known_ev = hotkey_notify_6xxx(hkey, &send_acpi_ev,
                                                  &ignore_acpi_ev);
                         break;
                 case 7:
@@ -3743,11 +3730,9 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         known_ev = false;
                 }
                 if (!known_ev) {
-                        printk(TPACPI_NOTICE
-                               "unhandled HKEY event 0x%04x\n", hkey);
-                        printk(TPACPI_NOTICE
-                               "please report the conditions when this "
-                               "event happened to %s\n", TPACPI_MAIL);
+                        pr_notice("unhandled HKEY event 0x%04x\n", hkey);
+                        pr_notice("please report the conditions when this "
+                                  "event happened to %s\n", TPACPI_MAIL);
                 }
 
                 /* Legacy events */
@@ -3780,8 +3765,7 @@ static void hotkey_resume(void)
 
         if (hotkey_status_set(true) < 0 ||
             hotkey_mask_set(hotkey_acpi_mask) < 0)
-                printk(TPACPI_ERR
-                       "error while attempting to reset the event "
+                pr_err("error while attempting to reset the event "
                        "firmware interface\n");
 
         tpacpi_send_radiosw_update();
@@ -3826,14 +3810,12 @@ static void hotkey_enabledisable_warn(bool enable)
 {
         tpacpi_log_usertask("procfs hotkey enable/disable");
         if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable),
-                        TPACPI_WARN
-                        "hotkey enable/disable functionality has been "
-                        "removed from the driver.  Hotkeys are always "
-                        "enabled\n"))
-                printk(TPACPI_ERR
-                        "Please remove the hotkey=enable module "
-                        "parameter, it is deprecated.  Hotkeys are always "
-                        "enabled\n");
+                  pr_fmt("hotkey enable/disable functionality has been "
+                         "removed from the driver.  "
+                         "Hotkeys are always enabled.\n")))
+                pr_err("Please remove the hotkey=enable module "
+                       "parameter, it is deprecated.  "
+                       "Hotkeys are always enabled.\n");
 }
 
 static int hotkey_write(char *buf)
@@ -3882,7 +3864,8 @@ errexit:
 }
 
 static const struct acpi_device_id ibm_htk_device_ids[] = {
-        {TPACPI_ACPI_HKEY_HID, 0},
+        {TPACPI_ACPI_IBM_HKEY_HID, 0},
+        {TPACPI_ACPI_LENOVO_HKEY_HID, 0},
         {"", 0},
 };
 
@@ -4012,8 +3995,7 @@ static void bluetooth_shutdown(void)
         /* Order firmware to save current state to NVRAM */
         if (!acpi_evalf(NULL, NULL, "\\BLTH", "vd",
                         TP_ACPI_BLTH_SAVE_STATE))
-                printk(TPACPI_NOTICE
-                        "failed to save bluetooth state to NVRAM\n");
+                pr_notice("failed to save bluetooth state to NVRAM\n");
         else
                 vdbg_printk(TPACPI_DBG_RFKILL,
                         "bluestooth state saved to NVRAM\n");
@@ -4052,8 +4034,7 @@ static int __init bluetooth_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_bluetoothemul) {
                 tp_features.bluetooth = 1;
-                printk(TPACPI_INFO
-                        "bluetooth switch emulation enabled\n");
+                pr_info("bluetooth switch emulation enabled\n");
         } else
 #endif
         if (tp_features.bluetooth &&
@@ -4204,8 +4185,7 @@ static void wan_shutdown(void)
         /* Order firmware to save current state to NVRAM */
         if (!acpi_evalf(NULL, NULL, "\\WGSV", "vd",
                         TP_ACPI_WGSV_SAVE_STATE))
-                printk(TPACPI_NOTICE
-                        "failed to save WWAN state to NVRAM\n");
+                pr_notice("failed to save WWAN state to NVRAM\n");
         else
                 vdbg_printk(TPACPI_DBG_RFKILL,
                         "WWAN state saved to NVRAM\n");
@@ -4242,8 +4222,7 @@ static int __init wan_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_wwanemul) {
                 tp_features.wan = 1;
-                printk(TPACPI_INFO
-                        "wwan switch emulation enabled\n");
+                pr_info("wwan switch emulation enabled\n");
         } else
 #endif
         if (tp_features.wan &&
@@ -4383,8 +4362,7 @@ static int __init uwb_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_uwbemul) {
                 tp_features.uwb = 1;
-                printk(TPACPI_INFO
-                        "uwb switch emulation enabled\n");
+                pr_info("uwb switch emulation enabled\n");
         } else
 #endif
         if (tp_features.uwb &&
@@ -4445,6 +4423,15 @@ static int video_orig_autosw;
 static int video_autosw_get(void);
 static int video_autosw_set(int enable);
 
+TPACPI_HANDLE(vid, root,
+              "\\_SB.PCI.AGP.VGA",      /* 570 */
+              "\\_SB.PCI0.AGP0.VID0",   /* 600e/x, 770x */
+              "\\_SB.PCI0.VID0",        /* 770e */
+              "\\_SB.PCI0.VID",         /* A21e, G4x, R50e, X30, X40 */
+              "\\_SB.PCI0.AGP.VGA",     /* X100e and a few others */
+              "\\_SB.PCI0.AGP.VID",     /* all others */
+        );                              /* R30, R31 */
+
 TPACPI_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID");       /* G41 */
 
 static int __init video_init(struct ibm_init_struct *iibm)
@@ -4488,7 +4475,7 @@ static void video_exit(void)
         dbg_printk(TPACPI_DBG_EXIT,
                    "restoring original video autoswitch mode\n");
         if (video_autosw_set(video_orig_autosw))
-                printk(TPACPI_ERR "error while trying to restore original "
+                pr_err("error while trying to restore original "
                         "video autoswitch mode\n");
 }
 
@@ -4561,8 +4548,7 @@ static int video_outputsw_set(int status)
                 res = acpi_evalf(vid_handle, NULL,
                                  "ASWT", "vdd", status * 0x100, 0);
                 if (!autosw && video_autosw_set(autosw)) {
-                        printk(TPACPI_ERR
-                               "video auto-switch left enabled due to error\n");
+                        pr_err("video auto-switch left enabled due to error\n");
                         return -EIO;
                 }
                 break;
@@ -4631,8 +4617,7 @@ static int video_outputsw_cycle(void)
                 return -ENOSYS;
         }
         if (!autosw && video_autosw_set(autosw)) {
-                printk(TPACPI_ERR
-                       "video auto-switch left enabled due to error\n");
+                pr_err("video auto-switch left enabled due to error\n");
                 return -EIO;
         }
 
@@ -5349,7 +5334,7 @@ static int __init led_init(struct ibm_init_struct *iibm)
         tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS,
                               GFP_KERNEL);
         if (!tpacpi_leds) {
-                printk(TPACPI_ERR "Out of memory for LED data\n");
+                pr_err("Out of memory for LED data\n");
                 return -ENOMEM;
         }
 
@@ -5368,9 +5353,8 @@ static int __init led_init(struct ibm_init_struct *iibm)
         }
 
 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
-        printk(TPACPI_NOTICE
-                "warning: userspace override of important "
-                "firmware LEDs is enabled\n");
+        pr_notice("warning: userspace override of important "
+                  "firmware LEDs is enabled\n");
 #endif
         return 0;
 }
@@ -5640,17 +5624,16 @@ static void thermal_dump_all_sensors(void)
         if (n <= 0)
                 return;
 
-        printk(TPACPI_NOTICE
-                "temperatures (Celsius):");
+        pr_notice("temperatures (Celsius):");
 
         for (i = 0; i < n; i++) {
                 if (t.temp[i] != TPACPI_THERMAL_SENSOR_NA)
-                        printk(KERN_CONT " %d", (int)(t.temp[i] / 1000));
+                        pr_cont(" %d", (int)(t.temp[i] / 1000));
                 else
-                        printk(KERN_CONT " N/A");
+                        pr_cont(" N/A");
         }
 
-        printk(KERN_CONT "\n");
+        pr_cont("\n");
 }
 
 /* sysfs temp##_input -------------------------------------------------- */
@@ -5770,14 +5753,12 @@ static int __init thermal_init(struct ibm_init_struct *iibm)
                 if (ta1 == 0) {
                         /* This is sheer paranoia, but we handle it anyway */
                         if (acpi_tmp7) {
-                                printk(TPACPI_ERR
-                                       "ThinkPad ACPI EC access misbehaving, "
+                                pr_err("ThinkPad ACPI EC access misbehaving, "
                                        "falling back to ACPI TMPx access "
                                        "mode\n");
                                 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
                         } else {
-                                printk(TPACPI_ERR
-                                       "ThinkPad ACPI EC access misbehaving, "
+                                pr_err("ThinkPad ACPI EC access misbehaving, "
                                        "disabling thermal sensors access\n");
                                 thermal_read_mode = TPACPI_THERMAL_NONE;
                         }
@@ -6109,7 +6090,7 @@ static void tpacpi_brightness_notify_change(void)
                                BACKLIGHT_UPDATE_HOTKEY);
 }
 
-static struct backlight_ops ibm_backlight_data = {
+static const struct backlight_ops ibm_backlight_data = {
         .get_brightness = brightness_get,
         .update_status  = brightness_update_status,
 };
@@ -6130,8 +6111,8 @@ static int __init tpacpi_query_bcl_levels(acpi_handle handle)
         if (ACPI_SUCCESS(acpi_evaluate_object(handle, "_BCL", NULL, &buffer))) {
                 obj = (union acpi_object *)buffer.pointer;
                 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
-                        printk(TPACPI_ERR "Unknown _BCL data, "
-                               "please report this to %s\n", TPACPI_MAIL);
+                        pr_err("Unknown _BCL data, please report this to %s\n",
+                               TPACPI_MAIL);
                         rc = 0;
                 } else {
                         rc = obj->package.count;
@@ -6215,18 +6196,15 @@ static void __init tpacpi_detect_brightness_capabilities(void)
         switch (b) {
         case 16:
                 bright_maxlvl = 15;
-                printk(TPACPI_INFO
-                       "detected a 16-level brightness capable ThinkPad\n");
+                pr_info("detected a 16-level brightness capable ThinkPad\n");
                 break;
         case 8:
         case 0:
                 bright_maxlvl = 7;
-                printk(TPACPI_INFO
-                       "detected a 8-level brightness capable ThinkPad\n");
+                pr_info("detected a 8-level brightness capable ThinkPad\n");
                 break;
         default:
-                printk(TPACPI_ERR
-                       "Unsupported brightness interface, "
+                pr_err("Unsupported brightness interface, "
                        "please contact %s\n", TPACPI_MAIL);
                 tp_features.bright_unkfw = 1;
                 bright_maxlvl = b - 1;
@@ -6261,22 +6239,19 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
 
         if (acpi_video_backlight_support()) {
                 if (brightness_enable > 1) {
-                        printk(TPACPI_INFO
-                               "Standard ACPI backlight interface "
-                               "available, not loading native one.\n");
+                        pr_info("Standard ACPI backlight interface "
+                                "available, not loading native one\n");
                         return 1;
                 } else if (brightness_enable == 1) {
-                        printk(TPACPI_WARN
-                                "Cannot enable backlight brightness support, "
+                        pr_warn("Cannot enable backlight brightness support, "
                                 "ACPI is already handling it.  Refer to the "
-                                "acpi_backlight kernel parameter\n");
+                                "acpi_backlight kernel parameter.\n");
                         return 1;
                 }
         } else if (tp_features.bright_acpimode && brightness_enable > 1) {
-                printk(TPACPI_NOTICE
-                        "Standard ACPI backlight interface not "
-                        "available, thinkpad_acpi native "
-                        "brightness control enabled\n");
+                pr_notice("Standard ACPI backlight interface not "
+                          "available, thinkpad_acpi native "
+                          "brightness control enabled\n");
         }
 
         /*
@@ -6310,6 +6285,7 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
                 return 1;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = bright_maxlvl;
         props.brightness = b & TP_EC_BACKLIGHT_LVLMSK;
         ibm_backlight_device = backlight_device_register(TPACPI_BACKLIGHT_DEV_NAME,
@@ -6319,19 +6295,17 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
         if (IS_ERR(ibm_backlight_device)) {
                 int rc = PTR_ERR(ibm_backlight_device);
                 ibm_backlight_device = NULL;
-                printk(TPACPI_ERR "Could not register backlight device\n");
+                pr_err("Could not register backlight device\n");
                 return rc;
         }
         vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
                         "brightness is supported\n");
 
         if (quirks & TPACPI_BRGHT_Q_ASK) {
-                printk(TPACPI_NOTICE
-                        "brightness: will use unverified default: "
-                        "brightness_mode=%d\n", brightness_mode);
-                printk(TPACPI_NOTICE
-                        "brightness: please report to %s whether it works well "
-                        "or not on your ThinkPad\n", TPACPI_MAIL);
+                pr_notice("brightness: will use unverified default: "
+                          "brightness_mode=%d\n", brightness_mode);
+                pr_notice("brightness: please report to %s whether it works well "
+                          "or not on your ThinkPad\n", TPACPI_MAIL);
         }
 
         /* Added by mistake in early 2007.  Probably useless, but it could
@@ -6345,7 +6319,7 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
                         "as change notification\n");
         tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
                                 | TP_ACPI_HKEY_BRGHTUP_MASK
-                                | TP_ACPI_HKEY_BRGHTDWN_MASK);;
+                                | TP_ACPI_HKEY_BRGHTDWN_MASK);
         return 0;
 }
 
@@ -6804,8 +6778,7 @@ static int __init volume_create_alsa_mixer(void)
         rc = snd_card_create(alsa_index, alsa_id, THIS_MODULE,
                             sizeof(struct tpacpi_alsa_data), &card);
         if (rc < 0 || !card) {
-                printk(TPACPI_ERR
-                        "Failed to create ALSA card structures: %d\n", rc);
+                pr_err("Failed to create ALSA card structures: %d\n", rc);
                 return 1;
         }
 
@@ -6839,9 +6812,8 @@ static int __init volume_create_alsa_mixer(void)
                 ctl_vol = snd_ctl_new1(&volume_alsa_control_vol, NULL);
                 rc = snd_ctl_add(card, ctl_vol);
                 if (rc < 0) {
-                        printk(TPACPI_ERR
-                                "Failed to create ALSA volume control: %d\n",
-                                rc);
+                        pr_err("Failed to create ALSA volume control: %d\n",
+                               rc);
                         goto err_exit;
                 }
                 data->ctl_vol_id = &ctl_vol->id;
@@ -6850,8 +6822,7 @@ static int __init volume_create_alsa_mixer(void)
         ctl_mute = snd_ctl_new1(&volume_alsa_control_mute, NULL);
         rc = snd_ctl_add(card, ctl_mute);
         if (rc < 0) {
-                printk(TPACPI_ERR "Failed to create ALSA mute control: %d\n",
-                        rc);
+                pr_err("Failed to create ALSA mute control: %d\n", rc);
                 goto err_exit;
         }
         data->ctl_mute_id = &ctl_mute->id;
@@ -6859,7 +6830,7 @@ static int __init volume_create_alsa_mixer(void)
         snd_card_set_dev(card, &tpacpi_pdev->dev);
         rc = snd_card_register(card);
         if (rc < 0) {
-                printk(TPACPI_ERR "Failed to register ALSA card: %d\n", rc);
+                pr_err("Failed to register ALSA card: %d\n", rc);
                 goto err_exit;
         }
 
@@ -6915,9 +6886,8 @@ static int __init volume_init(struct ibm_init_struct *iibm)
                 return -EINVAL;
 
         if (volume_mode == TPACPI_VOL_MODE_UCMS_STEP) {
-                printk(TPACPI_ERR
-                        "UCMS step volume mode not implemented, "
-                        "please contact %s\n", TPACPI_MAIL);
+                pr_err("UCMS step volume mode not implemented, "
+                       "please contact %s\n", TPACPI_MAIL);
                 return 1;
         }
 
@@ -6981,13 +6951,11 @@ static int __init volume_init(struct ibm_init_struct *iibm)
 
         rc = volume_create_alsa_mixer();
         if (rc) {
-                printk(TPACPI_ERR
-                        "Could not create the ALSA mixer interface\n");
+                pr_err("Could not create the ALSA mixer interface\n");
                 return rc;
         }
 
-        printk(TPACPI_INFO
-                "Console audio control enabled, mode: %s\n",
+        pr_info("Console audio control enabled, mode: %s\n",
                 (volume_control_allowed) ?
                         "override (read/write)" :
                         "monitor (read only)");
@@ -7049,12 +7017,10 @@ static int volume_write(char *buf)
         if (!volume_control_allowed && tpacpi_lifecycle != TPACPI_LIFE_INIT) {
                 if (unlikely(!tp_warned.volume_ctrl_forbidden)) {
                         tp_warned.volume_ctrl_forbidden = 1;
-                        printk(TPACPI_NOTICE
-                                "Console audio control in monitor mode, "
-                                "changes are not allowed.\n");
-                        printk(TPACPI_NOTICE
-                                "Use the volume_control=1 module parameter "
-                                "to enable volume control\n");
+                        pr_notice("Console audio control in monitor mode, "
+                                  "changes are not allowed\n");
+                        pr_notice("Use the volume_control=1 module parameter "
+                                  "to enable volume control\n");
                 }
                 return -EPERM;
         }
@@ -7129,8 +7095,7 @@ static void inline volume_alsa_notify_change(void)
 
 static int __init volume_init(struct ibm_init_struct *iibm)
 {
-        printk(TPACPI_INFO
-                "volume: disabled as there is no ALSA support in this kernel\n");
+        pr_info("volume: disabled as there is no ALSA support in this kernel\n");
 
         return 1;
 }
@@ -7193,7 +7158,7 @@ static struct ibm_struct volume_driver_data = {
  *              TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
  *
  *      FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
- *      boot. Apparently the EC does not intialize it, so unless ACPI DSDT
+ *      boot. Apparently the EC does not initialize it, so unless ACPI DSDT
  *      does so, its initial value is meaningless (0x07).
  *
  *      For firmware bugs, refer to:
@@ -7337,9 +7302,8 @@ TPACPI_HANDLE(sfan, ec, "SFAN",	/* 570 */
 static void fan_quirk1_setup(void)
 {
         if (fan_control_initial_status == 0x07) {
-                printk(TPACPI_NOTICE
-                       "fan_init: initial fan status is unknown, "
-                       "assuming it is in auto mode\n");
+                pr_notice("fan_init: initial fan status is unknown, "
+                          "assuming it is in auto mode\n");
                 tp_features.fan_ctrl_status_undef = 1;
         }
 }
@@ -7726,8 +7690,7 @@ static void fan_watchdog_reset(void)
                 if (!queue_delayed_work(tpacpi_wq, &fan_watchdog_task,
                                 msecs_to_jiffies(fan_watchdog_maxinterval
                                                  * 1000))) {
-                        printk(TPACPI_ERR
-                               "failed to queue the fan watchdog, "
+                        pr_err("failed to queue the fan watchdog, "
                                "watchdog will not trigger\n");
                 }
         } else
@@ -7741,11 +7704,11 @@ static void fan_watchdog_fire(struct work_struct *ignored)
         if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
                 return;
 
-        printk(TPACPI_NOTICE "fan watchdog: enabling fan\n");
+        pr_notice("fan watchdog: enabling fan\n");
         rc = fan_set_enable();
         if (rc < 0) {
-                printk(TPACPI_ERR "fan watchdog: error %d while enabling fan, "
-                        "will try again later...\n", -rc);
+                pr_err("fan watchdog: error %d while enabling fan, "
+                       "will try again later...\n", -rc);
                 /* reschedule for later */
                 fan_watchdog_reset();
         }
@@ -8049,8 +8012,7 @@ static int __init fan_init(struct ibm_init_struct *iibm)
                                         "secondary fan support enabled\n");
                         }
                 } else {
-                        printk(TPACPI_ERR
-                               "ThinkPad ACPI EC access misbehaving, "
+                        pr_err("ThinkPad ACPI EC access misbehaving, "
                                "fan status and control unavailable\n");
                         return 1;
                 }
@@ -8150,9 +8112,8 @@ static void fan_suspend(pm_message_t state)
         fan_control_resume_level = 0;
         rc = fan_get_status_safe(&fan_control_resume_level);
         if (rc < 0)
-                printk(TPACPI_NOTICE
-                        "failed to read fan level for later "
-                        "restore during resume: %d\n", rc);
+                pr_notice("failed to read fan level for later "
+                          "restore during resume: %d\n", rc);
 
         /* if it is undefined, don't attempt to restore it.
          * KEEP THIS LAST */
@@ -8207,13 +8168,11 @@ static void fan_resume(void)
                 return;
         }
         if (do_set) {
-                printk(TPACPI_NOTICE
-                        "restoring fan level to 0x%02x\n",
-                        fan_control_resume_level);
+                pr_notice("restoring fan level to 0x%02x\n",
+                          fan_control_resume_level);
                 rc = fan_set_level_safe(fan_control_resume_level);
                 if (rc < 0)
-                        printk(TPACPI_NOTICE
-                                "failed to restore fan level: %d\n", rc);
+                        pr_notice("failed to restore fan level: %d\n", rc);
         }
 }
 
@@ -8305,8 +8264,8 @@ static int fan_write_cmd_level(const char *cmd, int *rc)
 
         *rc = fan_set_level_safe(level);
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "level command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("level command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan",
                         "set level to %d\n", level);
@@ -8321,8 +8280,8 @@ static int fan_write_cmd_enable(const char *cmd, int *rc)
 
         *rc = fan_set_enable();
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "enable command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("enable command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan", "enable\n");
 
@@ -8336,8 +8295,8 @@ static int fan_write_cmd_disable(const char *cmd, int *rc)
 
         *rc = fan_set_disable();
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "disable command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("disable command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan", "disable\n");
 
@@ -8356,8 +8315,8 @@ static int fan_write_cmd_speed(const char *cmd, int *rc)
 
         *rc = fan_set_speed(speed);
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "speed command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("speed command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan",
                         "set speed to %d\n", speed);
@@ -8497,7 +8456,6 @@ static void ibm_exit(struct ibm_struct *ibm)
                                            ibm->acpi->type,
                                            dispatch_acpi_notify);
                 ibm->flags.acpi_notify_installed = 0;
-                ibm->flags.acpi_notify_installed = 0;
         }
 
         if (ibm->flags.proc_created) {
@@ -8561,8 +8519,8 @@ static int __init ibm_init(struct ibm_init_struct *iibm)
                 if (ibm->acpi->notify) {
                         ret = setup_acpi_notify(ibm);
                         if (ret == -ENODEV) {
-                                printk(TPACPI_NOTICE "disabling subdriver %s\n",
-                                        ibm->name);
+                                pr_notice("disabling subdriver %s\n",
+                                          ibm->name);
                                 ret = 0;
                                 goto err_out;
                         }
@@ -8584,8 +8542,7 @@ static int __init ibm_init(struct ibm_init_struct *iibm)
                 entry = proc_create_data(ibm->name, mode, proc_dir,
                                          &dispatch_proc_fops, ibm);
                 if (!entry) {
-                        printk(TPACPI_ERR "unable to create proc entry %s\n",
-                               ibm->name);
+                        pr_err("unable to create proc entry %s\n", ibm->name);
                         ret = -ENODEV;
                         goto err_out;
                 }
@@ -8621,8 +8578,7 @@ static bool __pure __init tpacpi_is_valid_fw_id(const char* const s,
                 tpacpi_is_fw_digit(s[1]) &&
                 s[2] == t && s[3] == 'T' &&
                 tpacpi_is_fw_digit(s[4]) &&
-                tpacpi_is_fw_digit(s[5]) &&
-                s[6] == 'W' && s[7] == 'W';
+                tpacpi_is_fw_digit(s[5]);
 }
 
 /* returns 0 - probe ok, or < 0 - probe error.
@@ -8685,13 +8641,11 @@ static int __must_check __init get_thinkpad_model_data(
                                 tp->ec_release = (ec_fw_string[4] << 8)
                                                 | ec_fw_string[5];
                         } else {
-                                printk(TPACPI_NOTICE
-                                        "ThinkPad firmware release %s "
-                                        "doesn't match the known patterns\n",
-                                        ec_fw_string);
-                                printk(TPACPI_NOTICE
-                                        "please report this to %s\n",
-                                        TPACPI_MAIL);
+                                pr_notice("ThinkPad firmware release %s "
+                                          "doesn't match the known patterns\n",
+                                          ec_fw_string);
+                                pr_notice("please report this to %s\n",
+                                          TPACPI_MAIL);
                         }
                         break;
                 }
@@ -8735,8 +8689,7 @@ static int __init probe_for_thinkpad(void)
         tpacpi_acpi_handle_locate("ec", TPACPI_ACPI_EC_HID, &ec_handle);
         if (!ec_handle) {
                 if (is_thinkpad)
-                        printk(TPACPI_ERR
-                                "Not yet supported ThinkPad detected!\n");
+                        pr_err("Not yet supported ThinkPad detected!\n");
                 return -ENODEV;
         }
 
@@ -8748,10 +8701,10 @@ static int __init probe_for_thinkpad(void)
 
 static void __init thinkpad_acpi_init_banner(void)
 {
-        printk(TPACPI_INFO "%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
-        printk(TPACPI_INFO "%s\n", TPACPI_URL);
+        pr_info("%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
+        pr_info("%s\n", TPACPI_URL);
 
-        printk(TPACPI_INFO "ThinkPad BIOS %s, EC %s\n",
+        pr_info("ThinkPad BIOS %s, EC %s\n",
                 (thinkpad_id.bios_version_str) ?
                         thinkpad_id.bios_version_str : "unknown",
                 (thinkpad_id.ec_version_str) ?
@@ -8760,7 +8713,7 @@ static void __init thinkpad_acpi_init_banner(void)
         BUG_ON(!thinkpad_id.vendor);
 
         if (thinkpad_id.model_str)
-                printk(TPACPI_INFO "%s %s, model %s\n",
+                pr_info("%s %s, model %s\n",
                         (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
                                 "IBM" : ((thinkpad_id.vendor ==
                                                 PCI_VENDOR_ID_LENOVO) ?
@@ -9026,8 +8979,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = get_thinkpad_model_data(&thinkpad_id);
         if (ret) {
-                printk(TPACPI_ERR
-                        "unable to get DMI data: %d\n", ret);
+                pr_err("unable to get DMI data: %d\n", ret);
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9053,16 +9005,14 @@ static int __init thinkpad_acpi_module_init(void)
 
         proc_dir = proc_mkdir(TPACPI_PROC_DIR, acpi_root_dir);
         if (!proc_dir) {
-                printk(TPACPI_ERR
-                       "unable to create proc dir " TPACPI_PROC_DIR);
+                pr_err("unable to create proc dir " TPACPI_PROC_DIR "\n");
                 thinkpad_acpi_module_exit();
                 return -ENODEV;
         }
 
         ret = platform_driver_register(&tpacpi_pdriver);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to register main platform driver\n");
+                pr_err("unable to register main platform driver\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9070,8 +9020,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = platform_driver_register(&tpacpi_hwmon_pdriver);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to register hwmon platform driver\n");
+                pr_err("unable to register hwmon platform driver\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9084,8 +9033,7 @@ static int __init thinkpad_acpi_module_init(void)
                                         &tpacpi_hwmon_pdriver.driver);
         }
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to create sysfs driver attributes\n");
+                pr_err("unable to create sysfs driver attributes\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9098,7 +9046,7 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_pdev)) {
                 ret = PTR_ERR(tpacpi_pdev);
                 tpacpi_pdev = NULL;
-                printk(TPACPI_ERR "unable to register platform device\n");
+                pr_err("unable to register platform device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9108,16 +9056,14 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_sensors_pdev)) {
                 ret = PTR_ERR(tpacpi_sensors_pdev);
                 tpacpi_sensors_pdev = NULL;
-                printk(TPACPI_ERR
-                       "unable to register hwmon platform device\n");
+                pr_err("unable to register hwmon platform device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
         ret = device_create_file(&tpacpi_sensors_pdev->dev,
                                  &dev_attr_thinkpad_acpi_pdev_name);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to create sysfs hwmon device attributes\n");
+                pr_err("unable to create sysfs hwmon device attributes\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9126,14 +9072,14 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_hwmon)) {
                 ret = PTR_ERR(tpacpi_hwmon);
                 tpacpi_hwmon = NULL;
-                printk(TPACPI_ERR "unable to register hwmon device\n");
+                pr_err("unable to register hwmon device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
         mutex_init(&tpacpi_inputdev_send_mutex);
         tpacpi_inputdev = input_allocate_device();
         if (!tpacpi_inputdev) {
-                printk(TPACPI_ERR "unable to allocate input device\n");
+                pr_err("unable to allocate input device\n");
                 thinkpad_acpi_module_exit();
                 return -ENOMEM;
         } else {
@@ -9165,7 +9111,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = input_register_device(tpacpi_inputdev);
         if (ret < 0) {
-                printk(TPACPI_ERR "unable to register input device\n");
+                pr_err("unable to register input device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         } else {
diff --git a/drivers/platform/x86/topstar-laptop.c b/drivers/platform/x86/topstar-laptop.c
index ff4b476f1950..4c20447ddbb7 100644
--- a/drivers/platform/x86/topstar-laptop.c
+++ b/drivers/platform/x86/topstar-laptop.c
@@ -19,6 +19,7 @@
 #include <linux/slab.h>
 #include <linux/acpi.h>
 #include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 
 #define ACPI_TOPSTAR_CLASS "topstar"
 
@@ -26,52 +27,37 @@ struct topstar_hkey {
         struct input_dev *inputdev;
 };
 
-struct tps_key_entry {
-        u8 code;
-        u16 keycode;
-};
-
-static struct tps_key_entry topstar_keymap[] = {
-        { 0x80, KEY_BRIGHTNESSUP },
-        { 0x81, KEY_BRIGHTNESSDOWN },
-        { 0x83, KEY_VOLUMEUP },
-        { 0x84, KEY_VOLUMEDOWN },
-        { 0x85, KEY_MUTE },
-        { 0x86, KEY_SWITCHVIDEOMODE },
-        { 0x87, KEY_F13 }, /* touchpad enable/disable key */
-        { 0x88, KEY_WLAN },
-        { 0x8a, KEY_WWW },
-        { 0x8b, KEY_MAIL },
-        { 0x8c, KEY_MEDIA },
-        { 0x96, KEY_F14 }, /* G key? */
-        { }
-};
-
-static struct tps_key_entry *tps_get_key_by_scancode(unsigned int code)
-{
-        struct tps_key_entry *key;
-
-        for (key = topstar_keymap; key->code; key++)
-                if (code == key->code)
-                        return key;
+static const struct key_entry topstar_keymap[] = {
+        { KE_KEY, 0x80, { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 0x81, { KEY_BRIGHTNESSDOWN } },
+        { KE_KEY, 0x83, { KEY_VOLUMEUP } },
+        { KE_KEY, 0x84, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 0x85, { KEY_MUTE } },
+        { KE_KEY, 0x86, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x87, { KEY_F13 } }, /* touchpad enable/disable key */
+        { KE_KEY, 0x88, { KEY_WLAN } },
+        { KE_KEY, 0x8a, { KEY_WWW } },
+        { KE_KEY, 0x8b, { KEY_MAIL } },
+        { KE_KEY, 0x8c, { KEY_MEDIA } },
 
-        return NULL;
-}
-
-static struct tps_key_entry *tps_get_key_by_keycode(unsigned int code)
-{
-        struct tps_key_entry *key;
+        /* Known non hotkey events don't handled or that we don't care yet */
+        { KE_IGNORE, 0x8e, },
+        { KE_IGNORE, 0x8f, },
+        { KE_IGNORE, 0x90, },
 
-        for (key = topstar_keymap; key->code; key++)
-                if (code == key->keycode)
-                        return key;
+        /*
+         * 'G key' generate two event codes, convert to only
+         * one event/key code for now, consider replacing by
+         * a switch (3G switch - SW_3G?)
+         */
+        { KE_KEY, 0x96, { KEY_F14 } },
+        { KE_KEY, 0x97, { KEY_F14 } },
 
-        return NULL;
-}
+        { KE_END, 0 }
+};
 
 static void acpi_topstar_notify(struct acpi_device *device, u32 event)
 {
-        struct tps_key_entry *key;
         static bool dup_evnt[2];
         bool *dup;
         struct topstar_hkey *hkey = acpi_driver_data(device);
@@ -86,27 +72,8 @@ static void acpi_topstar_notify(struct acpi_device *device, u32 event)
                 *dup = true;
         }
 
-        /*
-         * 'G key' generate two event codes, convert to only
-         * one event/key code for now (3G switch?)
-         */
-        if (event == 0x97)
-                event = 0x96;
-
-        key = tps_get_key_by_scancode(event);
-        if (key) {
-                input_report_key(hkey->inputdev, key->keycode, 1);
-                input_sync(hkey->inputdev);
-                input_report_key(hkey->inputdev, key->keycode, 0);
-                input_sync(hkey->inputdev);
-                return;
-        }
-
-        /* Known non hotkey events don't handled or that we don't care yet */
-        if (event == 0x8e || event == 0x8f || event == 0x90)
-                return;
-
-        pr_info("unknown event = 0x%02x\n", event);
+        if (!sparse_keymap_report_event(hkey->inputdev, event, 1, true))
+                pr_info("unknown event = 0x%02x\n", event);
 }
 
 static int acpi_topstar_fncx_switch(struct acpi_device *device, bool state)
@@ -127,62 +94,41 @@ static int acpi_topstar_fncx_switch(struct acpi_device *device, bool state)
         return 0;
 }
 
-static int topstar_getkeycode(struct input_dev *dev,
-                                unsigned int scancode, unsigned int *keycode)
-{
-        struct tps_key_entry *key = tps_get_key_by_scancode(scancode);
-
-        if (!key)
-                return -EINVAL;
-
-        *keycode = key->keycode;
-        return 0;
-}
-
-static int topstar_setkeycode(struct input_dev *dev,
-                                unsigned int scancode, unsigned int keycode)
-{
-        struct tps_key_entry *key;
-        int old_keycode;
-
-        key = tps_get_key_by_scancode(scancode);
-
-        if (!key)
-                return -EINVAL;
-
-        old_keycode = key->keycode;
-        key->keycode = keycode;
-        set_bit(keycode, dev->keybit);
-        if (!tps_get_key_by_keycode(old_keycode))
-                clear_bit(old_keycode, dev->keybit);
-        return 0;
-}
-
 static int acpi_topstar_init_hkey(struct topstar_hkey *hkey)
 {
-        struct tps_key_entry *key;
+        struct input_dev *input;
+        int error;
 
-        hkey->inputdev = input_allocate_device();
-        if (!hkey->inputdev) {
+        input = input_allocate_device();
+        if (!input) {
                 pr_err("Unable to allocate input device\n");
-                return -ENODEV;
+                return -ENOMEM;
         }
-        hkey->inputdev->name = "Topstar Laptop extra buttons";
-        hkey->inputdev->phys = "topstar/input0";
-        hkey->inputdev->id.bustype = BUS_HOST;
-        hkey->inputdev->getkeycode = topstar_getkeycode;
-        hkey->inputdev->setkeycode = topstar_setkeycode;
-        for (key = topstar_keymap; key->code; key++) {
-                set_bit(EV_KEY, hkey->inputdev->evbit);
-                set_bit(key->keycode, hkey->inputdev->keybit);
+
+        input->name = "Topstar Laptop extra buttons";
+        input->phys = "topstar/input0";
+        input->id.bustype = BUS_HOST;
+
+        error = sparse_keymap_setup(input, topstar_keymap, NULL);
+        if (error) {
+                pr_err("Unable to setup input device keymap\n");
+                goto err_free_dev;
         }
-        if (input_register_device(hkey->inputdev)) {
+
+        error = input_register_device(input);
+        if (error) {
                 pr_err("Unable to register input device\n");
-                input_free_device(hkey->inputdev);
-                return -ENODEV;
+                goto err_free_keymap;
         }
 
+        hkey->inputdev = input;
         return 0;
+
+ err_free_keymap:
+        sparse_keymap_free(input);
+ err_free_dev:
+        input_free_device(input);
+        return error;
 }
 
 static int acpi_topstar_add(struct acpi_device *device)
@@ -216,6 +162,7 @@ static int acpi_topstar_remove(struct acpi_device *device, int type)
 
         acpi_topstar_fncx_switch(device, false);
 
+        sparse_keymap_free(tps_hkey->inputdev);
         input_unregister_device(tps_hkey->inputdev);
         kfree(tps_hkey);
 
@@ -247,7 +194,7 @@ static int __init topstar_laptop_init(void)
         if (ret < 0)
                 return ret;
 
-        printk(KERN_INFO "Topstar Laptop ACPI extras driver loaded\n");
+        pr_info("ACPI extras driver loaded\n");
 
         return 0;
 }
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index 7d67a45bb2b0..cb009b2629ee 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -35,6 +35,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define TOSHIBA_ACPI_VERSION    "0.19"
 #define PROC_INTERFACE_VERSION  1
 
@@ -48,6 +50,7 @@
 #include <linux/platform_device.h>
 #include <linux/rfkill.h>
 #include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 #include <linux/leds.h>
 #include <linux/slab.h>
 
@@ -59,11 +62,6 @@ MODULE_AUTHOR("John Belmonte");
 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
 MODULE_LICENSE("GPL");
 
-#define MY_LOGPREFIX "toshiba_acpi: "
-#define MY_ERR KERN_ERR MY_LOGPREFIX
-#define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
-#define MY_INFO KERN_INFO MY_LOGPREFIX
-
 /* Toshiba ACPI method paths */
 #define METHOD_LCD_BRIGHTNESS   "\\_SB_.PCI0.VGA_.LCD_._BCM"
 #define TOSH_INTERFACE_1        "\\_SB_.VALD"
@@ -121,36 +119,29 @@ static const struct acpi_device_id toshiba_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
 
-struct key_entry {
-        char type;
-        u16 code;
-        u16 keycode;
-};
-
-enum {KE_KEY, KE_END};
-
-static struct key_entry toshiba_acpi_keymap[]  = {
-        {KE_KEY, 0x101, KEY_MUTE},
-        {KE_KEY, 0x102, KEY_ZOOMOUT},
-        {KE_KEY, 0x103, KEY_ZOOMIN},
-        {KE_KEY, 0x13b, KEY_COFFEE},
-        {KE_KEY, 0x13c, KEY_BATTERY},
-        {KE_KEY, 0x13d, KEY_SLEEP},
-        {KE_KEY, 0x13e, KEY_SUSPEND},
-        {KE_KEY, 0x13f, KEY_SWITCHVIDEOMODE},
-        {KE_KEY, 0x140, KEY_BRIGHTNESSDOWN},
-        {KE_KEY, 0x141, KEY_BRIGHTNESSUP},
-        {KE_KEY, 0x142, KEY_WLAN},
-        {KE_KEY, 0x143, KEY_PROG1},
-        {KE_KEY, 0xb05, KEY_PROG2},
-        {KE_KEY, 0xb06, KEY_WWW},
-        {KE_KEY, 0xb07, KEY_MAIL},
-        {KE_KEY, 0xb30, KEY_STOP},
-        {KE_KEY, 0xb31, KEY_PREVIOUSSONG},
-        {KE_KEY, 0xb32, KEY_NEXTSONG},
-        {KE_KEY, 0xb33, KEY_PLAYPAUSE},
-        {KE_KEY, 0xb5a, KEY_MEDIA},
-        {KE_END, 0, 0},
+static const struct key_entry toshiba_acpi_keymap[] __initconst = {
+        { KE_KEY, 0x101, { KEY_MUTE } },
+        { KE_KEY, 0x102, { KEY_ZOOMOUT } },
+        { KE_KEY, 0x103, { KEY_ZOOMIN } },
+        { KE_KEY, 0x13b, { KEY_COFFEE } },
+        { KE_KEY, 0x13c, { KEY_BATTERY } },
+        { KE_KEY, 0x13d, { KEY_SLEEP } },
+        { KE_KEY, 0x13e, { KEY_SUSPEND } },
+        { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
+        { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 0x142, { KEY_WLAN } },
+        { KE_KEY, 0x143, { KEY_PROG1 } },
+        { KE_KEY, 0x17f, { KEY_FN } },
+        { KE_KEY, 0xb05, { KEY_PROG2 } },
+        { KE_KEY, 0xb06, { KEY_WWW } },
+        { KE_KEY, 0xb07, { KEY_MAIL } },
+        { KE_KEY, 0xb30, { KEY_STOP } },
+        { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
+        { KE_KEY, 0xb32, { KEY_NEXTSONG } },
+        { KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
+        { KE_KEY, 0xb5a, { KEY_MEDIA } },
+        { KE_END, 0 },
 };
 
 /* utility
@@ -307,7 +298,7 @@ static int toshiba_illumination_available(void)
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return 0;
         }
         in[0] = 0xf400;
@@ -326,7 +317,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return;
         }
 
@@ -337,7 +328,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
                 in[2] = 1;
                 status = hci_raw(in, out);
                 if (ACPI_FAILURE(status)) {
-                        printk(MY_INFO "ACPI call for illumination failed.\n");
+                        pr_info("ACPI call for illumination failed\n");
                         return;
                 }
         } else {
@@ -347,7 +338,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
                 in[2] = 0;
                 status = hci_raw(in, out);
                 if (ACPI_FAILURE(status)) {
-                        printk(MY_INFO "ACPI call for illumination failed.\n");
+                        pr_info("ACPI call for illumination failed.\n");
                         return;
                 }
         }
@@ -370,7 +361,7 @@ static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return LED_OFF;
         }
 
@@ -379,7 +370,7 @@ static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
         in[1] = 0x14e;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "ACPI call for illumination failed.\n");
+                pr_info("ACPI call for illumination failed.\n");
                 return LED_OFF;
         }
 
@@ -523,7 +514,7 @@ static int lcd_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "brightness_levels:       %d\n",
                              HCI_LCD_BRIGHTNESS_LEVELS);
         } else {
-                printk(MY_ERR "Error reading LCD brightness\n");
+                pr_err("Error reading LCD brightness\n");
         }
 
         return 0;
@@ -598,7 +589,7 @@ static int video_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "crt_out:                 %d\n", is_crt);
                 seq_printf(m, "tv_out:                  %d\n", is_tv);
         } else {
-                printk(MY_ERR "Error reading video out status\n");
+                pr_err("Error reading video out status\n");
         }
 
         return 0;
@@ -692,7 +683,7 @@ static int fan_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "running:                 %d\n", (value > 0));
                 seq_printf(m, "force_on:                %d\n", force_fan);
         } else {
-                printk(MY_ERR "Error reading fan status\n");
+                pr_err("Error reading fan status\n");
         }
 
         return 0;
@@ -756,9 +747,9 @@ static int keys_proc_show(struct seq_file *m, void *v)
                          * some machines where system events sporadically
                          * become disabled. */
                         hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
-                        printk(MY_NOTICE "Re-enabled hotkeys\n");
+                        pr_notice("Re-enabled hotkeys\n");
                 } else {
-                        printk(MY_ERR "Error reading hotkey status\n");
+                        pr_err("Error reading hotkey status\n");
                         goto end;
                 }
         }
@@ -847,69 +838,14 @@ static void remove_toshiba_proc_entries(void)
         remove_proc_entry("version", toshiba_proc_dir);
 }
 
-static struct backlight_ops toshiba_backlight_data = {
+static const struct backlight_ops toshiba_backlight_data = {
         .get_brightness = get_lcd,
         .update_status  = set_lcd_status,
 };
 
-static struct key_entry *toshiba_acpi_get_entry_by_scancode(unsigned int code)
-{
-        struct key_entry *key;
-
-        for (key = toshiba_acpi_keymap; key->type != KE_END; key++)
-                if (code == key->code)
-                        return key;
-
-        return NULL;
-}
-
-static struct key_entry *toshiba_acpi_get_entry_by_keycode(unsigned int code)
-{
-        struct key_entry *key;
-
-        for (key = toshiba_acpi_keymap; key->type != KE_END; key++)
-                if (code == key->keycode && key->type == KE_KEY)
-                        return key;
-
-        return NULL;
-}
-
-static int toshiba_acpi_getkeycode(struct input_dev *dev,
-                                   unsigned int scancode, unsigned int *keycode)
-{
-        struct key_entry *key = toshiba_acpi_get_entry_by_scancode(scancode);
-
-        if (key && key->type == KE_KEY) {
-                *keycode = key->keycode;
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
-static int toshiba_acpi_setkeycode(struct input_dev *dev,
-                                   unsigned int scancode, unsigned int keycode)
-{
-        struct key_entry *key;
-        unsigned int old_keycode;
-
-        key = toshiba_acpi_get_entry_by_scancode(scancode);
-        if (key && key->type == KE_KEY) {
-                old_keycode = key->keycode;
-                key->keycode = keycode;
-                set_bit(keycode, dev->keybit);
-                if (!toshiba_acpi_get_entry_by_keycode(old_keycode))
-                        clear_bit(old_keycode, dev->keybit);
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
 static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
 {
         u32 hci_result, value;
-        struct key_entry *key;
 
         if (event != 0x80)
                 return;
@@ -922,87 +858,89 @@ static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
                         if (value & 0x80)
                                 continue;
 
-                        key = toshiba_acpi_get_entry_by_scancode
-                                (value);
-                        if (!key) {
-                                printk(MY_INFO "Unknown key %x\n",
+                        if (!sparse_keymap_report_event(toshiba_acpi.hotkey_dev,
+                                                        value, 1, true)) {
+                                pr_info("Unknown key %x\n",
                                        value);
-                                continue;
                         }
-                        input_report_key(toshiba_acpi.hotkey_dev,
-                                         key->keycode, 1);
-                        input_sync(toshiba_acpi.hotkey_dev);
-                        input_report_key(toshiba_acpi.hotkey_dev,
-                                         key->keycode, 0);
-                        input_sync(toshiba_acpi.hotkey_dev);
                 } else if (hci_result == HCI_NOT_SUPPORTED) {
                         /* This is a workaround for an unresolved issue on
                          * some machines where system events sporadically
                          * become disabled. */
                         hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
-                        printk(MY_NOTICE "Re-enabled hotkeys\n");
+                        pr_notice("Re-enabled hotkeys\n");
                 }
         } while (hci_result != HCI_EMPTY);
 }
 
-static int toshiba_acpi_setup_keyboard(char *device)
+static int __init toshiba_acpi_setup_keyboard(char *device)
 {
         acpi_status status;
-        acpi_handle handle;
-        int result;
-        const struct key_entry *key;
+        int error;
 
-        status = acpi_get_handle(NULL, device, &handle);
+        status = acpi_get_handle(NULL, device, &toshiba_acpi.handle);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to get notification device\n");
-                return -ENODEV;
-        }
-
-        toshiba_acpi.handle = handle;
-
-        status = acpi_evaluate_object(handle, "ENAB", NULL, NULL);
-        if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to enable hotkeys\n");
-                return -ENODEV;
-        }
-
-        status = acpi_install_notify_handler(handle, ACPI_DEVICE_NOTIFY,
-                                              toshiba_acpi_notify, NULL);
-        if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to install hotkey notification\n");
+                pr_info("Unable to get notification device\n");
                 return -ENODEV;
         }
 
         toshiba_acpi.hotkey_dev = input_allocate_device();
         if (!toshiba_acpi.hotkey_dev) {
-                printk(MY_INFO "Unable to register input device\n");
+                pr_info("Unable to register input device\n");
                 return -ENOMEM;
         }
 
         toshiba_acpi.hotkey_dev->name = "Toshiba input device";
         toshiba_acpi.hotkey_dev->phys = device;
         toshiba_acpi.hotkey_dev->id.bustype = BUS_HOST;
-        toshiba_acpi.hotkey_dev->getkeycode = toshiba_acpi_getkeycode;
-        toshiba_acpi.hotkey_dev->setkeycode = toshiba_acpi_setkeycode;
 
-        for (key = toshiba_acpi_keymap; key->type != KE_END; key++) {
-                set_bit(EV_KEY, toshiba_acpi.hotkey_dev->evbit);
-                set_bit(key->keycode, toshiba_acpi.hotkey_dev->keybit);
+        error = sparse_keymap_setup(toshiba_acpi.hotkey_dev,
+                                    toshiba_acpi_keymap, NULL);
+        if (error)
+                goto err_free_dev;
+
+        status = acpi_install_notify_handler(toshiba_acpi.handle,
+                                ACPI_DEVICE_NOTIFY, toshiba_acpi_notify, NULL);
+        if (ACPI_FAILURE(status)) {
+                pr_info("Unable to install hotkey notification\n");
+                error = -ENODEV;
+                goto err_free_keymap;
         }
 
-        result = input_register_device(toshiba_acpi.hotkey_dev);
-        if (result) {
-                printk(MY_INFO "Unable to register input device\n");
-                return result;
+        status = acpi_evaluate_object(toshiba_acpi.handle, "ENAB", NULL, NULL);
+        if (ACPI_FAILURE(status)) {
+                pr_info("Unable to enable hotkeys\n");
+                error = -ENODEV;
+                goto err_remove_notify;
+        }
+
+        error = input_register_device(toshiba_acpi.hotkey_dev);
+        if (error) {
+                pr_info("Unable to register input device\n");
+                goto err_remove_notify;
         }
 
         return 0;
+
+ err_remove_notify:
+        acpi_remove_notify_handler(toshiba_acpi.handle,
+                                   ACPI_DEVICE_NOTIFY, toshiba_acpi_notify);
+ err_free_keymap:
+        sparse_keymap_free(toshiba_acpi.hotkey_dev);
+ err_free_dev:
+        input_free_device(toshiba_acpi.hotkey_dev);
+        toshiba_acpi.hotkey_dev = NULL;
+        return error;
 }
 
 static void toshiba_acpi_exit(void)
 {
-        if (toshiba_acpi.hotkey_dev)
+        if (toshiba_acpi.hotkey_dev) {
+                acpi_remove_notify_handler(toshiba_acpi.handle,
+                                ACPI_DEVICE_NOTIFY, toshiba_acpi_notify);
+                sparse_keymap_free(toshiba_acpi.hotkey_dev);
                 input_unregister_device(toshiba_acpi.hotkey_dev);
+        }
 
         if (toshiba_acpi.bt_rfk) {
                 rfkill_unregister(toshiba_acpi.bt_rfk);
@@ -1017,9 +955,6 @@ static void toshiba_acpi_exit(void)
         if (toshiba_proc_dir)
                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
 
-        acpi_remove_notify_handler(toshiba_acpi.handle, ACPI_DEVICE_NOTIFY,
-                                   toshiba_acpi_notify);
-
         if (toshiba_acpi.illumination_installed)
                 led_classdev_unregister(&toshiba_led);
 
@@ -1042,17 +977,17 @@ static int __init toshiba_acpi_init(void)
         if (is_valid_acpi_path(TOSH_INTERFACE_1 GHCI_METHOD)) {
                 method_hci = TOSH_INTERFACE_1 GHCI_METHOD;
                 if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_1))
-                        printk(MY_INFO "Unable to activate hotkeys\n");
+                        pr_info("Unable to activate hotkeys\n");
         } else if (is_valid_acpi_path(TOSH_INTERFACE_2 GHCI_METHOD)) {
                 method_hci = TOSH_INTERFACE_2 GHCI_METHOD;
                 if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_2))
-                        printk(MY_INFO "Unable to activate hotkeys\n");
+                        pr_info("Unable to activate hotkeys\n");
         } else
                 return -ENODEV;
 
-        printk(MY_INFO "Toshiba Laptop ACPI Extras version %s\n",
+        pr_info("Toshiba Laptop ACPI Extras version %s\n",
                TOSHIBA_ACPI_VERSION);
-        printk(MY_INFO "    HCI method: %s\n", method_hci);
+        pr_info("    HCI method: %s\n", method_hci);
 
         mutex_init(&toshiba_acpi.mutex);
 
@@ -1060,7 +995,7 @@ static int __init toshiba_acpi_init(void)
                                                               -1, NULL, 0);
         if (IS_ERR(toshiba_acpi.p_dev)) {
                 ret = PTR_ERR(toshiba_acpi.p_dev);
-                printk(MY_ERR "unable to register platform device\n");
+                pr_err("unable to register platform device\n");
                 toshiba_acpi.p_dev = NULL;
                 toshiba_acpi_exit();
                 return ret;
@@ -1080,6 +1015,7 @@ static int __init toshiba_acpi_init(void)
                 create_toshiba_proc_entries();
         }
 
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
         toshiba_backlight_device = backlight_device_register("toshiba",
                                                              &toshiba_acpi.p_dev->dev,
@@ -1089,7 +1025,7 @@ static int __init toshiba_acpi_init(void)
         if (IS_ERR(toshiba_backlight_device)) {
                 ret = PTR_ERR(toshiba_backlight_device);
 
-                printk(KERN_ERR "Could not register toshiba backlight device\n");
+                pr_err("Could not register toshiba backlight device\n");
                 toshiba_backlight_device = NULL;
                 toshiba_acpi_exit();
                 return ret;
@@ -1103,14 +1039,14 @@ static int __init toshiba_acpi_init(void)
                                                    &toshiba_rfk_ops,
                                                    &toshiba_acpi);
                 if (!toshiba_acpi.bt_rfk) {
-                        printk(MY_ERR "unable to allocate rfkill device\n");
+                        pr_err("unable to allocate rfkill device\n");
                         toshiba_acpi_exit();
                         return -ENOMEM;
                 }
 
                 ret = rfkill_register(toshiba_acpi.bt_rfk);
                 if (ret) {
-                        printk(MY_ERR "unable to register rfkill device\n");
+                        pr_err("unable to register rfkill device\n");
                         rfkill_destroy(toshiba_acpi.bt_rfk);
                         toshiba_acpi_exit();
                         return ret;
diff --git a/drivers/platform/x86/toshiba_bluetooth.c b/drivers/platform/x86/toshiba_bluetooth.c
index 944068611919..5fb7186694df 100644
--- a/drivers/platform/x86/toshiba_bluetooth.c
+++ b/drivers/platform/x86/toshiba_bluetooth.c
@@ -17,6 +17,8 @@
  * delivered.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -70,14 +72,13 @@ static int toshiba_bluetooth_enable(acpi_handle handle)
         if (!(result & 0x01))
                 return 0;
 
-        printk(KERN_INFO "toshiba_bluetooth: Re-enabling Toshiba Bluetooth\n");
+        pr_info("Re-enabling Toshiba Bluetooth\n");
         res1 = acpi_evaluate_object(handle, "AUSB", NULL, NULL);
         res2 = acpi_evaluate_object(handle, "BTPO", NULL, NULL);
         if (!ACPI_FAILURE(res1) || !ACPI_FAILURE(res2))
                 return 0;
 
-        printk(KERN_WARNING "toshiba_bluetooth: Failed to re-enable "
-               "Toshiba Bluetooth\n");
+        pr_warn("Failed to re-enable Toshiba Bluetooth\n");
 
         return -ENODEV;
 }
@@ -107,8 +108,8 @@ static int toshiba_bt_rfkill_add(struct acpi_device *device)
                                        &bt_present);
 
         if (!ACPI_FAILURE(status) && bt_present) {
-                printk(KERN_INFO "Detected Toshiba ACPI Bluetooth device - "
-                      "installing RFKill handler\n");
+                pr_info("Detected Toshiba ACPI Bluetooth device - "
+                        "installing RFKill handler\n");
                 result = toshiba_bluetooth_enable(device->handle);
         }
 
diff --git a/drivers/platform/x86/wmi.c b/drivers/platform/x86/wmi.c
index b2978a04317f..f23d5a84e7b1 100644
--- a/drivers/platform/x86/wmi.c
+++ b/drivers/platform/x86/wmi.c
@@ -27,6 +27,8 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
+#define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/types.h>
@@ -44,9 +46,8 @@ MODULE_LICENSE("GPL");
 
 #define ACPI_WMI_CLASS "wmi"
 
-#define PREFIX "ACPI: WMI: "
-
 static DEFINE_MUTEX(wmi_data_lock);
+static LIST_HEAD(wmi_block_list);
 
 struct guid_block {
         char guid[16];
@@ -67,10 +68,9 @@ struct wmi_block {
         acpi_handle handle;
         wmi_notify_handler handler;
         void *handler_data;
-        struct device *dev;
+        struct device dev;
 };
 
-static struct wmi_block wmi_blocks;
 
 /*
  * If the GUID data block is marked as expensive, we must enable and
@@ -110,7 +110,7 @@ static struct acpi_driver acpi_wmi_driver = {
                 .add = acpi_wmi_add,
                 .remove = acpi_wmi_remove,
                 .notify = acpi_wmi_notify,
-                },
+        },
 };
 
 /*
@@ -128,30 +128,18 @@ static struct acpi_driver acpi_wmi_driver = {
  */
 static int wmi_parse_hexbyte(const u8 *src)
 {
-        unsigned int x; /* For correct wrapping */
         int h;
+        int value;
 
         /* high part */
-        x = src[0];
-        if (x - '0' <= '9' - '0') {
-                h = x - '0';
-        } else if (x - 'a' <= 'f' - 'a') {
-                h = x - 'a' + 10;
-        } else if (x - 'A' <= 'F' - 'A') {
-                h = x - 'A' + 10;
-        } else {
+        h = value = hex_to_bin(src[0]);
+        if (value < 0)
                 return -1;
-        }
-        h <<= 4;
 
         /* low part */
-        x = src[1];
-        if (x - '0' <= '9' - '0')
-                return h | (x - '0');
-        if (x - 'a' <= 'f' - 'a')
-                return h | (x - 'a' + 10);
-        if (x - 'A' <= 'F' - 'A')
-                return h | (x - 'A' + 10);
+        value = hex_to_bin(src[1]);
+        if (value >= 0)
+                return (h << 4) | value;
         return -1;
 }
 
@@ -232,7 +220,7 @@ static int wmi_gtoa(const char *in, char *out)
         for (i = 10; i <= 15; i++)
                 out += sprintf(out, "%02X", in[i] & 0xFF);
 
-        out = '\0';
+        *out = '\0';
         return 0;
 }
 
@@ -246,7 +234,7 @@ static bool find_guid(const char *guid_string, struct wmi_block **out)
         wmi_parse_guid(guid_string, tmp);
         wmi_swap_bytes(tmp, guid_input);
 
-        list_for_each(p, &wmi_blocks.list) {
+        list_for_each(p, &wmi_block_list) {
                 wblock = list_entry(p, struct wmi_block, list);
                 block = &wblock->gblock;
 
@@ -487,30 +475,29 @@ const struct acpi_buffer *in)
 }
 EXPORT_SYMBOL_GPL(wmi_set_block);
 
-static void wmi_dump_wdg(struct guid_block *g)
+static void wmi_dump_wdg(const struct guid_block *g)
 {
         char guid_string[37];
 
         wmi_gtoa(g->guid, guid_string);
-        printk(KERN_INFO PREFIX "%s:\n", guid_string);
-        printk(KERN_INFO PREFIX "\tobject_id: %c%c\n",
-               g->object_id[0], g->object_id[1]);
-        printk(KERN_INFO PREFIX "\tnotify_id: %02X\n", g->notify_id);
-        printk(KERN_INFO PREFIX "\treserved: %02X\n", g->reserved);
-        printk(KERN_INFO PREFIX "\tinstance_count: %d\n", g->instance_count);
-        printk(KERN_INFO PREFIX "\tflags: %#x", g->flags);
+
+        pr_info("%s:\n", guid_string);
+        pr_info("\tobject_id: %c%c\n", g->object_id[0], g->object_id[1]);
+        pr_info("\tnotify_id: %02X\n", g->notify_id);
+        pr_info("\treserved: %02X\n", g->reserved);
+        pr_info("\tinstance_count: %d\n", g->instance_count);
+        pr_info("\tflags: %#x", g->flags);
         if (g->flags) {
-                printk(" ");
                 if (g->flags & ACPI_WMI_EXPENSIVE)
-                        printk("ACPI_WMI_EXPENSIVE ");
+                        pr_cont(" ACPI_WMI_EXPENSIVE");
                 if (g->flags & ACPI_WMI_METHOD)
-                        printk("ACPI_WMI_METHOD ");
+                        pr_cont(" ACPI_WMI_METHOD");
                 if (g->flags & ACPI_WMI_STRING)
-                        printk("ACPI_WMI_STRING ");
+                        pr_cont(" ACPI_WMI_STRING");
                 if (g->flags & ACPI_WMI_EVENT)
-                        printk("ACPI_WMI_EVENT ");
+                        pr_cont(" ACPI_WMI_EVENT");
         }
-        printk("\n");
+        pr_cont("\n");
 
 }
 
@@ -522,7 +509,7 @@ static void wmi_notify_debug(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO "wmi: bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -531,22 +518,22 @@ static void wmi_notify_debug(u32 value, void *context)
         if (!obj)
                 return;
 
-        printk(KERN_INFO PREFIX "DEBUG Event ");
+        pr_info("DEBUG Event ");
         switch(obj->type) {
         case ACPI_TYPE_BUFFER:
-                printk("BUFFER_TYPE - length %d\n", obj->buffer.length);
+                pr_cont("BUFFER_TYPE - length %d\n", obj->buffer.length);
                 break;
         case ACPI_TYPE_STRING:
-                printk("STRING_TYPE - %s\n", obj->string.pointer);
+                pr_cont("STRING_TYPE - %s\n", obj->string.pointer);
                 break;
         case ACPI_TYPE_INTEGER:
-                printk("INTEGER_TYPE - %llu\n", obj->integer.value);
+                pr_cont("INTEGER_TYPE - %llu\n", obj->integer.value);
                 break;
         case ACPI_TYPE_PACKAGE:
-                printk("PACKAGE_TYPE - %d elements\n", obj->package.count);
+                pr_cont("PACKAGE_TYPE - %d elements\n", obj->package.count);
                 break;
         default:
-                printk("object type 0x%X\n", obj->type);
+                pr_cont("object type 0x%X\n", obj->type);
         }
         kfree(obj);
 }
@@ -562,21 +549,34 @@ acpi_status wmi_install_notify_handler(const char *guid,
 wmi_notify_handler handler, void *data)
 {
         struct wmi_block *block;
-        acpi_status status;
+        acpi_status status = AE_NOT_EXIST;
+        char tmp[16], guid_input[16];
+        struct list_head *p;
 
         if (!guid || !handler)
                 return AE_BAD_PARAMETER;
 
-        if (!find_guid(guid, &block))
-                return AE_NOT_EXIST;
+        wmi_parse_guid(guid, tmp);
+        wmi_swap_bytes(tmp, guid_input);
 
-        if (block->handler && block->handler != wmi_notify_debug)
-                return AE_ALREADY_ACQUIRED;
+        list_for_each(p, &wmi_block_list) {
+                acpi_status wmi_status;
+                block = list_entry(p, struct wmi_block, list);
 
-        block->handler = handler;
-        block->handler_data = data;
+                if (memcmp(block->gblock.guid, guid_input, 16) == 0) {
+                        if (block->handler &&
+                            block->handler != wmi_notify_debug)
+                                return AE_ALREADY_ACQUIRED;
 
-        status = wmi_method_enable(block, 1);
+                        block->handler = handler;
+                        block->handler_data = data;
+
+                        wmi_status = wmi_method_enable(block, 1);
+                        if ((wmi_status != AE_OK) ||
+                            ((wmi_status == AE_OK) && (status == AE_NOT_EXIST)))
+                                status = wmi_status;
+                }
+        }
 
         return status;
 }
@@ -590,24 +590,40 @@ EXPORT_SYMBOL_GPL(wmi_install_notify_handler);
 acpi_status wmi_remove_notify_handler(const char *guid)
 {
         struct wmi_block *block;
-        acpi_status status = AE_OK;
+        acpi_status status = AE_NOT_EXIST;
+        char tmp[16], guid_input[16];
+        struct list_head *p;
 
         if (!guid)
                 return AE_BAD_PARAMETER;
 
-        if (!find_guid(guid, &block))
-                return AE_NOT_EXIST;
+        wmi_parse_guid(guid, tmp);
+        wmi_swap_bytes(tmp, guid_input);
 
-        if (!block->handler || block->handler == wmi_notify_debug)
-                return AE_NULL_ENTRY;
+        list_for_each(p, &wmi_block_list) {
+                acpi_status wmi_status;
+                block = list_entry(p, struct wmi_block, list);
 
-        if (debug_event) {
-                block->handler = wmi_notify_debug;
-        } else {
-                status = wmi_method_enable(block, 0);
-                block->handler = NULL;
-                block->handler_data = NULL;
+                if (memcmp(block->gblock.guid, guid_input, 16) == 0) {
+                        if (!block->handler ||
+                            block->handler == wmi_notify_debug)
+                                return AE_NULL_ENTRY;
+
+                        if (debug_event) {
+                                block->handler = wmi_notify_debug;
+                                status = AE_OK;
+                        } else {
+                                wmi_status = wmi_method_enable(block, 0);
+                                block->handler = NULL;
+                                block->handler_data = NULL;
+                                if ((wmi_status != AE_OK) ||
+                                    ((wmi_status == AE_OK) &&
+                                     (status == AE_NOT_EXIST)))
+                                        status = wmi_status;
+                        }
+                }
         }
+
         return status;
 }
 EXPORT_SYMBOL_GPL(wmi_remove_notify_handler);
@@ -633,7 +649,7 @@ acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out)
         params[0].type = ACPI_TYPE_INTEGER;
         params[0].integer.value = event;
 
-        list_for_each(p, &wmi_blocks.list) {
+        list_for_each(p, &wmi_block_list) {
                 wblock = list_entry(p, struct wmi_block, list);
                 gblock = &wblock->gblock;
 
@@ -662,7 +678,7 @@ EXPORT_SYMBOL_GPL(wmi_has_guid);
 /*
  * sysfs interface
  */
-static ssize_t show_modalias(struct device *dev, struct device_attribute *attr,
+static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
                              char *buf)
 {
         char guid_string[37];
@@ -676,7 +692,11 @@ static ssize_t show_modalias(struct device *dev, struct device_attribute *attr,
 
         return sprintf(buf, "wmi:%s\n", guid_string);
 }
-static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
+
+static struct device_attribute wmi_dev_attrs[] = {
+        __ATTR_RO(modalias),
+        __ATTR_NULL
+};
 
 static int wmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
@@ -702,108 +722,51 @@ static int wmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 
 static void wmi_dev_free(struct device *dev)
 {
-        kfree(dev);
+        struct wmi_block *wmi_block = container_of(dev, struct wmi_block, dev);
+
+        kfree(wmi_block);
 }
 
 static struct class wmi_class = {
         .name = "wmi",
         .dev_release = wmi_dev_free,
         .dev_uevent = wmi_dev_uevent,
+        .dev_attrs = wmi_dev_attrs,
 };
 
-static int wmi_create_devs(void)
+static int wmi_create_device(const struct guid_block *gblock,
+                             struct wmi_block *wblock, acpi_handle handle)
 {
-        int result;
         char guid_string[37];
-        struct guid_block *gblock;
-        struct wmi_block *wblock;
-        struct list_head *p;
-        struct device *guid_dev;
-
-        /* Create devices for all the GUIDs */
-        list_for_each(p, &wmi_blocks.list) {
-                wblock = list_entry(p, struct wmi_block, list);
-
-                guid_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
-                if (!guid_dev)
-                        return -ENOMEM;
-
-                wblock->dev = guid_dev;
-
-                guid_dev->class = &wmi_class;
-                dev_set_drvdata(guid_dev, wblock);
-
-                gblock = &wblock->gblock;
 
-                wmi_gtoa(gblock->guid, guid_string);
-                dev_set_name(guid_dev, guid_string);
+        wblock->dev.class = &wmi_class;
 
-                result = device_register(guid_dev);
-                if (result)
-                        return result;
+        wmi_gtoa(gblock->guid, guid_string);
+        dev_set_name(&wblock->dev, guid_string);
 
-                result = device_create_file(guid_dev, &dev_attr_modalias);
-                if (result)
-                        return result;
-        }
+        dev_set_drvdata(&wblock->dev, wblock);
 
-        return 0;
+        return device_register(&wblock->dev);
 }
 
-static void wmi_remove_devs(void)
+static void wmi_free_devices(void)
 {
-        struct guid_block *gblock;
-        struct wmi_block *wblock;
-        struct list_head *p;
-        struct device *guid_dev;
+        struct wmi_block *wblock, *next;
 
         /* Delete devices for all the GUIDs */
-        list_for_each(p, &wmi_blocks.list) {
-                wblock = list_entry(p, struct wmi_block, list);
-
-                guid_dev = wblock->dev;
-                gblock = &wblock->gblock;
-
-                device_remove_file(guid_dev, &dev_attr_modalias);
-
-                device_unregister(guid_dev);
-        }
-}
-
-static void wmi_class_exit(void)
-{
-        wmi_remove_devs();
-        class_unregister(&wmi_class);
-}
-
-static int wmi_class_init(void)
-{
-        int ret;
-
-        ret = class_register(&wmi_class);
-        if (ret)
-                return ret;
-
-        ret = wmi_create_devs();
-        if (ret)
-                wmi_class_exit();
-
-        return ret;
+        list_for_each_entry_safe(wblock, next, &wmi_block_list, list)
+                if (wblock->dev.class)
+                        device_unregister(&wblock->dev);
 }
 
 static bool guid_already_parsed(const char *guid_string)
 {
-        struct guid_block *gblock;
         struct wmi_block *wblock;
-        struct list_head *p;
 
-        list_for_each(p, &wmi_blocks.list) {
-                wblock = list_entry(p, struct wmi_block, list);
-                gblock = &wblock->gblock;
-
-                if (strncmp(gblock->guid, guid_string, 16) == 0)
+        list_for_each_entry(wblock, &wmi_block_list, list)
+                if (memcmp(wblock->gblock.guid, guid_string, 16) == 0)
                         return true;
-        }
+
         return false;
 }
 
@@ -814,68 +777,67 @@ static acpi_status parse_wdg(acpi_handle handle)
 {
         struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
         union acpi_object *obj;
-        struct guid_block *gblock;
+        const struct guid_block *gblock;
         struct wmi_block *wblock;
-        char guid_string[37];
         acpi_status status;
+        int retval;
         u32 i, total;
 
         status = acpi_evaluate_object(handle, "_WDG", NULL, &out);
-
         if (ACPI_FAILURE(status))
-                return status;
+                return -ENXIO;
 
         obj = (union acpi_object *) out.pointer;
+        if (!obj)
+                return -ENXIO;
 
-        if (obj->type != ACPI_TYPE_BUFFER)
-                return AE_ERROR;
-
-        total = obj->buffer.length / sizeof(struct guid_block);
-
-        gblock = kmemdup(obj->buffer.pointer, obj->buffer.length, GFP_KERNEL);
-        if (!gblock) {
-                status = AE_NO_MEMORY;
+        if (obj->type != ACPI_TYPE_BUFFER) {
+                retval = -ENXIO;
                 goto out_free_pointer;
         }
 
+        gblock = (const struct guid_block *)obj->buffer.pointer;
+        total = obj->buffer.length / sizeof(struct guid_block);
+
         for (i = 0; i < total; i++) {
+                if (debug_dump_wdg)
+                        wmi_dump_wdg(&gblock[i]);
+
+                wblock = kzalloc(sizeof(struct wmi_block), GFP_KERNEL);
+                if (!wblock)
+                        return AE_NO_MEMORY;
+
+                wblock->handle = handle;
+                wblock->gblock = gblock[i];
+
                 /*
                   Some WMI devices, like those for nVidia hooks, have a
                   duplicate GUID. It's not clear what we should do in this
-                  case yet, so for now, we'll just ignore the duplicate.
-                  Anyone who wants to add support for that device can come
-                  up with a better workaround for the mess then.
+                  case yet, so for now, we'll just ignore the duplicate
+                  for device creation.
                 */
-                if (guid_already_parsed(gblock[i].guid) == true) {
-                        wmi_gtoa(gblock[i].guid, guid_string);
-                        printk(KERN_INFO PREFIX "Skipping duplicate GUID %s\n",
-                                guid_string);
-                        continue;
+                if (!guid_already_parsed(gblock[i].guid)) {
+                        retval = wmi_create_device(&gblock[i], wblock, handle);
+                        if (retval) {
+                                wmi_free_devices();
+                                goto out_free_pointer;
+                        }
                 }
-                if (debug_dump_wdg)
-                        wmi_dump_wdg(&gblock[i]);
 
-                wblock = kzalloc(sizeof(struct wmi_block), GFP_KERNEL);
-                if (!wblock) {
-                        status = AE_NO_MEMORY;
-                        goto out_free_gblock;
-                }
+                list_add_tail(&wblock->list, &wmi_block_list);
 
-                wblock->gblock = gblock[i];
-                wblock->handle = handle;
                 if (debug_event) {
                         wblock->handler = wmi_notify_debug;
-                        status = wmi_method_enable(wblock, 1);
+                        wmi_method_enable(wblock, 1);
                 }
-                list_add_tail(&wblock->list, &wmi_blocks.list);
         }
 
-out_free_gblock:
-        kfree(gblock);
+        retval = 0;
+
 out_free_pointer:
         kfree(out.pointer);
 
-        return status;
+        return retval;
 }
 
 /*
@@ -929,7 +891,7 @@ static void acpi_wmi_notify(struct acpi_device *device, u32 event)
         struct list_head *p;
         char guid_string[37];
 
-        list_for_each(p, &wmi_blocks.list) {
+        list_for_each(p, &wmi_block_list) {
                 wblock = list_entry(p, struct wmi_block, list);
                 block = &wblock->gblock;
 
@@ -939,8 +901,7 @@ static void acpi_wmi_notify(struct acpi_device *device, u32 event)
                                 wblock->handler(event, wblock->handler_data);
                         if (debug_event) {
                                 wmi_gtoa(wblock->gblock.guid, guid_string);
-                                printk(KERN_INFO PREFIX "DEBUG Event GUID:"
-                                       " %s\n", guid_string);
+                                pr_info("DEBUG Event GUID: %s\n", guid_string);
                         }
 
                         acpi_bus_generate_netlink_event(
@@ -955,6 +916,7 @@ static int acpi_wmi_remove(struct acpi_device *device, int type)
 {
         acpi_remove_address_space_handler(device->handle,
                                 ACPI_ADR_SPACE_EC, &acpi_wmi_ec_space_handler);
+        wmi_free_devices();
 
         return 0;
 }
@@ -962,68 +924,57 @@ static int acpi_wmi_remove(struct acpi_device *device, int type)
 static int acpi_wmi_add(struct acpi_device *device)
 {
         acpi_status status;
-        int result = 0;
+        int error;
 
         status = acpi_install_address_space_handler(device->handle,
                                                     ACPI_ADR_SPACE_EC,
                                                     &acpi_wmi_ec_space_handler,
                                                     NULL, NULL);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        status = parse_wdg(device->handle);
         if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR PREFIX "Error installing EC region handler\n");
+                pr_err("Error installing EC region handler\n");
                 return -ENODEV;
         }
 
-        return result;
+        error = parse_wdg(device->handle);
+        if (error) {
+                acpi_remove_address_space_handler(device->handle,
+                                                  ACPI_ADR_SPACE_EC,
+                                                  &acpi_wmi_ec_space_handler);
+                pr_err("Failed to parse WDG method\n");
+                return error;
+        }
+
+        return 0;
 }
 
 static int __init acpi_wmi_init(void)
 {
-        int result;
-
-        INIT_LIST_HEAD(&wmi_blocks.list);
+        int error;
 
         if (acpi_disabled)
                 return -ENODEV;
 
-        result = acpi_bus_register_driver(&acpi_wmi_driver);
-
-        if (result < 0) {
-                printk(KERN_INFO PREFIX "Error loading mapper\n");
-                return -ENODEV;
-        }
+        error = class_register(&wmi_class);
+        if (error)
+                return error;
 
-        result = wmi_class_init();
-        if (result) {
-                acpi_bus_unregister_driver(&acpi_wmi_driver);
-                return result;
+        error = acpi_bus_register_driver(&acpi_wmi_driver);
+        if (error) {
+                pr_err("Error loading mapper\n");
+                class_unregister(&wmi_class);
+                return error;
         }
 
-        printk(KERN_INFO PREFIX "Mapper loaded\n");
-
-        return result;
+        pr_info("Mapper loaded\n");
+        return 0;
 }
 
 static void __exit acpi_wmi_exit(void)
 {
-        struct list_head *p, *tmp;
-        struct wmi_block *wblock;
-
-        wmi_class_exit();
-
         acpi_bus_unregister_driver(&acpi_wmi_driver);
+        class_unregister(&wmi_class);
 
-        list_for_each_safe(p, tmp, &wmi_blocks.list) {
-                wblock = list_entry(p, struct wmi_block, list);
-
-                list_del(p);
-                kfree(wblock);
-        }
-
-        printk(KERN_INFO PREFIX "Mapper unloaded\n");
+        pr_info("Mapper unloaded\n");
 }
 
 subsys_initcall(acpi_wmi_init);
diff --git a/drivers/platform/x86/xo1-rfkill.c b/drivers/platform/x86/xo1-rfkill.c
new file mode 100644
index 000000000000..e549eeeda121
--- /dev/null
+++ b/drivers/platform/x86/xo1-rfkill.c
@@ -0,0 +1,85 @@
+/*
+ * Support for rfkill through the OLPC XO-1 laptop embedded controller
+ *
+ * Copyright (C) 2010 One Laptop per Child
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rfkill.h>
+
+#include <asm/olpc.h>
+
+static int rfkill_set_block(void *data, bool blocked)
+{
+        unsigned char cmd;
+        if (blocked)
+                cmd = EC_WLAN_ENTER_RESET;
+        else
+                cmd = EC_WLAN_LEAVE_RESET;
+
+        return olpc_ec_cmd(cmd, NULL, 0, NULL, 0);
+}
+
+static const struct rfkill_ops rfkill_ops = {
+        .set_block = rfkill_set_block,
+};
+
+static int __devinit xo1_rfkill_probe(struct platform_device *pdev)
+{
+        struct rfkill *rfk;
+        int r;
+
+        rfk = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_WLAN,
+                           &rfkill_ops, NULL);
+        if (!rfk)
+                return -ENOMEM;
+
+        r = rfkill_register(rfk);
+        if (r) {
+                rfkill_destroy(rfk);
+                return r;
+        }
+
+        platform_set_drvdata(pdev, rfk);
+        return 0;
+}
+
+static int __devexit xo1_rfkill_remove(struct platform_device *pdev)
+{
+        struct rfkill *rfk = platform_get_drvdata(pdev);
+        rfkill_unregister(rfk);
+        rfkill_destroy(rfk);
+        return 0;
+}
+
+static struct platform_driver xo1_rfkill_driver = {
+        .driver = {
+                .name = "xo1-rfkill",
+                .owner = THIS_MODULE,
+        },
+        .probe          = xo1_rfkill_probe,
+        .remove         = __devexit_p(xo1_rfkill_remove),
+};
+
+static int __init xo1_rfkill_init(void)
+{
+        return platform_driver_register(&xo1_rfkill_driver);
+}
+
+static void __exit xo1_rfkill_exit(void)
+{
+        platform_driver_unregister(&xo1_rfkill_driver);
+}
+
+MODULE_AUTHOR("Daniel Drake <dsd@laptop.org>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:xo1-rfkill");
+
+module_init(xo1_rfkill_init);
+module_exit(xo1_rfkill_exit);
diff --git a/drivers/platform/x86/xo15-ebook.c b/drivers/platform/x86/xo15-ebook.c
new file mode 100644
index 000000000000..fad153dc0355
--- /dev/null
+++ b/drivers/platform/x86/xo15-ebook.c
@@ -0,0 +1,181 @@
+/*
+ *  OLPC XO-1.5 ebook switch driver
+ *  (based on generic ACPI button driver)
+ *
+ *  Copyright (C) 2009 Paul Fox <pgf@laptop.org>
+ *  Copyright (C) 2010 One Laptop per Child
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or (at
+ *  your option) any later version.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#define MODULE_NAME "xo15-ebook"
+
+#define XO15_EBOOK_CLASS                MODULE_NAME
+#define XO15_EBOOK_TYPE_UNKNOWN 0x00
+#define XO15_EBOOK_NOTIFY_STATUS        0x80
+
+#define XO15_EBOOK_SUBCLASS             "ebook"
+#define XO15_EBOOK_HID                  "XO15EBK"
+#define XO15_EBOOK_DEVICE_NAME          "EBook Switch"
+
+ACPI_MODULE_NAME(MODULE_NAME);
+
+MODULE_DESCRIPTION("OLPC XO-1.5 ebook switch driver");
+MODULE_LICENSE("GPL");
+
+static const struct acpi_device_id ebook_device_ids[] = {
+        { XO15_EBOOK_HID, 0 },
+        { "", 0 },
+};
+MODULE_DEVICE_TABLE(acpi, ebook_device_ids);
+
+struct ebook_switch {
+        struct input_dev *input;
+        char phys[32];                  /* for input device */
+};
+
+static int ebook_send_state(struct acpi_device *device)
+{
+        struct ebook_switch *button = acpi_driver_data(device);
+        unsigned long long state;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "EBK", NULL, &state);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        /* input layer checks if event is redundant */
+        input_report_switch(button->input, SW_TABLET_MODE, !state);
+        input_sync(button->input);
+        return 0;
+}
+
+static void ebook_switch_notify(struct acpi_device *device, u32 event)
+{
+        switch (event) {
+        case ACPI_FIXED_HARDWARE_EVENT:
+        case XO15_EBOOK_NOTIFY_STATUS:
+                ebook_send_state(device);
+                break;
+        default:
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                                  "Unsupported event [0x%x]\n", event));
+                break;
+        }
+}
+
+static int ebook_switch_resume(struct acpi_device *device)
+{
+        return ebook_send_state(device);
+}
+
+static int ebook_switch_add(struct acpi_device *device)
+{
+        struct ebook_switch *button;
+        struct input_dev *input;
+        const char *hid = acpi_device_hid(device);
+        char *name, *class;
+        int error;
+
+        button = kzalloc(sizeof(struct ebook_switch), GFP_KERNEL);
+        if (!button)
+                return -ENOMEM;
+
+        device->driver_data = button;
+
+        button->input = input = input_allocate_device();
+        if (!input) {
+                error = -ENOMEM;
+                goto err_free_button;
+        }
+
+        name = acpi_device_name(device);
+        class = acpi_device_class(device);
+
+        if (strcmp(hid, XO15_EBOOK_HID)) {
+                pr_err("Unsupported hid [%s]\n", hid);
+                error = -ENODEV;
+                goto err_free_input;
+        }
+
+        strcpy(name, XO15_EBOOK_DEVICE_NAME);
+        sprintf(class, "%s/%s", XO15_EBOOK_CLASS, XO15_EBOOK_SUBCLASS);
+
+        snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
+
+        input->name = name;
+        input->phys = button->phys;
+        input->id.bustype = BUS_HOST;
+        input->dev.parent = &device->dev;
+
+        input->evbit[0] = BIT_MASK(EV_SW);
+        set_bit(SW_TABLET_MODE, input->swbit);
+
+        error = input_register_device(input);
+        if (error)
+                goto err_free_input;
+
+        ebook_send_state(device);
+
+        if (device->wakeup.flags.valid) {
+                /* Button's GPE is run-wake GPE */
+                acpi_enable_gpe(device->wakeup.gpe_device,
+                                device->wakeup.gpe_number);
+                device_set_wakeup_enable(&device->dev, true);
+        }
+
+        return 0;
+
+ err_free_input:
+        input_free_device(input);
+ err_free_button:
+        kfree(button);
+        return error;
+}
+
+static int ebook_switch_remove(struct acpi_device *device, int type)
+{
+        struct ebook_switch *button = acpi_driver_data(device);
+
+        input_unregister_device(button->input);
+        kfree(button);
+        return 0;
+}
+
+static struct acpi_driver xo15_ebook_driver = {
+        .name = MODULE_NAME,
+        .class = XO15_EBOOK_CLASS,
+        .ids = ebook_device_ids,
+        .ops = {
+                .add = ebook_switch_add,
+                .resume = ebook_switch_resume,
+                .remove = ebook_switch_remove,
+                .notify = ebook_switch_notify,
+        },
+};
+
+static int __init xo15_ebook_init(void)
+{
+        return acpi_bus_register_driver(&xo15_ebook_driver);
+}
+
+static void __exit xo15_ebook_exit(void)
+{
+        acpi_bus_unregister_driver(&xo15_ebook_driver);
+}
+
+module_init(xo15_ebook_init);
+module_exit(xo15_ebook_exit);