1 files changed, 217 insertions, 34 deletions

diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 0c595410e788..a36addf106a0 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -34,6 +34,8 @@
 #include <linux/input/sparse-keymap.h>
 #include <linux/backlight.h>
 #include <linux/fb.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 
 #define IDEAPAD_RFKILL_DEV_NUM  (3)
 
@@ -42,15 +44,41 @@
 #define CFG_WIFI_BIT    (18)
 #define CFG_CAMERA_BIT  (19)
 
+enum {
+        VPCCMD_R_VPC1 = 0x10,
+        VPCCMD_R_BL_MAX,
+        VPCCMD_R_BL,
+        VPCCMD_W_BL,
+        VPCCMD_R_WIFI,
+        VPCCMD_W_WIFI,
+        VPCCMD_R_BT,
+        VPCCMD_W_BT,
+        VPCCMD_R_BL_POWER,
+        VPCCMD_R_NOVO,
+        VPCCMD_R_VPC2,
+        VPCCMD_R_TOUCHPAD,
+        VPCCMD_W_TOUCHPAD,
+        VPCCMD_R_CAMERA,
+        VPCCMD_W_CAMERA,
+        VPCCMD_R_3G,
+        VPCCMD_W_3G,
+        VPCCMD_R_ODD, /* 0x21 */
+        VPCCMD_R_RF = 0x23,
+        VPCCMD_W_RF,
+        VPCCMD_W_BL_POWER = 0x33,
+};
+
 struct ideapad_private {
         struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
         struct platform_device *platform_device;
         struct input_dev *inputdev;
         struct backlight_device *blightdev;
+        struct dentry *debug;
         unsigned long cfg;
 };
 
 static acpi_handle ideapad_handle;
+static struct ideapad_private *ideapad_priv;
 static bool no_bt_rfkill;
 module_param(no_bt_rfkill, bool, 0444);
 MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");
