Merge branch 'for_linus' of git://cavan.codon.org.uk/platform-drivers-x86

Pull x86 platform driver update from Matthew Garrett:
 "Some small updates for a few drivers, and some hardware enablement for
  new Ideapads and the gmux hardware in the latest Macs.

  This code won't run on older devices and has been well tested on new
  ones, so low risk of regressions."

* 'for_linus' of git://cavan.codon.org.uk/platform-drivers-x86:
  ideapad: add Lenovo IdeaPad Z570 support (part 3)
  ideapad: add Lenovo IdeaPad Z570 support (part 2)
  ideapad: add Lenovo IdeaPad Z570 support (part 1)
  classmate-laptop: always call input_sync() after input_report_switch()
  thinkpad-acpi: recognize latest V-Series using DMI_BIOS_VENDOR
  dell-laptop: Fixed typo in touchpad LED quirk
  vga_switcheroo: Don't require handler init callback
  vga_switcheroo: Remove assumptions about registration/unregistration ordering
  apple-gmux: Add display mux support
  apple-gmux: Fix kconfig dependencies
  asus-wmi: record wlan status while controlled by userapp
  apple_gmux: Fix ACPI video unregister
  apple_gmux: Add support for newer hardware
  gmux: Add generic write32 function

10 files changed, 595 insertions, 67 deletions

diff --git a/drivers/gpu/drm/nouveau/nouveau_acpi.c b/drivers/gpu/drm/nouveau/nouveau_acpi.c
index fc841e87b343..26ebffebe710 100644
--- a/drivers/gpu/drm/nouveau/nouveau_acpi.c
+++ b/drivers/gpu/drm/nouveau/nouveau_acpi.c
@@ -211,11 +211,6 @@ static int nouveau_dsm_power_state(enum vga_switcheroo_client_id id,
         return nouveau_dsm_set_discrete_state(nouveau_dsm_priv.dhandle, state);
 }
 
-static int nouveau_dsm_init(void)
-{
-        return 0;
-}
-
 static int nouveau_dsm_get_client_id(struct pci_dev *pdev)
 {
         /* easy option one - intel vendor ID means Integrated */
@@ -232,7 +227,6 @@ static int nouveau_dsm_get_client_id(struct pci_dev *pdev)
 static struct vga_switcheroo_handler nouveau_dsm_handler = {
         .switchto = nouveau_dsm_switchto,
         .power_state = nouveau_dsm_power_state,
-        .init = nouveau_dsm_init,
         .get_client_id = nouveau_dsm_get_client_id,
 };
 
diff --git a/drivers/gpu/vga/vga_switcheroo.c b/drivers/gpu/vga/vga_switcheroo.c
index 5b3c7d135dc9..e25cf31faab2 100644
--- a/drivers/gpu/vga/vga_switcheroo.c
+++ b/drivers/gpu/vga/vga_switcheroo.c
@@ -70,27 +70,12 @@ static struct vgasr_priv vgasr_priv = {
         .clients = LIST_HEAD_INIT(vgasr_priv.clients),
 };
 
-int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler)
-{
-        mutex_lock(&vgasr_mutex);
-        if (vgasr_priv.handler) {
-                mutex_unlock(&vgasr_mutex);
-                return -EINVAL;
-        }
-
-        vgasr_priv.handler = handler;
-        mutex_unlock(&vgasr_mutex);
-        return 0;
-}
-EXPORT_SYMBOL(vga_switcheroo_register_handler);
-
-void vga_switcheroo_unregister_handler(void)
+static bool vga_switcheroo_ready(void)
 {
-        mutex_lock(&vgasr_mutex);
-        vgasr_priv.handler = NULL;
-        mutex_unlock(&vgasr_mutex);
+        /* we're ready if we get two clients + handler */
+        return !vgasr_priv.active &&
+               vgasr_priv.registered_clients == 2 && vgasr_priv.handler;
 }
-EXPORT_SYMBOL(vga_switcheroo_unregister_handler);
 
 static void vga_switcheroo_enable(void)
 {
@@ -98,7 +83,8 @@ static void vga_switcheroo_enable(void)
         struct vga_switcheroo_client *client;
 
         /* call the handler to init */
-        vgasr_priv.handler->init();
+        if (vgasr_priv.handler->init)
+                vgasr_priv.handler->init();
 
         list_for_each_entry(client, &vgasr_priv.clients, list) {
                 if (client->id != -1)
@@ -113,6 +99,37 @@ static void vga_switcheroo_enable(void)
         vgasr_priv.active = true;
 }
 
+int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler)
+{
+        mutex_lock(&vgasr_mutex);
+        if (vgasr_priv.handler) {
+                mutex_unlock(&vgasr_mutex);
+                return -EINVAL;
+        }
+
+        vgasr_priv.handler = handler;
+        if (vga_switcheroo_ready()) {
+                printk(KERN_INFO "vga_switcheroo: enabled\n");
+                vga_switcheroo_enable();
+        }
+        mutex_unlock(&vgasr_mutex);
+        return 0;
+}
+EXPORT_SYMBOL(vga_switcheroo_register_handler);
+
+void vga_switcheroo_unregister_handler(void)
+{
+        mutex_lock(&vgasr_mutex);
+        vgasr_priv.handler = NULL;
+        if (vgasr_priv.active) {
+                pr_info("vga_switcheroo: disabled\n");
+                vga_switcheroo_debugfs_fini(&vgasr_priv);
+                vgasr_priv.active = false;
+        }
+        mutex_unlock(&vgasr_mutex);
+}
+EXPORT_SYMBOL(vga_switcheroo_unregister_handler);
+
 static int register_client(struct pci_dev *pdev,
                            const struct vga_switcheroo_client_ops *ops,
                            int id, bool active)
