ideapad_laptop: introduce struct acpi_device pointer to ideapad_private structure

[cascardo/linux.git] / drivers / platform / x86 / ideapad-laptop.c

diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 89c4519..edd3656 100644 (file)
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -73,6 +73,7 @@ enum {
 };
 
 struct ideapad_private {
+       struct acpi_device *adev;
        struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
        struct platform_device *platform_device;
        struct input_dev *inputdev;
@@ -468,9 +469,9 @@ static void ideapad_sync_rfk_state(struct ideapad_private *priv)
                        rfkill_set_hw_state(priv->rfk[i], hw_blocked);
 }
 
-static int ideapad_register_rfkill(struct acpi_device *adevice, int dev)
+static int ideapad_register_rfkill(struct acpi_device *adev, int dev)
 {
-       struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+       struct ideapad_private *priv = dev_get_drvdata(&adev->dev);
        int ret;
        unsigned long sw_blocked;
 
@@ -482,7 +483,7 @@ static int ideapad_register_rfkill(struct acpi_device *adevice, int dev)
                return 0;
        }
 
-       priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name, &adevice->dev,
+       priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name, &adev->dev,
                                      ideapad_rfk_data[dev].type, &ideapad_rfk_ops,
                                      (void *)(long)dev);
        if (!priv->rfk[dev])
@@ -504,9 +505,9 @@ static int ideapad_register_rfkill(struct acpi_device *adevice, int dev)
        return 0;
 }
 
-static void ideapad_unregister_rfkill(struct acpi_device *adevice, int dev)
+static void ideapad_unregister_rfkill(struct acpi_device *adev, int dev)
 {
-       struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+       struct ideapad_private *priv = dev_get_drvdata(&adev->dev);
 
        if (!priv->rfk[dev])
                return;
@@ -761,13 +762,13 @@ 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)
+static void ideapad_sync_touchpad_state(struct acpi_device *adev)
 {
-       struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+       struct ideapad_private *priv = dev_get_drvdata(&adev->dev);
        unsigned long value;
 
        /* Without reading from EC touchpad LED doesn't switch state */
-       if (!read_ec_data(adevice->handle, VPCCMD_R_TOUCHPAD, &value)) {
+       if (!read_ec_data(adev->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
@@ -779,22 +780,23 @@ static void ideapad_sync_touchpad_state(struct acpi_device *adevice)
        }
 }
 
-static int ideapad_acpi_add(struct acpi_device *adevice)
+static int ideapad_acpi_add(struct acpi_device *adev)
 {
        int ret, i;
        int cfg;
        struct ideapad_private *priv;
 
-       if (read_method_int(adevice->handle, "_CFG", &cfg))
+       if (read_method_int(adev->handle, "_CFG", &cfg))
                return -ENODEV;
 
        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
-       dev_set_drvdata(&adevice->dev, priv);
+       dev_set_drvdata(&adev->dev, priv);
        ideapad_priv = priv;
-       ideapad_handle = adevice->handle;
+       ideapad_handle = adev->handle;
        priv->cfg = cfg;
+       priv->adev = adev;
 
        ret = ideapad_platform_init(priv);
        if (ret)
@@ -810,12 +812,12 @@ static int ideapad_acpi_add(struct acpi_device *adevice)
 
        for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) {
                if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
-                       ideapad_register_rfkill(adevice, i);
+                       ideapad_register_rfkill(adev, i);
                else
                        priv->rfk[i] = NULL;
        }
        ideapad_sync_rfk_state(priv);
-       ideapad_sync_touchpad_state(adevice);
+       ideapad_sync_touchpad_state(adev);
 
        if (!acpi_video_backlight_support()) {
                ret = ideapad_backlight_init(priv);
@@ -827,7 +829,7 @@ static int ideapad_acpi_add(struct acpi_device *adevice)
 
 backlight_failed:
        for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
-               ideapad_unregister_rfkill(adevice, i);
+               ideapad_unregister_rfkill(adev, i);
        ideapad_input_exit(priv);
 input_failed:
        ideapad_debugfs_exit(priv);
@@ -838,27 +840,27 @@ platform_failed:
        return ret;
 }
 
-static int ideapad_acpi_remove(struct acpi_device *adevice)
+static int ideapad_acpi_remove(struct acpi_device *adev)
 {
-       struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+       struct ideapad_private *priv = dev_get_drvdata(&adev->dev);
        int i;
 
        ideapad_backlight_exit(priv);
        for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
-               ideapad_unregister_rfkill(adevice, i);
+               ideapad_unregister_rfkill(adev, i);
        ideapad_input_exit(priv);
        ideapad_debugfs_exit(priv);
        ideapad_platform_exit(priv);
-       dev_set_drvdata(&adevice->dev, NULL);
+       dev_set_drvdata(&adev->dev, NULL);
        kfree(priv);
 
        return 0;
 }
 
-static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
+static void ideapad_acpi_notify(struct acpi_device *adev, u32 event)
 {
-       struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
-       acpi_handle handle = adevice->handle;
+       struct ideapad_private *priv = dev_get_drvdata(&adev->dev);
+       acpi_handle handle = adev->handle;
        unsigned long vpc1, vpc2, vpc_bit;
 
        if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
@@ -880,7 +882,7 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
                                ideapad_input_report(priv, vpc_bit);
                                break;
                        case 5:
-                               ideapad_sync_touchpad_state(adevice);
+                               ideapad_sync_touchpad_state(adev);
                                break;
                        case 4:
                                ideapad_backlight_notify_brightness(priv);
@@ -901,6 +903,7 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
        }
 }
 
+#ifdef CONFIG_PM_SLEEP
 static int ideapad_acpi_resume(struct device *device)
 {
        ideapad_sync_rfk_state(ideapad_priv);
@@ -909,6 +912,7 @@ static int ideapad_acpi_resume(struct device *device)
 }
 
 static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
+#endif
 
 static struct acpi_driver ideapad_acpi_driver = {
        .name = "ideapad_acpi",
@@ -917,7 +921,9 @@ static struct acpi_driver ideapad_acpi_driver = {
        .ops.add = ideapad_acpi_add,
        .ops.remove = ideapad_acpi_remove,
        .ops.notify = ideapad_acpi_notify,
+#ifdef CONFIG_PM_SLEEP
        .drv.pm = &ideapad_pm,
+#endif
        .owner = THIS_MODULE,
 };
 module_acpi_driver(ideapad_acpi_driver);