Merge tag 'pm+acpi-3.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull ACPI and power management updates from Rafael J Wysocki:

 - New power capping framework and the the Intel Running Average Power
   Limit (RAPL) driver using it from Srinivas Pandruvada and Jacob Pan.

 - Addition of the in-kernel switching feature to the arm_big_little
   cpufreq driver from Viresh Kumar and Nicolas Pitre.

 - cpufreq support for iMac G5 from Aaro Koskinen.

 - Baytrail processors support for intel_pstate from Dirk Brandewie.

 - cpufreq support for Midway/ECX-2000 from Mark Langsdorf.

 - ARM vexpress/TC2 cpufreq support from Sudeep KarkadaNagesha.

 - ACPI power management support for the I2C and SPI bus types from Mika
   Westerberg and Lv Zheng.

 - cpufreq core fixes and cleanups from Viresh Kumar, Srivatsa S Bhat,
   Stratos Karafotis, Xiaoguang Chen, Lan Tianyu.

 - cpufreq drivers updates (mostly fixes and cleanups) from Viresh
   Kumar, Aaro Koskinen, Jungseok Lee, Sudeep KarkadaNagesha, Lukasz
   Majewski, Manish Badarkhe, Hans-Christian Egtvedt, Evgeny Kapaev.

 - intel_pstate updates from Dirk Brandewie and Adrian Huang.

 - ACPICA update to version 20130927 includig fixes and cleanups and
   some reduction of divergences between the ACPICA code in the kernel
   and ACPICA upstream in order to improve the automatic ACPICA patch
   generation process.  From Bob Moore, Lv Zheng, Tomasz Nowicki, Naresh
   Bhat, Bjorn Helgaas, David E Box.

 - ACPI IPMI driver fixes and cleanups from Lv Zheng.

 - ACPI hotplug fixes and cleanups from Bjorn Helgaas, Toshi Kani, Zhang
   Yanfei, Rafael J Wysocki.

 - Conversion of the ACPI AC driver to the platform bus type and
   multiple driver fixes and cleanups related to ACPI from Zhang Rui.

 - ACPI processor driver fixes and cleanups from Hanjun Guo, Jiang Liu,
   Bartlomiej Zolnierkiewicz, Mathieu Rhéaume, Rafael J Wysocki.

 - Fixes and cleanups and new blacklist entries related to the ACPI
   video support from Aaron Lu, Felipe Contreras, Lennart Poettering,
   Kirill Tkhai.

 - cpuidle core cleanups from Viresh Kumar and Lorenzo Pieralisi.

 - cpuidle drivers fixes and cleanups from Daniel Lezcano, Jingoo Han,
   Bartlomiej Zolnierkiewicz, Prarit Bhargava.

 - devfreq updates from Sachin Kamat, Dan Carpenter, Manish Badarkhe.

 - Operation Performance Points (OPP) core updates from Nishanth Menon.

 - Runtime power management core fix from Rafael J Wysocki and update
   from Ulf Hansson.

 - Hibernation fixes from Aaron Lu and Rafael J Wysocki.

 - Device suspend/resume lockup detection mechanism from Benoit Goby.

 - Removal of unused proc directories created for various ACPI drivers
   from Lan Tianyu.

 - ACPI LPSS driver fix and new device IDs for the ACPI platform scan
   handler from Heikki Krogerus and Jarkko Nikula.

 - New ACPI _OSI blacklist entry for Toshiba NB100 from Levente Kurusa.

 - Assorted fixes and cleanups related to ACPI from Andy Shevchenko, Al
   Stone, Bartlomiej Zolnierkiewicz, Colin Ian King, Dan Carpenter,
   Felipe Contreras, Jianguo Wu, Lan Tianyu, Yinghai Lu, Mathias Krause,
   Liu Chuansheng.

 - Assorted PM fixes and cleanups from Andy Shevchenko, Thierry Reding,
   Jean-Christophe Plagniol-Villard.

* tag 'pm+acpi-3.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (386 commits)
  cpufreq: conservative: fix requested_freq reduction issue
  ACPI / hotplug: Consolidate deferred execution of ACPI hotplug routines
  PM / runtime: Use pm_runtime_put_sync() in __device_release_driver()
  ACPI / event: remove unneeded NULL pointer check
  Revert "ACPI / video: Ignore BIOS initial backlight value for HP 250 G1"
  ACPI / video: Quirk initial backlight level 0
  ACPI / video: Fix initial level validity test
  intel_pstate: skip the driver if ACPI has power mgmt option
  PM / hibernate: Avoid overflow in hibernate_preallocate_memory()
  ACPI / hotplug: Do not execute "insert in progress" _OST
  ACPI / hotplug: Carry out PCI root eject directly
  ACPI / hotplug: Merge device hot-removal routines
  ACPI / hotplug: Make acpi_bus_hot_remove_device() internal
  ACPI / hotplug: Simplify device ejection routines
  ACPI / hotplug: Fix handle_root_bridge_removal()
  ACPI / hotplug: Refuse to hot-remove all objects with disabled hotplug
  ACPI / scan: Start matching drivers after trying scan handlers
  ACPI: Remove acpi_pci_slot_init() headers from internal.h
  ACPI / blacklist: fix name of ThinkPad Edge E530
  PowerCap: Fix build error with option -Werror=format-security
  ...

Conflicts:
	arch/arm/mach-omap2/opp.c
	drivers/Kconfig
	drivers/spi/spi.c

11 files changed, 264 insertions, 356 deletions

diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index a6afd4108beb..aefcc32e5634 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -190,16 +190,10 @@ struct eeepc_laptop {
  */
 static int write_acpi_int(acpi_handle handle, const char *method, int val)
 {
-        struct acpi_object_list params;
-        union acpi_object in_obj;
         acpi_status status;
 
-        params.count = 1;
-        params.pointer = &in_obj;
-        in_obj.type = ACPI_TYPE_INTEGER;
-        in_obj.integer.value = val;
+        status = acpi_execute_simple_method(handle, (char *)method, val);
 
-        status = acpi_evaluate_object(handle, (char *)method, &params, NULL);
         return (status == AE_OK ? 0 : -1);
 }
 
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index 52b8a97efde1..9d30d69aa78f 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -219,8 +219,7 @@ static int call_fext_func(int cmd, int arg0, int arg1, int arg2)
         { .type = ACPI_TYPE_INTEGER }
         };
         struct acpi_object_list arg_list = { 4, &params[0] };