@@ -134,9 +151,7 @@ static int register_client(struct pci_dev *pdev,
         if (client_is_vga(client))
                 vgasr_priv.registered_clients++;
 
-        /* if we get two clients + handler */
-        if (!vgasr_priv.active &&
-            vgasr_priv.registered_clients == 2 && vgasr_priv.handler) {
+        if (vga_switcheroo_ready()) {
                 printk(KERN_INFO "vga_switcheroo: enabled\n");
                 vga_switcheroo_enable();
         }
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 2a262f5c5c0c..c86bae828c28 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -289,6 +289,7 @@ config IDEAPAD_LAPTOP
         tristate "Lenovo IdeaPad Laptop Extras"
         depends on ACPI
         depends on RFKILL && INPUT
+        depends on SERIO_I8042
         select INPUT_SPARSEKMAP
         help
           This is a driver for the rfkill switches on Lenovo IdeaPad netbooks.
@@ -758,8 +759,11 @@ config SAMSUNG_Q10
 
 config APPLE_GMUX
         tristate "Apple Gmux Driver"
+        depends on ACPI
         depends on PNP
-        select BACKLIGHT_CLASS_DEVICE
+        depends on BACKLIGHT_CLASS_DEVICE
+        depends on BACKLIGHT_APPLE=n || BACKLIGHT_APPLE
+        depends on ACPI_VIDEO=n || ACPI_VIDEO
         ---help---
           This driver provides support for the gmux device found on many
           Apple laptops, which controls the display mux for the hybrid
diff --git a/drivers/platform/x86/apple-gmux.c b/drivers/platform/x86/apple-gmux.c
index 905fa01ac8df..dfb1a92ce949 100644
--- a/drivers/platform/x86/apple-gmux.c
+++ b/drivers/platform/x86/apple-gmux.c
@@ -2,6 +2,7 @@
  *  Gmux driver for Apple laptops
  *
  *  Copyright (C) Canonical Ltd. <seth.forshee@canonical.com>
+ *  Copyright (C) 2010-2012 Andreas Heider <andreas@meetr.de>
  *
  *  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
@@ -18,16 +19,30 @@
 #include <linux/pnp.h>
 #include <linux/apple_bl.h>
 #include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/vga_switcheroo.h>
 #include <acpi/video.h>
 #include <asm/io.h>
 
 struct apple_gmux_data {
         unsigned long iostart;
         unsigned long iolen;
+        bool indexed;
+        struct mutex index_lock;
 
         struct backlight_device *bdev;
+
+        /* switcheroo data */
+        acpi_handle dhandle;
+        int gpe;
+        enum vga_switcheroo_client_id resume_client_id;
+        enum vga_switcheroo_state power_state;
+        struct completion powerchange_done;
 };
 
+static struct apple_gmux_data *apple_gmux_data;
+
 /*
  * gmux port offsets. Many of these are not yet used, but may be in the
  * future, and it's useful to have them documented here anyhow.
@@ -45,6 +60,9 @@ struct apple_gmux_data {
 #define GMUX_PORT_DISCRETE_POWER        0x50
 #define GMUX_PORT_MAX_BRIGHTNESS        0x70
 #define GMUX_PORT_BRIGHTNESS            0x74
+#define GMUX_PORT_VALUE                 0xc2
+#define GMUX_PORT_READ                  0xd0
+#define GMUX_PORT_WRITE                 0xd4
 
 #define GMUX_MIN_IO_LEN                 (GMUX_PORT_BRIGHTNESS + 4)
 
@@ -59,22 +77,172 @@ struct apple_gmux_data {
 #define GMUX_BRIGHTNESS_MASK            0x00ffffff
 #define GMUX_MAX_BRIGHTNESS             GMUX_BRIGHTNESS_MASK
 
-static inline u8 gmux_read8(struct apple_gmux_data *gmux_data, int port)
+static u8 gmux_pio_read8(struct apple_gmux_data *gmux_data, int port)
 {
         return inb(gmux_data->iostart + port);
 }
 
-static inline void gmux_write8(struct apple_gmux_data *gmux_data, int port,
+static void gmux_pio_write8(struct apple_gmux_data *gmux_data, int port,
                                u8 val)
 {
         outb(val, gmux_data->iostart + port);
 }
 
-static inline u32 gmux_read32(struct apple_gmux_data *gmux_data, int port)
+static u32 gmux_pio_read32(struct apple_gmux_data *gmux_data, int port)
 {
         return inl(gmux_data->iostart + port);
 }
 
+static void gmux_pio_write32(struct apple_gmux_data *gmux_data, int port,
+                             u32 val)
+{
+        int i;
+        u8 tmpval;
+
+        for (i = 0; i < 4; i++) {
+                tmpval = (val >> (i * 8)) & 0xff;
+                outb(tmpval, port + i);
+        }
+}
+
+static int gmux_index_wait_ready(struct apple_gmux_data *gmux_data)
+{
+        int i = 200;
+        u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
+
+        while (i && (gwr & 0x01)) {
+                inb(gmux_data->iostart + GMUX_PORT_READ);
+                gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
+                udelay(100);
+                i--;
+        }
+
+        return !!i;
+}
+
+static int gmux_index_wait_complete(struct apple_gmux_data *gmux_data)
+{
+        int i = 200;
+        u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
+
+        while (i && !(gwr & 0x01)) {
+                gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
+                udelay(100);
+                i--;
+        }
+
+        if (gwr & 0x01)
+                inb(gmux_data->iostart + GMUX_PORT_READ);
+
+        return !!i;
+}
+
+static u8 gmux_index_read8(struct apple_gmux_data *gmux_data, int port)
+{
+        u8 val;
+
+        mutex_lock(&gmux_data->index_lock);
+        outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ);
+        gmux_index_wait_ready(gmux_data);
+        val = inb(gmux_data->iostart + GMUX_PORT_VALUE);
+        mutex_unlock(&gmux_data->index_lock);
+
+        return val;
+}
+
+static void gmux_index_write8(struct apple_gmux_data *gmux_data, int port,
+                              u8 val)
+{
+        mutex_lock(&gmux_data->index_lock);
+        outb(val, gmux_data->iostart + GMUX_PORT_VALUE);
+        gmux_index_wait_ready(gmux_data);
+        outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE);
+        gmux_index_wait_complete(gmux_data);
+        mutex_unlock(&gmux_data->index_lock);
+}
+
+static u32 gmux_index_read32(struct apple_gmux_data *gmux_data, int port)
+{
+        u32 val;
+
+        mutex_lock(&gmux_data->index_lock);
+        outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ);
+        gmux_index_wait_ready(gmux_data);
+        val = inl(gmux_data->iostart + GMUX_PORT_VALUE);
+        mutex_unlock(&gmux_data->index_lock);
+
+        return val;
+}
+
+static void gmux_index_write32(struct apple_gmux_data *gmux_data, int port,
+                               u32 val)
+{
+        int i;
+        u8 tmpval;
+
+        mutex_lock(&gmux_data->index_lock);
+
+        for (i = 0; i < 4; i++) {
+                tmpval = (val >> (i * 8)) & 0xff;
+                outb(tmpval, gmux_data->iostart + GMUX_PORT_VALUE + i);
+        }
+
+        gmux_index_wait_ready(gmux_data);
+        outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE);
+        gmux_index_wait_complete(gmux_data);
+        mutex_unlock(&gmux_data->index_lock);
+}
+
+static u8 gmux_read8(struct apple_gmux_data *gmux_data, int port)
+{
+        if (gmux_data->indexed)
+                return gmux_index_read8(gmux_data, port);
+        else
+                return gmux_pio_read8(gmux_data, port);
+}
+
+static void gmux_write8(struct apple_gmux_data *gmux_data, int port, u8 val)
+{
+        if (gmux_data->indexed)
+                gmux_index_write8(gmux_data, port, val);
+        else
+                gmux_pio_write8(gmux_data, port, val);
+}
+
+static u32 gmux_read32(struct apple_gmux_data *gmux_data, int port)
+{
+        if (gmux_data->indexed)
+                return gmux_index_read32(gmux_data, port);
+        else
+                return gmux_pio_read32(gmux_data, port);
+}
+
+static void gmux_write32(struct apple_gmux_data *gmux_data, int port,
+                             u32 val)
+{
+        if (gmux_data->indexed)
+                gmux_index_write32(gmux_data, port, val);
+        else
+                gmux_pio_write32(gmux_data, port, val);
+}
+
+static bool gmux_is_indexed(struct apple_gmux_data *gmux_data)
+{
+        u16 val;
+
+        outb(0xaa, gmux_data->iostart + 0xcc);
+        outb(0x55, gmux_data->iostart + 0xcd);
+        outb(0x00, gmux_data->iostart + 0xce);
+
+        val = inb(gmux_data->iostart + 0xcc) |
+                (inb(gmux_data->iostart + 0xcd) << 8);
+
+        if (val == 0x55aa)
+                return true;
+
+        return false;
+}
+
 static int gmux_get_brightness(struct backlight_device *bd)
 {
         struct apple_gmux_data *gmux_data = bl_get_data(bd);
@@ -90,16 +258,7 @@ static int gmux_update_status(struct backlight_device *bd)
         if (bd->props.state & BL_CORE_SUSPENDED)
                 return 0;
 
-        /*
-         * Older gmux versions require writing out lower bytes first then
-         * setting the upper byte to 0 to flush the values. Newer versions
-         * accept a single u32 write, but the old method also works, so we
-         * just use the old method for all gmux versions.
-         */
-        gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS, brightness);
-        gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS + 1, brightness >> 8);
-        gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS + 2, brightness >> 16);
-        gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS + 3, 0);
+        gmux_write32(gmux_data, GMUX_PORT_BRIGHTNESS, brightness);
 
         return 0;
 }
