13 files changed, 98 insertions, 115 deletions

diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index d1fcbc0f6cbc..ac7034129f3f 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -61,7 +61,6 @@ static int acpi_ac_open_fs(struct inode *inode, struct file *file);
 
 static int acpi_ac_add(struct acpi_device *device);
 static int acpi_ac_remove(struct acpi_device *device, int type);
-static int acpi_ac_resume(struct acpi_device *device);
 static void acpi_ac_notify(struct acpi_device *device, u32 event);
 
 static const struct acpi_device_id ac_device_ids[] = {
@@ -70,6 +69,9 @@ static const struct acpi_device_id ac_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, ac_device_ids);
 
+static int acpi_ac_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
+
 static struct acpi_driver acpi_ac_driver = {
         .name = "ac",
         .class = ACPI_AC_CLASS,
@@ -78,9 +80,9 @@ static struct acpi_driver acpi_ac_driver = {
         .ops = {
                 .add = acpi_ac_add,
                 .remove = acpi_ac_remove,
-                .resume = acpi_ac_resume,
                 .notify = acpi_ac_notify,
                 },
+        .drv.pm = &acpi_ac_pm,
 };
 
 struct acpi_ac {
@@ -311,13 +313,18 @@ static int acpi_ac_add(struct acpi_device *device)
         return result;
 }
 
-static int acpi_ac_resume(struct acpi_device *device)
+static int acpi_ac_resume(struct device *dev)
 {
         struct acpi_ac *ac;
         unsigned old_state;
-        if (!device || !acpi_driver_data(device))
+
+        if (!dev)
                 return -EINVAL;
-        ac = acpi_driver_data(device);
+
+        ac = acpi_driver_data(to_acpi_device(dev));
+        if (!ac)
+                return -EINVAL;
+
         old_state = ac->state;
         if (acpi_ac_get_state(ac))
                 return 0;
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 5662d64e6733..ff2c876ec412 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -1053,17 +1053,24 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
 }
 
 /* this is needed to learn about changes made in suspended state */
-static int acpi_battery_resume(struct acpi_device *device)
+static int acpi_battery_resume(struct device *dev)
 {
         struct acpi_battery *battery;
-        if (!device)
+
+        if (!dev)
                 return -EINVAL;
-        battery = acpi_driver_data(device);
+
+        battery = acpi_driver_data(to_acpi_device(dev));
+        if (!battery)
+                return -EINVAL;
+
         battery->update_time = 0;
         acpi_battery_update(battery);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
+
 static struct acpi_driver acpi_battery_driver = {
         .name = "battery",
         .class = ACPI_BATTERY_CLASS,
@@ -1071,10 +1078,10 @@ static struct acpi_driver acpi_battery_driver = {
         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
         .ops = {
                 .add = acpi_battery_add,
-                .resume = acpi_battery_resume,
                 .remove = acpi_battery_remove,
                 .notify = acpi_battery_notify,
                 },
+        .drv.pm = &acpi_battery_pm,
 };
 
 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index d27d072472f9..79d4c22f7a6d 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -76,19 +76,21 @@ MODULE_DEVICE_TABLE(acpi, button_device_ids);
 
 static int acpi_button_add(struct acpi_device *device);
 static int acpi_button_remove(struct acpi_device *device, int type);
-static int acpi_button_resume(struct acpi_device *device);
 static void acpi_button_notify(struct acpi_device *device, u32 event);
 
+static int acpi_button_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_button_pm, NULL, acpi_button_resume);
+
 static struct acpi_driver acpi_button_driver = {
         .name = "button",
         .class = ACPI_BUTTON_CLASS,
         .ids = button_device_ids,
         .ops = {
                 .add = acpi_button_add,
-                .resume = acpi_button_resume,
                 .remove = acpi_button_remove,
                 .notify = acpi_button_notify,
         },
+        .drv.pm = &acpi_button_pm,
 };
 
 struct acpi_button {
@@ -308,8 +310,9 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
         }
 }
 
-static int acpi_button_resume(struct acpi_device *device)
+static int acpi_button_resume(struct device *dev)
 {
+        struct acpi_device *device = to_acpi_device(dev);
         struct acpi_button *button = acpi_driver_data(device);
 
         if (button->type == ACPI_BUTTON_TYPE_LID)
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 0f0356ca1a9e..669d9ee80d16 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -46,8 +46,6 @@ MODULE_LICENSE("GPL");
 
 static int acpi_fan_add(struct acpi_device *device);
 static int acpi_fan_remove(struct acpi_device *device, int type);
-static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state);
-static int acpi_fan_resume(struct acpi_device *device);
 
 static const struct acpi_device_id fan_device_ids[] = {
         {"PNP0C0B", 0},
@@ -55,6 +53,10 @@ static const struct acpi_device_id fan_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, fan_device_ids);
 
+static int acpi_fan_suspend(struct device *dev);
+static int acpi_fan_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_fan_pm, acpi_fan_suspend, acpi_fan_resume);
+
 static struct acpi_driver acpi_fan_driver = {
         .name = "fan",
         .class = ACPI_FAN_CLASS,
@@ -62,9 +64,8 @@ static struct acpi_driver acpi_fan_driver = {
         .ops = {
                 .add = acpi_fan_add,
                 .remove = acpi_fan_remove,
-                .suspend = acpi_fan_suspend,
-                .resume = acpi_fan_resume,
                 },
+        .drv.pm = &acpi_fan_pm,
 };
 
 /* thermal cooling device callbacks */
@@ -183,24 +184,24 @@ static int acpi_fan_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state)
+static int acpi_fan_suspend(struct device *dev)
 {
-        if (!device)
+        if (!dev)
                 return -EINVAL;
 
-        acpi_bus_set_power(device->handle, ACPI_STATE_D0);
+        acpi_bus_set_power(to_acpi_device(dev)->handle, ACPI_STATE_D0);
 
         return AE_OK;
 }
 