@@ -164,6 +192,146 @@ static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
 }
 
 /*
+ * debugfs
+ */
+#define DEBUGFS_EVENT_LEN (4096)
+static int debugfs_status_show(struct seq_file *s, void *data)
+{
+        unsigned long value;
+
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_BL_MAX, &value))
+                seq_printf(s, "Backlight max:\t%lu\n", value);
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_BL, &value))
+                seq_printf(s, "Backlight now:\t%lu\n", value);
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &value))
+                seq_printf(s, "BL power value:\t%s\n", value ? "On" : "Off");
+        seq_printf(s, "=====================\n");
+
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_RF, &value))
+                seq_printf(s, "Radio status:\t%s(%lu)\n",
+                           value ? "On" : "Off", value);
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_WIFI, &value))
+                seq_printf(s, "Wifi status:\t%s(%lu)\n",
+                           value ? "On" : "Off", value);
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_BT, &value))
+                seq_printf(s, "BT status:\t%s(%lu)\n",
+                           value ? "On" : "Off", value);
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_3G, &value))
+                seq_printf(s, "3G status:\t%s(%lu)\n",
+                           value ? "On" : "Off", value);
+        seq_printf(s, "=====================\n");
+
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_TOUCHPAD, &value))
+                seq_printf(s, "Touchpad status:%s(%lu)\n",
+                           value ? "On" : "Off", value);
+        if (!read_ec_data(ideapad_handle, VPCCMD_R_CAMERA, &value))
+                seq_printf(s, "Camera status:\t%s(%lu)\n",
+                           value ? "On" : "Off", value);
+
+        return 0;
+}
+
+static int debugfs_status_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, debugfs_status_show, NULL);
+}
+
+static const struct file_operations debugfs_status_fops = {
+        .owner = THIS_MODULE,
+        .open = debugfs_status_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static int debugfs_cfg_show(struct seq_file *s, void *data)
+{
+        if (!ideapad_priv) {
+                seq_printf(s, "cfg: N/A\n");
+        } else {
+                seq_printf(s, "cfg: 0x%.8lX\n\nCapability: ",
+                           ideapad_priv->cfg);
+                if (test_bit(CFG_BT_BIT, &ideapad_priv->cfg))
+                        seq_printf(s, "Bluetooth ");
+                if (test_bit(CFG_3G_BIT, &ideapad_priv->cfg))
+                        seq_printf(s, "3G ");
+                if (test_bit(CFG_WIFI_BIT, &ideapad_priv->cfg))
+                        seq_printf(s, "Wireless ");
+                if (test_bit(CFG_CAMERA_BIT, &ideapad_priv->cfg))
+                        seq_printf(s, "Camera ");
+                seq_printf(s, "\nGraphic: ");
+                switch ((ideapad_priv->cfg)&0x700) {
+                case 0x100:
+                        seq_printf(s, "Intel");
+                        break;
+                case 0x200:
+                        seq_printf(s, "ATI");
+                        break;
+                case 0x300:
+                        seq_printf(s, "Nvidia");
+                        break;
+                case 0x400:
+                        seq_printf(s, "Intel and ATI");
+                        break;
+                case 0x500:
+                        seq_printf(s, "Intel and Nvidia");
+                        break;
+                }
+                seq_printf(s, "\n");
+        }
+        return 0;
+}
+
+static int debugfs_cfg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, debugfs_cfg_show, NULL);
+}
+
+static const struct file_operations debugfs_cfg_fops = {
+        .owner = THIS_MODULE,
+        .open = debugfs_cfg_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static int __devinit ideapad_debugfs_init(struct ideapad_private *priv)
+{
+        struct dentry *node;
+
+        priv->debug = debugfs_create_dir("ideapad", NULL);
+        if (priv->debug == NULL) {
+                pr_err("failed to create debugfs directory");
+                goto errout;
+        }
+
+        node = debugfs_create_file("cfg", S_IRUGO, priv->debug, NULL,
+                                   &debugfs_cfg_fops);
+        if (!node) {
+                pr_err("failed to create cfg in debugfs");
+                goto errout;
+        }
+
+        node = debugfs_create_file("status", S_IRUGO, priv->debug, NULL,
+                                   &debugfs_status_fops);
+        if (!node) {
+                pr_err("failed to create event in debugfs");
+                goto errout;
+        }
+
+        return 0;
+
+errout:
+        return -ENOMEM;
+}
+
+static void ideapad_debugfs_exit(struct ideapad_private *priv)
+{
+        debugfs_remove_recursive(priv->debug);
+        priv->debug = NULL;
+}
+
+/*
  * sysfs
  */
 static ssize_t show_ideapad_cam(struct device *dev,
@@ -172,7 +340,7 @@ static ssize_t show_ideapad_cam(struct device *dev,
 {
         unsigned long result;
 
-        if (read_ec_data(ideapad_handle, 0x1D, &result))
+        if (read_ec_data(ideapad_handle, VPCCMD_R_CAMERA, &result))
                 return sprintf(buf, "-1\n");
         return sprintf(buf, "%lu\n", result);
 }
@@ -187,7 +355,7 @@ static ssize_t store_ideapad_cam(struct device *dev,
                 return 0;
         if (sscanf(buf, "%i", &state) != 1)
                 return -EINVAL;
-        ret = write_ec_cmd(ideapad_handle, 0x1E, state);
+        ret = write_ec_cmd(ideapad_handle, VPCCMD_W_CAMERA, state);
         if (ret < 0)
                 return ret;
         return count;
@@ -195,20 +363,8 @@ static ssize_t store_ideapad_cam(struct device *dev,
 
 static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
 
-static ssize_t show_ideapad_cfg(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
-{
-        struct ideapad_private *priv = dev_get_drvdata(dev);
-
-        return sprintf(buf, "0x%.8lX\n", priv->cfg);
-}
-
-static DEVICE_ATTR(cfg, 0444, show_ideapad_cfg, NULL);
-
 static struct attribute *ideapad_attributes[] = {
         &dev_attr_camera_power.attr,
-        &dev_attr_cfg.attr,
         NULL
 };
 
@@ -244,9 +400,9 @@ struct ideapad_rfk_data {
 };
 
 const struct ideapad_rfk_data ideapad_rfk_data[] = {
-        { "ideapad_wlan",      CFG_WIFI_BIT, 0x15, RFKILL_TYPE_WLAN },
-        { "ideapad_bluetooth", CFG_BT_BIT,   0x17, RFKILL_TYPE_BLUETOOTH },
-        { "ideapad_3g",        CFG_3G_BIT,   0x20, RFKILL_TYPE_WWAN },
+        { "ideapad_wlan",    CFG_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
+        { "ideapad_bluetooth", CFG_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH },
+        { "ideapad_3g",        CFG_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN },
 };
 
 static int ideapad_rfk_set(void *data, bool blocked)
@@ -260,13 +416,12 @@ static struct rfkill_ops ideapad_rfk_ops = {
         .set_block = ideapad_rfk_set,
 };
 
-static void ideapad_sync_rfk_state(struct acpi_device *adevice)
+static void ideapad_sync_rfk_state(struct ideapad_private *priv)
 {
-        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
         unsigned long hw_blocked;
         int i;
 
-        if (read_ec_data(ideapad_handle, 0x23, &hw_blocked))
+        if (read_ec_data(ideapad_handle, VPCCMD_R_RF, &hw_blocked))
                 return;
         hw_blocked = !hw_blocked;
 
@@ -363,8 +518,10 @@ static void ideapad_platform_exit(struct ideapad_private *priv)
  * input device
  */
 static const struct key_entry ideapad_keymap[] = {
-        { KE_KEY, 0x06, { KEY_SWITCHVIDEOMODE } },
-        { KE_KEY, 0x0D, { KEY_WLAN } },
+        { KE_KEY, 6,  { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 13, { KEY_WLAN } },
+        { KE_KEY, 16, { KEY_PROG1 } },
+        { KE_KEY, 17, { KEY_PROG2 } },
         { KE_END, 0 },
 };
 
@@ -419,6 +576,18 @@ static void ideapad_input_report(struct ideapad_private *priv,
         sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
 }
 
+static void ideapad_input_novokey(struct ideapad_private *priv)
+{
+        unsigned long long_pressed;
+
+        if (read_ec_data(ideapad_handle, VPCCMD_R_NOVO, &long_pressed))
+                return;
+        if (long_pressed)
+                ideapad_input_report(priv, 17);
+        else
+                ideapad_input_report(priv, 16);
+}
+
 /*
  * backlight
  */
@@ -426,16 +595,17 @@ static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
 {
         unsigned long now;
 
-        if (read_ec_data(ideapad_handle, 0x12, &now))
+        if (read_ec_data(ideapad_handle, VPCCMD_R_BL, &now))
                 return -EIO;
         return now;
 }
 
 static int ideapad_backlight_update_status(struct backlight_device *blightdev)
 {
-        if (write_ec_cmd(ideapad_handle, 0x13, blightdev->props.brightness))
+        if (write_ec_cmd(ideapad_handle, VPCCMD_W_BL,
+                         blightdev->props.brightness))
                 return -EIO;
-        if (write_ec_cmd(ideapad_handle, 0x33,
+        if (write_ec_cmd(ideapad_handle, VPCCMD_W_BL_POWER,
                          blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
                 return -EIO;
 
@@ -453,11 +623,11 @@ static int ideapad_backlight_init(struct ideapad_private *priv)
         struct backlight_properties props;
         unsigned long max, now, power;
 
-        if (read_ec_data(ideapad_handle, 0x11, &max))
+        if (read_ec_data(ideapad_handle, VPCCMD_R_BL_MAX, &max))
                 return -EIO;
-        if (read_ec_data(ideapad_handle, 0x12, &now))
+        if (read_ec_data(ideapad_handle, VPCCMD_R_BL, &now))
                 return -EIO;
-        if (read_ec_data(ideapad_handle, 0x18, &power))
+        if (read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &power))
                 return -EIO;
 
         memset(&props, 0, sizeof(struct backlight_properties));
@@ -493,7 +663,9 @@ static void ideapad_backlight_notify_power(struct ideapad_private *priv)
         unsigned long power;
         struct backlight_device *blightdev = priv->blightdev;
 
-        if (read_ec_data(ideapad_handle, 0x18, &power))
+        if (!blightdev)
+                return;
+        if (read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &power))
                 return;
         blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
 }
@@ -504,7 +676,7 @@ static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
 
         /* if we control brightness via acpi video driver */
         if (priv->blightdev == NULL) {
-                read_ec_data(ideapad_handle, 0x12, &now);
+                read_ec_data(ideapad_handle, VPCCMD_R_BL, &now);
                 return;
         }
 
@@ -533,6 +705,7 @@ static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
         if (!priv)
                 return -ENOMEM;
         dev_set_drvdata(&adevice->dev, priv);
+        ideapad_priv = priv;
         ideapad_handle = adevice->handle;
         priv->cfg = cfg;
 
@@ -540,6 +713,10 @@ static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
         if (ret)
                 goto platform_failed;
 
+        ret = ideapad_debugfs_init(priv);
+        if (ret)
+                goto debugfs_failed;
+
         ret = ideapad_input_init(priv);
         if (ret)
                 goto input_failed;
@@ -550,7 +727,7 @@ static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
                 else
                         priv->rfk[i] = NULL;
         }
-        ideapad_sync_rfk_state(adevice);
+        ideapad_sync_rfk_state(priv);
 
         if (!acpi_video_backlight_support()) {
                 ret = ideapad_backlight_init(priv);
@@ -565,6 +742,8 @@ backlight_failed:
                 ideapad_unregister_rfkill(adevice, i);
         ideapad_input_exit(priv);
 input_failed:
+        ideapad_debugfs_exit(priv);
+debugfs_failed:
         ideapad_platform_exit(priv);
 platform_failed:
         kfree(priv);
@@ -580,6 +759,7 @@ static int __devexit ideapad_acpi_remove(struct acpi_device *adevice, int type)
         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
                 ideapad_unregister_rfkill(adevice, i);
         ideapad_input_exit(priv);
+        ideapad_debugfs_exit(priv);
         ideapad_platform_exit(priv);
         dev_set_drvdata(&adevice->dev, NULL);
         kfree(priv);
@@ -593,9 +773,9 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
         acpi_handle handle = adevice->handle;
         unsigned long vpc1, vpc2, vpc_bit;
 
-        if (read_ec_data(handle, 0x10, &vpc1))
+        if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
                 return;
-        if (read_ec_data(handle, 0x1A, &vpc2))
+        if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
                 return;
 
         vpc1 = (vpc2 << 8) | vpc1;
@@ -603,11 +783,14 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
                 if (test_bit(vpc_bit, &vpc1)) {
                         switch (vpc_bit) {
                         case 9:
-                                ideapad_sync_rfk_state(adevice);
+                                ideapad_sync_rfk_state(priv);
                                 break;
                         case 4:
                                 ideapad_backlight_notify_brightness(priv);
                                 break;
+                        case 3:
+                                ideapad_input_novokey(priv);
+                                break;
                         case 2:
                                 ideapad_backlight_notify_power(priv);
                                 break;