@@ -110,6 +269,146 @@ static const struct backlight_ops gmux_bl_ops = {
         .update_status = gmux_update_status,
 };
 
+static int gmux_switchto(enum vga_switcheroo_client_id id)
+{
+        if (id == VGA_SWITCHEROO_IGD) {
+                gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 1);
+                gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DISPLAY, 2);
+                gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 2);
+        } else {
+                gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 2);
+                gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DISPLAY, 3);
+                gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 3);
+        }
+
+        return 0;
+}
+
+static int gmux_set_discrete_state(struct apple_gmux_data *gmux_data,
+                                   enum vga_switcheroo_state state)
+{
+        INIT_COMPLETION(gmux_data->powerchange_done);
+
+        if (state == VGA_SWITCHEROO_ON) {
+                gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1);
+                gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 3);
+                pr_debug("Discrete card powered up\n");
+        } else {
+                gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1);
+                gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 0);
+                pr_debug("Discrete card powered down\n");
+        }
+
+        gmux_data->power_state = state;
+
+        if (gmux_data->gpe >= 0 &&
+            !wait_for_completion_interruptible_timeout(&gmux_data->powerchange_done,
+                                                       msecs_to_jiffies(200)))
+                pr_warn("Timeout waiting for gmux switch to complete\n");
+
+        return 0;
+}
+
+static int gmux_set_power_state(enum vga_switcheroo_client_id id,
+                                enum vga_switcheroo_state state)
+{
+        if (id == VGA_SWITCHEROO_IGD)
+                return 0;
+
+        return gmux_set_discrete_state(apple_gmux_data, state);
+}
+
+static int gmux_get_client_id(struct pci_dev *pdev)
+{
+        /*
+         * Early Macbook Pros with switchable graphics use nvidia
+         * integrated graphics. Hardcode that the 9400M is integrated.
+         */
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL)
+                return VGA_SWITCHEROO_IGD;
+        else if (pdev->vendor == PCI_VENDOR_ID_NVIDIA &&
+                 pdev->device == 0x0863)
+                return VGA_SWITCHEROO_IGD;
+        else
+                return VGA_SWITCHEROO_DIS;
+}
+
+static enum vga_switcheroo_client_id
+gmux_active_client(struct apple_gmux_data *gmux_data)
+{
+        if (gmux_read8(gmux_data, GMUX_PORT_SWITCH_DISPLAY) == 2)
+                return VGA_SWITCHEROO_IGD;
+
+        return VGA_SWITCHEROO_DIS;
+}
+
+static struct vga_switcheroo_handler gmux_handler = {
+        .switchto = gmux_switchto,
+        .power_state = gmux_set_power_state,
+        .get_client_id = gmux_get_client_id,
+};
+
+static inline void gmux_disable_interrupts(struct apple_gmux_data *gmux_data)
+{
+        gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE,
+                    GMUX_INTERRUPT_DISABLE);
+}
+
+static inline void gmux_enable_interrupts(struct apple_gmux_data *gmux_data)
+{
+        gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE,
+                    GMUX_INTERRUPT_ENABLE);
+}
+
+static inline u8 gmux_interrupt_get_status(struct apple_gmux_data *gmux_data)
+{
+        return gmux_read8(gmux_data, GMUX_PORT_INTERRUPT_STATUS);
+}
+
+static void gmux_clear_interrupts(struct apple_gmux_data *gmux_data)
+{
+        u8 status;
+
+        /* to clear interrupts write back current status */
+        status = gmux_interrupt_get_status(gmux_data);
+        gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_STATUS, status);
+}
+
+static void gmux_notify_handler(acpi_handle device, u32 value, void *context)
+{
+        u8 status;
+        struct pnp_dev *pnp = (struct pnp_dev *)context;
+        struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
+
+        status = gmux_interrupt_get_status(gmux_data);
+        gmux_disable_interrupts(gmux_data);
+        pr_debug("Notify handler called: status %d\n", status);
+
+        gmux_clear_interrupts(gmux_data);
+        gmux_enable_interrupts(gmux_data);
+
+        if (status & GMUX_INTERRUPT_STATUS_POWER)
+                complete(&gmux_data->powerchange_done);
+}
+
+static int gmux_suspend(struct pnp_dev *pnp, pm_message_t state)
+{
+        struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
+        gmux_data->resume_client_id = gmux_active_client(gmux_data);
+        gmux_disable_interrupts(gmux_data);
+        return 0;
+}
+
+static int gmux_resume(struct pnp_dev *pnp)
+{
+        struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
+        gmux_enable_interrupts(gmux_data);
+        gmux_switchto(gmux_data->resume_client_id);
+        if (gmux_data->power_state == VGA_SWITCHEROO_OFF)
+                gmux_set_discrete_state(gmux_data, gmux_data->power_state);
+        return 0;
+}
+
 static int __devinit gmux_probe(struct pnp_dev *pnp,
                                 const struct pnp_device_id *id)
 {
@@ -119,6 +418,11 @@ static int __devinit gmux_probe(struct pnp_dev *pnp,
         struct backlight_device *bdev;
         u8 ver_major, ver_minor, ver_release;
         int ret = -ENXIO;
+        acpi_status status;
+        unsigned long long gpe;
+
+        if (apple_gmux_data)
+                return -EBUSY;
 
         gmux_data = kzalloc(sizeof(*gmux_data), GFP_KERNEL);
         if (!gmux_data)
@@ -147,22 +451,29 @@ static int __devinit gmux_probe(struct pnp_dev *pnp,
         }
 
         /*
-         * On some machines the gmux is in ACPI even thought the machine
-         * doesn't really have a gmux. Check for invalid version information
-         * to detect this.
+         * Invalid version information may indicate either that the gmux
+         * device isn't present or that it's a new one that uses indexed
+         * io
          */
+
         ver_major = gmux_read8(gmux_data, GMUX_PORT_VERSION_MAJOR);
         ver_minor = gmux_read8(gmux_data, GMUX_PORT_VERSION_MINOR);
         ver_release = gmux_read8(gmux_data, GMUX_PORT_VERSION_RELEASE);
         if (ver_major == 0xff && ver_minor == 0xff && ver_release == 0xff) {
-                pr_info("gmux device not present\n");
-                ret = -ENODEV;
-                goto err_release;
+                if (gmux_is_indexed(gmux_data)) {
+                        mutex_init(&gmux_data->index_lock);
+                        gmux_data->indexed = true;
+                } else {
+                        pr_info("gmux device not present\n");
+                        ret = -ENODEV;
+                        goto err_release;
+                }
+                pr_info("Found indexed gmux\n");
+        } else {
+                pr_info("Found gmux version %d.%d.%d\n", ver_major, ver_minor,
+                        ver_release);
         }
 
-        pr_info("Found gmux version %d.%d.%d\n", ver_major, ver_minor,
-                ver_release);
-
         memset(&props, 0, sizeof(props));
         props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = gmux_read32(gmux_data, GMUX_PORT_MAX_BRIGHTNESS);
@@ -194,13 +505,67 @@ static int __devinit gmux_probe(struct pnp_dev *pnp,
          * Disable the other backlight choices.
          */
         acpi_video_dmi_promote_vendor();
-#ifdef CONFIG_ACPI_VIDEO
+#if defined (CONFIG_ACPI_VIDEO) || defined (CONFIG_ACPI_VIDEO_MODULE)
         acpi_video_unregister();
 #endif
         apple_bl_unregister();
 
+        gmux_data->power_state = VGA_SWITCHEROO_ON;
+
+        gmux_data->dhandle = DEVICE_ACPI_HANDLE(&pnp->dev);
+        if (!gmux_data->dhandle) {
+                pr_err("Cannot find acpi handle for pnp device %s\n",
+                       dev_name(&pnp->dev));
+                ret = -ENODEV;
+                goto err_notify;
+        }
+
+        status = acpi_evaluate_integer(gmux_data->dhandle, "GMGP", NULL, &gpe);
+        if (ACPI_SUCCESS(status)) {
+                gmux_data->gpe = (int)gpe;
+
+                status = acpi_install_notify_handler(gmux_data->dhandle,
+                                                     ACPI_DEVICE_NOTIFY,
+                                                     &gmux_notify_handler, pnp);
+                if (ACPI_FAILURE(status)) {
+                        pr_err("Install notify handler failed: %s\n",
+                               acpi_format_exception(status));
+                        ret = -ENODEV;
+                        goto err_notify;
+                }
+
+                status = acpi_enable_gpe(NULL, gmux_data->gpe);
+                if (ACPI_FAILURE(status)) {
+                        pr_err("Cannot enable gpe: %s\n",
+                               acpi_format_exception(status));
+                        goto err_enable_gpe;
+                }
+        } else {
+                pr_warn("No GPE found for gmux\n");
+                gmux_data->gpe = -1;
+        }
+
+        if (vga_switcheroo_register_handler(&gmux_handler)) {
+                ret = -ENODEV;
+                goto err_register_handler;
+        }
+
+        init_completion(&gmux_data->powerchange_done);
+        apple_gmux_data = gmux_data;
+        gmux_enable_interrupts(gmux_data);
+
         return 0;
 
+err_register_handler:
+        if (gmux_data->gpe >= 0)
+                acpi_disable_gpe(NULL, gmux_data->gpe);
+err_enable_gpe:
+        if (gmux_data->gpe >= 0)
+                acpi_remove_notify_handler(gmux_data->dhandle,
+                                           ACPI_DEVICE_NOTIFY,
+                                           &gmux_notify_handler);
+err_notify:
+        backlight_device_unregister(bdev);
 err_release:
         release_region(gmux_data->iostart, gmux_data->iolen);
 err_free:
@@ -212,12 +577,23 @@ static void __devexit gmux_remove(struct pnp_dev *pnp)
 {
         struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
 
+        vga_switcheroo_unregister_handler();
+        gmux_disable_interrupts(gmux_data);
+        if (gmux_data->gpe >= 0) {
+                acpi_disable_gpe(NULL, gmux_data->gpe);
+                acpi_remove_notify_handler(gmux_data->dhandle,
+                                           ACPI_DEVICE_NOTIFY,
+                                           &gmux_notify_handler);
+        }
+
         backlight_device_unregister(gmux_data->bdev);
+
         release_region(gmux_data->iostart, gmux_data->iolen);
+        apple_gmux_data = NULL;
         kfree(gmux_data);
 
         acpi_video_dmi_demote_vendor();
-#ifdef CONFIG_ACPI_VIDEO
+#if defined (CONFIG_ACPI_VIDEO) || defined (CONFIG_ACPI_VIDEO_MODULE)
         acpi_video_register();
 #endif
         apple_bl_register();
@@ -233,6 +609,8 @@ static struct pnp_driver gmux_pnp_driver = {
         .probe          = gmux_probe,
         .remove         = __devexit_p(gmux_remove),
         .id_table       = gmux_device_ids,
+        .suspend        = gmux_suspend,
+        .resume         = gmux_resume
 };
 
 static int __init apple_gmux_init(void)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index c7a36f6b0580..2eb9fe8e8efd 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -101,6 +101,7 @@ MODULE_LICENSE("GPL");
 #define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
 #define ASUS_WMI_DEVID_CWAP             0x00010003
 #define ASUS_WMI_DEVID_WLAN             0x00010011
+#define ASUS_WMI_DEVID_WLAN_LED         0x00010012
 #define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
 #define ASUS_WMI_DEVID_GPS              0x00010015
 #define ASUS_WMI_DEVID_WIMAX            0x00010017
@@ -731,8 +732,21 @@ static int asus_rfkill_set(void *data, bool blocked)
 {
         struct asus_rfkill *priv = data;
         u32 ctrl_param = !blocked;
+        u32 dev_id = priv->dev_id;
 
-        return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
+        /*
+         * If the user bit is set, BIOS can't set and record the wlan status,
+         * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
+         * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
+         * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
+         * while setting the wlan status through WMI.
+         * This is also the behavior that windows app will do.
+         */
+        if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
+             priv->asus->driver->wlan_ctrl_by_user)
+                dev_id = ASUS_WMI_DEVID_WLAN_LED;
+
+        return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
 }
 
 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
@@ -1653,6 +1667,7 @@ static int asus_wmi_add(struct platform_device *pdev)
         struct asus_wmi *asus;
         acpi_status status;
         int err;
+        u32 result;
 
         asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
         if (!asus)
@@ -1711,6 +1726,10 @@ static int asus_wmi_add(struct platform_device *pdev)
         if (err)
                 goto fail_debugfs;
 
+        asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
+        if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
+                asus->driver->wlan_ctrl_by_user = 1;
+
         return 0;
 
 fail_debugfs:
diff --git a/drivers/platform/x86/asus-wmi.h b/drivers/platform/x86/asus-wmi.h
index 9c1da8b81bea..4c9bd38bb0a2 100644
--- a/drivers/platform/x86/asus-wmi.h
+++ b/drivers/platform/x86/asus-wmi.h
@@ -46,6 +46,7 @@ struct quirk_entry {
 struct asus_wmi_driver {
         int                     brightness;
         int                     panel_power;
+        int                     wlan_ctrl_by_user;
 
         const char              *name;
         struct module           *owner;
diff --git a/drivers/platform/x86/classmate-laptop.c b/drivers/platform/x86/classmate-laptop.c
index cd33add118ce..c87ff16873f9 100644
--- a/drivers/platform/x86/classmate-laptop.c
+++ b/drivers/platform/x86/classmate-laptop.c
@@ -725,8 +725,10 @@ static void cmpc_tablet_handler(struct acpi_device *dev, u32 event)
         struct input_dev *inputdev = dev_get_drvdata(&dev->dev);
 
         if (event == 0x81) {
-                if (ACPI_SUCCESS(cmpc_get_tablet(dev->handle, &val)))
+                if (ACPI_SUCCESS(cmpc_get_tablet(dev->handle, &val))) {
                         input_report_switch(inputdev, SW_TABLET_MODE, !val);
+                        input_sync(inputdev);
+                }
         }
 }
 
@@ -739,8 +741,10 @@ static void cmpc_tablet_idev_init(struct input_dev *inputdev)
         set_bit(SW_TABLET_MODE, inputdev->swbit);
 
         acpi = to_acpi_device(inputdev->dev.parent);
-        if (ACPI_SUCCESS(cmpc_get_tablet(acpi->handle, &val)))
+        if (ACPI_SUCCESS(cmpc_get_tablet(acpi->handle, &val))) {
                 input_report_switch(inputdev, SW_TABLET_MODE, !val);
+                input_sync(inputdev);
+        }
 }
 
 static int cmpc_tablet_add(struct acpi_device *acpi)
@@ -760,8 +764,10 @@ static int cmpc_tablet_resume(struct device *dev)
         struct input_dev *inputdev = dev_get_drvdata(dev);
 
         unsigned long long val = 0;
-        if (ACPI_SUCCESS(cmpc_get_tablet(to_acpi_device(dev)->handle, &val)))
+        if (ACPI_SUCCESS(cmpc_get_tablet(to_acpi_device(dev)->handle, &val))) {
                 input_report_switch(inputdev, SW_TABLET_MODE, !val);
+                input_sync(inputdev);
+        }
         return 0;
 }
 #endif
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index 4e96e8c0b60f..927c33af67ec 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -211,7 +211,7 @@ static struct dmi_system_id __devinitdata dell_quirks[] = {
                 .ident = "Dell Inspiron 5420",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "Isnpiron 5420"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5420"),
                 },
                 .driver_data = &quirk_dell_vostro_v130,
         },
@@ -220,7 +220,7 @@ static struct dmi_system_id __devinitdata dell_quirks[] = {
                 .ident = "Dell Inspiron 5520",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "Isnpiron 5520"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5520"),
                 },
                 .driver_data = &quirk_dell_vostro_v130,
         },
