Merge branch 'pm-drivers'

* pm-drivers:
  rtc-cmos: report wakeups from interrupt handler
  PM / crypto / ux500: Use struct dev_pm_ops for power management
  PM / IPMI: Remove empty legacy PCI PM callbacks
  tpm_nsc: Use struct dev_pm_ops for power management
  tpm_tis: Use struct dev_pm_ops for power management
  tpm_atmel: Use struct dev_pm_ops for power management
  PM / TPM: Drop unused pm_message_t argument from tpm_pm_suspend()
  omap-rng: Use struct dev_pm_ops for power management
  mg_disk: Use struct dev_pm_ops for power management
  msi-laptop: Use struct dev_pm_ops for power management
  hdaps: Use struct dev_pm_ops for power management
  sonypi: Use struct dev_pm_ops for power management
  intel_mid_thermal: Use struct dev_pm_ops for power management
  acer-wmi: Use struct dev_pm_ops for power management
  intel_ips: Remove empty legacy PM callbacks
  thinkpad_acpi: Use struct dev_pm_ops instead of legacy PM routines
  thinkpad_acpi: Drop pm_message_t arguments from suspend routines

18 files changed, 104 insertions, 150 deletions

diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index 76fa3deaee84..1788f491e0fb 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -780,9 +780,9 @@ static const struct block_device_operations mg_disk_ops = {
         .getgeo = mg_getgeo
 };
 
-static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
+static int mg_suspend(struct device *dev)
 {
-        struct mg_drv_data *prv_data = plat_dev->dev.platform_data;
+        struct mg_drv_data *prv_data = dev->platform_data;
         struct mg_host *host = prv_data->host;
 
         if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
@@ -804,9 +804,9 @@ static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
         return 0;
 }
 