-        struct acpi_buffer output;
-        union acpi_object out_obj;
+        unsigned long long value;
         acpi_handle handle = NULL;
 
         status = acpi_get_handle(fujitsu_hotkey->acpi_handle, "FUNC", &handle);
@@ -235,10 +234,7 @@ static int call_fext_func(int cmd, int arg0, int arg1, int arg2)
         params[2].integer.value = arg1;
         params[3].integer.value = arg2;
 
-        output.length = sizeof(out_obj);
-        output.pointer = &out_obj;
-
-        status = acpi_evaluate_object(handle, NULL, &arg_list, &output);
+        status = acpi_evaluate_integer(handle, NULL, &arg_list, &value);
         if (ACPI_FAILURE(status)) {
                 vdbg_printk(FUJLAPTOP_DBG_WARN,
                         "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) call failed\n",
@@ -246,18 +242,10 @@ static int call_fext_func(int cmd, int arg0, int arg1, int arg2)
                 return -ENODEV;
         }
 
-        if (out_obj.type != ACPI_TYPE_INTEGER) {
-                vdbg_printk(FUJLAPTOP_DBG_WARN,
-                        "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) did not "
-                        "return an integer\n",
-                        cmd, arg0, arg1, arg2);
-                return -ENODEV;
-        }
-
         vdbg_printk(FUJLAPTOP_DBG_TRACE,
                 "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) returned 0x%x\n",
-                        cmd, arg0, arg1, arg2, (int)out_obj.integer.value);
-        return out_obj.integer.value;
+                        cmd, arg0, arg1, arg2, (int)value);
+        return value;
 }
 
 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
@@ -317,8 +305,6 @@ static enum led_brightness kblamps_get(struct led_classdev *cdev)
 static int set_lcd_level(int level)
 {
         acpi_status status = AE_OK;
-        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &arg0 };
         acpi_handle handle = NULL;
 
         vdbg_printk(FUJLAPTOP_DBG_TRACE, "set lcd level via SBLL [%d]\n",
@@ -333,9 +319,8 @@ static int set_lcd_level(int level)
                 return -ENODEV;
         }
 
-        arg0.integer.value = level;
 
-        status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
+        status = acpi_execute_simple_method(handle, NULL, level);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
@@ -345,8 +330,6 @@ static int set_lcd_level(int level)
 static int set_lcd_level_alt(int level)
 {
         acpi_status status = AE_OK;
-        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list arg_list = { 1, &arg0 };
         acpi_handle handle = NULL;
 
         vdbg_printk(FUJLAPTOP_DBG_TRACE, "set lcd level via SBL2 [%d]\n",
@@ -361,9 +344,7 @@ static int set_lcd_level_alt(int level)
                 return -ENODEV;
         }
 
-        arg0.integer.value = level;
-
-        status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
+        status = acpi_execute_simple_method(handle, NULL, level);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
@@ -586,11 +567,10 @@ static struct platform_driver fujitsupf_driver = {
 
 static void dmi_check_cb_common(const struct dmi_system_id *id)
 {
-        acpi_handle handle;
         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)))
+                if (acpi_has_method(NULL,
+                                "\\_SB.PCI0.LPCB.FJEX.SBL2"))
                         use_alt_lcd_levels = 1;
                 else
                         use_alt_lcd_levels = 0;