@@ -229,7 +229,7 @@ static struct dmi_system_id __devinitdata dell_quirks[] = {
                 .ident = "Dell Inspiron 5720",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "Isnpiron 5720"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5720"),
                 },
                 .driver_data = &quirk_dell_vostro_v130,
         },
@@ -238,7 +238,7 @@ static struct dmi_system_id __devinitdata dell_quirks[] = {
                 .ident = "Dell Inspiron 7420",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "Isnpiron 7420"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7420"),
                 },
                 .driver_data = &quirk_dell_vostro_v130,
         },
@@ -247,7 +247,7 @@ static struct dmi_system_id __devinitdata dell_quirks[] = {
                 .ident = "Dell Inspiron 7520",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "Isnpiron 7520"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7520"),
                 },
                 .driver_data = &quirk_dell_vostro_v130,
         },
@@ -256,7 +256,7 @@ static struct dmi_system_id __devinitdata dell_quirks[] = {
                 .ident = "Dell Inspiron 7720",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "Isnpiron 7720"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7720"),
                 },
                 .driver_data = &quirk_dell_vostro_v130,
         },
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 17f6dfd8dbfb..dae7abe1d711 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -36,6 +36,7 @@
 #include <linux/fb.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
+#include <linux/i8042.h>
 
 #define IDEAPAD_RFKILL_DEV_NUM  (3)
 