-static int mg_resume(struct platform_device *plat_dev)
+static int mg_resume(struct device *dev)
 {
-        struct mg_drv_data *prv_data = plat_dev->dev.platform_data;
+        struct mg_drv_data *prv_data = dev->platform_data;
         struct mg_host *host = prv_data->host;
 
         if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
@@ -825,6 +825,8 @@ static int mg_resume(struct platform_device *plat_dev)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(mg_pm, mg_suspend, mg_resume);
+
 static int mg_probe(struct platform_device *plat_dev)
 {
         struct mg_host *host;
@@ -1074,11 +1076,10 @@ static int mg_remove(struct platform_device *plat_dev)
 static struct platform_driver mg_disk_driver = {
         .probe = mg_probe,
         .remove = mg_remove,
-        .suspend = mg_suspend,
-        .resume = mg_resume,
         .driver = {
                 .name = MG_DEV_NAME,
                 .owner = THIS_MODULE,
+                .pm = &mg_pm,
         }
 };
 
diff --git a/drivers/char/hw_random/omap-rng.c b/drivers/char/hw_random/omap-rng.c
index 1412565c01af..d706bd0e9e80 100644
--- a/drivers/char/hw_random/omap-rng.c
+++ b/drivers/char/hw_random/omap-rng.c
@@ -162,22 +162,24 @@ static int __exit omap_rng_remove(struct platform_device *pdev)
 
 #ifdef CONFIG_PM
 
-static int omap_rng_suspend(struct platform_device *pdev, pm_message_t message)
+static int omap_rng_suspend(struct device *dev)
 {
         omap_rng_write_reg(RNG_MASK_REG, 0x0);
         return 0;
 }
 
-static int omap_rng_resume(struct platform_device *pdev)
+static int omap_rng_resume(struct device *dev)
 {
         omap_rng_write_reg(RNG_MASK_REG, 0x1);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(omap_rng_pm, omap_rng_suspend, omap_rng_resume);
+#define OMAP_RNG_PM     (&omap_rng_pm)
+
 #else
 
-#define omap_rng_suspend        NULL
-#define omap_rng_resume         NULL
+#define OMAP_RNG_PM     NULL
 
 #endif
 
@@ -188,11 +190,10 @@ static struct platform_driver omap_rng_driver = {
         .driver = {
                 .name           = "omap_rng",
                 .owner          = THIS_MODULE,
+                .pm             = OMAP_RNG_PM,
         },
         .probe          = omap_rng_probe,
         .remove         = __exit_p(omap_rng_remove),
-        .suspend        = omap_rng_suspend,
-        .resume         = omap_rng_resume
 };
 
 static int __init omap_rng_init(void)
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 1e638fff40ea..83f85cf7fb1b 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -2503,18 +2503,6 @@ static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
         cleanup_one_si(info);
 }
 
-#ifdef CONFIG_PM
-static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
-{
-        return 0;
-}
-
-static int ipmi_pci_resume(struct pci_dev *pdev)
-{
-        return 0;
-}
-#endif
-
 static struct pci_device_id ipmi_pci_devices[] = {
         { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
         { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
@@ -2527,10 +2515,6 @@ static struct pci_driver ipmi_pci_driver = {
         .id_table =     ipmi_pci_devices,
         .probe =        ipmi_pci_probe,
         .remove =       __devexit_p(ipmi_pci_remove),
-#ifdef CONFIG_PM
-        .suspend =      ipmi_pci_suspend,
-        .resume =       ipmi_pci_resume,
-#endif
 };
 #endif /* CONFIG_PCI */
 
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index 45713f0e7d61..f87780502b41 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -1459,7 +1459,7 @@ static int __devexit sonypi_remove(struct platform_device *dev)
 #ifdef CONFIG_PM
 static int old_camera_power;
 
-static int sonypi_suspend(struct platform_device *dev, pm_message_t state)
+static int sonypi_suspend(struct device *dev)
 {
         old_camera_power = sonypi_device.camera_power;
         sonypi_disable();
@@ -1467,14 +1467,16 @@ static int sonypi_suspend(struct platform_device *dev, pm_message_t state)
         return 0;
 }
 
-static int sonypi_resume(struct platform_device *dev)
+static int sonypi_resume(struct device *dev)
 {
         sonypi_enable(old_camera_power);
         return 0;
 }
+
+static SIMPLE_DEV_PM_OPS(sonypi_pm, sonypi_suspend, sonypi_resume);
+#define SONYPI_PM       (&sonypi_pm)
 #else
-#define sonypi_suspend  NULL
-#define sonypi_resume   NULL
+#define SONYPI_PM       NULL
 #endif
 
 static void sonypi_shutdown(struct platform_device *dev)
@@ -1486,12 +1488,11 @@ static struct platform_driver sonypi_driver = {
         .driver         = {
                 .name   = "sonypi",
                 .owner  = THIS_MODULE,
+                .pm     = SONYPI_PM,
         },
         .probe          = sonypi_probe,
         .remove         = __devexit_p(sonypi_remove),
         .shutdown       = sonypi_shutdown,
-        .suspend        = sonypi_suspend,
-        .resume         = sonypi_resume,
 };
 
 static struct platform_device *sonypi_platform_device;
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index ad7c7320dd1b..ae43ac55fc1e 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -1274,7 +1274,7 @@ static struct tpm_input_header savestate_header = {
  * We are about to suspend. Save the TPM state
  * so that it can be restored.
  */
-int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
+int tpm_pm_suspend(struct device *dev)
 {
         struct tpm_chip *chip = dev_get_drvdata(dev);
         struct tpm_cmd_t cmd;
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index b1c5280ac159..917f727e6740 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -299,7 +299,7 @@ extern ssize_t tpm_write(struct file *, const char __user *, size_t,
                          loff_t *);
 extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *);
 extern void tpm_remove_hardware(struct device *);
-extern int tpm_pm_suspend(struct device *, pm_message_t);
+extern int tpm_pm_suspend(struct device *);
 extern int tpm_pm_resume(struct device *);
 extern int wait_for_tpm_stat(struct tpm_chip *, u8, unsigned long,
                              wait_queue_head_t *);
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index c64a1bc65349..678d57019dc4 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -168,22 +168,14 @@ static void atml_plat_remove(void)
         }
 }
 
-static int tpm_atml_suspend(struct platform_device *dev, pm_message_t msg)
-{
-        return tpm_pm_suspend(&dev->dev, msg);
-}
+static SIMPLE_DEV_PM_OPS(tpm_atml_pm, tpm_pm_suspend, tpm_pm_resume);
 
-static int tpm_atml_resume(struct platform_device *dev)
-{
-        return tpm_pm_resume(&dev->dev);
-}
 static struct platform_driver atml_drv = {
         .driver = {
                 .name = "tpm_atmel",
                 .owner          = THIS_MODULE,
+                .pm             = &tpm_atml_pm,
         },
-        .suspend = tpm_atml_suspend,
-        .resume = tpm_atml_resume,
 };
 
 static int __init init_atmel(void)
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index 4d2464871ada..640c9a427b59 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -274,22 +274,13 @@ static void tpm_nsc_remove(struct device *dev)
         }
 }
 
-static int tpm_nsc_suspend(struct platform_device *dev, pm_message_t msg)
-{
-        return tpm_pm_suspend(&dev->dev, msg);
-}
-
-static int tpm_nsc_resume(struct platform_device *dev)
-{
-        return tpm_pm_resume(&dev->dev);
-}
+static SIMPLE_DEV_PM_OPS(tpm_nsc_pm, tpm_pm_suspend, tpm_pm_resume);
 
 static struct platform_driver nsc_drv = {
-        .suspend         = tpm_nsc_suspend,
-        .resume          = tpm_nsc_resume,
         .driver          = {
                 .name    = "tpm_nsc",
                 .owner   = THIS_MODULE,
+                .pm      = &tpm_nsc_pm,
         },
 };
 
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index d2a70cae76df..89682fa8801e 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -750,7 +750,7 @@ static int __devinit tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
 
 static int tpm_tis_pnp_suspend(struct pnp_dev *dev, pm_message_t msg)
 {
-        return tpm_pm_suspend(&dev->dev, msg);
+        return tpm_pm_suspend(&dev->dev);
 }
 
 static int tpm_tis_pnp_resume(struct pnp_dev *dev)
@@ -806,27 +806,25 @@ module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
 #endif
-static int tpm_tis_suspend(struct platform_device *dev, pm_message_t msg)
-{
-        return tpm_pm_suspend(&dev->dev, msg);
-}
 
-static int tpm_tis_resume(struct platform_device *dev)
+static int tpm_tis_resume(struct device *dev)
 {
-        struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip->vendor.irq)
                 tpm_tis_reenable_interrupts(chip);
 
-        return tpm_pm_resume(&dev->dev);
+        return tpm_pm_resume(dev);
 }
+
+static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
+
 static struct platform_driver tis_drv = {
         .driver = {
                 .name = "tpm_tis",
                 .owner          = THIS_MODULE,
+                .pm             = &tpm_tis_pm,
         },
-        .suspend = tpm_tis_suspend,
-        .resume = tpm_tis_resume,
 };
 
 static struct platform_device *pdev;
diff --git a/drivers/crypto/ux500/cryp/cryp_core.c b/drivers/crypto/ux500/cryp/cryp_core.c
index 7cac12793a4b..1c307e1b840c 100644
--- a/drivers/crypto/ux500/cryp/cryp_core.c
+++ b/drivers/crypto/ux500/cryp/cryp_core.c
@@ -1661,27 +1661,26 @@ static void ux500_cryp_shutdown(struct platform_device *pdev)
 
 }
 