@@ -653,7 +633,6 @@ static struct dmi_system_id fujitsu_dmi_table[] = {
 
 static int acpi_fujitsu_add(struct acpi_device *device)
 {
-        acpi_handle handle;
         int result = 0;
         int state = 0;
         struct input_dev *input;
@@ -702,8 +681,7 @@ static int acpi_fujitsu_add(struct acpi_device *device)
 
         fujitsu->dev = device;
 
-        if (ACPI_SUCCESS
-            (acpi_get_handle(device->handle, METHOD_NAME__INI, &handle))) {
+        if (acpi_has_method(device->handle, METHOD_NAME__INI)) {
                 vdbg_printk(FUJLAPTOP_DBG_INFO, "Invoking _INI\n");
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
@@ -803,7 +781,6 @@ static void acpi_fujitsu_notify(struct acpi_device *device, u32 event)
 
 static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
 {
-        acpi_handle handle;
         int result = 0;
         int state = 0;
         struct input_dev *input;
@@ -866,8 +843,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
 
         fujitsu_hotkey->dev = device;
 
-        if (ACPI_SUCCESS
-            (acpi_get_handle(device->handle, METHOD_NAME__INI, &handle))) {
+        if (acpi_has_method(device->handle, METHOD_NAME__INI)) {
                 vdbg_printk(FUJLAPTOP_DBG_INFO, "Invoking _INI\n");
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 89c4519d48ac..6788acc22ab9 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -72,8 +72,15 @@ enum {
         VPCCMD_W_BL_POWER = 0x33,
 };
 
+struct ideapad_rfk_priv {
+        int dev;
+        struct ideapad_private *priv;
+};
+
 struct ideapad_private {
+        struct acpi_device *adev;
         struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
+        struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM];
         struct platform_device *platform_device;
         struct input_dev *inputdev;
         struct backlight_device *blightdev;
@@ -81,8 +88,6 @@ struct ideapad_private {
         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.");
@@ -200,34 +205,38 @@ static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
  */
 static int debugfs_status_show(struct seq_file *s, void *data)
 {
+        struct ideapad_private *priv = s->private;
         unsigned long value;
 
-        if (!read_ec_data(ideapad_handle, VPCCMD_R_BL_MAX, &value))
+        if (!priv)
+                return -EINVAL;
+
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->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))
+        if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value))
                 seq_printf(s, "Camera status:\t%s(%lu)\n",
                            value ? "On" : "Off", value);
 
@@ -236,7 +245,7 @@ static int debugfs_status_show(struct seq_file *s, void *data)
 
 static int debugfs_status_open(struct inode *inode, struct file *file)
 {
-        return single_open(file, debugfs_status_show, NULL);
+        return single_open(file, debugfs_status_show, inode->i_private);
 }
 
 static const struct file_operations debugfs_status_fops = {
@@ -249,21 +258,23 @@ static const struct file_operations debugfs_status_fops = {
 
 static int debugfs_cfg_show(struct seq_file *s, void *data)
 {
-        if (!ideapad_priv) {
+        struct ideapad_private *priv = s->private;
+
+        if (!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))
+                           priv->cfg);
+                if (test_bit(CFG_BT_BIT, &priv->cfg))
                         seq_printf(s, "Bluetooth ");
-                if (test_bit(CFG_3G_BIT, &ideapad_priv->cfg))
+                if (test_bit(CFG_3G_BIT, &priv->cfg))
                         seq_printf(s, "3G ");
-                if (test_bit(CFG_WIFI_BIT, &ideapad_priv->cfg))
+                if (test_bit(CFG_WIFI_BIT, &priv->cfg))
                         seq_printf(s, "Wireless ");
-                if (test_bit(CFG_CAMERA_BIT, &ideapad_priv->cfg))
+                if (test_bit(CFG_CAMERA_BIT, &priv->cfg))
                         seq_printf(s, "Camera ");
                 seq_printf(s, "\nGraphic: ");
-                switch ((ideapad_priv->cfg)&0x700) {
+                switch ((priv->cfg)&0x700) {
                 case 0x100:
                         seq_printf(s, "Intel");
                         break;
@@ -287,7 +298,7 @@ static int debugfs_cfg_show(struct seq_file *s, void *data)
 
 static int debugfs_cfg_open(struct inode *inode, struct file *file)
 {
-        return single_open(file, debugfs_cfg_show, NULL);
+        return single_open(file, debugfs_cfg_show, inode->i_private);
 }
 
 static const struct file_operations debugfs_cfg_fops = {
@@ -308,14 +319,14 @@ static int ideapad_debugfs_init(struct ideapad_private *priv)
                 goto errout;
         }
 
-        node = debugfs_create_file("cfg", S_IRUGO, priv->debug, NULL,
+        node = debugfs_create_file("cfg", S_IRUGO, priv->debug, priv,
                                    &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,
+        node = debugfs_create_file("status", S_IRUGO, priv->debug, priv,
                                    &debugfs_status_fops);
         if (!node) {
                 pr_err("failed to create status in debugfs");
@@ -342,8 +353,9 @@ static ssize_t show_ideapad_cam(struct device *dev,
                                 char *buf)
 {
         unsigned long result;
+        struct ideapad_private *priv = dev_get_drvdata(dev);
 
-        if (read_ec_data(ideapad_handle, VPCCMD_R_CAMERA, &result))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result))
                 return sprintf(buf, "-1\n");
         return sprintf(buf, "%lu\n", result);
 }
@@ -353,12 +365,13 @@ static ssize_t store_ideapad_cam(struct device *dev,
                                  const char *buf, size_t count)
 {
         int ret, state;
+        struct ideapad_private *priv = dev_get_drvdata(dev);
 
         if (!count)
                 return 0;
         if (sscanf(buf, "%i", &state) != 1)
                 return -EINVAL;
-        ret = write_ec_cmd(ideapad_handle, VPCCMD_W_CAMERA, state);
+        ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state);
         if (ret < 0)
                 return -EIO;
         return count;
@@ -371,8 +384,9 @@ static ssize_t show_ideapad_fan(struct device *dev,
                                 char *buf)
 {
         unsigned long result;
+        struct ideapad_private *priv = dev_get_drvdata(dev);
 
-        if (read_ec_data(ideapad_handle, VPCCMD_R_FAN, &result))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result))
                 return sprintf(buf, "-1\n");
         return sprintf(buf, "%lu\n", result);
 }
@@ -382,6 +396,7 @@ static ssize_t store_ideapad_fan(struct device *dev,
                                  const char *buf, size_t count)
 {
         int ret, state;
+        struct ideapad_private *priv = dev_get_drvdata(dev);
 
         if (!count)
                 return 0;
@@ -389,7 +404,7 @@ static ssize_t store_ideapad_fan(struct device *dev,
                 return -EINVAL;
         if (state < 0 || state > 4 || state == 3)
                 return -EINVAL;
-        ret = write_ec_cmd(ideapad_handle, VPCCMD_W_FAN, state);
+        ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state);
         if (ret < 0)
                 return -EIO;
         return count;
@@ -415,7 +430,8 @@ static umode_t ideapad_is_visible(struct kobject *kobj,
                 supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
         else if (attr == &dev_attr_fan_mode.attr) {
                 unsigned long value;
-                supported = !read_ec_data(ideapad_handle, VPCCMD_R_FAN, &value);
+                supported = !read_ec_data(priv->adev->handle, VPCCMD_R_FAN,
+                                          &value);
         } else
                 supported = true;
 
@@ -445,9 +461,9 @@ const struct ideapad_rfk_data ideapad_rfk_data[] = {
 
 static int ideapad_rfk_set(void *data, bool blocked)
 {
-        unsigned long opcode = (unsigned long)data;
+        struct ideapad_rfk_priv *priv = data;
 
-        return write_ec_cmd(ideapad_handle, opcode, !blocked);
+        return write_ec_cmd(priv->priv->adev->handle, priv->dev, !blocked);
 }
 
 static struct rfkill_ops ideapad_rfk_ops = {
@@ -459,7 +475,7 @@ static void ideapad_sync_rfk_state(struct ideapad_private *priv)
         unsigned long hw_blocked;
         int i;
 
-        if (read_ec_data(ideapad_handle, VPCCMD_R_RF, &hw_blocked))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked))
                 return;
         hw_blocked = !hw_blocked;
 
@@ -468,27 +484,30 @@ 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 ideapad_private *priv, 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,
+                write_ec_cmd(priv->adev->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);
+        priv->rfk_priv[dev].dev = dev;
+        priv->rfk_priv[dev].priv = priv;
+
+        priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name,
+                                      &priv->platform_device->dev,
+                                      ideapad_rfk_data[dev].type,
+                                      &ideapad_rfk_ops,
+                                      &priv->rfk_priv[dev]);
         if (!priv->rfk[dev])
                 return -ENOMEM;
 
-        if (read_ec_data(ideapad_handle, ideapad_rfk_data[dev].opcode-1,
+        if (read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode-1,
                          &sw_blocked)) {
                 rfkill_init_sw_state(priv->rfk[dev], 0);
         } else {
@@ -504,10 +523,8 @@ 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 ideapad_private *priv, int dev)
 {
-        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
-
         if (!priv->rfk[dev])
                 return;
 
@@ -518,37 +535,16 @@ static void ideapad_unregister_rfkill(struct acpi_device *adevice, int dev)
 /*
  * Platform device
  */
-static int ideapad_platform_init(struct ideapad_private *priv)
+static int ideapad_sysfs_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,
+        return 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)
+static void ideapad_sysfs_exit(struct ideapad_private *priv)
 {
         sysfs_remove_group(&priv->platform_device->dev.kobj,
                            &ideapad_attribute_group);
-        platform_device_unregister(priv->platform_device);
 }
 
 /*
@@ -623,7 +619,7 @@ static void ideapad_input_novokey(struct ideapad_private *priv)
 {
         unsigned long long_pressed;
 
-        if (read_ec_data(ideapad_handle, VPCCMD_R_NOVO, &long_pressed))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed))
                 return;
         if (long_pressed)
                 ideapad_input_report(priv, 17);
@@ -635,7 +631,7 @@ static void ideapad_check_special_buttons(struct ideapad_private *priv)
 {
         unsigned long bit, value;
 
-        read_ec_data(ideapad_handle, VPCCMD_R_SPECIAL_BUTTONS, &value);
+        read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value);
 
         for (bit = 0; bit < 16; bit++) {
                 if (test_bit(bit, &value)) {
@@ -662,19 +658,28 @@ static void ideapad_check_special_buttons(struct ideapad_private *priv)
  */
 static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
 {
+        struct ideapad_private *priv = bl_get_data(blightdev);
         unsigned long now;
 
-        if (read_ec_data(ideapad_handle, VPCCMD_R_BL, &now))
+        if (!priv)
+                return -EINVAL;
+
+        if (read_ec_data(priv->adev->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, VPCCMD_W_BL,
+        struct ideapad_private *priv = bl_get_data(blightdev);
+
+        if (!priv)
+                return -EINVAL;
+
+        if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL,
                          blightdev->props.brightness))
                 return -EIO;
-        if (write_ec_cmd(ideapad_handle, VPCCMD_W_BL_POWER,
+        if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER,
                          blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
                 return -EIO;
 
@@ -692,11 +697,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, VPCCMD_R_BL_MAX, &max))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max))
                 return -EIO;
-        if (read_ec_data(ideapad_handle, VPCCMD_R_BL, &now))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
                 return -EIO;
-        if (read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &power))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
                 return -EIO;
 
         memset(&props, 0, sizeof(struct backlight_properties));
@@ -734,7 +739,7 @@ static void ideapad_backlight_notify_power(struct ideapad_private *priv)
 
         if (!blightdev)
                 return;
-        if (read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &power))
+        if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
                 return;
         blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
 }
@@ -745,7 +750,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, VPCCMD_R_BL, &now);
+                read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
                 return;
         }
 
@@ -755,19 +760,12 @@ static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
 /*
  * module init/exit
  */
-static const struct acpi_device_id ideapad_device_ids[] = {
-        { "VPC2004", 0},
-        { "", 0},
-};
-MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
-
-static void ideapad_sync_touchpad_state(struct acpi_device *adevice)
+static void ideapad_sync_touchpad_state(struct ideapad_private *priv)
 {
-        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)) {
+        if (!read_ec_data(priv->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,26 +777,77 @@ static void ideapad_sync_touchpad_state(struct acpi_device *adevice)
         }
 }
 
-static int ideapad_acpi_add(struct acpi_device *adevice)
+static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct ideapad_private *priv = data;
+        unsigned long vpc1, vpc2, vpc_bit;
+
+        if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
+                return;
+        if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
+                return;
+
+        vpc1 = (vpc2 << 8) | vpc1;
+        for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
+                if (test_bit(vpc_bit, &vpc1)) {
+                        switch (vpc_bit) {
+                        case 9:
+                                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(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;
+                        case 0:
+                                ideapad_check_special_buttons(priv);
+                                break;
+                        default:
+                                pr_info("Unknown event: %lu\n", vpc_bit);
+                        }
+                }
+        }
+}
+
+static int ideapad_acpi_add(struct platform_device *pdev)
 {
         int ret, i;
         int cfg;
         struct ideapad_private *priv;
+        struct acpi_device *adev;
+
+        ret = acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev);
+        if (ret)
+                return -ENODEV;
 
-        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);
-        ideapad_priv = priv;
-        ideapad_handle = adevice->handle;
+
+        dev_set_drvdata(&pdev->dev, priv);
         priv->cfg = cfg;
+        priv->adev = adev;
+        priv->platform_device = pdev;
 
-        ret = ideapad_platform_init(priv);
+        ret = ideapad_sysfs_init(priv);
         if (ret)
-                goto platform_failed;
+                goto sysfs_failed;
 
         ret = ideapad_debugfs_init(priv);
         if (ret)
@@ -810,117 +859,92 @@ 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(priv, i);
                 else
                         priv->rfk[i] = NULL;
         }
         ideapad_sync_rfk_state(priv);
-        ideapad_sync_touchpad_state(adevice);
+        ideapad_sync_touchpad_state(priv);
 
         if (!acpi_video_backlight_support()) {
                 ret = ideapad_backlight_init(priv);
                 if (ret && ret != -ENODEV)
                         goto backlight_failed;
         }
+        ret = acpi_install_notify_handler(adev->handle,
+                ACPI_DEVICE_NOTIFY, ideapad_acpi_notify, priv);
+        if (ret)
+                goto notification_failed;
 
         return 0;
-
+notification_failed:
+        ideapad_backlight_exit(priv);
 backlight_failed:
         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
-                ideapad_unregister_rfkill(adevice, i);
+                ideapad_unregister_rfkill(priv, i);
         ideapad_input_exit(priv);
 input_failed:
         ideapad_debugfs_exit(priv);
 debugfs_failed:
-        ideapad_platform_exit(priv);
-platform_failed:
+        ideapad_sysfs_exit(priv);
+sysfs_failed:
         kfree(priv);
         return ret;
 }
 