@@ -63,8 +64,11 @@ enum {
         VPCCMD_R_3G,
         VPCCMD_W_3G,
         VPCCMD_R_ODD, /* 0x21 */
-        VPCCMD_R_RF = 0x23,
+        VPCCMD_W_FAN,
+        VPCCMD_R_RF,
         VPCCMD_W_RF,
+        VPCCMD_R_FAN = 0x2B,
+        VPCCMD_R_SPECIAL_BUTTONS = 0x31,
         VPCCMD_W_BL_POWER = 0x33,
 };
 
@@ -356,14 +360,46 @@ static ssize_t store_ideapad_cam(struct device *dev,
                 return -EINVAL;
         ret = write_ec_cmd(ideapad_handle, VPCCMD_W_CAMERA, state);
         if (ret < 0)
-                return ret;
+                return -EIO;
         return count;
 }
 
 static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
 
+static ssize_t show_ideapad_fan(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        unsigned long result;
+
+        if (read_ec_data(ideapad_handle, VPCCMD_R_FAN, &result))
+                return sprintf(buf, "-1\n");
+        return sprintf(buf, "%lu\n", result);
+}
+
+static ssize_t store_ideapad_fan(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;
+        if (state < 0 || state > 4 || state == 3)
+                return -EINVAL;
+        ret = write_ec_cmd(ideapad_handle, VPCCMD_W_FAN, state);
+        if (ret < 0)
+                return -EIO;
+        return count;
+}
+
+static DEVICE_ATTR(fan_mode, 0644, show_ideapad_fan, store_ideapad_fan);
+
 static struct attribute *ideapad_attributes[] = {
         &dev_attr_camera_power.attr,
+        &dev_attr_fan_mode.attr,
         NULL
 };
 