-static int ux500_cryp_suspend(struct platform_device *pdev, pm_message_t state)
+static int ux500_cryp_suspend(struct device *dev)
 {
         int ret;
+        struct platform_device *pdev = to_platform_device(dev);
         struct cryp_device_data *device_data;
         struct resource *res_irq;
         struct cryp_ctx *temp_ctx = NULL;
 
-        dev_dbg(&pdev->dev, "[%s]", __func__);
+        dev_dbg(dev, "[%s]", __func__);
 
         /* Handle state? */
         device_data = platform_get_drvdata(pdev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s]: platform_get_drvdata() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
         res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (!res_irq)
-                dev_err(&pdev->dev, "[%s]: IORESOURCE_IRQ, unavailable",
-                        __func__);
+                dev_err(dev, "[%s]: IORESOURCE_IRQ, unavailable", __func__);
         else
                 disable_irq(res_irq->start);
 
@@ -1692,32 +1691,32 @@ static int ux500_cryp_suspend(struct platform_device *pdev, pm_message_t state)
 
         if (device_data->current_ctx == ++temp_ctx) {
                 if (down_interruptible(&driver_data.device_allocation))
-                        dev_dbg(&pdev->dev, "[%s]: down_interruptible() "
-                                        "failed", __func__);
-                ret = cryp_disable_power(&pdev->dev, device_data, false);
+                        dev_dbg(dev, "[%s]: down_interruptible() failed",
+                                __func__);
+                ret = cryp_disable_power(dev, device_data, false);
 
         } else
-                ret = cryp_disable_power(&pdev->dev, device_data, true);
+                ret = cryp_disable_power(dev, device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: cryp_disable_power()", __func__);
+                dev_err(dev, "[%s]: cryp_disable_power()", __func__);
 
         return ret;
 }
 
-static int ux500_cryp_resume(struct platform_device *pdev)
+static int ux500_cryp_resume(struct device *dev)
 {
         int ret = 0;
+        struct platform_device *pdev = to_platform_device(dev);
         struct cryp_device_data *device_data;
         struct resource *res_irq;
         struct cryp_ctx *temp_ctx = NULL;
 
-        dev_dbg(&pdev->dev, "[%s]", __func__);
+        dev_dbg(dev, "[%s]", __func__);
 
         device_data = platform_get_drvdata(pdev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s]: platform_get_drvdata() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
@@ -1730,11 +1729,10 @@ static int ux500_cryp_resume(struct platform_device *pdev)
         if (!device_data->current_ctx)
                 up(&driver_data.device_allocation);
         else
-                ret = cryp_enable_power(&pdev->dev, device_data, true);
+                ret = cryp_enable_power(dev, device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: cryp_enable_power() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: cryp_enable_power() failed!", __func__);
         else {
                 res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
                 if (res_irq)
@@ -1744,15 +1742,16 @@ static int ux500_cryp_resume(struct platform_device *pdev)
         return ret;
 }
 
+static SIMPLE_DEV_PM_OPS(ux500_cryp_pm, ux500_cryp_suspend, ux500_cryp_resume);
+
 static struct platform_driver cryp_driver = {
         .probe  = ux500_cryp_probe,
         .remove = ux500_cryp_remove,
         .shutdown = ux500_cryp_shutdown,
-        .suspend  = ux500_cryp_suspend,
-        .resume   = ux500_cryp_resume,
         .driver = {
                 .owner = THIS_MODULE,
                 .name  = "cryp1"
+                .pm    = &ux500_cryp_pm,
         }
 };
 
diff --git a/drivers/crypto/ux500/hash/hash_core.c b/drivers/crypto/ux500/hash/hash_core.c
index 6dbb9ec709a3..08d5032cb564 100644
--- a/drivers/crypto/ux500/hash/hash_core.c
+++ b/drivers/crypto/ux500/hash/hash_core.c
@@ -1894,19 +1894,17 @@ static void ux500_hash_shutdown(struct platform_device *pdev)
 
 /**
  * ux500_hash_suspend - Function that suspends the hash device.
- * @pdev:       The platform device.
- * @state:      -
+ * @dev:        Device to suspend.
  */
-static int ux500_hash_suspend(struct platform_device *pdev, pm_message_t state)
+static int ux500_hash_suspend(struct device *dev)
 {
         int ret;
         struct hash_device_data *device_data;
         struct hash_ctx *temp_ctx = NULL;
 
-        device_data = platform_get_drvdata(pdev);
+        device_data = dev_get_drvdata(dev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s] platform_get_drvdata() failed!",
-                                __func__);
+                dev_err(dev, "[%s] platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
@@ -1917,33 +1915,32 @@ static int ux500_hash_suspend(struct platform_device *pdev, pm_message_t state)
 
         if (device_data->current_ctx == ++temp_ctx) {
                 if (down_interruptible(&driver_data.device_allocation))
-                        dev_dbg(&pdev->dev, "[%s]: down_interruptible() "
-                                        "failed", __func__);
+                        dev_dbg(dev, "[%s]: down_interruptible() failed",
+                                __func__);
                 ret = hash_disable_power(device_data, false);
 
         } else
                 ret = hash_disable_power(device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: hash_disable_power()", __func__);
+                dev_err(dev, "[%s]: hash_disable_power()", __func__);
 
         return ret;
 }
 
 /**
  * ux500_hash_resume - Function that resume the hash device.
- * @pdev:       The platform device.
+ * @dev:        Device to resume.
  */
-static int ux500_hash_resume(struct platform_device *pdev)
+static int ux500_hash_resume(struct device *dev)
 {
         int ret = 0;
         struct hash_device_data *device_data;
         struct hash_ctx *temp_ctx = NULL;
 
-        device_data = platform_get_drvdata(pdev);
+        device_data = dev_get_drvdata(dev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s] platform_get_drvdata() failed!",
-                                __func__);
+                dev_err(dev, "[%s] platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
@@ -1958,21 +1955,21 @@ static int ux500_hash_resume(struct platform_device *pdev)
                 ret = hash_enable_power(device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: hash_enable_power() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: hash_enable_power() failed!", __func__);
 
         return ret;
 }
 
+static SIMPLE_DEV_PM_OPS(ux500_hash_pm, ux500_hash_suspend, ux500_hash_resume);
+
 static struct platform_driver hash_driver = {
         .probe  = ux500_hash_probe,
         .remove = ux500_hash_remove,
         .shutdown = ux500_hash_shutdown,
-        .suspend  = ux500_hash_suspend,
-        .resume   = ux500_hash_resume,
         .driver = {
                 .owner = THIS_MODULE,
                 .name  = "hash1",
+                .pm    = &ux500_hash_pm,
         }
 };
 
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index ce875dc365e5..c8f40c9c0428 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -1877,8 +1877,7 @@ static int acer_platform_remove(struct platform_device *device)
         return 0;
 }
 
-static int acer_platform_suspend(struct platform_device *dev,
-pm_message_t state)
+static int acer_suspend(struct device *dev)
 {
         u32 value;
         struct acer_data *data = &interface->data;
@@ -1900,7 +1899,7 @@ pm_message_t state)
         return 0;
 }
 
-static int acer_platform_resume(struct platform_device *device)
+static int acer_resume(struct device *dev)
 {
         struct acer_data *data = &interface->data;
 
@@ -1916,6 +1915,8 @@ static int acer_platform_resume(struct platform_device *device)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acer_pm, acer_suspend, acer_resume);
+
 static void acer_platform_shutdown(struct platform_device *device)
 {
         struct acer_data *data = &interface->data;
@@ -1931,11 +1932,10 @@ static struct platform_driver acer_platform_driver = {
         .driver = {
                 .name = "acer-wmi",
                 .owner = THIS_MODULE,
+                .pm = &acer_pm,
         },
         .probe = acer_platform_probe,
         .remove = acer_platform_remove,
-        .suspend = acer_platform_suspend,
-        .resume = acer_platform_resume,
         .shutdown = acer_platform_shutdown,
 };
 
diff --git a/drivers/platform/x86/hdaps.c b/drivers/platform/x86/hdaps.c
index 24a3ae065f1b..d9ab6f64dcec 100644
--- a/drivers/platform/x86/hdaps.c
+++ b/drivers/platform/x86/hdaps.c
@@ -305,17 +305,19 @@ static int hdaps_probe(struct platform_device *dev)
         return 0;
 }
 
-static int hdaps_resume(struct platform_device *dev)
+static int hdaps_resume(struct device *dev)
 {
         return hdaps_device_init();
 }
 
+static SIMPLE_DEV_PM_OPS(hdaps_pm, NULL, hdaps_resume);
+
 static struct platform_driver hdaps_driver = {
         .probe = hdaps_probe,
-        .resume = hdaps_resume,
         .driver = {
                 .name = "hdaps",
                 .owner = THIS_MODULE,
+                .pm = &hdaps_pm,
         },
 };
 
diff --git a/drivers/platform/x86/intel_ips.c b/drivers/platform/x86/intel_ips.c
index 0ffdb3cde2bb..bd89f3c8e76e 100644
--- a/drivers/platform/x86/intel_ips.c
+++ b/drivers/platform/x86/intel_ips.c
@@ -1697,21 +1697,6 @@ static void ips_remove(struct pci_dev *dev)
         dev_dbg(&dev->dev, "IPS driver removed\n");
 }
 
-#ifdef CONFIG_PM
-static int ips_suspend(struct pci_dev *dev, pm_message_t state)
-{
-        return 0;
-}
-
-static int ips_resume(struct pci_dev *dev)
-{
-        return 0;
-}
-#else
-#define ips_suspend NULL
-#define ips_resume NULL
-#endif /* CONFIG_PM */
-
 static void ips_shutdown(struct pci_dev *dev)
 {
 }
@@ -1721,8 +1706,6 @@ static struct pci_driver ips_pci_driver = {
         .id_table = ips_id_table,
         .probe = ips_probe,
         .remove = ips_remove,
-        .suspend = ips_suspend,
-        .resume = ips_resume,
         .shutdown = ips_shutdown,
 };
 
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
index 5ae9cd9c7e6e..ea7422f6fa03 100644
--- a/drivers/platform/x86/intel_mid_thermal.c
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -418,23 +418,23 @@ static struct thermal_device_info *initialize_sensor(int index)
 
 /**
  * mid_thermal_resume - resume routine
- * @pdev: platform device structure
+ * @dev: device structure
  *
  * mid thermal resume: re-initializes the adc. Can sleep.
  */
-static int mid_thermal_resume(struct platform_device *pdev)
+static int mid_thermal_resume(struct device *dev)
 {
-        return mid_initialize_adc(&pdev->dev);
+        return mid_initialize_adc(dev);
 }
 
 /**
  * mid_thermal_suspend - suspend routine
- * @pdev: platform device structure
+ * @dev: device structure
  *
  * mid thermal suspend implements the suspend functionality
  * by stopping the ADC. Can sleep.
  */
-static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
+static int mid_thermal_suspend(struct device *dev)
 {
         /*
          * This just stops the ADC and does not disable it.
@@ -444,6 +444,9 @@ static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
         return configure_adc(0);
 }
 
+static SIMPLE_DEV_PM_OPS(mid_thermal_pm,
+                         mid_thermal_suspend, mid_thermal_resume);
+
 /**
  * read_curr_temp - reads the current temperature and stores in temp
  * @temp: holds the current temperature value after reading
@@ -557,10 +560,9 @@ static struct platform_driver mid_thermal_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
+                .pm = &mid_thermal_pm,
         },
         .probe = mid_thermal_probe,
-        .suspend = mid_thermal_suspend,
-        .resume = mid_thermal_resume,
         .remove = __devexit_p(mid_thermal_remove),
         .id_table = therm_id_table,
 };
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index bb5132128b33..f64441844317 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -85,7 +85,8 @@
 #define MSI_STANDARD_EC_TOUCHPAD_ADDRESS        0xe4
 #define MSI_STANDARD_EC_TOUCHPAD_MASK           (1 << 4)
 
-static int msi_laptop_resume(struct platform_device *device);
+static int msi_laptop_resume(struct device *device);
+static SIMPLE_DEV_PM_OPS(msi_laptop_pm, NULL, msi_laptop_resume);
 
 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS  0x2f
 
@@ -437,8 +438,8 @@ static struct platform_driver msipf_driver = {
         .driver = {
                 .name = "msi-laptop-pf",
                 .owner = THIS_MODULE,
+                .pm = &msi_laptop_pm,
         },
-        .resume = msi_laptop_resume,
 };
 
 static struct platform_device *msipf_device;
@@ -752,7 +753,7 @@ err_bluetooth:
         return retval;
 }
 
-static int msi_laptop_resume(struct platform_device *device)
+static int msi_laptop_resume(struct device *device)
 {
         u8 data;
         int result;
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 8b5610d88418..d5fd4a1193f8 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -277,7 +277,7 @@ struct ibm_struct {
         int (*write) (char *);
         void (*exit) (void);
         void (*resume) (void);
-        void (*suspend) (pm_message_t state);
+        void (*suspend) (void);
         void (*shutdown) (void);
 
         struct list_head all_drivers;
@@ -922,8 +922,7 @@ static struct input_dev *tpacpi_inputdev;
 static struct mutex tpacpi_inputdev_send_mutex;
 static LIST_HEAD(tpacpi_all_drivers);
 
-static int tpacpi_suspend_handler(struct platform_device *pdev,
-                                  pm_message_t state)
+static int tpacpi_suspend_handler(struct device *dev)
 {
         struct ibm_struct *ibm, *itmp;
 
@@ -931,13 +930,13 @@ static int tpacpi_suspend_handler(struct platform_device *pdev,
                                  &tpacpi_all_drivers,
                                  all_drivers) {
                 if (ibm->suspend)
-                        (ibm->suspend)(state);
+                        (ibm->suspend)();
         }
 
         return 0;
 }
 
-static int tpacpi_resume_handler(struct platform_device *pdev)
+static int tpacpi_resume_handler(struct device *dev)
 {
         struct ibm_struct *ibm, *itmp;
 
@@ -951,6 +950,9 @@ static int tpacpi_resume_handler(struct platform_device *pdev)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(tpacpi_pm,
+                         tpacpi_suspend_handler, tpacpi_resume_handler);
+
 static void tpacpi_shutdown_handler(struct platform_device *pdev)
 {
         struct ibm_struct *ibm, *itmp;
@@ -967,9 +969,8 @@ static struct platform_driver tpacpi_pdriver = {
         .driver = {
                 .name = TPACPI_DRVR_NAME,
                 .owner = THIS_MODULE,
+                .pm = &tpacpi_pm,
         },
-        .suspend = tpacpi_suspend_handler,
-        .resume = tpacpi_resume_handler,
         .shutdown = tpacpi_shutdown_handler,
 };
 
@@ -3758,7 +3759,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
         }
 }
 
-static void hotkey_suspend(pm_message_t state)
+static void hotkey_suspend(void)
 {
         /* Do these on suspend, we get the events on early resume! */
         hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
@@ -6329,7 +6330,7 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
         return 0;
 }
 
-static void brightness_suspend(pm_message_t state)
+static void brightness_suspend(void)
 {
         tpacpi_brightness_checkpoint_nvram();
 }
@@ -6748,7 +6749,7 @@ static struct snd_kcontrol_new volume_alsa_control_mute __devinitdata = {
         .get = volume_alsa_mute_get,
 };
 
-static void volume_suspend(pm_message_t state)
+static void volume_suspend(void)
 {
         tpacpi_volume_checkpoint_nvram();
 }
@@ -8107,7 +8108,7 @@ static void fan_exit(void)
         flush_workqueue(tpacpi_wq);
 }
 
-static void fan_suspend(pm_message_t state)
+static void fan_suspend(void)
 {
         int rc;
 
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 4267789ca995..132333d75408 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -568,6 +568,7 @@ static irqreturn_t cmos_interrupt(int irq, void *p)
                 hpet_mask_rtc_irq_bit(RTC_AIE);
 
                 CMOS_READ(RTC_INTR_FLAGS);
+                pm_wakeup_event(cmos_rtc.dev, 0);
         }
         spin_unlock(&rtc_lock);