-static int ideapad_acpi_remove(struct acpi_device *adevice)
+static int ideapad_acpi_remove(struct platform_device *pdev)
 {
-        struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
+        struct ideapad_private *priv = dev_get_drvdata(&pdev->dev);
         int i;
 
+        acpi_remove_notify_handler(priv->adev->handle,
+                ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
         ideapad_backlight_exit(priv);
         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
-                ideapad_unregister_rfkill(adevice, i);
+                ideapad_unregister_rfkill(priv, i);
         ideapad_input_exit(priv);
         ideapad_debugfs_exit(priv);
-        ideapad_platform_exit(priv);
-        dev_set_drvdata(&adevice->dev, NULL);
+        ideapad_sysfs_exit(priv);
+        dev_set_drvdata(&pdev->dev, NULL);
         kfree(priv);
 
         return 0;
 }
 
-static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
+#ifdef CONFIG_PM_SLEEP
+static int ideapad_acpi_resume(struct device *device)
 {
-        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, VPCCMD_R_VPC1, &vpc1))
-                return;
-        if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
-                return;
+        struct ideapad_private *priv;
 
-        vpc1 = (vpc2 << 8) | vpc1;
-        for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
-                if (test_bit(vpc_bit, &vpc1)) {
-                        switch (vpc_bit) {
-                        case 9:
-                                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;
-                        case 3:
-                                ideapad_input_novokey(priv);
-                                break;
-                        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);
-                        }
-                }
-        }
-}
+        if (!device)
+                return -EINVAL;
+        priv = dev_get_drvdata(device);
 