@@ -377,7 +413,10 @@ static umode_t ideapad_is_visible(struct kobject *kobj,
 
         if (attr == &dev_attr_camera_power.attr)
                 supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
-        else
+        else if (attr == &dev_attr_fan_mode.attr) {
+                unsigned long value;
+                supported = !read_ec_data(ideapad_handle, VPCCMD_R_FAN, &value);
+        } else
                 supported = true;
 
         return supported ? attr->mode : 0;
@@ -518,9 +557,15 @@ static void ideapad_platform_exit(struct ideapad_private *priv)
  */
 static const struct key_entry ideapad_keymap[] = {
         { KE_KEY, 6,  { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 7,  { KEY_CAMERA } },
+        { KE_KEY, 11, { KEY_F16 } },
         { KE_KEY, 13, { KEY_WLAN } },
         { KE_KEY, 16, { KEY_PROG1 } },
         { KE_KEY, 17, { KEY_PROG2 } },
+        { KE_KEY, 64, { KEY_PROG3 } },
+        { KE_KEY, 65, { KEY_PROG4 } },
+        { KE_KEY, 66, { KEY_TOUCHPAD_OFF } },
+        { KE_KEY, 67, { KEY_TOUCHPAD_ON } },
         { KE_END, 0 },
 };
 
@@ -587,6 +632,28 @@ static void ideapad_input_novokey(struct ideapad_private *priv)
                 ideapad_input_report(priv, 16);
 }
 
+static void ideapad_check_special_buttons(struct ideapad_private *priv)
+{
+        unsigned long bit, value;
+
+        read_ec_data(ideapad_handle, VPCCMD_R_SPECIAL_BUTTONS, &value);
+
+        for (bit = 0; bit < 16; bit++) {
+                if (test_bit(bit, &value)) {
+                        switch (bit) {
+                        case 6:
+                                /* Thermal Management button */
+                                ideapad_input_report(priv, 65);
+                                break;
+                        case 1:
+                                /* OneKey Theater button */
+                                ideapad_input_report(priv, 64);
+                                break;
+                        }
+                }
+        }
+}
+
 /*
  * backlight
  */
@@ -691,6 +758,24 @@ static const struct acpi_device_id ideapad_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
 
+static void ideapad_sync_touchpad_state(struct acpi_device *adevice)
+{
+        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+        unsigned long value;
+
+        /* Without reading from EC touchpad LED doesn't switch state */
+        if (!read_ec_data(adevice->handle, VPCCMD_R_TOUCHPAD, &value)) {
+                /* Some IdeaPads don't really turn off touchpad - they only
+                 * switch the LED state. We (de)activate KBC AUX port to turn
+                 * touchpad off and on. We send KEY_TOUCHPAD_OFF and
+                 * KEY_TOUCHPAD_ON to not to get out of sync with LED */
+                unsigned char param;
+                i8042_command(&param, value ? I8042_CMD_AUX_ENABLE :
+                              I8042_CMD_AUX_DISABLE);
+                ideapad_input_report(priv, value ? 67 : 66);
+        }
+}
+
 static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
 {
         int ret, i;
@@ -727,6 +812,7 @@ static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
                         priv->rfk[i] = NULL;
         }
         ideapad_sync_rfk_state(priv);
+        ideapad_sync_touchpad_state(adevice);
 
         if (!acpi_video_backlight_support()) {
                 ret = ideapad_backlight_init(priv);
@@ -785,9 +871,14 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
                                 ideapad_sync_rfk_state(priv);
                                 break;
                         case 13:
+                        case 11:
+                        case 7:
                         case 6:
                                 ideapad_input_report(priv, vpc_bit);
                                 break;
+                        case 5:
+                                ideapad_sync_touchpad_state(adevice);
+                                break;
                         case 4:
                                 ideapad_backlight_notify_brightness(priv);
                                 break;
@@ -797,6 +888,9 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
                         case 2:
                                 ideapad_backlight_notify_power(priv);
                                 break;
+                        case 0:
+                                ideapad_check_special_buttons(priv);
+                                break;
                         default:
                                 pr_info("Unknown event: %lu\n", vpc_bit);
                         }
@@ -804,6 +898,15 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
         }
 }
 