-static int acpi_fan_resume(struct acpi_device *device)
+static int acpi_fan_resume(struct device *dev)
 {
         int result;
 
-        if (!device)
+        if (!dev)
                 return -EINVAL;
 
-        result = acpi_bus_update_power(device->handle, NULL);
+        result = acpi_bus_update_power(to_acpi_device(dev)->handle, NULL);
         if (result)
                 printk(KERN_ERR PREFIX "Error updating fan power state\n");
 
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 1564e0927c21..243ee85e4d2e 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -39,6 +39,7 @@ int register_acpi_bus_type(struct acpi_bus_type *type)
         }
         return -ENODEV;
 }
+EXPORT_SYMBOL_GPL(register_acpi_bus_type);
 
 int unregister_acpi_bus_type(struct acpi_bus_type *type)
 {
@@ -54,6 +55,7 @@ int unregister_acpi_bus_type(struct acpi_bus_type *type)
         }
         return -ENODEV;
 }
+EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
 
 static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
 {
@@ -69,7 +71,6 @@ static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
         up_read(&bus_type_sem);
         return ret;
 }
-EXPORT_SYMBOL_GPL(register_acpi_bus_type);
 
 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
 {
@@ -86,7 +87,6 @@ static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
         up_read(&bus_type_sem);
         return ret;
 }
-EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
 
 /* Get device's handler per its address under its parent */
 struct acpi_find_child {
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 7aff6312ce7c..ec54014c321c 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -505,6 +505,8 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
         strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
         device->driver_data = root;
 
+        root->mcfg_addr = acpi_pci_root_get_mcfg_addr(device->handle);
+
         /*
          * All supported architectures that use ACPI have support for
          * PCI domains, so we indicate this in _OSC support capabilities.
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index dd6d6a3c6780..215ecd097408 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -60,7 +60,6 @@ ACPI_MODULE_NAME("power");
 
 static int acpi_power_add(struct acpi_device *device);
 static int acpi_power_remove(struct acpi_device *device, int type);
-static int acpi_power_resume(struct acpi_device *device);
 
 static const struct acpi_device_id power_device_ids[] = {
         {ACPI_POWER_HID, 0},
@@ -68,6 +67,9 @@ static const struct acpi_device_id power_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, power_device_ids);
 
+static int acpi_power_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_power_pm, NULL, acpi_power_resume);
+
 static struct acpi_driver acpi_power_driver = {
         .name = "power",
         .class = ACPI_POWER_CLASS,
@@ -75,8 +77,8 @@ static struct acpi_driver acpi_power_driver = {
         .ops = {
                 .add = acpi_power_add,
                 .remove = acpi_power_remove,
-                .resume = acpi_power_resume,
                 },
+        .drv.pm = &acpi_power_pm,
 };
 
 /*
@@ -390,6 +392,7 @@ void acpi_power_resource_unregister_device(struct device *dev, acpi_handle handl
                 __acpi_power_resource_unregister_device(dev,
                         list->handles[i]);
 }
+EXPORT_SYMBOL_GPL(acpi_power_resource_unregister_device);
 
 static int __acpi_power_resource_register_device(
         struct acpi_power_managed_device *powered_device, acpi_handle handle)
@@ -460,6 +463,7 @@ no_power_resource:
         printk(KERN_WARNING PREFIX "Invalid Power Resource to register!");
         return -ENODEV;
 }
+EXPORT_SYMBOL_GPL(acpi_power_resource_register_device);
 
 /**
  * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
@@ -771,14 +775,16 @@ static int acpi_power_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_power_resume(struct acpi_device *device)
+static int acpi_power_resume(struct device *dev)
 {
         int result = 0, state;
+        struct acpi_device *device;
         struct acpi_power_resource *resource;
 
-        if (!device)
+        if (!dev)
                 return -EINVAL;
 
+        device = to_acpi_device(dev);
         resource = acpi_driver_data(device);
         if (!resource)
                 return -EINVAL;
diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index 971c45474703..ff8e04f2fab4 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -93,6 +93,9 @@ static const struct acpi_device_id processor_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, processor_device_ids);
 
+static SIMPLE_DEV_PM_OPS(acpi_processor_pm,
+                         acpi_processor_suspend, acpi_processor_resume);
+
 static struct acpi_driver acpi_processor_driver = {
         .name = "processor",
         .class = ACPI_PROCESSOR_CLASS,
@@ -100,10 +103,9 @@ static struct acpi_driver acpi_processor_driver = {
         .ops = {
                 .add = acpi_processor_add,
                 .remove = acpi_processor_remove,
-                .suspend = acpi_processor_suspend,
-                .resume = acpi_processor_resume,
                 .notify = acpi_processor_notify,
                 },
+        .drv.pm = &acpi_processor_pm,
 };
 
 #define INSTALL_NOTIFY_HANDLER          1
@@ -427,18 +429,11 @@ static int acpi_cpu_soft_notify(struct notifier_block *nfb,
                  * Initialize missing things
                  */
                 if (pr->flags.need_hotplug_init) {
-                        struct cpuidle_driver *idle_driver =
-                                cpuidle_get_driver();
-
                         printk(KERN_INFO "Will online and init hotplugged "
                                "CPU: %d\n", pr->id);
                         WARN(acpi_processor_start(pr), "Failed to start CPU:"
                                 " %d\n", pr->id);
                         pr->flags.need_hotplug_init = 0;
-                        if (idle_driver && !strcmp(idle_driver->name,
-                                                   "intel_idle")) {
-                                intel_idle_cpu_init(pr->id);
-                        }
                 /* Normal CPU soft online event */
                 } else {
                         acpi_processor_ppc_has_changed(pr, 0);
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 9837c9c4f009..ad3730b4038b 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -221,10 +221,6 @@ static void lapic_timer_state_broadcast(struct acpi_processor *pr,
 
 #endif
 
-/*
- * Suspend / resume control
- */
-static int acpi_idle_suspend;
 static u32 saved_bm_rld;
 
 static void acpi_idle_bm_rld_save(void)
@@ -241,23 +237,15 @@ static void acpi_idle_bm_rld_restore(void)
                 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
 }
 
-int acpi_processor_suspend(struct acpi_device * device, pm_message_t state)
+int acpi_processor_suspend(struct device *dev)
 {
-        if (acpi_idle_suspend == 1)
-                return 0;
-
         acpi_idle_bm_rld_save();
-        acpi_idle_suspend = 1;
         return 0;
 }
 
-int acpi_processor_resume(struct acpi_device * device)
+int acpi_processor_resume(struct device *dev)
 {
-        if (acpi_idle_suspend == 0)
-                return 0;
-
         acpi_idle_bm_rld_restore();
-        acpi_idle_suspend = 0;
         return 0;
 }
 
@@ -595,7 +583,6 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
          */
         cx->valid = 1;
 
-        cx->latency_ticks = cx->latency;
         /*
          * On older chipsets, BM_RLD needs to be set
          * in order for Bus Master activity to wake the
@@ -628,7 +615,6 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
                         if (!cx->address)
                                 break;
                         cx->valid = 1; 
-                        cx->latency_ticks = cx->latency; /* Normalize latency */
                         break;
 
                 case ACPI_STATE_C3:
@@ -763,11 +749,6 @@ static int acpi_idle_enter_c1(struct cpuidle_device *dev,
 
         local_irq_disable();
 
-        if (acpi_idle_suspend) {
-                local_irq_enable();
-                cpu_relax();
-                return -EBUSY;
-        }
 
         lapic_timer_state_broadcast(pr, cx, 1);
         kt1 = ktime_get_real();
@@ -779,7 +760,6 @@ static int acpi_idle_enter_c1(struct cpuidle_device *dev,
         dev->last_residency = (int)idle_time;
 
         local_irq_enable();
-        cx->usage++;
         lapic_timer_state_broadcast(pr, cx, 0);
 
         return index;
@@ -838,11 +818,6 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
 
         local_irq_disable();
 
-        if (acpi_idle_suspend) {
-                local_irq_enable();
-                cpu_relax();
-                return -EBUSY;
-        }
 
         if (cx->entry_method != ACPI_CSTATE_FFH) {
                 current_thread_info()->status &= ~TS_POLLING;
@@ -887,10 +862,7 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
         if (cx->entry_method != ACPI_CSTATE_FFH)
                 current_thread_info()->status |= TS_POLLING;
 
-        cx->usage++;
-
         lapic_timer_state_broadcast(pr, cx, 0);
-        cx->time += idle_time;
         return index;
 }
 
@@ -928,8 +900,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
                                                 drv, drv->safe_state_index);
                 } else {
                         local_irq_disable();
-                        if (!acpi_idle_suspend)
-                                acpi_safe_halt();
+                        acpi_safe_halt();
                         local_irq_enable();
                         return -EBUSY;
                 }
@@ -937,11 +908,6 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
 
         local_irq_disable();
 
-        if (acpi_idle_suspend) {
-                local_irq_enable();
-                cpu_relax();
-                return -EBUSY;
-        }
 
         if (cx->entry_method != ACPI_CSTATE_FFH) {
                 current_thread_info()->status &= ~TS_POLLING;
@@ -1014,10 +980,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
         if (cx->entry_method != ACPI_CSTATE_FFH)
                 current_thread_info()->status |= TS_POLLING;
 
-        cx->usage++;
-
         lapic_timer_state_broadcast(pr, cx, 0);
-        cx->time += idle_time;
         return index;
 }
 
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 6e36d0c0057c..c0b9aa5faf4c 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -988,16 +988,18 @@ static void acpi_sbs_rmdirs(void)
 #endif
 }
 
-static int acpi_sbs_resume(struct acpi_device *device)
+static int acpi_sbs_resume(struct device *dev)
 {
         struct acpi_sbs *sbs;
-        if (!device)
+        if (!dev)
                 return -EINVAL;
-        sbs = device->driver_data;
+        sbs = to_acpi_device(dev)->driver_data;
         acpi_sbs_callback(sbs);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acpi_sbs_pm, NULL, acpi_sbs_resume);
+
 static struct acpi_driver acpi_sbs_driver = {
         .name = "sbs",
         .class = ACPI_SBS_CLASS,
@@ -1005,8 +1007,8 @@ static struct acpi_driver acpi_sbs_driver = {
         .ops = {
                 .add = acpi_sbs_add,
                 .remove = acpi_sbs_remove,
-                .resume = acpi_sbs_resume,
                 },
+        .drv.pm = &acpi_sbs_pm,
 };
 
 static int __init acpi_sbs_init(void)
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 148556a8f0f2..d1ecca2b641a 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -330,26 +330,6 @@ static void acpi_device_release(struct device *dev)
         kfree(acpi_dev);
 }
 
-static int acpi_device_suspend(struct device *dev, pm_message_t state)
-{
-        struct acpi_device *acpi_dev = to_acpi_device(dev);
-        struct acpi_driver *acpi_drv = acpi_dev->driver;
-
-        if (acpi_drv && acpi_drv->ops.suspend)
-                return acpi_drv->ops.suspend(acpi_dev, state);
-        return 0;
-}
-
-static int acpi_device_resume(struct device *dev)
-{
-        struct acpi_device *acpi_dev = to_acpi_device(dev);
-        struct acpi_driver *acpi_drv = acpi_dev->driver;
-
-        if (acpi_drv && acpi_drv->ops.resume)
-                return acpi_drv->ops.resume(acpi_dev);
-        return 0;
-}
-
 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 {
         struct acpi_device *acpi_dev = to_acpi_device(dev);
@@ -481,8 +461,6 @@ static int acpi_device_remove(struct device * dev)
 
 struct bus_type acpi_bus_type = {
         .name           = "acpi",
-        .suspend        = acpi_device_suspend,
-        .resume         = acpi_device_resume,
         .match          = acpi_bus_match,
         .probe          = acpi_device_probe,
         .remove         = acpi_device_remove,
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index 23a53c013f1e..7a7a9c929247 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -716,8 +716,9 @@ int acpi_suspend(u32 acpi_state)
  *      @dev: device to examine; its driver model wakeup flags control
  *              whether it should be able to wake up the system
  *      @d_min_p: used to store the upper limit of allowed states range
- *      Return value: preferred power state of the device on success, -ENODEV on
- *              failure (ie. if there's no 'struct acpi_device' for @dev)
+ *      @d_max_in: specify the lowest allowed states
+ *      Return value: preferred power state of the device on success, -ENODEV
+ *      (ie. if there's no 'struct acpi_device' for @dev) or -EINVAL on failure
  *
  *      Find the lowest power (highest number) ACPI device power state that
  *      device @dev can be in while the system is in the sleep state represented
@@ -732,13 +733,15 @@ int acpi_suspend(u32 acpi_state)
  *      via @wake.
  */
 
-int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
+int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
 {
         acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
         struct acpi_device *adev;
         char acpi_method[] = "_SxD";
         unsigned long long d_min, d_max;
 
+        if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3)
+                return -EINVAL;
         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
                 printk(KERN_DEBUG "ACPI handle has no context!\n");
                 return -ENODEV;
@@ -746,8 +749,10 @@ int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
 
         acpi_method[2] = '0' + acpi_target_sleep_state;
         /*
-         * If the sleep state is S0, we will return D3, but if the device has
-         * _S0W, we will use the value from _S0W
+         * If the sleep state is S0, the lowest limit from ACPI is D3,
+         * but if the device has _S0W, we will use the value from _S0W
+         * as the lowest limit from ACPI.  Finally, we will constrain
+         * the lowest limit with the specified one.
          */
         d_min = ACPI_STATE_D0;
         d_max = ACPI_STATE_D3;
@@ -791,10 +796,20 @@ int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
                 }
         }
 
+        if (d_max_in < d_min)
+                return -EINVAL;
         if (d_min_p)
                 *d_min_p = d_min;
+        /* constrain d_max with specified lowest limit (max number) */
+        if (d_max > d_max_in) {
+                for (d_max = d_max_in; d_max > d_min; d_max--) {
+                        if (adev->power.states[d_max].flags.valid)
+                                break;
+                }
+        }
         return d_max;
 }
+EXPORT_SYMBOL(acpi_pm_device_sleep_state);
 #endif /* CONFIG_PM */
 
 #ifdef CONFIG_PM_SLEEP
@@ -831,6 +846,7 @@ int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
 
         return 0;
 }
+EXPORT_SYMBOL(acpi_pm_device_run_wake);
 
 /**
  *      acpi_pm_device_sleep_wake - enable or disable the system wake-up
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 8275e7b06962..9fe90e9fecb5 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -98,7 +98,6 @@ MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
 
 static int acpi_thermal_add(struct acpi_device *device);
 static int acpi_thermal_remove(struct acpi_device *device, int type);
-static int acpi_thermal_resume(struct acpi_device *device);
 static void acpi_thermal_notify(struct acpi_device *device, u32 event);
 
 static const struct acpi_device_id  thermal_device_ids[] = {
@@ -107,6 +106,9 @@ static const struct acpi_device_id  thermal_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
 
+static int acpi_thermal_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, NULL, acpi_thermal_resume);
+
 static struct acpi_driver acpi_thermal_driver = {
         .name = "thermal",
         .class = ACPI_THERMAL_CLASS,
@@ -114,9 +116,9 @@ static struct acpi_driver acpi_thermal_driver = {
         .ops = {
                 .add = acpi_thermal_add,
                 .remove = acpi_thermal_remove,
-                .resume = acpi_thermal_resume,
                 .notify = acpi_thermal_notify,
                 },
+        .drv.pm = &acpi_thermal_pm,
 };
 
 struct acpi_thermal_state {
@@ -1039,16 +1041,17 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_thermal_resume(struct acpi_device *device)
+static int acpi_thermal_resume(struct device *dev)
 {
-        struct acpi_thermal *tz = NULL;
+        struct acpi_thermal *tz;
         int i, j, power_state, result;
 
-
-        if (!device || !acpi_driver_data(device))
+        if (!dev)
                 return -EINVAL;
 
-        tz = acpi_driver_data(device);
+        tz = acpi_driver_data(to_acpi_device(dev));
+        if (!tz)
+                return -EINVAL;
 
         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
                 if (!(&tz->trips.active[i]))