-static int ideapad_acpi_resume(struct device *device)
-{
-        ideapad_sync_rfk_state(ideapad_priv);
-        ideapad_sync_touchpad_state(to_acpi_device(device));
+        ideapad_sync_rfk_state(priv);
+        ideapad_sync_touchpad_state(priv);
         return 0;
 }
-
+#endif
 static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
 
-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,
-        .drv.pm = &ideapad_pm,
-        .owner = THIS_MODULE,
+static const struct acpi_device_id ideapad_device_ids[] = {
+        { "VPC2004", 0},
+        { "", 0},
 };
-module_acpi_driver(ideapad_acpi_driver);
+MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
+
+static struct platform_driver ideapad_acpi_driver = {
+        .probe = ideapad_acpi_add,
+        .remove = ideapad_acpi_remove,
+        .driver = {
+                .name   = "ideapad_acpi",
+                .owner  = THIS_MODULE,
+                .pm     = &ideapad_pm,
+                .acpi_match_table = ACPI_PTR(ideapad_device_ids),
+        },
+};
+
+module_platform_driver(ideapad_acpi_driver);
 
 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
 MODULE_DESCRIPTION("IdeaPad ACPI Extras");
diff --git a/drivers/platform/x86/intel-rst.c b/drivers/platform/x86/intel-rst.c
index 41b740cb28bc..a2083a9e5662 100644
--- a/drivers/platform/x86/intel-rst.c
+++ b/drivers/platform/x86/intel-rst.c
@@ -29,24 +29,16 @@ static ssize_t irst_show_wakeup_events(struct device *dev,
                                        char *buf)
 {
         struct acpi_device *acpi;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *result;
+        unsigned long long value;
         acpi_status status;
 
         acpi = to_acpi_device(dev);
 
-        status = acpi_evaluate_object(acpi->handle, "GFFS", NULL, &output);
+        status = acpi_evaluate_integer(acpi->handle, "GFFS", NULL, &value);
         if (!ACPI_SUCCESS(status))
                 return -EINVAL;
 
-        result = output.pointer;
-
-        if (result->type != ACPI_TYPE_INTEGER) {
-                kfree(result);
-                return -EINVAL;
-        }
-
-        return sprintf(buf, "%lld\n", result->integer.value);
+        return sprintf(buf, "%lld\n", value);
 }
 
 static ssize_t irst_store_wakeup_events(struct device *dev,
@@ -54,8 +46,6 @@ static ssize_t irst_store_wakeup_events(struct device *dev,
                                         const char *buf, size_t count)
 {
         struct acpi_device *acpi;
-        struct acpi_object_list input;
-        union acpi_object param;
         acpi_status status;
         unsigned long value;
         int error;
@@ -67,13 +57,7 @@ static ssize_t irst_store_wakeup_events(struct device *dev,
         if (error)
                 return error;
 
-        param.type = ACPI_TYPE_INTEGER;
-        param.integer.value = value;
-
-        input.count = 1;
-        input.pointer = &param;
-
-        status = acpi_evaluate_object(acpi->handle, "SFFS", &input, NULL);
+        status = acpi_execute_simple_method(acpi->handle, "SFFS", value);
 
         if (!ACPI_SUCCESS(status))
                 return -EINVAL;
@@ -91,24 +75,16 @@ static ssize_t irst_show_wakeup_time(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
         struct acpi_device *acpi;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *result;
+        unsigned long long value;
         acpi_status status;
 
         acpi = to_acpi_device(dev);
 
-        status = acpi_evaluate_object(acpi->handle, "GFTV", NULL, &output);
+        status = acpi_evaluate_integer(acpi->handle, "GFTV", NULL, &value);
         if (!ACPI_SUCCESS(status))
                 return -EINVAL;
 
-        result = output.pointer;
-
-        if (result->type != ACPI_TYPE_INTEGER) {
-                kfree(result);
-                return -EINVAL;
-        }
-
-        return sprintf(buf, "%lld\n", result->integer.value);
+        return sprintf(buf, "%lld\n", value);
 }
 
 static ssize_t irst_store_wakeup_time(struct device *dev,
@@ -116,8 +92,6 @@ static ssize_t irst_store_wakeup_time(struct device *dev,
                                       const char *buf, size_t count)
 {
         struct acpi_device *acpi;
-        struct acpi_object_list input;
-        union acpi_object param;
         acpi_status status;
         unsigned long value;
         int error;
@@ -129,13 +103,7 @@ static ssize_t irst_store_wakeup_time(struct device *dev,
         if (error)
                 return error;
 
-        param.type = ACPI_TYPE_INTEGER;
-        param.integer.value = value;
-
-        input.count = 1;
-        input.pointer = &param;
-
-        status = acpi_evaluate_object(acpi->handle, "SFTV", &input, NULL);
+        status = acpi_execute_simple_method(acpi->handle, "SFTV", value);
 
         if (!ACPI_SUCCESS(status))
                 return -EINVAL;
diff --git a/drivers/platform/x86/intel-smartconnect.c b/drivers/platform/x86/intel-smartconnect.c
index 52259dcabecb..1838400dc036 100644
--- a/drivers/platform/x86/intel-smartconnect.c
+++ b/drivers/platform/x86/intel-smartconnect.c
@@ -25,37 +25,18 @@ MODULE_LICENSE("GPL");
 
 static int smartconnect_acpi_init(struct acpi_device *acpi)
 {
-        struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *result;
-        union acpi_object param;
+        unsigned long long value;
         acpi_status status;
 
-        status = acpi_evaluate_object(acpi->handle, "GAOS", NULL, &output);
+        status = acpi_evaluate_integer(acpi->handle, "GAOS", NULL, &value);
         if (!ACPI_SUCCESS(status))
                 return -EINVAL;
 
-        result = output.pointer;
-
-        if (result->type != ACPI_TYPE_INTEGER) {
-                kfree(result);
-                return -EINVAL;
-        }
-
-        if (result->integer.value & 0x1) {
-                param.type = ACPI_TYPE_INTEGER;
-                param.integer.value = 0;
-
-                input.count = 1;
-                input.pointer = &param;
-
+        if (value & 0x1) {
                 dev_info(&acpi->dev, "Disabling Intel Smart Connect\n");
-                status = acpi_evaluate_object(acpi->handle, "SAOS", &input,
-                                              NULL);
+                status = acpi_execute_simple_method(acpi->handle, "SAOS", 0);
         }
 
-        kfree(result);
-
         return 0;
 }
 
diff --git a/drivers/platform/x86/intel_menlow.c b/drivers/platform/x86/intel_menlow.c
index d6cfc1558c2f..11244f8703c4 100644
--- a/drivers/platform/x86/intel_menlow.c
+++ b/drivers/platform/x86/intel_menlow.c
@@ -156,19 +156,15 @@ static struct thermal_cooling_device_ops memory_cooling_ops = {
 static int intel_menlow_memory_add(struct acpi_device *device)
 {
         int result = -ENODEV;
-        acpi_status status = AE_OK;
-        acpi_handle dummy;
         struct thermal_cooling_device *cdev;
 
         if (!device)
                 return -EINVAL;
 
-        status = acpi_get_handle(device->handle, MEMORY_GET_BANDWIDTH, &dummy);
-        if (ACPI_FAILURE(status))
+        if (!acpi_has_method(device->handle, MEMORY_GET_BANDWIDTH))
                 goto end;
 
-        status = acpi_get_handle(device->handle, MEMORY_SET_BANDWIDTH, &dummy);
-        if (ACPI_FAILURE(status))
+        if (!acpi_has_method(device->handle, MEMORY_SET_BANDWIDTH))
                 goto end;
 
         cdev = thermal_cooling_device_register("Memory controller", device,
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 13ec195f0ca6..47caab0ea7a1 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -1508,7 +1508,6 @@ static void sony_nc_function_resume(void)
 static int sony_nc_resume(struct device *dev)
 {
         struct sony_nc_value *item;
-        acpi_handle handle;
 
         for (item = sony_nc_values; item->name; item++) {
                 int ret;
@@ -1523,15 +1522,13 @@ static int sony_nc_resume(struct device *dev)
                 }
         }
 
-        if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "ECON",
-                                         &handle))) {
+        if (acpi_has_method(sony_nc_acpi_handle, "ECON")) {
                 int arg = 1;
                 if (sony_nc_int_call(sony_nc_acpi_handle, "ECON", &arg, NULL))
                         dprintk("ECON Method failed\n");
         }
 
-        if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "SN00",
-                                         &handle)))
+        if (acpi_has_method(sony_nc_acpi_handle, "SN00"))
                 sony_nc_function_resume();
 
         return 0;
@@ -2682,7 +2679,6 @@ static void sony_nc_backlight_ng_read_limits(int handle,
 
 static void sony_nc_backlight_setup(void)
 {
-        acpi_handle unused;
         int max_brightness = 0;
         const struct backlight_ops *ops = NULL;
         struct backlight_properties props;
@@ -2717,8 +2713,7 @@ static void sony_nc_backlight_setup(void)
                 sony_nc_backlight_ng_read_limits(0x14c, &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))) {
+        } else if (acpi_has_method(sony_nc_acpi_handle, "GBRT")) {
                 ops = &sony_backlight_ops;
                 max_brightness = SONY_MAX_BRIGHTNESS - 1;
 
@@ -2750,7 +2745,6 @@ static int sony_nc_add(struct acpi_device *device)
 {
         acpi_status status;
         int result = 0;
-        acpi_handle handle;
         struct sony_nc_value *item;
 
         pr_info("%s v%s\n", SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
@@ -2790,15 +2784,13 @@ static int sony_nc_add(struct acpi_device *device)
                 goto outplatform;
         }
 
-        if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "ECON",
-                                         &handle))) {
+        if (acpi_has_method(sony_nc_acpi_handle, "ECON")) {
                 int arg = 1;
                 if (sony_nc_int_call(sony_nc_acpi_handle, "ECON", &arg, NULL))
                         dprintk("ECON Method failed\n");
         }
 
-        if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "SN00",
-                                         &handle))) {
+        if (acpi_has_method(sony_nc_acpi_handle, "SN00")) {
                 dprintk("Doing SNC setup\n");
                 /* retrieve the available handles */
                 result = sony_nc_handles_setup(sony_pf_device);
@@ -2821,9 +2813,8 @@ static int sony_nc_add(struct acpi_device *device)
 
                 /* find the available acpiget as described in the DSDT */
                 for (; item->acpiget && *item->acpiget; ++item->acpiget) {
-                        if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle,
-                                                         *item->acpiget,
-                                                         &handle))) {
+                        if (acpi_has_method(sony_nc_acpi_handle,
+                                                        *item->acpiget)) {
                                 dprintk("Found %s getter: %s\n",
                                                 item->name, *item->acpiget);
                                 item->devattr.attr.mode |= S_IRUGO;
@@ -2833,9 +2824,8 @@ static int sony_nc_add(struct acpi_device *device)
 
                 /* find the available acpiset as described in the DSDT */
                 for (; item->acpiset && *item->acpiset; ++item->acpiset) {
-                        if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle,
-                                                         *item->acpiset,
-                                                         &handle))) {
+                        if (acpi_has_method(sony_nc_acpi_handle,
+                                                        *item->acpiset)) {
                                 dprintk("Found %s setter: %s\n",
                                                 item->name, *item->acpiset);
                                 item->devattr.attr.mode |= S_IWUSR;
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 0b7efb269cf1..05e046aa5e31 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -701,6 +701,14 @@ static void __init drv_acpi_handle_init(const char *name,
 static acpi_status __init tpacpi_acpi_handle_locate_callback(acpi_handle handle,
                         u32 level, void *context, void **return_value)
 {
+        struct acpi_device *dev;
+        if (!strcmp(context, "video")) {
+                if (acpi_bus_get_device(handle, &dev))
+                        return AE_OK;
+                if (strcmp(ACPI_VIDEO_HID, acpi_device_hid(dev)))
+                        return AE_OK;
+        }
+
         *(acpi_handle *)return_value = handle;
 
         return AE_CTRL_TERMINATE;
@@ -713,10 +721,10 @@ static void __init tpacpi_acpi_handle_locate(const char *name,
         acpi_status status;
         acpi_handle device_found;
 
-        BUG_ON(!name || !hid || !handle);
+        BUG_ON(!name || !handle);
         vdbg_printk(TPACPI_DBG_INIT,
                         "trying to locate ACPI handle for %s, using HID %s\n",
-                        name, hid);
+                        name, hid ? hid : "NULL");
 
         memset(&device_found, 0, sizeof(device_found));
         status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback,
@@ -6091,19 +6099,28 @@ static int __init tpacpi_query_bcl_levels(acpi_handle handle)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *obj;
+        struct acpi_device *device, *child;
         int rc;
 
-        if (ACPI_SUCCESS(acpi_evaluate_object(handle, "_BCL", NULL, &buffer))) {
+        if (acpi_bus_get_device(handle, &device))
+                return 0;
+
+        rc = 0;
+        list_for_each_entry(child, &device->children, node) {
+                acpi_status status = acpi_evaluate_object(child->handle, "_BCL",
+                                                          NULL, &buffer);
+                if (ACPI_FAILURE(status))
+                        continue;
+
                 obj = (union acpi_object *)buffer.pointer;
                 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
                         pr_err("Unknown _BCL data, please report this to %s\n",
-                               TPACPI_MAIL);
+                                TPACPI_MAIL);
                         rc = 0;
                 } else {
                         rc = obj->package.count;
                 }
-        } else {
-                return 0;
+                break;
         }
 
         kfree(buffer.pointer);
@@ -6119,7 +6136,7 @@ static unsigned int __init tpacpi_check_std_acpi_brightness_support(void)
         acpi_handle video_device;
         int bcl_levels = 0;
 
-        tpacpi_acpi_handle_locate("video", ACPI_VIDEO_HID, &video_device);
+        tpacpi_acpi_handle_locate("video", NULL, &video_device);
         if (video_device)
                 bcl_levels = tpacpi_query_bcl_levels(video_device);
 
diff --git a/drivers/platform/x86/topstar-laptop.c b/drivers/platform/x86/topstar-laptop.c
index 4ab618c63b45..67897c8740ba 100644
--- a/drivers/platform/x86/topstar-laptop.c
+++ b/drivers/platform/x86/topstar-laptop.c
@@ -80,13 +80,9 @@ static void acpi_topstar_notify(struct acpi_device *device, u32 event)
 static int acpi_topstar_fncx_switch(struct acpi_device *device, bool state)
 {
         acpi_status status;
-        union acpi_object fncx_params[1] = {
-                { .type = ACPI_TYPE_INTEGER }
-        };
-        struct acpi_object_list fncx_arg_list = { 1, &fncx_params[0] };
 
-        fncx_params[0].integer.value = state ? 0x86 : 0x87;
-        status = acpi_evaluate_object(device->handle, "FNCX", &fncx_arg_list, NULL);
+        status = acpi_execute_simple_method(device->handle, "FNCX",
+                                                state ? 0x86 : 0x87);
         if (ACPI_FAILURE(status)) {
                 pr_err("Unable to switch FNCX notifications\n");
                 return -ENODEV;
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index eb3467ea6d86..0cfadb65f7c6 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -191,16 +191,9 @@ static __inline__ void _set_bit(u32 * word, u32 mask, int value)
 
 static int write_acpi_int(const char *methodName, int val)
 {
-        struct acpi_object_list params;
-        union acpi_object in_objs[1];
         acpi_status status;
 
-        params.count = ARRAY_SIZE(in_objs);
-        params.pointer = in_objs;
-        in_objs[0].type = ACPI_TYPE_INTEGER;
-        in_objs[0].integer.value = val;
-
-        status = acpi_evaluate_object(NULL, (char *)methodName, &params, NULL);
+        status = acpi_execute_simple_method(NULL, (char *)methodName, val);
         return (status == AE_OK) ? 0 : -EIO;
 }
 
@@ -947,21 +940,17 @@ static void toshiba_acpi_hotkey_work(struct work_struct *work)
  */
 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
 {
-        struct acpi_buffer buf;
-        union acpi_object out_obj;
+        unsigned long long value;
         acpi_status status;
 
-        buf.pointer = &out_obj;
-        buf.length = sizeof(out_obj);
-
-        status = acpi_evaluate_object(dev->acpi_dev->handle, "INFO",
-                                      NULL, &buf);
-        if (ACPI_FAILURE(status) || out_obj.type != ACPI_TYPE_INTEGER) {
+        status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO",
+                                      NULL, &value);
+        if (ACPI_FAILURE(status)) {
                 pr_err("ACPI INFO method execution failed\n");
                 return -EIO;
         }
 
-        return out_obj.integer.value;
+        return value;
 }
 
 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
@@ -981,7 +970,7 @@ static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
 {
         acpi_status status;
-        acpi_handle ec_handle, handle;
+        acpi_handle ec_handle;
         int error;
         u32 hci_result;
 
@@ -1008,10 +997,7 @@ static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
          */
         status = AE_ERROR;
         ec_handle = ec_get_handle();
-        if (ec_handle)
-                status = acpi_get_handle(ec_handle, "NTFY", &handle);
-
-        if (ACPI_SUCCESS(status)) {
+        if (ec_handle && acpi_has_method(ec_handle, "NTFY")) {
                 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);
 
                 error = i8042_install_filter(toshiba_acpi_i8042_filter);
@@ -1027,10 +1013,9 @@ static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
          * Determine hotkey query interface. Prefer using the INFO
          * method when it is available.
          */
-        status = acpi_get_handle(dev->acpi_dev->handle, "INFO", &handle);
-        if (ACPI_SUCCESS(status)) {
+        if (acpi_has_method(dev->acpi_dev->handle, "INFO"))
                 dev->info_supported = 1;
-        } else {
+        else {
                 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
                 if (hci_result == HCI_SUCCESS)
                         dev->system_event_supported = 1;
@@ -1155,15 +1140,10 @@ static int toshiba_acpi_remove(struct acpi_device *acpi_dev)
 
 static const char *find_hci_method(acpi_handle handle)
 {
-        acpi_status status;
-        acpi_handle hci_handle;
-
-        status = acpi_get_handle(handle, "GHCI", &hci_handle);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(handle, "GHCI"))
                 return "GHCI";
 
-        status = acpi_get_handle(handle, "SPFC", &hci_handle);
-        if (ACPI_SUCCESS(status))
+        if (acpi_has_method(handle, "SPFC"))
                 return "SPFC";
 
         return NULL;
diff --git a/drivers/platform/x86/wmi.c b/drivers/platform/x86/wmi.c
index 601ea9512242..62e8c221d01e 100644
--- a/drivers/platform/x86/wmi.c
+++ b/drivers/platform/x86/wmi.c
@@ -252,8 +252,6 @@ static acpi_status wmi_method_enable(struct wmi_block *wblock, int enable)
 {
         struct guid_block *block = NULL;
         char method[5];
-        struct acpi_object_list input;
-        union acpi_object params[1];
         acpi_status status;
         acpi_handle handle;
 
@@ -263,13 +261,9 @@ static acpi_status wmi_method_enable(struct wmi_block *wblock, int enable)
         if (!block)
                 return AE_NOT_EXIST;
 
-        input.count = 1;
-        input.pointer = params;
-        params[0].type = ACPI_TYPE_INTEGER;
-        params[0].integer.value = enable;
 
         snprintf(method, 5, "WE%02X", block->notify_id);
-        status = acpi_evaluate_object(handle, method, &input, NULL);
+        status = acpi_execute_simple_method(handle, method, enable);
 
         if (status != AE_OK && status != AE_NOT_FOUND)
                 return status;
@@ -353,10 +347,10 @@ struct acpi_buffer *out)
 {
         struct guid_block *block = NULL;
         struct wmi_block *wblock = NULL;
-        acpi_handle handle, wc_handle;
+        acpi_handle handle;
         acpi_status status, wc_status = AE_ERROR;
-        struct acpi_object_list input, wc_input;
-        union acpi_object wc_params[1], wq_params[1];
+        struct acpi_object_list input;
+        union acpi_object wq_params[1];
         char method[5];
         char wc_method[5] = "WC";
 
@@ -386,11 +380,6 @@ struct acpi_buffer *out)
          * enable collection.
          */
         if (block->flags & ACPI_WMI_EXPENSIVE) {
-                wc_input.count = 1;
-                wc_input.pointer = wc_params;
-                wc_params[0].type = ACPI_TYPE_INTEGER;
-                wc_params[0].integer.value = 1;
-
                 strncat(wc_method, block->object_id, 2);
 
                 /*
@@ -398,10 +387,9 @@ struct acpi_buffer *out)
                  * expensive, but have no corresponding WCxx method. So we
                  * should not fail if this happens.
                  */
-                wc_status = acpi_get_handle(handle, wc_method, &wc_handle);
-                if (ACPI_SUCCESS(wc_status))
-                        wc_status = acpi_evaluate_object(handle, wc_method,
-                                &wc_input, NULL);
+                if (acpi_has_method(handle, wc_method))
+                        wc_status = acpi_execute_simple_method(handle,
+                                                                wc_method, 1);
         }
 
         strcpy(method, "WQ");
@@ -414,9 +402,7 @@ struct acpi_buffer *out)
          * the WQxx method failed - we should disable collection anyway.
          */
         if ((block->flags & ACPI_WMI_EXPENSIVE) && ACPI_SUCCESS(wc_status)) {
-                wc_params[0].integer.value = 0;
-                status = acpi_evaluate_object(handle,
-                wc_method, &wc_input, NULL);
+                status = acpi_execute_simple_method(handle, wc_method, 0);
         }
 
         return status;