+static int ideapad_acpi_resume(struct device *device)
+{
+        ideapad_sync_rfk_state(ideapad_priv);
+        ideapad_sync_touchpad_state(to_acpi_device(device));
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
+
 static struct acpi_driver ideapad_acpi_driver = {
         .name = "ideapad_acpi",
         .class = "IdeaPad",
@@ -811,6 +914,7 @@ static struct acpi_driver ideapad_acpi_driver = {
         .ops.add = ideapad_acpi_add,
         .ops.remove = ideapad_acpi_remove,
         .ops.notify = ideapad_acpi_notify,
+        .drv.pm = &ideapad_pm,
         .owner = THIS_MODULE,
 };
 
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index f28f36ccdcf4..80e377949314 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -8664,6 +8664,13 @@ static int __must_check __init get_thinkpad_model_data(
                 tp->model_str = kstrdup(s, GFP_KERNEL);
                 if (!tp->model_str)
                         return -ENOMEM;
+        } else {
+                s = dmi_get_system_info(DMI_BIOS_VENDOR);
+                if (s && !(strnicmp(s, "Lenovo", 6))) {
+                        tp->model_str = kstrdup(s, GFP_KERNEL);
+                        if (!tp->model_str)
+                                return -ENOMEM;
+                }
         }
 
         s = dmi_get_system_info(DMI_PRODUCT_NAME);