106 files changed, 863 insertions, 1584 deletions
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 79fbe3832dfc..0c81915b1997 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -402,7 +402,7 @@ config RTC_DRV_TPS6586X
        tristate "TI TPS6586X RTC driver"
        depends on MFD_TPS6586X
        help
-          TI Power Managment IC TPS6586X supports RTC functionality
+          TI Power Management IC TPS6586X supports RTC functionality
          along with alarm. This driver supports the RTC driver for
          the TPS6586X RTC module.
@@ -420,7 +420,7 @@ config RTC_DRV_TPS80031
        tristate "TI TPS80031/TPS80032 RTC driver"
        depends on MFD_TPS80031
        help
-          TI Power Managment IC TPS80031 supports RTC functionality
+          TI Power Management IC TPS80031 supports RTC functionality
          along with alarm. This driver supports the RTC driver for
          the TPS80031 RTC module.
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 9b742d3ffb94..66385402d20e 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -259,6 +259,76 @@ void rtc_device_unregister(struct rtc_device *rtc)
 }
 EXPORT_SYMBOL_GPL(rtc_device_unregister);
+static void devm_rtc_device_release(struct device *dev, void *res)
+{
+        struct rtc_device *rtc = *(struct rtc_device **)res;
+        rtc_device_unregister(rtc);
+}
+static int devm_rtc_device_match(struct device *dev, void *res, void *data)
+{
+        struct rtc **r = res;
+        return *r == data;
+}
+/**
+ * devm_rtc_device_register - resource managed rtc_device_register()
+ * @dev: the device to register
+ * @name: the name of the device
+ * @ops: the rtc operations structure
+ * @owner: the module owner
+ *
+ * @return a struct rtc on success, or an ERR_PTR on error
+ *
+ * Managed rtc_device_register(). The rtc_device returned from this function
+ * are automatically freed on driver detach. See rtc_device_register()
+ * for more information.
+ */
+struct rtc_device *devm_rtc_device_register(struct device *dev,
+                                        const char *name,
+                                        const struct rtc_class_ops *ops,
+                                        struct module *owner)
+{
+        struct rtc_device **ptr, *rtc;
+        ptr = devres_alloc(devm_rtc_device_release, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return ERR_PTR(-ENOMEM);
+        rtc = rtc_device_register(name, dev, ops, owner);
+        if (!IS_ERR(rtc)) {
+                *ptr = rtc;
+                devres_add(dev, ptr);
+        } else {
+                devres_free(ptr);
+        }
+        return rtc;
+}
+EXPORT_SYMBOL_GPL(devm_rtc_device_register);
+/**
+ * devm_rtc_device_unregister - resource managed devm_rtc_device_unregister()
+ * @dev: the device to unregister
+ * @rtc: the RTC class device to unregister
+ *
+ * Deallocated a rtc allocated with devm_rtc_device_register(). Normally this
+ * function will not need to be called and the resource management code will
+ * ensure that the resource is freed.
+ */
+void devm_rtc_device_unregister(struct device *dev, struct rtc_device *rtc)
+{
+        int rc;
+        rc = devres_release(dev, devm_rtc_device_release,
+                                devm_rtc_device_match, rtc);
+        WARN_ON(rc);
+}
+EXPORT_SYMBOL_GPL(devm_rtc_device_unregister);
 static int __init rtc_init(void)
 {
        rtc_class = class_create(THIS_MODULE, "rtc");
diff --git a/drivers/rtc/rtc-88pm80x.c b/drivers/rtc/rtc-88pm80x.c
index 63b17ebe90e8..f3742f364eb8 100644
--- a/drivers/rtc/rtc-88pm80x.c
+++ b/drivers/rtc/rtc-88pm80x.c
@@ -234,7 +234,7 @@ static const struct rtc_class_ops pm80x_rtc_ops = {
        .alarm_irq_enable = pm80x_rtc_alarm_irq_enable,
 };
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int pm80x_rtc_suspend(struct device *dev)
 {
        return pm80x_dev_suspend(dev);
@@ -312,7 +312,7 @@ static int pm80x_rtc_probe(struct platform_device *pdev)
        }
        rtc_tm_to_time(&tm, &ticks);
-        info->rtc_dev = rtc_device_register("88pm80x-rtc", &pdev->dev,
+        info->rtc_dev = devm_rtc_device_register(&pdev->dev, "88pm80x-rtc",
                                            &pm80x_rtc_ops, THIS_MODULE);
        if (IS_ERR(info->rtc_dev)) {
                ret = PTR_ERR(info->rtc_dev);
@@ -346,7 +346,6 @@ static int pm80x_rtc_remove(struct platform_device *pdev)
 {
        struct pm80x_rtc_info *info = platform_get_drvdata(pdev);
        platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(info->rtc_dev);
        pm80x_free_irq(info->chip, info->irq, info);
        return 0;
 }
diff --git a/drivers/rtc/rtc-88pm860x.c b/drivers/rtc/rtc-88pm860x.c
index f663746f4603..0f2b91bfee37 100644
--- a/drivers/rtc/rtc-88pm860x.c
+++ b/drivers/rtc/rtc-88pm860x.c
@@ -318,14 +318,14 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
        pdata = pdev->dev.platform_data;
-        info = kzalloc(sizeof(struct pm860x_rtc_info), GFP_KERNEL);
+        info = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_rtc_info),
+                            GFP_KERNEL);
        if (!info)
                return -ENOMEM;
        info->irq = platform_get_irq(pdev, 0);
        if (info->irq < 0) {
                dev_err(&pdev->dev, "No IRQ resource!\n");
-                ret = -EINVAL;
+                return info->irq;
-                goto out;
        }
        info->chip = chip;
@@ -333,12 +333,13 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
        info->dev = &pdev->dev;
        dev_set_drvdata(&pdev->dev, info);
-        ret = request_threaded_irq(info->irq, NULL, rtc_update_handler,
+        ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
-                                   IRQF_ONESHOT, "rtc", info);
+                                        rtc_update_handler, IRQF_ONESHOT, "rtc",
+                                        info);
        if (ret < 0) {
                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
                        info->irq, ret);
-                goto out;
+                return ret;
        }
        /* set addresses of 32-bit base value for RTC time */
@@ -350,7 +351,7 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
        ret = pm860x_rtc_read_time(&pdev->dev, &tm);
        if (ret < 0) {
                dev_err(&pdev->dev, "Failed to read initial time.\n");
-                goto out_rtc;
+                return ret;
        }
        if ((tm.tm_year < 70) || (tm.tm_year > 138)) {
                tm.tm_year = 70;
@@ -362,7 +363,7 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
                ret = pm860x_rtc_set_time(&pdev->dev, &tm);
                if (ret < 0) {
                        dev_err(&pdev->dev, "Failed to set initial time.\n");
-                        goto out_rtc;
+                        return ret;
                }
        }
        rtc_tm_to_time(&tm, &ticks);
@@ -373,12 +374,12 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
                }
        }
-        info->rtc_dev = rtc_device_register("88pm860x-rtc", &pdev->dev,
+        info->rtc_dev = devm_rtc_device_register(&pdev->dev, "88pm860x-rtc",
                                            &pm860x_rtc_ops, THIS_MODULE);
        ret = PTR_ERR(info->rtc_dev);
        if (IS_ERR(info->rtc_dev)) {
                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
-                goto out_rtc;
+                return ret;
        }
        /*
@@ -405,11 +406,6 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
        return 0;
-out_rtc:
-        free_irq(info->irq, info);
-out:
-        kfree(info);
-        return ret;
 }
 static int pm860x_rtc_remove(struct platform_device *pdev)
@@ -423,9 +419,6 @@ static int pm860x_rtc_remove(struct platform_device *pdev)
 #endif  /* VRTC_CALIBRATION */
        platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(info->rtc_dev);
-        free_irq(info->irq, info);
-        kfree(info);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ab3100.c b/drivers/rtc/rtc-ab3100.c
index 261a07e0fb24..47a4f2c4d30e 100644
--- a/drivers/rtc/rtc-ab3100.c
+++ b/drivers/rtc/rtc-ab3100.c
@@ -229,8 +229,8 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev)
                /* Ignore any error on this write */
        }
-        rtc = rtc_device_register("ab3100-rtc", &pdev->dev, &ab3100_rtc_ops,
+        rtc = devm_rtc_device_register(&pdev->dev, "ab3100-rtc",
-                                  THIS_MODULE);
+                                        &ab3100_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                err = PTR_ERR(rtc);
                return err;
@@ -242,9 +242,6 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev)
 static int __exit ab3100_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
 }
@@ -257,19 +254,7 @@ static struct platform_driver ab3100_rtc_driver = {
        .remove  = __exit_p(ab3100_rtc_remove),
 };
-static int __init ab3100_rtc_init(void)
+module_platform_driver_probe(ab3100_rtc_driver, ab3100_rtc_probe);
-{
-        return platform_driver_probe(&ab3100_rtc_driver,
-                                     ab3100_rtc_probe);
-}
-static void __exit ab3100_rtc_exit(void)
-{
-        platform_driver_unregister(&ab3100_rtc_driver);
-}
-module_init(ab3100_rtc_init);
-module_exit(ab3100_rtc_exit);
 MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
 MODULE_DESCRIPTION("AB3100 RTC Driver");
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index 57cde2b061e6..63cfa314a39f 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -422,20 +422,19 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, true);
-        rtc = rtc_device_register("ab8500-rtc", &pdev->dev, &ab8500_rtc_ops,
+        rtc = devm_rtc_device_register(&pdev->dev, "ab8500-rtc",
-                        THIS_MODULE);
+                                        &ab8500_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                dev_err(&pdev->dev, "Registration failed\n");
                err = PTR_ERR(rtc);
                return err;
        }
-        err = request_threaded_irq(irq, NULL, rtc_alarm_handler,
+        err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
-                IRQF_NO_SUSPEND | IRQF_ONESHOT, "ab8500-rtc", rtc);
+                        rtc_alarm_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT,
-        if (err < 0) {
+                        "ab8500-rtc", rtc);
-                rtc_device_unregister(rtc);
+        if (err < 0)
                return err;
-        }
        platform_set_drvdata(pdev, rtc);
@@ -450,13 +449,8 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
 static int ab8500_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        int irq = platform_get_irq_byname(pdev, "ALARM");
        ab8500_sysfs_rtc_unregister(&pdev->dev);
-        free_irq(irq, rtc);
-        rtc_device_unregister(rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
diff --git a/drivers/rtc/rtc-at32ap700x.c b/drivers/rtc/rtc-at32ap700x.c
index 8dd08305aae1..f47fbb5eee8b 100644
--- a/drivers/rtc/rtc-at32ap700x.c
+++ b/drivers/rtc/rtc-at32ap700x.c
@@ -202,7 +202,8 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
        int irq;
        int ret;
-        rtc = kzalloc(sizeof(struct rtc_at32ap700x), GFP_KERNEL);
+        rtc = devm_kzalloc(&pdev->dev, sizeof(struct rtc_at32ap700x),
+                           GFP_KERNEL);
        if (!rtc) {
                dev_dbg(&pdev->dev, "out of memory\n");
                return -ENOMEM;
@@ -223,7 +224,7 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
        }
        rtc->irq = irq;
-        rtc->regs = ioremap(regs->start, resource_size(regs));
+        rtc->regs = devm_ioremap(&pdev->dev, regs->start, resource_size(regs));
        if (!rtc->regs) {
                ret = -ENOMEM;
                dev_dbg(&pdev->dev, "could not map I/O memory\n");
@@ -244,20 +245,21 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
                                | RTC_BIT(CTRL_EN));
        }
-        ret = request_irq(irq, at32_rtc_interrupt, IRQF_SHARED, "rtc", rtc);
+        ret = devm_request_irq(&pdev->dev, irq, at32_rtc_interrupt, IRQF_SHARED,
+                                "rtc", rtc);
        if (ret) {
                dev_dbg(&pdev->dev, "could not request irq %d\n", irq);
-                goto out_iounmap;
+                goto out;
        }
        platform_set_drvdata(pdev, rtc);
-        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                &at32_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
                dev_dbg(&pdev->dev, "could not register rtc device\n");
                ret = PTR_ERR(rtc->rtc);
-                goto out_free_irq;
+                goto out;
        }
        device_init_wakeup(&pdev->dev, 1);
@@ -267,26 +269,15 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
        return 0;
-out_free_irq:
-        platform_set_drvdata(pdev, NULL);
-        free_irq(irq, rtc);
-out_iounmap:
-        iounmap(rtc->regs);
 out:
-        kfree(rtc);
+        platform_set_drvdata(pdev, NULL);
        return ret;
 }
 static int __exit at32_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_at32ap700x *rtc = platform_get_drvdata(pdev);
        device_init_wakeup(&pdev->dev, 0);
-        free_irq(rtc->irq, rtc);
-        iounmap(rtc->regs);
-        rtc_device_unregister(rtc->rtc);
-        kfree(rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
@@ -302,17 +293,7 @@ static struct platform_driver at32_rtc_driver = {
        },
 };
-static int __init at32_rtc_init(void)
+module_platform_driver_probe(at32_rtc_driver, at32_rtc_probe);
-{
-        return platform_driver_probe(&at32_rtc_driver, at32_rtc_probe);
-}
-module_init(at32_rtc_init);
-static void __exit at32_rtc_exit(void)
-{
-        platform_driver_unregister(&at32_rtc_driver);
-}
-module_exit(at32_rtc_exit);
 MODULE_AUTHOR("Hans-Christian Egtvedt <hcegtvedt@atmel.com>");
 MODULE_DESCRIPTION("Real time clock for AVR32 AT32AP700x");
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index 434ebc3a99dc..0eab77b22340 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -28,6 +28,8 @@
 #include <linux/ioctl.h>
 #include <linux/completion.h>
 #include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 #include <asm/uaccess.h>
@@ -297,7 +299,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
                                "at91_rtc", pdev);
        if (ret) {
                dev_err(&pdev->dev, "IRQ %d already in use.\n", irq);
-                return ret;
+                goto err_unmap;
        }
        /* cpu init code should really have flagged this device as
@@ -309,13 +311,20 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
        rtc = rtc_device_register(pdev->name, &pdev->dev,
                                &at91_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
-                free_irq(irq, pdev);
+                ret = PTR_ERR(rtc);
-                return PTR_ERR(rtc);
+                goto err_free_irq;
        }
        platform_set_drvdata(pdev, rtc);
        dev_info(&pdev->dev, "AT91 Real Time Clock driver.\n");
        return 0;
+err_free_irq:
+        free_irq(irq, pdev);
+err_unmap:
+        iounmap(at91_rtc_regs);
+        return ret;
 }
 /*
@@ -332,12 +341,13 @@ static int __exit at91_rtc_remove(struct platform_device *pdev)
        free_irq(irq, pdev);
        rtc_device_unregister(rtc);
+        iounmap(at91_rtc_regs);
        platform_set_drvdata(pdev, NULL);
        return 0;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 /* AT91RM9200 RTC Power management control */
@@ -369,39 +379,27 @@ static int at91_rtc_resume(struct device *dev)
        }
        return 0;
 }
+#endif
-static const struct dev_pm_ops at91_rtc_pm = {
+static SIMPLE_DEV_PM_OPS(at91_rtc_pm_ops, at91_rtc_suspend, at91_rtc_resume);
-        .suspend =      at91_rtc_suspend,
-        .resume =       at91_rtc_resume,
-};
-#define at91_rtc_pm_ptr &at91_rtc_pm
-#else
+static const struct of_device_id at91_rtc_dt_ids[] = {
-#define at91_rtc_pm_ptr NULL
+        { .compatible = "atmel,at91rm9200-rtc" },
-#endif
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, at91_rtc_dt_ids);
 static struct platform_driver at91_rtc_driver = {
        .remove         = __exit_p(at91_rtc_remove),
        .driver         = {
                .name   = "at91_rtc",
                .owner  = THIS_MODULE,
-                .pm     = at91_rtc_pm_ptr,
+                .pm     = &at91_rtc_pm_ops,
+                .of_match_table = of_match_ptr(at91_rtc_dt_ids),
        },
 };
-static int __init at91_rtc_init(void)
+module_platform_driver_probe(at91_rtc_driver, at91_rtc_probe);
-{
-        return platform_driver_probe(&at91_rtc_driver, at91_rtc_probe);
-}
-static void __exit at91_rtc_exit(void)
-{
-        platform_driver_unregister(&at91_rtc_driver);
-}
-module_init(at91_rtc_init);
-module_exit(at91_rtc_exit);
 MODULE_AUTHOR("Rick Bronson");
 MODULE_DESCRIPTION("RTC driver for Atmel AT91RM9200");
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 39cfd2ee0042..b60a34cb145a 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -20,6 +20,7 @@
 #include <linux/ioctl.h>
 #include <linux/slab.h>
 #include <linux/platform_data/atmel.h>
+#include <linux/io.h>
 #include <mach/at91_rtt.h>
 #include <mach/cpu.h>
@@ -309,7 +310,7 @@ static int at91_rtc_probe(struct platform_device *pdev)
                return irq;
        }
-        rtc = kzalloc(sizeof *rtc, GFP_KERNEL);
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
        if (!rtc)
                return -ENOMEM;
@@ -320,18 +321,19 @@ static int at91_rtc_probe(struct platform_device *pdev)
                device_init_wakeup(&pdev->dev, 1);
        platform_set_drvdata(pdev, rtc);
-        rtc->rtt = ioremap(r->start, resource_size(r));
+        rtc->rtt = devm_ioremap(&pdev->dev, r->start, resource_size(r));
        if (!rtc->rtt) {
                dev_err(&pdev->dev, "failed to map registers, aborting.\n");
                ret = -ENOMEM;
                goto fail;
        }
-        rtc->gpbr = ioremap(r_gpbr->start, resource_size(r_gpbr));
+        rtc->gpbr = devm_ioremap(&pdev->dev, r_gpbr->start,
+                                resource_size(r_gpbr));
        if (!rtc->gpbr) {
                dev_err(&pdev->dev, "failed to map gpbr registers, aborting.\n");
                ret = -ENOMEM;
-                goto fail_gpbr;
+                goto fail;
        }
        mr = rtt_readl(rtc, MR);
@@ -346,20 +348,19 @@ static int at91_rtc_probe(struct platform_device *pdev)
        mr &= ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN);
        rtt_writel(rtc, MR, mr);
-        rtc->rtcdev = rtc_device_register(pdev->name, &pdev->dev,
+        rtc->rtcdev = devm_rtc_device_register(&pdev->dev, pdev->name,
-                                &at91_rtc_ops, THIS_MODULE);
+                                        &at91_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtcdev)) {
                ret = PTR_ERR(rtc->rtcdev);
-                goto fail_register;
+                goto fail;
        }
        /* register irq handler after we know what name we'll use */
-        ret = request_irq(rtc->irq, at91_rtc_interrupt, IRQF_SHARED,
+        ret = devm_request_irq(&pdev->dev, rtc->irq, at91_rtc_interrupt,
-                                dev_name(&rtc->rtcdev->dev), rtc);
+                                IRQF_SHARED, dev_name(&rtc->rtcdev->dev), rtc);
        if (ret) {
                dev_dbg(&pdev->dev, "can't share IRQ %d?\n", rtc->irq);
-                rtc_device_unregister(rtc->rtcdev);
+                goto fail;
-                goto fail_register;
        }
        /* NOTE:  sam9260 rev A silicon has a ROM bug which resets the
@@ -374,13 +375,8 @@ static int at91_rtc_probe(struct platform_device *pdev)
        return 0;
-fail_register:
-        iounmap(rtc->gpbr);
-fail_gpbr:
-        iounmap(rtc->rtt);
 fail:
        platform_set_drvdata(pdev, NULL);
-        kfree(rtc);
        return ret;
 }
@@ -394,14 +390,8 @@ static int at91_rtc_remove(struct platform_device *pdev)
        /* disable all interrupts */
        rtt_writel(rtc, MR, mr & ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN));
-        free_irq(rtc->irq, rtc);
-        rtc_device_unregister(rtc->rtcdev);
-        iounmap(rtc->gpbr);
-        iounmap(rtc->rtt);
        platform_set_drvdata(pdev, NULL);
-        kfree(rtc);
        return 0;
 }
@@ -414,14 +404,13 @@ static void at91_rtc_shutdown(struct platform_device *pdev)
        rtt_writel(rtc, MR, mr & ~rtc->imr);
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 /* AT91SAM9 RTC Power management control */
-static int at91_rtc_suspend(struct platform_device *pdev,
+static int at91_rtc_suspend(struct device *dev)
-                                        pm_message_t state)
 {
-        struct sam9_rtc *rtc = platform_get_drvdata(pdev);
+        struct sam9_rtc *rtc = dev_get_drvdata(dev);
        u32             mr = rtt_readl(rtc, MR);
        /*
@@ -430,7 +419,7 @@ static int at91_rtc_suspend(struct platform_device *pdev,
         */
        rtc->imr = mr & (AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN);
        if (rtc->imr) {
-                if (device_may_wakeup(&pdev->dev) && (mr & AT91_RTT_ALMIEN)) {
+                if (device_may_wakeup(dev) && (mr & AT91_RTT_ALMIEN)) {
                        enable_irq_wake(rtc->irq);
                        /* don't let RTTINC cause wakeups */
                        if (mr & AT91_RTT_RTTINCIEN)
@@ -442,13 +431,13 @@ static int at91_rtc_suspend(struct platform_device *pdev,
        return 0;
 }
-static int at91_rtc_resume(struct platform_device *pdev)
+static int at91_rtc_resume(struct device *dev)
 {
-        struct sam9_rtc *rtc = platform_get_drvdata(pdev);
+        struct sam9_rtc *rtc = dev_get_drvdata(dev);
        u32             mr;
        if (rtc->imr) {
-                if (device_may_wakeup(&pdev->dev))
+                if (device_may_wakeup(dev))
                        disable_irq_wake(rtc->irq);
                mr = rtt_readl(rtc, MR);
                rtt_writel(rtc, MR, mr | rtc->imr);
@@ -456,20 +445,18 @@ static int at91_rtc_resume(struct platform_device *pdev)
        return 0;
 }
-#else
-#define at91_rtc_suspend        NULL
-#define at91_rtc_resume         NULL
 #endif
+static SIMPLE_DEV_PM_OPS(at91_rtc_pm_ops, at91_rtc_suspend, at91_rtc_resume);
 static struct platform_driver at91_rtc_driver = {
        .probe          = at91_rtc_probe,
        .remove         = at91_rtc_remove,
        .shutdown       = at91_rtc_shutdown,
-        .suspend        = at91_rtc_suspend,
-        .resume         = at91_rtc_resume,
        .driver         = {
                .name   = "rtc-at91sam9",
                .owner  = THIS_MODULE,
+                .pm     = &at91_rtc_pm_ops,
        },
 };
diff --git a/drivers/rtc/rtc-au1xxx.c b/drivers/rtc/rtc-au1xxx.c
index b309da4ec745..7995abc391fc 100644
--- a/drivers/rtc/rtc-au1xxx.c
+++ b/drivers/rtc/rtc-au1xxx.c
@@ -101,7 +101,7 @@ static int au1xtoy_rtc_probe(struct platform_device *pdev)
        while (au_readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_C0S)
                msleep(1);
-        rtcdev = rtc_device_register("rtc-au1xxx", &pdev->dev,
+        rtcdev = devm_rtc_device_register(&pdev->dev, "rtc-au1xxx",
                                     &au1xtoy_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtcdev)) {
                ret = PTR_ERR(rtcdev);
@@ -118,9 +118,6 @@ out_err:
 static int au1xtoy_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtcdev = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtcdev);
        platform_set_drvdata(pdev, NULL);
        return 0;
@@ -134,18 +131,7 @@ static struct platform_driver au1xrtc_driver = {
        .remove         = au1xtoy_rtc_remove,
 };
-static int __init au1xtoy_rtc_init(void)
+module_platform_driver_probe(au1xrtc_driver, au1xtoy_rtc_probe);
-{
-        return platform_driver_probe(&au1xrtc_driver, au1xtoy_rtc_probe);
-}
-static void __exit au1xtoy_rtc_exit(void)
-{
-        platform_driver_unregister(&au1xrtc_driver);
-}
-module_init(au1xtoy_rtc_init);
-module_exit(au1xtoy_rtc_exit);
 MODULE_DESCRIPTION("Au1xxx TOY-counter-based RTC driver");
 MODULE_AUTHOR("Manuel Lauss <manuel.lauss@gmail.com>");
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index 4ec614b0954d..ad44ec5dc29a 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -352,14 +352,14 @@ static int bfin_rtc_probe(struct platform_device *pdev)
        dev_dbg_stamp(dev);
        /* Allocate memory for our RTC struct */
-        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        rtc = devm_kzalloc(dev, sizeof(*rtc), GFP_KERNEL);
        if (unlikely(!rtc))
                return -ENOMEM;
        platform_set_drvdata(pdev, rtc);
        device_init_wakeup(dev, 1);
        /* Register our RTC with the RTC framework */
-        rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops,
+        rtc->rtc_dev = devm_rtc_device_register(dev, pdev->name, &bfin_rtc_ops,
                                                THIS_MODULE);
        if (unlikely(IS_ERR(rtc->rtc_dev))) {
                ret = PTR_ERR(rtc->rtc_dev);
@@ -367,9 +367,10 @@ static int bfin_rtc_probe(struct platform_device *pdev)
        }
        /* Grab the IRQ and init the hardware */
-        ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, 0, pdev->name, dev);
+        ret = devm_request_irq(dev, IRQ_RTC, bfin_rtc_interrupt, 0,
+                                pdev->name, dev);
        if (unlikely(ret))
-                goto err_reg;
+                goto err;
        /* sometimes the bootloader touched things, but the write complete was not
         * enabled, so let's just do a quick timeout here since the IRQ will not fire ...
         */
@@ -381,32 +382,23 @@ static int bfin_rtc_probe(struct platform_device *pdev)
        return 0;
-err_reg:
-        rtc_device_unregister(rtc->rtc_dev);
 err:
-        kfree(rtc);
        return ret;
 }
 static int bfin_rtc_remove(struct platform_device *pdev)
 {
-        struct bfin_rtc *rtc = platform_get_drvdata(pdev);
        struct device *dev = &pdev->dev;
        bfin_rtc_reset(dev, 0);
-        free_irq(IRQ_RTC, dev);
-        rtc_device_unregister(rtc->rtc_dev);
        platform_set_drvdata(pdev, NULL);
-        kfree(rtc);
        return 0;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
-static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int bfin_rtc_suspend(struct device *dev)
 {
-        struct device *dev = &pdev->dev;
        dev_dbg_stamp(dev);
        if (device_may_wakeup(dev)) {
@@ -418,10 +410,8 @@ static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
        return 0;
 }
-static int bfin_rtc_resume(struct platform_device *pdev)
+static int bfin_rtc_resume(struct device *dev)
 {
-        struct device *dev = &pdev->dev;
        dev_dbg_stamp(dev);
        if (device_may_wakeup(dev))
@@ -440,20 +430,18 @@ static int bfin_rtc_resume(struct platform_device *pdev)
        return 0;
 }
-#else
-# define bfin_rtc_suspend NULL
-# define bfin_rtc_resume  NULL
 #endif
+static SIMPLE_DEV_PM_OPS(bfin_rtc_pm_ops, bfin_rtc_suspend, bfin_rtc_resume);
 static struct platform_driver bfin_rtc_driver = {
        .driver         = {
                .name   = "rtc-bfin",
                .owner  = THIS_MODULE,
+                .pm     = &bfin_rtc_pm_ops,
        },
        .probe          = bfin_rtc_probe,
        .remove         = bfin_rtc_remove,
-        .suspend        = bfin_rtc_suspend,
-        .resume         = bfin_rtc_resume,
 };
 module_platform_driver(bfin_rtc_driver);
diff --git a/drivers/rtc/rtc-bq32k.c b/drivers/rtc/rtc-bq32k.c
index 036cb89f8188..fea78bc713ca 100644
--- a/drivers/rtc/rtc-bq32k.c
+++ b/drivers/rtc/rtc-bq32k.c
@@ -153,7 +153,7 @@ static int bq32k_probe(struct i2c_client *client,
        if (error)
                return error;
-        rtc = rtc_device_register(bq32k_driver.driver.name, &client->dev,
+        rtc = devm_rtc_device_register(&client->dev, bq32k_driver.driver.name,
                                                &bq32k_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -165,9 +165,6 @@ static int bq32k_probe(struct i2c_client *client,
 static int bq32k_remove(struct i2c_client *client)
 {
-        struct rtc_device *rtc = i2c_get_clientdata(client);
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-bq4802.c b/drivers/rtc/rtc-bq4802.c
index 693be71b5b18..af2886784a7b 100644
--- a/drivers/rtc/rtc-bq4802.c
+++ b/drivers/rtc/rtc-bq4802.c
@@ -142,7 +142,7 @@ static const struct rtc_class_ops bq4802_ops = {
 static int bq4802_probe(struct platform_device *pdev)
 {
-        struct bq4802 *p = kzalloc(sizeof(*p), GFP_KERNEL);
+        struct bq4802 *p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
        int err = -ENOMEM;
        if (!p)
@@ -155,54 +155,41 @@ static int bq4802_probe(struct platform_device *pdev)
                p->r = platform_get_resource(pdev, IORESOURCE_IO, 0);
                err = -EINVAL;
                if (!p->r)
-                        goto out_free;
+                        goto out;
        }
        if (p->r->flags & IORESOURCE_IO) {
                p->ioport = p->r->start;
                p->read = bq4802_read_io;
                p->write = bq4802_write_io;
        } else if (p->r->flags & IORESOURCE_MEM) {
-                p->regs = ioremap(p->r->start, resource_size(p->r));
+                p->regs = devm_ioremap(&pdev->dev, p->r->start,
+                                        resource_size(p->r));
                p->read = bq4802_read_mem;
                p->write = bq4802_write_mem;
        } else {
                err = -EINVAL;
-                goto out_free;
+                goto out;
        }
        platform_set_drvdata(pdev, p);
-        p->rtc = rtc_device_register("bq4802", &pdev->dev,
+        p->rtc = devm_rtc_device_register(&pdev->dev, "bq4802",
-                                     &bq4802_ops, THIS_MODULE);
+                                        &bq4802_ops, THIS_MODULE);
        if (IS_ERR(p->rtc)) {
                err = PTR_ERR(p->rtc);
-                goto out_iounmap;
+                goto out;
        }
        err = 0;
 out:
        return err;
-out_iounmap:
-        if (p->r->flags & IORESOURCE_MEM)
-                iounmap(p->regs);
-out_free:
-        kfree(p);
-        goto out;
 }
 static int bq4802_remove(struct platform_device *pdev)
 {
-        struct bq4802 *p = platform_get_drvdata(pdev);
-        rtc_device_unregister(p->rtc);
-        if (p->r->flags & IORESOURCE_MEM)
-                iounmap(p->regs);
        platform_set_drvdata(pdev, NULL);
-        kfree(p);
        return 0;
 }
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index af97c94e8a3a..cc5bea9c4b1c 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -804,9 +804,8 @@ static int cmos_suspend(struct device *dev)
                        mask = RTC_IRQMASK;
                tmp &= ~mask;
                CMOS_WRITE(tmp, RTC_CONTROL);
+                hpet_mask_rtc_irq_bit(mask);
-                /* shut down hpet emulation - we don't need it for alarm */
-                hpet_mask_rtc_irq_bit(RTC_PIE|RTC_AIE|RTC_UIE);
                cmos_checkintr(cmos, tmp);
        }
        spin_unlock_irq(&rtc_lock);
@@ -870,6 +869,7 @@ static int cmos_resume(struct device *dev)
                        rtc_update_irq(cmos->rtc, 1, mask);
                        tmp &= ~RTC_AIE;
                        hpet_mask_rtc_irq_bit(RTC_AIE);
+                        hpet_rtc_timer_init();
                } while (mask & RTC_AIE);
                spin_unlock_irq(&rtc_lock);
        }
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index 2d28ec1aa1cd..93c06588ddca 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -47,7 +47,7 @@ struct coh901331_port {
        u32 physize;
        void __iomem *virtbase;
        int irq;
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
        u32 irqmaskstore;
 #endif
 };
@@ -155,7 +155,6 @@ static int __exit coh901331_remove(struct platform_device *pdev)
        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
        if (rtap) {
-                rtc_device_unregister(rtap->rtc);
                clk_unprepare(rtap->clk);
                platform_set_drvdata(pdev, NULL);
        }
@@ -211,8 +210,8 @@ static int __init coh901331_probe(struct platform_device *pdev)
        clk_disable(rtap->clk);
        platform_set_drvdata(pdev, rtap);
-        rtap->rtc = rtc_device_register("coh901331", &pdev->dev, &coh901331_ops,
+        rtap->rtc = devm_rtc_device_register(&pdev->dev, "coh901331",
-                                         THIS_MODULE);
+                                        &coh901331_ops, THIS_MODULE);
        if (IS_ERR(rtap->rtc)) {
                ret = PTR_ERR(rtap->rtc);
                goto out_no_rtc;
@@ -226,17 +225,17 @@ static int __init coh901331_probe(struct platform_device *pdev)
        return ret;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
-static int coh901331_suspend(struct platform_device *pdev, pm_message_t state)
+static int coh901331_suspend(struct device *dev)
 {
-        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
+        struct coh901331_port *rtap = dev_get_drvdata(dev);
        /*
         * If this RTC alarm will be used for waking the system up,
         * don't disable it of course. Else we just disable the alarm
         * and await suspension.
         */
-        if (device_may_wakeup(&pdev->dev)) {
+        if (device_may_wakeup(dev)) {
                enable_irq_wake(rtap->irq);
        } else {
                clk_enable(rtap->clk);
@@ -248,12 +247,12 @@ static int coh901331_suspend(struct platform_device *pdev, pm_message_t state)
        return 0;
 }
-static int coh901331_resume(struct platform_device *pdev)
+static int coh901331_resume(struct device *dev)
 {
-        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
+        struct coh901331_port *rtap = dev_get_drvdata(dev);
        clk_prepare(rtap->clk);
-        if (device_may_wakeup(&pdev->dev)) {
+        if (device_may_wakeup(dev)) {
                disable_irq_wake(rtap->irq);
        } else {
                clk_enable(rtap->clk);
@@ -262,11 +261,10 @@ static int coh901331_resume(struct platform_device *pdev)
        }
        return 0;
 }
-#else
-#define coh901331_suspend NULL
-#define coh901331_resume NULL
 #endif
+static SIMPLE_DEV_PM_OPS(coh901331_pm_ops, coh901331_suspend, coh901331_resume);
 static void coh901331_shutdown(struct platform_device *pdev)
 {
        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
@@ -280,25 +278,13 @@ static struct platform_driver coh901331_driver = {
        .driver = {
                .name = "rtc-coh901331",
                .owner = THIS_MODULE,
+                .pm = &coh901331_pm_ops,
        },
        .remove = __exit_p(coh901331_remove),
-        .suspend = coh901331_suspend,
-        .resume = coh901331_resume,
        .shutdown = coh901331_shutdown,
 };
-static int __init coh901331_init(void)
+module_platform_driver_probe(coh901331_driver, coh901331_probe);
-{
-        return platform_driver_probe(&coh901331_driver, coh901331_probe);
-}
-static void __exit coh901331_exit(void)
-{
-        platform_driver_unregister(&coh901331_driver);
-}
-module_init(coh901331_init);
-module_exit(coh901331_exit);
 MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
 MODULE_DESCRIPTION("ST-Ericsson AB COH 901 331 RTC Driver");
diff --git a/drivers/rtc/rtc-da9052.c b/drivers/rtc/rtc-da9052.c
index 0dde688ca09b..7286b279cf2d 100644
--- a/drivers/rtc/rtc-da9052.c
+++ b/drivers/rtc/rtc-da9052.c
@@ -239,17 +239,15 @@ static int da9052_rtc_probe(struct platform_device *pdev)
        rtc->da9052 = dev_get_drvdata(pdev->dev.parent);
        platform_set_drvdata(pdev, rtc);
-        rtc->irq = platform_get_irq_byname(pdev, "ALM");
+        rtc->irq =  DA9052_IRQ_ALARM;
-        ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
+        ret = da9052_request_irq(rtc->da9052, rtc->irq, "ALM",
-                                da9052_rtc_irq,
+                                da9052_rtc_irq, rtc);
-                                IRQF_TRIGGER_LOW | IRQF_ONESHOT,
-                                "ALM", rtc);
        if (ret != 0) {
                rtc_err(rtc->da9052, "irq registration failed: %d\n", ret);
                return ret;
        }
-        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                       &da9052_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc))
                return PTR_ERR(rtc->rtc);
@@ -259,9 +257,6 @@ static int da9052_rtc_probe(struct platform_device *pdev)
 static int da9052_rtc_remove(struct platform_device *pdev)
 {
-        struct da9052_rtc *rtc = pdev->dev.platform_data;
-        rtc_device_unregister(rtc->rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
diff --git a/drivers/rtc/rtc-da9055.c b/drivers/rtc/rtc-da9055.c
index 8f0dcfedb83c..73858ca9709a 100644
--- a/drivers/rtc/rtc-da9055.c
+++ b/drivers/rtc/rtc-da9055.c
@@ -294,7 +294,7 @@ static int da9055_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                        &da9055_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
                ret = PTR_ERR(rtc->rtc);
@@ -317,9 +317,6 @@ err_rtc:
 static int da9055_rtc_remove(struct platform_device *pdev)
 {
-        struct da9055_rtc *rtc = pdev->dev.platform_data;
-        rtc_device_unregister(rtc->rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
diff --git a/drivers/rtc/rtc-davinci.c b/drivers/rtc/rtc-davinci.c
index 56b73089bb29..a55048c3e26f 100644
--- a/drivers/rtc/rtc-davinci.c
+++ b/drivers/rtc/rtc-davinci.c
@@ -523,7 +523,7 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, davinci_rtc);
-        davinci_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        davinci_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                    &davinci_rtc_ops, THIS_MODULE);
        if (IS_ERR(davinci_rtc->rtc)) {
                ret = PTR_ERR(davinci_rtc->rtc);
@@ -543,7 +543,7 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
                          0, "davinci_rtc", davinci_rtc);
        if (ret < 0) {
                dev_err(dev, "unable to register davinci RTC interrupt\n");
-                goto fail2;
+                goto fail1;
        }
        /* Enable interrupts */
@@ -557,14 +557,12 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
        return 0;
-fail2:
-        rtc_device_unregister(davinci_rtc->rtc);
 fail1:
        platform_set_drvdata(pdev, NULL);
        return ret;
 }
-static int davinci_rtc_remove(struct platform_device *pdev)
+static int __exit davinci_rtc_remove(struct platform_device *pdev)
 {
        struct davinci_rtc *davinci_rtc = platform_get_drvdata(pdev);
@@ -572,8 +570,6 @@ static int davinci_rtc_remove(struct platform_device *pdev)
        rtcif_write(davinci_rtc, 0, PRTCIF_INTEN);
-        rtc_device_unregister(davinci_rtc->rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
@@ -581,24 +577,14 @@ static int davinci_rtc_remove(struct platform_device *pdev)
 static struct platform_driver davinci_rtc_driver = {
        .probe          = davinci_rtc_probe,
-        .remove         = davinci_rtc_remove,
+        .remove         = __exit_p(davinci_rtc_remove),
        .driver         = {
                .name = "rtc_davinci",
                .owner = THIS_MODULE,
        },
 };
-static int __init rtc_init(void)
+module_platform_driver_probe(davinci_rtc_driver, davinci_rtc_probe);
-{
-        return platform_driver_probe(&davinci_rtc_driver, davinci_rtc_probe);
-}
-module_init(rtc_init);
-static void __exit rtc_exit(void)
-{
-        platform_driver_unregister(&davinci_rtc_driver);
-}
-module_exit(rtc_exit);
 MODULE_AUTHOR("Miguel Aguilar <miguel.aguilar@ridgerun.com>");
 MODULE_DESCRIPTION("Texas Instruments DaVinci PRTC Driver");
diff --git a/drivers/rtc/rtc-dm355evm.c b/drivers/rtc/rtc-dm355evm.c
index b2ed2c94b081..1e1ca63d58a9 100644
--- a/drivers/rtc/rtc-dm355evm.c
+++ b/drivers/rtc/rtc-dm355evm.c
@@ -127,8 +127,8 @@ static int dm355evm_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
-        rtc = rtc_device_register(pdev->name,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                                  &pdev->dev, &dm355evm_rtc_ops, THIS_MODULE);
+                                        &dm355evm_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
                        PTR_ERR(rtc));
@@ -141,9 +141,6 @@ static int dm355evm_rtc_probe(struct platform_device *pdev)
 static int dm355evm_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds1216.c b/drivers/rtc/rtc-ds1216.c
index 45cd8c9f5a39..c7702b7269f7 100644
--- a/drivers/rtc/rtc-ds1216.c
+++ b/drivers/rtc/rtc-ds1216.c
@@ -30,8 +30,6 @@ struct ds1216_regs {
 struct ds1216_priv {
        struct rtc_device *rtc;
        void __iomem *ioaddr;
-        size_t size;
-        unsigned long baseaddr;
 };
 static const u8 magic[] = {
@@ -144,57 +142,33 @@ static int __init ds1216_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct ds1216_priv *priv;
-        int ret = 0;
        u8 dummy[8];
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res)
                return -ENODEV;
-        priv = kzalloc(sizeof *priv, GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
        platform_set_drvdata(pdev, priv);
-        priv->size = resource_size(res);
+        priv->ioaddr = devm_ioremap_resource(&pdev->dev, res);
-        if (!request_mem_region(res->start, priv->size, pdev->name)) {
+        if (IS_ERR(priv->ioaddr))
-                ret = -EBUSY;
+                return PTR_ERR(priv->ioaddr);
-                goto out;
-        }
+        priv->rtc = devm_rtc_device_register(&pdev->dev, "ds1216",
-        priv->baseaddr = res->start;
+                                        &ds1216_rtc_ops, THIS_MODULE);
-        priv->ioaddr = ioremap(priv->baseaddr, priv->size);
+        if (IS_ERR(priv->rtc))
-        if (!priv->ioaddr) {
+                return PTR_ERR(priv->rtc);
-                ret = -ENOMEM;
-                goto out;
-        }
-        priv->rtc = rtc_device_register("ds1216", &pdev->dev,
-                                  &ds1216_rtc_ops, THIS_MODULE);
-        if (IS_ERR(priv->rtc)) {
-                ret = PTR_ERR(priv->rtc);
-                goto out;
-        }
        /* dummy read to get clock into a known state */
        ds1216_read(priv->ioaddr, dummy);
        return 0;
-out:
-        if (priv->ioaddr)
-                iounmap(priv->ioaddr);
-        if (priv->baseaddr)
-                release_mem_region(priv->baseaddr, priv->size);
-        kfree(priv);
-        return ret;
 }
 static int __exit ds1216_rtc_remove(struct platform_device *pdev)
 {
-        struct ds1216_priv *priv = platform_get_drvdata(pdev);
-        rtc_device_unregister(priv->rtc);
-        iounmap(priv->ioaddr);
-        release_mem_region(priv->baseaddr, priv->size);
-        kfree(priv);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds1286.c b/drivers/rtc/rtc-ds1286.c
index d989412a348a..398c96a98fc4 100644
--- a/drivers/rtc/rtc-ds1286.c
+++ b/drivers/rtc/rtc-ds1286.c
@@ -25,8 +25,6 @@
 struct ds1286_priv {
        struct rtc_device *rtc;
        u32 __iomem *rtcregs;
-        size_t size;
-        unsigned long baseaddr;
        spinlock_t lock;
 };
@@ -270,7 +268,6 @@ static int ds1286_set_time(struct device *dev, struct rtc_time *tm)
 static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
        struct ds1286_priv *priv = dev_get_drvdata(dev);
-        unsigned char cmd;
        unsigned long flags;
        /*
@@ -281,7 +278,7 @@ static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
        alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
        alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM)  & 0x1f;
        alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM)    & 0x07;
-        cmd = ds1286_rtc_read(priv, RTC_CMD);
+        ds1286_rtc_read(priv, RTC_CMD);
        spin_unlock_irqrestore(&priv->lock, flags);
        alm->time.tm_min = bcd2bin(alm->time.tm_min);
@@ -334,56 +331,30 @@ static int ds1286_probe(struct platform_device *pdev)
        struct rtc_device *rtc;
        struct resource *res;
        struct ds1286_priv *priv;
-        int ret = 0;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res)
                return -ENODEV;
-        priv = kzalloc(sizeof(struct ds1286_priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct ds1286_priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
-        priv->size = resource_size(res);
+        priv->rtcregs = devm_ioremap_resource(&pdev->dev, res);
-        if (!request_mem_region(res->start, priv->size, pdev->name)) {
+        if (IS_ERR(priv->rtcregs))
-                ret = -EBUSY;
+                return PTR_ERR(priv->rtcregs);
-                goto out;
-        }
-        priv->baseaddr = res->start;
-        priv->rtcregs = ioremap(priv->baseaddr, priv->size);
-        if (!priv->rtcregs) {
-                ret = -ENOMEM;
-                goto out;
-        }
        spin_lock_init(&priv->lock);
        platform_set_drvdata(pdev, priv);
-        rtc = rtc_device_register("ds1286", &pdev->dev,
+        rtc = devm_rtc_device_register(&pdev->dev, "ds1286", &ds1286_ops,
-                                  &ds1286_ops, THIS_MODULE);
+                                        THIS_MODULE);
-        if (IS_ERR(rtc)) {
+        if (IS_ERR(rtc))
-                ret = PTR_ERR(rtc);
+                return PTR_ERR(rtc);
-                goto out;
-        }
        priv->rtc = rtc;
        return 0;
-out:
-        if (priv->rtc)
-                rtc_device_unregister(priv->rtc);
-        if (priv->rtcregs)
-                iounmap(priv->rtcregs);
-        if (priv->baseaddr)
-                release_mem_region(priv->baseaddr, priv->size);
-        kfree(priv);
-        return ret;
 }
 static int ds1286_remove(struct platform_device *pdev)
 {
-        struct ds1286_priv *priv = platform_get_drvdata(pdev);
-        rtc_device_unregister(priv->rtc);
-        iounmap(priv->rtcregs);
-        release_mem_region(priv->baseaddr, priv->size);
-        kfree(priv);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index fdbcdb289d60..d13954346286 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -224,7 +224,7 @@ static int __init ds1302_rtc_probe(struct platform_device *pdev)
                return -ENODEV;
        }
-        rtc = rtc_device_register("ds1302", &pdev->dev,
+        rtc = devm_rtc_device_register(&pdev->dev, "ds1302",
                                           &ds1302_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -234,11 +234,8 @@ static int __init ds1302_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int ds1302_rtc_remove(struct platform_device *pdev)
+static int __exit ds1302_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
@@ -249,21 +246,10 @@ static struct platform_driver ds1302_platform_driver = {
                .name   = DRV_NAME,
                .owner  = THIS_MODULE,
        },
-        .remove         = ds1302_rtc_remove,
+        .remove         = __exit_p(ds1302_rtc_remove),
 };
-static int __init ds1302_rtc_init(void)
+module_platform_driver_probe(ds1302_platform_driver, ds1302_rtc_probe);
-{
-        return platform_driver_probe(&ds1302_platform_driver, ds1302_rtc_probe);
-}
-static void __exit ds1302_rtc_exit(void)
-{
-        platform_driver_unregister(&ds1302_platform_driver);
-}
-module_init(ds1302_rtc_init);
-module_exit(ds1302_rtc_exit);
 MODULE_DESCRIPTION("Dallas DS1302 RTC driver");
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index b05a6dc96405..bb5f13f63630 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -619,7 +619,7 @@ static int ds1305_probe(struct spi_device *spi)
                return -EINVAL;
        /* set up driver data */
-        ds1305 = kzalloc(sizeof *ds1305, GFP_KERNEL);
+        ds1305 = devm_kzalloc(&spi->dev, sizeof(*ds1305), GFP_KERNEL);
        if (!ds1305)
                return -ENOMEM;
        ds1305->spi = spi;
@@ -632,7 +632,7 @@ static int ds1305_probe(struct spi_device *spi)
        if (status < 0) {
                dev_dbg(&spi->dev, "can't %s, %d\n",
                                "read", status);
-                goto fail0;
+                return status;
        }
        dev_dbg(&spi->dev, "ctrl %s: %3ph\n", "read", ds1305->ctrl);
@@ -644,8 +644,7 @@ static int ds1305_probe(struct spi_device *spi)
         */
        if ((ds1305->ctrl[0] & 0x38) != 0 || (ds1305->ctrl[1] & 0xfc) != 0) {
                dev_dbg(&spi->dev, "RTC chip is not present\n");
-                status = -ENODEV;
+                return -ENODEV;
-                goto fail0;
        }
        if (ds1305->ctrl[2] == 0)
                dev_dbg(&spi->dev, "chip may not be present\n");
@@ -664,7 +663,7 @@ static int ds1305_probe(struct spi_device *spi)
                dev_dbg(&spi->dev, "clear WP --> %d\n", status);
                if (status < 0)
-                        goto fail0;
+                        return status;
        }
        /* on DS1305, maybe start oscillator; like most low power
@@ -718,7 +717,7 @@ static int ds1305_probe(struct spi_device *spi)
                if (status < 0) {
                        dev_dbg(&spi->dev, "can't %s, %d\n",
                                        "write", status);
-                        goto fail0;
+                        return status;
                }
                dev_dbg(&spi->dev, "ctrl %s: %3ph\n", "write", ds1305->ctrl);
@@ -730,7 +729,7 @@ static int ds1305_probe(struct spi_device *spi)
                                &value, sizeof value);
        if (status < 0) {
                dev_dbg(&spi->dev, "read HOUR --> %d\n", status);
-                goto fail0;
+                return status;
        }
        ds1305->hr12 = (DS1305_HR_12 & value) != 0;
@@ -738,12 +737,12 @@ static int ds1305_probe(struct spi_device *spi)
                dev_dbg(&spi->dev, "AM/PM\n");
        /* register RTC ... from here on, ds1305->ctrl needs locking */
-        ds1305->rtc = rtc_device_register("ds1305", &spi->dev,
+        ds1305->rtc = devm_rtc_device_register(&spi->dev, "ds1305",
                        &ds1305_ops, THIS_MODULE);
        if (IS_ERR(ds1305->rtc)) {
                status = PTR_ERR(ds1305->rtc);
                dev_dbg(&spi->dev, "register rtc --> %d\n", status);
-                goto fail0;
+                return status;
        }
        /* Maybe set up alarm IRQ; be ready to handle it triggering right
@@ -754,12 +753,12 @@ static int ds1305_probe(struct spi_device *spi)
         */
        if (spi->irq) {
                INIT_WORK(&ds1305->work, ds1305_work);
-                status = request_irq(spi->irq, ds1305_irq,
+                status = devm_request_irq(&spi->dev, spi->irq, ds1305_irq,
                                0, dev_name(&ds1305->rtc->dev), ds1305);
                if (status < 0) {
                        dev_dbg(&spi->dev, "request_irq %d --> %d\n",
                                        spi->irq, status);
-                        goto fail1;
+                        return status;
                }
                device_set_wakeup_capable(&spi->dev, 1);
@@ -769,18 +768,10 @@ static int ds1305_probe(struct spi_device *spi)
        status = sysfs_create_bin_file(&spi->dev.kobj, &nvram);
        if (status < 0) {
                dev_dbg(&spi->dev, "register nvram --> %d\n", status);
-                goto fail2;
+                return status;
        }
        return 0;
-fail2:
-        free_irq(spi->irq, ds1305);
-fail1:
-        rtc_device_unregister(ds1305->rtc);
-fail0:
-        kfree(ds1305);
-        return status;
 }
 static int ds1305_remove(struct spi_device *spi)
@@ -792,13 +783,11 @@ static int ds1305_remove(struct spi_device *spi)
        /* carefully shut down irq and workqueue, if present */
        if (spi->irq) {
                set_bit(FLAG_EXITING, &ds1305->flags);
-                free_irq(spi->irq, ds1305);
+                devm_free_irq(&spi->dev, spi->irq, ds1305);
                cancel_work_sync(&ds1305->work);
        }
-        rtc_device_unregister(ds1305->rtc);
        spi_set_drvdata(spi, NULL);
-        kfree(ds1305);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index 970a236b147a..b53992ab3090 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -4,6 +4,7 @@
 *  Copyright (C) 2005 James Chapman (ds1337 core)
 *  Copyright (C) 2006 David Brownell
 *  Copyright (C) 2009 Matthias Fuchs (rx8025 support)
+ *  Copyright (C) 2012 Bertrand Achard (nvram access fixes)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
@@ -196,7 +197,7 @@ static s32 ds1307_read_block_data_once(const struct i2c_client *client,
 static s32 ds1307_read_block_data(const struct i2c_client *client, u8 command,
                                  u8 length, u8 *values)
 {
-        u8 oldvalues[I2C_SMBUS_BLOCK_MAX];
+        u8 oldvalues[255];
        s32 ret;
        int tries = 0;
@@ -222,7 +223,7 @@ static s32 ds1307_read_block_data(const struct i2c_client *client, u8 command,
 static s32 ds1307_write_block_data(const struct i2c_client *client, u8 command,
                                   u8 length, const u8 *values)
 {
-        u8 currvalues[I2C_SMBUS_BLOCK_MAX];
+        u8 currvalues[255];
        int tries = 0;
        dev_dbg(&client->dev, "ds1307_write_block_data (length=%d)\n", length);
@@ -250,6 +251,57 @@ static s32 ds1307_write_block_data(const struct i2c_client *client, u8 command,
 /*----------------------------------------------------------------------*/
+/* These RTC devices are not designed to be connected to a SMbus adapter.
+   SMbus limits block operations length to 32 bytes, whereas it's not
+   limited on I2C buses. As a result, accesses may exceed 32 bytes;
+   in that case, split them into smaller blocks */
+static s32 ds1307_native_smbus_write_block_data(const struct i2c_client *client,
+                                u8 command, u8 length, const u8 *values)
+{
+        u8 suboffset = 0;
+        if (length <= I2C_SMBUS_BLOCK_MAX)
+                return i2c_smbus_write_i2c_block_data(client,
+                                        command, length, values);
+        while (suboffset < length) {
+                s32 retval = i2c_smbus_write_i2c_block_data(client,
+                                command + suboffset,
+                                min(I2C_SMBUS_BLOCK_MAX, length - suboffset),
+                                values + suboffset);
+                if (retval < 0)
+                        return retval;
+                suboffset += I2C_SMBUS_BLOCK_MAX;
+        }
+        return length;
+}
+static s32 ds1307_native_smbus_read_block_data(const struct i2c_client *client,
+                                u8 command, u8 length, u8 *values)
+{
+        u8 suboffset = 0;
+        if (length <= I2C_SMBUS_BLOCK_MAX)
+                return i2c_smbus_read_i2c_block_data(client,
+                                        command, length, values);
+        while (suboffset < length) {
+                s32 retval = i2c_smbus_read_i2c_block_data(client,
+                                command + suboffset,
+                                min(I2C_SMBUS_BLOCK_MAX, length - suboffset),
+                                values + suboffset);
+                if (retval < 0)
+                        return retval;
+                suboffset += I2C_SMBUS_BLOCK_MAX;
+        }
+        return length;
+}
+/*----------------------------------------------------------------------*/
 /*
 * The IRQ logic includes a "real" handler running in IRQ context just
 * long enough to schedule this workqueue entry.   We need a task context
@@ -646,8 +698,8 @@ static int ds1307_probe(struct i2c_client *client,
        buf = ds1307->regs;
        if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
-                ds1307->read_block_data = i2c_smbus_read_i2c_block_data;
+                ds1307->read_block_data = ds1307_native_smbus_read_block_data;
-                ds1307->write_block_data = i2c_smbus_write_i2c_block_data;
+                ds1307->write_block_data = ds1307_native_smbus_write_block_data;
        } else {
                ds1307->read_block_data = ds1307_read_block_data;
                ds1307->write_block_data = ds1307_write_block_data;
@@ -661,7 +713,7 @@ static int ds1307_probe(struct i2c_client *client,
                tmp = ds1307->read_block_data(ds1307->client,
                                DS1337_REG_CONTROL, 2, buf);
                if (tmp != 2) {
-                        pr_debug("read error %d\n", tmp);
+                        dev_dbg(&client->dev, "read error %d\n", tmp);
                        err = -EIO;
                        goto exit_free;
                }
@@ -700,7 +752,7 @@ static int ds1307_probe(struct i2c_client *client,
                tmp = i2c_smbus_read_i2c_block_data(ds1307->client,
                                RX8025_REG_CTRL1 << 4 | 0x08, 2, buf);
                if (tmp != 2) {
-                        pr_debug("read error %d\n", tmp);
+                        dev_dbg(&client->dev, "read error %d\n", tmp);
                        err = -EIO;
                        goto exit_free;
                }
@@ -744,7 +796,7 @@ static int ds1307_probe(struct i2c_client *client,
                        tmp = i2c_smbus_read_i2c_block_data(ds1307->client,
                                        RX8025_REG_CTRL1 << 4 | 0x08, 2, buf);
                        if (tmp != 2) {
-                                pr_debug("read error %d\n", tmp);
+                                dev_dbg(&client->dev, "read error %d\n", tmp);
                                err = -EIO;
                                goto exit_free;
                        }
@@ -772,7 +824,7 @@ read_rtc:
        /* read RTC registers */
        tmp = ds1307->read_block_data(ds1307->client, ds1307->offset, 8, buf);
        if (tmp != 8) {
-                pr_debug("read error %d\n", tmp);
+                dev_dbg(&client->dev, "read error %d\n", tmp);
                err = -EIO;
                goto exit_free;
        }
@@ -814,7 +866,7 @@ read_rtc:
                tmp = i2c_smbus_read_byte_data(client, DS1340_REG_FLAG);
                if (tmp < 0) {
-                        pr_debug("read error %d\n", tmp);
+                        dev_dbg(&client->dev, "read error %d\n", tmp);
                        err = -EIO;
                        goto exit_free;
                }
@@ -908,8 +960,8 @@ read_rtc:
                ds1307->nvram->attr.name = "nvram";
                ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
                sysfs_bin_attr_init(ds1307->nvram);
-                ds1307->nvram->read = ds1307_nvram_read,
+                ds1307->nvram->read = ds1307_nvram_read;
-                ds1307->nvram->write = ds1307_nvram_write,
+                ds1307->nvram->write = ds1307_nvram_write;
                ds1307->nvram->size = chip->nvram_size;
                ds1307->nvram_offset = chip->nvram_offset;
                err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram);
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index fef76868aae0..94366e12f40f 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -347,7 +347,7 @@ static int ds1374_probe(struct i2c_client *client,
        struct ds1374 *ds1374;
        int ret;
-        ds1374 = kzalloc(sizeof(struct ds1374), GFP_KERNEL);
+        ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL);
        if (!ds1374)
                return -ENOMEM;
@@ -359,36 +359,27 @@ static int ds1374_probe(struct i2c_client *client,
        ret = ds1374_check_rtc_status(client);
        if (ret)
-                goto out_free;
+                return ret;
        if (client->irq > 0) {
-                ret = request_irq(client->irq, ds1374_irq, 0,
+                ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0,
                                  "ds1374", client);
                if (ret) {
                        dev_err(&client->dev, "unable to request IRQ\n");
-                        goto out_free;
+                        return ret;
                }
                device_set_wakeup_capable(&client->dev, 1);
        }
-        ds1374->rtc = rtc_device_register(client->name, &client->dev,
+        ds1374->rtc = devm_rtc_device_register(&client->dev, client->name,
                                          &ds1374_rtc_ops, THIS_MODULE);
        if (IS_ERR(ds1374->rtc)) {
-                ret = PTR_ERR(ds1374->rtc);
                dev_err(&client->dev, "unable to register the class device\n");
-                goto out_irq;
+                return PTR_ERR(ds1374->rtc);
        }
        return 0;
-out_irq:
-        if (client->irq > 0)
-                free_irq(client->irq, client);
-out_free:
-        kfree(ds1374);
-        return ret;
 }
 static int ds1374_remove(struct i2c_client *client)
@@ -400,16 +391,14 @@ static int ds1374_remove(struct i2c_client *client)
                ds1374->exiting = 1;
                mutex_unlock(&ds1374->mutex);
-                free_irq(client->irq, client);
+                devm_free_irq(&client->dev, client->irq, client);
                cancel_work_sync(&ds1374->work);
        }
-        rtc_device_unregister(ds1374->rtc);
-        kfree(ds1374);
        return 0;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int ds1374_suspend(struct device *dev)
 {
        struct i2c_client *client = to_i2c_client(dev);
@@ -427,19 +416,15 @@ static int ds1374_resume(struct device *dev)
                disable_irq_wake(client->irq);
        return 0;
 }
+#endif
 static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
-#define DS1374_PM (&ds1374_pm)
-#else
-#define DS1374_PM NULL
-#endif
 static struct i2c_driver ds1374_driver = {
        .driver = {
                .name = "rtc-ds1374",
                .owner = THIS_MODULE,
-                .pm = DS1374_PM,
+                .pm = &ds1374_pm,
        },
        .probe = ds1374_probe,
        .remove = ds1374_remove,
diff --git a/drivers/rtc/rtc-ds1390.c b/drivers/rtc/rtc-ds1390.c
index f994257981a0..289af419dff4 100644
--- a/drivers/rtc/rtc-ds1390.c
+++ b/drivers/rtc/rtc-ds1390.c
@@ -131,26 +131,24 @@ static int ds1390_probe(struct spi_device *spi)
        spi->bits_per_word = 8;
        spi_setup(spi);
-        chip = kzalloc(sizeof *chip, GFP_KERNEL);
+        chip = devm_kzalloc(&spi->dev, sizeof(*chip), GFP_KERNEL);
        if (!chip) {
                dev_err(&spi->dev, "unable to allocate device memory\n");
                return -ENOMEM;
        }
-        dev_set_drvdata(&spi->dev, chip);
+        spi_set_drvdata(spi, chip);
        res = ds1390_get_reg(&spi->dev, DS1390_REG_SECONDS, &tmp);
        if (res != 0) {
                dev_err(&spi->dev, "unable to read device\n");
-                kfree(chip);
                return res;
        }
-        chip->rtc = rtc_device_register("ds1390",
+        chip->rtc = devm_rtc_device_register(&spi->dev, "ds1390",
-                                &spi->dev, &ds1390_rtc_ops, THIS_MODULE);
+                                        &ds1390_rtc_ops, THIS_MODULE);
        if (IS_ERR(chip->rtc)) {
                dev_err(&spi->dev, "unable to register device\n");
                res = PTR_ERR(chip->rtc);
-                kfree(chip);
        }
        return res;
@@ -158,11 +156,6 @@ static int ds1390_probe(struct spi_device *spi)
 static int ds1390_remove(struct spi_device *spi)
 {
-        struct ds1390 *chip = spi_get_drvdata(spi);
-        rtc_device_unregister(chip->rtc);
-        kfree(chip);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 6a3fcfe3b0e7..6ce8a997cf51 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -538,15 +538,14 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
                }
        }
-        rtc = rtc_device_register(pdev->name, &pdev->dev, &ds1511_rtc_ops,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &ds1511_rtc_ops,
-                THIS_MODULE);
+                                        THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
        pdata->rtc = rtc;
        ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1511_nvram_attr);
-        if (ret)
-                rtc_device_unregister(pdata->rtc);
        return ret;
 }
@@ -555,7 +554,6 @@ static int ds1511_rtc_remove(struct platform_device *pdev)
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        sysfs_remove_bin_file(&pdev->dev.kobj, &ds1511_nvram_attr);
-        rtc_device_unregister(pdata->rtc);
        if (pdata->irq > 0) {
                /*
                 * disable the alarm interrupt
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index 25ce0621ade9..8c6c952e90b1 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -326,15 +326,14 @@ static int ds1553_rtc_probe(struct platform_device *pdev)
                }
        }
-        rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                  &ds1553_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
        pdata->rtc = rtc;
        ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
-        if (ret)
-                rtc_device_unregister(rtc);
        return ret;
 }
@@ -343,7 +342,6 @@ static int ds1553_rtc_remove(struct platform_device *pdev)
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        sysfs_remove_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
-        rtc_device_unregister(pdata->rtc);
        if (pdata->irq > 0)
                writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
        return 0;
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 45d65c0b3a85..3fc2a4738027 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -155,11 +155,6 @@ static const struct rtc_class_ops ds1672_rtc_ops = {
 static int ds1672_remove(struct i2c_client *client)
 {
-        struct rtc_device *rtc = i2c_get_clientdata(client);
-        if (rtc)
-                rtc_device_unregister(rtc);
        return 0;
 }
@@ -177,7 +172,7 @@ static int ds1672_probe(struct i2c_client *client,
        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
-        rtc = rtc_device_register(ds1672_driver.driver.name, &client->dev,
+        rtc = devm_rtc_device_register(&client->dev, ds1672_driver.driver.name,
                                  &ds1672_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
@@ -202,7 +197,6 @@ static int ds1672_probe(struct i2c_client *client,
        return 0;
 exit_devreg:
-        rtc_device_unregister(rtc);
        return err;
 }
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 609c870e2cc5..eccdc62ae1c0 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -208,17 +208,14 @@ static int ds1742_rtc_probe(struct platform_device *pdev)
        pdata->last_jiffies = jiffies;
        platform_set_drvdata(pdev, pdata);
-        rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                  &ds1742_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
        pdata->rtc = rtc;
        ret = sysfs_create_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
-        if (ret) {
-                dev_err(&pdev->dev, "creating nvram file in sysfs failed\n");
-                rtc_device_unregister(rtc);
-        }
        return ret;
 }
@@ -227,7 +224,6 @@ static int ds1742_rtc_remove(struct platform_device *pdev)
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        sysfs_remove_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
-        rtc_device_unregister(pdata->rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds2404.c b/drivers/rtc/rtc-ds2404.c
index b04fc4272fb3..2ca5a23aba8a 100644
--- a/drivers/rtc/rtc-ds2404.c
+++ b/drivers/rtc/rtc-ds2404.c
@@ -228,7 +228,7 @@ static int rtc_probe(struct platform_device *pdev)
        struct ds2404 *chip;
        int retval = -EBUSY;
-        chip = kzalloc(sizeof(struct ds2404), GFP_KERNEL);
+        chip = devm_kzalloc(&pdev->dev, sizeof(struct ds2404), GFP_KERNEL);
        if (!chip)
                return -ENOMEM;
@@ -244,8 +244,8 @@ static int rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, chip);
-        chip->rtc = rtc_device_register("ds2404",
+        chip->rtc = devm_rtc_device_register(&pdev->dev, "ds2404",
-                                &pdev->dev, &ds2404_rtc_ops, THIS_MODULE);
+                                        &ds2404_rtc_ops, THIS_MODULE);
        if (IS_ERR(chip->rtc)) {
                retval = PTR_ERR(chip->rtc);
                goto err_io;
@@ -257,20 +257,14 @@ static int rtc_probe(struct platform_device *pdev)
 err_io:
        chip->ops->unmap_io(chip);
 err_chip:
-        kfree(chip);
        return retval;
 }
 static int rtc_remove(struct platform_device *dev)
 {
        struct ds2404 *chip = platform_get_drvdata(dev);
-        struct rtc_device *rtc = chip->rtc;
-        if (rtc)
-                rtc_device_unregister(rtc);
        chip->ops->unmap_io(chip);
-        kfree(chip);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds3232.c b/drivers/rtc/rtc-ds3232.c
index db0ca08db315..b83bb5a527f8 100644
--- a/drivers/rtc/rtc-ds3232.c
+++ b/drivers/rtc/rtc-ds3232.c
@@ -397,7 +397,7 @@ static int ds3232_probe(struct i2c_client *client,
        struct ds3232 *ds3232;
        int ret;
-        ds3232 = kzalloc(sizeof(struct ds3232), GFP_KERNEL);
+        ds3232 = devm_kzalloc(&client->dev, sizeof(struct ds3232), GFP_KERNEL);
        if (!ds3232)
                return -ENOMEM;
@@ -409,34 +409,25 @@ static int ds3232_probe(struct i2c_client *client,
        ret = ds3232_check_rtc_status(client);
        if (ret)
-                goto out_free;
+                return ret;
-        ds3232->rtc = rtc_device_register(client->name, &client->dev,
+        ds3232->rtc = devm_rtc_device_register(&client->dev, client->name,
                                          &ds3232_rtc_ops, THIS_MODULE);
        if (IS_ERR(ds3232->rtc)) {
-                ret = PTR_ERR(ds3232->rtc);
                dev_err(&client->dev, "unable to register the class device\n");
-                goto out_irq;
+                return PTR_ERR(ds3232->rtc);
        }
        if (client->irq >= 0) {
-                ret = request_irq(client->irq, ds3232_irq, 0,
+                ret = devm_request_irq(&client->dev, client->irq, ds3232_irq, 0,
                                 "ds3232", client);
                if (ret) {
                        dev_err(&client->dev, "unable to request IRQ\n");
-                        goto out_free;
+                        return ret;
                }
        }
        return 0;
-out_irq:
-        if (client->irq >= 0)
-                free_irq(client->irq, client);
-out_free:
-        kfree(ds3232);
-        return ret;
 }
 static int ds3232_remove(struct i2c_client *client)
@@ -448,12 +439,10 @@ static int ds3232_remove(struct i2c_client *client)
                ds3232->exiting = 1;
                mutex_unlock(&ds3232->mutex);
-                free_irq(client->irq, client);
+                devm_free_irq(&client->dev, client->irq, client);
                cancel_work_sync(&ds3232->work);
        }
-        rtc_device_unregister(ds3232->rtc);
-        kfree(ds3232);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds3234.c b/drivers/rtc/rtc-ds3234.c
index 7a4495ef1c39..ba98c0e9580d 100644
--- a/drivers/rtc/rtc-ds3234.c
+++ b/drivers/rtc/rtc-ds3234.c
@@ -146,21 +146,18 @@ static int ds3234_probe(struct spi_device *spi)
        ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);
        dev_info(&spi->dev, "Ctrl/Stat Reg: 0x%02x\n", tmp);
-        rtc = rtc_device_register("ds3234",
+        rtc = devm_rtc_device_register(&spi->dev, "ds3234",
-                                &spi->dev, &ds3234_rtc_ops, THIS_MODULE);
+                                &ds3234_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
-        dev_set_drvdata(&spi->dev, rtc);
+        spi_set_drvdata(spi, rtc);
        return 0;
 }
 static int ds3234_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = spi_get_drvdata(spi);
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-efi.c b/drivers/rtc/rtc-efi.c
index 1a0c37c9152b..b3c8c0b1709d 100644
--- a/drivers/rtc/rtc-efi.c
+++ b/drivers/rtc/rtc-efi.c
@@ -191,7 +191,7 @@ static int __init efi_rtc_probe(struct platform_device *dev)
 {
        struct rtc_device *rtc;
-        rtc = rtc_device_register("rtc-efi", &dev->dev, &efi_rtc_ops,
+        rtc = devm_rtc_device_register(&dev->dev, "rtc-efi", &efi_rtc_ops,
                                        THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -203,10 +203,6 @@ static int __init efi_rtc_probe(struct platform_device *dev)
 static int __exit efi_rtc_remove(struct platform_device *dev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(dev);
-        rtc_device_unregister(rtc);
        return 0;
 }
@@ -218,18 +214,7 @@ static struct platform_driver efi_rtc_driver = {
        .remove = __exit_p(efi_rtc_remove),
 };
-static int __init efi_rtc_init(void)
+module_platform_driver_probe(efi_rtc_driver, efi_rtc_probe);
-{
-        return platform_driver_probe(&efi_rtc_driver, efi_rtc_probe);
-}
-static void __exit efi_rtc_exit(void)
-{
-        platform_driver_unregister(&efi_rtc_driver);
-}
-module_init(efi_rtc_init);
-module_exit(efi_rtc_exit);
 MODULE_AUTHOR("dann frazier <dannf@hp.com>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-em3027.c b/drivers/rtc/rtc-em3027.c
index f6c24ce35d36..3f9eb57d0486 100644
--- a/drivers/rtc/rtc-em3027.c
+++ b/drivers/rtc/rtc-em3027.c
@@ -121,7 +121,7 @@ static int em3027_probe(struct i2c_client *client,
        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
                return -ENODEV;
-        rtc = rtc_device_register(em3027_driver.driver.name, &client->dev,
+        rtc = devm_rtc_device_register(&client->dev, em3027_driver.driver.name,
                                  &em3027_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -133,11 +133,6 @@ static int em3027_probe(struct i2c_client *client,
 static int em3027_remove(struct i2c_client *client)
 {
-        struct rtc_device *rtc = i2c_get_clientdata(client);
-        if (rtc)
-                rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 1a4e5e4a70cd..5807b77c444a 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -153,8 +153,8 @@ static int ep93xx_rtc_probe(struct platform_device *pdev)
        pdev->dev.platform_data = ep93xx_rtc;
        platform_set_drvdata(pdev, ep93xx_rtc);
-        ep93xx_rtc->rtc = rtc_device_register(pdev->name,
+        ep93xx_rtc->rtc = devm_rtc_device_register(&pdev->dev,
-                                &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
+                                pdev->name, &ep93xx_rtc_ops, THIS_MODULE);
        if (IS_ERR(ep93xx_rtc->rtc)) {
                err = PTR_ERR(ep93xx_rtc->rtc);
                goto exit;
@@ -162,12 +162,10 @@ static int ep93xx_rtc_probe(struct platform_device *pdev)
        err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
        if (err)
-                goto fail;
+                goto exit;
        return 0;
-fail:
-        rtc_device_unregister(ep93xx_rtc->rtc);
 exit:
        platform_set_drvdata(pdev, NULL);
        pdev->dev.platform_data = NULL;
@@ -176,11 +174,8 @@ exit:
 static int ep93xx_rtc_remove(struct platform_device *pdev)
 {
-        struct ep93xx_rtc *ep93xx_rtc = platform_get_drvdata(pdev);
        sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
        platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(ep93xx_rtc->rtc);
        pdev->dev.platform_data = NULL;
        return 0;
diff --git a/drivers/rtc/rtc-fm3130.c b/drivers/rtc/rtc-fm3130.c
index bff3cdc5140e..2835fb6c1965 100644
--- a/drivers/rtc/rtc-fm3130.c
+++ b/drivers/rtc/rtc-fm3130.c
@@ -358,7 +358,7 @@ static int fm3130_probe(struct i2c_client *client,
                        I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
                return -EIO;
-        fm3130 = kzalloc(sizeof(struct fm3130), GFP_KERNEL);
+        fm3130 = devm_kzalloc(&client->dev, sizeof(struct fm3130), GFP_KERNEL);
        if (!fm3130)
                return -ENOMEM;
@@ -395,7 +395,7 @@ static int fm3130_probe(struct i2c_client *client,
        tmp = i2c_transfer(adapter, fm3130->msg, 4);
        if (tmp != 4) {
-                pr_debug("read error %d\n", tmp);
+                dev_dbg(&client->dev, "read error %d\n", tmp);
                err = -EIO;
                goto exit_free;
        }
@@ -507,7 +507,7 @@ bad_clock:
        /* We won't bail out here because we just got invalid data.
           Time setting from u-boot doesn't work anyway */
-        fm3130->rtc = rtc_device_register(client->name, &client->dev,
+        fm3130->rtc = devm_rtc_device_register(&client->dev, client->name,
                                &fm3130_rtc_ops, THIS_MODULE);
        if (IS_ERR(fm3130->rtc)) {
                err = PTR_ERR(fm3130->rtc);
@@ -517,16 +517,11 @@ bad_clock:
        }
        return 0;
 exit_free:
-        kfree(fm3130);
        return err;
 }
 static int fm3130_remove(struct i2c_client *client)
 {
-        struct fm3130 *fm3130 = i2c_get_clientdata(client);
-        rtc_device_unregister(fm3130->rtc);
-        kfree(fm3130);
        return 0;
 }
diff --git a/drivers/rtc/rtc-generic.c b/drivers/rtc/rtc-generic.c
index 98322004ad2e..06279ce6bff2 100644
--- a/drivers/rtc/rtc-generic.c
+++ b/drivers/rtc/rtc-generic.c
@@ -38,8 +38,8 @@ static int __init generic_rtc_probe(struct platform_device *dev)
 {
        struct rtc_device *rtc;
-        rtc = rtc_device_register("rtc-generic", &dev->dev, &generic_rtc_ops,
+        rtc = devm_rtc_device_register(&dev->dev, "rtc-generic",
-                                  THIS_MODULE);
+                                        &generic_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -50,10 +50,6 @@ static int __init generic_rtc_probe(struct platform_device *dev)
 static int __exit generic_rtc_remove(struct platform_device *dev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(dev);
-        rtc_device_unregister(rtc);
        return 0;
 }
@@ -65,18 +61,7 @@ static struct platform_driver generic_rtc_driver = {
        .remove = __exit_p(generic_rtc_remove),
 };
-static int __init generic_rtc_init(void)
+module_platform_driver_probe(generic_rtc_driver, generic_rtc_probe);
-{
-        return platform_driver_probe(&generic_rtc_driver, generic_rtc_probe);
-}
-static void __exit generic_rtc_fini(void)
-{
-        platform_driver_unregister(&generic_rtc_driver);
-}
-module_init(generic_rtc_init);
-module_exit(generic_rtc_fini);
 MODULE_AUTHOR("Kyle McMartin <kyle@mcmartin.ca>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-hid-sensor-time.c b/drivers/rtc/rtc-hid-sensor-time.c
index 31c5728ef629..63024505dddc 100644
--- a/drivers/rtc/rtc-hid-sensor-time.c
+++ b/drivers/rtc/rtc-hid-sensor-time.c
@@ -255,8 +255,9 @@ static int hid_time_probe(struct platform_device *pdev)
                return ret;
        }
-        time_state->rtc = rtc_device_register("hid-sensor-time",
+        time_state->rtc = devm_rtc_device_register(&pdev->dev,
-                                &pdev->dev, &hid_time_rtc_ops, THIS_MODULE);
+                                        "hid-sensor-time", &hid_time_rtc_ops,
+                                        THIS_MODULE);
        if (IS_ERR(time_state->rtc)) {
                dev_err(&pdev->dev, "rtc device register failed!\n");
@@ -269,9 +270,7 @@ static int hid_time_probe(struct platform_device *pdev)
 static int hid_time_remove(struct platform_device *pdev)
 {
        struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
-        struct hid_time_state *time_state = platform_get_drvdata(pdev);
-        rtc_device_unregister(time_state->rtc);
        sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME);
        return 0;
diff --git a/drivers/rtc/rtc-imxdi.c b/drivers/rtc/rtc-imxdi.c
index 82aad695979e..d3a8c8e255de 100644
--- a/drivers/rtc/rtc-imxdi.c
+++ b/drivers/rtc/rtc-imxdi.c
@@ -369,7 +369,7 @@ static void dryice_work(struct work_struct *work)
 /*
 * probe for dryice rtc device
 */
-static int dryice_rtc_probe(struct platform_device *pdev)
+static int __init dryice_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct imxdi_dev *imxdi;
@@ -464,7 +464,7 @@ static int dryice_rtc_probe(struct platform_device *pdev)
        }
        platform_set_drvdata(pdev, imxdi);
-        imxdi->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        imxdi->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                  &dryice_rtc_ops, THIS_MODULE);
        if (IS_ERR(imxdi->rtc)) {
                rc = PTR_ERR(imxdi->rtc);
@@ -479,7 +479,7 @@ err:
        return rc;
 }
-static int dryice_rtc_remove(struct platform_device *pdev)
+static int __exit dryice_rtc_remove(struct platform_device *pdev)
 {
        struct imxdi_dev *imxdi = platform_get_drvdata(pdev);
@@ -488,8 +488,6 @@ static int dryice_rtc_remove(struct platform_device *pdev)
        /* mask all interrupts */
        __raw_writel(0, imxdi->ioaddr + DIER);
-        rtc_device_unregister(imxdi->rtc);
        clk_disable_unprepare(imxdi->clk);
        return 0;
@@ -510,21 +508,10 @@ static struct platform_driver dryice_rtc_driver = {
                   .owner = THIS_MODULE,
                   .of_match_table = of_match_ptr(dryice_dt_ids),
                   },
-        .remove = dryice_rtc_remove,
+        .remove = __exit_p(dryice_rtc_remove),
 };
-static int __init dryice_rtc_init(void)
+module_platform_driver_probe(dryice_rtc_driver, dryice_rtc_probe);
-{
-        return platform_driver_probe(&dryice_rtc_driver, dryice_rtc_probe);
-}
-static void __exit dryice_rtc_exit(void)
-{
-        platform_driver_unregister(&dryice_rtc_driver);
-}
-module_init(dryice_rtc_init);
-module_exit(dryice_rtc_exit);
 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
diff --git a/drivers/rtc/rtc-isl12022.c b/drivers/rtc/rtc-isl12022.c
index 6b4298ea683d..a1bbbb8de029 100644
--- a/drivers/rtc/rtc-isl12022.c
+++ b/drivers/rtc/rtc-isl12022.c
@@ -252,12 +252,11 @@ static int isl12022_probe(struct i2c_client *client,
 {
        struct isl12022 *isl12022;
-        int ret = 0;
        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
                return -ENODEV;
-        isl12022 = kzalloc(sizeof(struct isl12022), GFP_KERNEL);
+        isl12022 = devm_kzalloc(&client->dev, sizeof(struct isl12022),
+                                GFP_KERNEL);
        if (!isl12022)
                return -ENOMEM;
@@ -265,37 +264,22 @@ static int isl12022_probe(struct i2c_client *client,
        i2c_set_clientdata(client, isl12022);
-        isl12022->rtc = rtc_device_register(isl12022_driver.driver.name,
+        isl12022->rtc = devm_rtc_device_register(&client->dev,
-                                            &client->dev,
+                                        isl12022_driver.driver.name,
-                                            &isl12022_rtc_ops,
+                                        &isl12022_rtc_ops, THIS_MODULE);
-                                            THIS_MODULE);
+        if (IS_ERR(isl12022->rtc))
+                return PTR_ERR(isl12022->rtc);
-        if (IS_ERR(isl12022->rtc)) {
-                ret = PTR_ERR(isl12022->rtc);
-                goto exit_kfree;
-        }
        return 0;
-exit_kfree:
-        kfree(isl12022);
-        return ret;
 }
 static int isl12022_remove(struct i2c_client *client)
 {
-        struct isl12022 *isl12022 = i2c_get_clientdata(client);
-        rtc_device_unregister(isl12022->rtc);
-        kfree(isl12022);
        return 0;
 }
 static const struct i2c_device_id isl12022_id[] = {
        { "isl12022", 0 },
-        { "rtc8564", 0 },
        { }
 };
 MODULE_DEVICE_TABLE(i2c, isl12022_id);
diff --git a/drivers/rtc/rtc-lp8788.c b/drivers/rtc/rtc-lp8788.c
index 9a4631218f41..9853ac15b296 100644
--- a/drivers/rtc/rtc-lp8788.c
+++ b/drivers/rtc/rtc-lp8788.c
@@ -299,7 +299,7 @@ static int lp8788_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(dev, 1);
-        rtc->rdev = rtc_device_register("lp8788_rtc", dev,
+        rtc->rdev = devm_rtc_device_register(dev, "lp8788_rtc",
                                        &lp8788_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rdev)) {
                dev_err(dev, "can not register rtc device\n");
@@ -314,9 +314,6 @@ static int lp8788_rtc_probe(struct platform_device *pdev)
 static int lp8788_rtc_remove(struct platform_device *pdev)
 {
-        struct lp8788_rtc *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc->rdev);
        platform_set_drvdata(pdev, NULL);
        return 0;
diff --git a/drivers/rtc/rtc-lpc32xx.c b/drivers/rtc/rtc-lpc32xx.c
index 40a598332bac..787550d756e9 100644
--- a/drivers/rtc/rtc-lpc32xx.c
+++ b/drivers/rtc/rtc-lpc32xx.c
@@ -273,8 +273,8 @@ static int lpc32xx_rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, rtc);
-        rtc->rtc = rtc_device_register(RTC_NAME, &pdev->dev, &lpc32xx_rtc_ops,
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, RTC_NAME,
-                THIS_MODULE);
+                                        &lpc32xx_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
                dev_err(&pdev->dev, "Can't get RTC\n");
                platform_set_drvdata(pdev, NULL);
@@ -307,7 +307,6 @@ static int lpc32xx_rtc_remove(struct platform_device *pdev)
                device_init_wakeup(&pdev->dev, 0);
        platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(rtc->rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ls1x.c b/drivers/rtc/rtc-ls1x.c
index f59b6349551a..db82f91f4562 100644
--- a/drivers/rtc/rtc-ls1x.c
+++ b/drivers/rtc/rtc-ls1x.c
@@ -172,7 +172,7 @@ static int ls1x_rtc_probe(struct platform_device *pdev)
        while (readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_TTS)
                usleep_range(1000, 3000);
-        rtcdev = rtc_device_register("ls1x-rtc", &pdev->dev,
+        rtcdev = devm_rtc_device_register(&pdev->dev, "ls1x-rtc",
                                        &ls1x_rtc_ops , THIS_MODULE);
        if (IS_ERR(rtcdev)) {
                ret = PTR_ERR(rtcdev);
@@ -187,9 +187,6 @@ err:
 static int ls1x_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtcdev = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtcdev);
        platform_set_drvdata(pdev, NULL);
        return 0;
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index b885bcd08908..89674b5e6efd 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -637,7 +637,8 @@ static int m41t80_probe(struct i2c_client *client,
        dev_info(&client->dev,
                 "chip found, driver version " DRV_VERSION "\n");
-        clientdata = kzalloc(sizeof(*clientdata), GFP_KERNEL);
+        clientdata = devm_kzalloc(&client->dev, sizeof(*clientdata),
+                                GFP_KERNEL);
        if (!clientdata) {
                rc = -ENOMEM;
                goto exit;
@@ -646,8 +647,8 @@ static int m41t80_probe(struct i2c_client *client,
        clientdata->features = id->driver_data;
        i2c_set_clientdata(client, clientdata);
-        rtc = rtc_device_register(client->name, &client->dev,
+        rtc = devm_rtc_device_register(&client->dev, client->name,
-                                  &m41t80_rtc_ops, THIS_MODULE);
+                                        &m41t80_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                rc = PTR_ERR(rtc);
                rtc = NULL;
@@ -718,26 +719,19 @@ ht_err:
        goto exit;
 exit:
-        if (rtc)
-                rtc_device_unregister(rtc);
-        kfree(clientdata);
        return rc;
 }
 static int m41t80_remove(struct i2c_client *client)
 {
+#ifdef CONFIG_RTC_DRV_M41T80_WDT
        struct m41t80_data *clientdata = i2c_get_clientdata(client);
-        struct rtc_device *rtc = clientdata->rtc;
-#ifdef CONFIG_RTC_DRV_M41T80_WDT
        if (clientdata->features & M41T80_FEATURE_HT) {
                misc_deregister(&wdt_dev);
                unregister_reboot_notifier(&wdt_notifier);
        }
 #endif
-        if (rtc)
-                rtc_device_unregister(rtc);
-        kfree(clientdata);
        return 0;
 }
diff --git a/drivers/rtc/rtc-m41t93.c b/drivers/rtc/rtc-m41t93.c
index 49169680786e..9707d36e8b15 100644
--- a/drivers/rtc/rtc-m41t93.c
+++ b/drivers/rtc/rtc-m41t93.c
@@ -184,12 +184,12 @@ static int m41t93_probe(struct spi_device *spi)
                return -ENODEV;
        }
-        rtc = rtc_device_register(m41t93_driver.driver.name,
+        rtc = devm_rtc_device_register(&spi->dev, m41t93_driver.driver.name,
-                &spi->dev, &m41t93_rtc_ops, THIS_MODULE);
+                                        &m41t93_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
-        dev_set_drvdata(&spi->dev, rtc);
+        spi_set_drvdata(spi, rtc);
        return 0;
 }
@@ -197,11 +197,6 @@ static int m41t93_probe(struct spi_device *spi)
 static int m41t93_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = spi_get_drvdata(spi);
-        if (rtc)
-                rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-m41t94.c b/drivers/rtc/rtc-m41t94.c
index 89266c6764bc..7454ef0a4cfa 100644
--- a/drivers/rtc/rtc-m41t94.c
+++ b/drivers/rtc/rtc-m41t94.c
@@ -124,23 +124,18 @@ static int m41t94_probe(struct spi_device *spi)
                return res;
        }
-        rtc = rtc_device_register(m41t94_driver.driver.name,
+        rtc = devm_rtc_device_register(&spi->dev, m41t94_driver.driver.name,
-                &spi->dev, &m41t94_rtc_ops, THIS_MODULE);
+                                        &m41t94_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
-        dev_set_drvdata(&spi->dev, rtc);
+        spi_set_drvdata(spi, rtc);
        return 0;
 }
 static int m41t94_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = spi_get_drvdata(spi);
-        if (rtc)
-                rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-m48t35.c b/drivers/rtc/rtc-m48t35.c
index 31c9190a1fcb..37444246e5e4 100644
--- a/drivers/rtc/rtc-m48t35.c
+++ b/drivers/rtc/rtc-m48t35.c
@@ -145,12 +145,11 @@ static int m48t35_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct m48t35_priv *priv;
-        int ret = 0;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res)
                return -ENODEV;
-        priv = kzalloc(sizeof(struct m48t35_priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct m48t35_priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
@@ -160,50 +159,29 @@ static int m48t35_probe(struct platform_device *pdev)
         * conflicts are resolved
         */
 #ifndef CONFIG_SGI_IP27
-        if (!request_mem_region(res->start, priv->size, pdev->name)) {
+        if (!devm_request_mem_region(&pdev->dev, res->start, priv->size,
-                ret = -EBUSY;
+                                     pdev->name))
-                goto out;
+                return -EBUSY;
-        }
 #endif
        priv->baseaddr = res->start;
-        priv->reg = ioremap(priv->baseaddr, priv->size);
+        priv->reg = devm_ioremap(&pdev->dev, priv->baseaddr, priv->size);
-        if (!priv->reg) {
+        if (!priv->reg)
-                ret = -ENOMEM;
+                return -ENOMEM;
-                goto out;
-        }
        spin_lock_init(&priv->lock);
        platform_set_drvdata(pdev, priv);
-        priv->rtc = rtc_device_register("m48t35", &pdev->dev,
+        priv->rtc = devm_rtc_device_register(&pdev->dev, "m48t35",
                                  &m48t35_ops, THIS_MODULE);
-        if (IS_ERR(priv->rtc)) {
+        if (IS_ERR(priv->rtc))
-                ret = PTR_ERR(priv->rtc);
+                return PTR_ERR(priv->rtc);
-                goto out;
-        }
        return 0;
-out:
-        if (priv->reg)
-                iounmap(priv->reg);
-        if (priv->baseaddr)
-                release_mem_region(priv->baseaddr, priv->size);
-        kfree(priv);
-        return ret;
 }
 static int m48t35_remove(struct platform_device *pdev)
 {
-        struct m48t35_priv *priv = platform_get_drvdata(pdev);
-        rtc_device_unregister(priv->rtc);
-        iounmap(priv->reg);
-#ifndef CONFIG_SGI_IP27
-        release_mem_region(priv->baseaddr, priv->size);
-#endif
-        kfree(priv);
        return 0;
 }
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
index 2ffbcacd2439..33a91c484533 100644
--- a/drivers/rtc/rtc-m48t86.c
+++ b/drivers/rtc/rtc-m48t86.c
@@ -148,8 +148,10 @@ static int m48t86_rtc_probe(struct platform_device *dev)
 {
        unsigned char reg;
        struct m48t86_ops *ops = dev->dev.platform_data;
-        struct rtc_device *rtc = rtc_device_register("m48t86",
+        struct rtc_device *rtc;
-                                &dev->dev, &m48t86_rtc_ops, THIS_MODULE);
+        rtc = devm_rtc_device_register(&dev->dev, "m48t86",
+                                &m48t86_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -166,11 +168,6 @@ static int m48t86_rtc_probe(struct platform_device *dev)
 static int m48t86_rtc_remove(struct platform_device *dev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(dev);
-        if (rtc)
-                rtc_device_unregister(rtc);
        platform_set_drvdata(dev, NULL);
        return 0;
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index a00e33204b91..8669d6d09a00 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -214,11 +214,6 @@ static int max6900_rtc_set_time(struct device *dev, struct rtc_time *tm)
 static int max6900_remove(struct i2c_client *client)
 {
-        struct rtc_device *rtc = i2c_get_clientdata(client);
-        if (rtc)
-                rtc_device_unregister(rtc);
        return 0;
 }
@@ -237,8 +232,8 @@ max6900_probe(struct i2c_client *client, const struct i2c_device_id *id)
        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
-        rtc = rtc_device_register(max6900_driver.driver.name,
+        rtc = devm_rtc_device_register(&client->dev, max6900_driver.driver.name,
-                                  &client->dev, &max6900_rtc_ops, THIS_MODULE);
+                                        &max6900_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index 7d0bf698b79e..e3aea00c3145 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -93,24 +93,24 @@ static int max6902_set_time(struct device *dev, struct rtc_time *dt)
        dt->tm_year = dt->tm_year + 1900;
        /* Remove write protection */
-        max6902_set_reg(dev, 0xF, 0);
+        max6902_set_reg(dev, MAX6902_REG_CONTROL, 0);
-        max6902_set_reg(dev, 0x01, bin2bcd(dt->tm_sec));
+        max6902_set_reg(dev, MAX6902_REG_SECONDS, bin2bcd(dt->tm_sec));
-        max6902_set_reg(dev, 0x03, bin2bcd(dt->tm_min));
+        max6902_set_reg(dev, MAX6902_REG_MINUTES, bin2bcd(dt->tm_min));
-        max6902_set_reg(dev, 0x05, bin2bcd(dt->tm_hour));
+        max6902_set_reg(dev, MAX6902_REG_HOURS, bin2bcd(dt->tm_hour));
-        max6902_set_reg(dev, 0x07, bin2bcd(dt->tm_mday));
+        max6902_set_reg(dev, MAX6902_REG_DATE, bin2bcd(dt->tm_mday));
-        max6902_set_reg(dev, 0x09, bin2bcd(dt->tm_mon + 1));
+        max6902_set_reg(dev, MAX6902_REG_MONTH, bin2bcd(dt->tm_mon + 1));
-        max6902_set_reg(dev, 0x0B, bin2bcd(dt->tm_wday));
+        max6902_set_reg(dev, MAX6902_REG_DAY, bin2bcd(dt->tm_wday));
-        max6902_set_reg(dev, 0x0D, bin2bcd(dt->tm_year % 100));
+        max6902_set_reg(dev, MAX6902_REG_YEAR, bin2bcd(dt->tm_year % 100));
-        max6902_set_reg(dev, 0x13, bin2bcd(dt->tm_year / 100));
+        max6902_set_reg(dev, MAX6902_REG_CENTURY, bin2bcd(dt->tm_year / 100));
        /* Compulab used a delay here. However, the datasheet
         * does not mention a delay being required anywhere... */
        /* delay(2000); */
        /* Write protect */
-        max6902_set_reg(dev, 0xF, 0x80);
+        max6902_set_reg(dev, MAX6902_REG_CONTROL, 0x80);
        return 0;
 }
@@ -134,20 +134,17 @@ static int max6902_probe(struct spi_device *spi)
        if (res != 0)
                return res;
-        rtc = rtc_device_register("max6902",
+        rtc = devm_rtc_device_register(&spi->dev, "max6902",
-                                &spi->dev, &max6902_rtc_ops, THIS_MODULE);
+                                &max6902_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
-        dev_set_drvdata(&spi->dev, rtc);
+        spi_set_drvdata(spi, rtc);
        return 0;
 }
 static int max6902_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-max77686.c b/drivers/rtc/rtc-max77686.c
index 6b1337f9baf4..771812d62e6b 100644
--- a/drivers/rtc/rtc-max77686.c
+++ b/drivers/rtc/rtc-max77686.c
@@ -24,7 +24,7 @@
 /* RTC Control Register */
 #define BCD_EN_SHIFT                    0
-#define BCD_EN_MASK                             (1 << BCD_EN_SHIFT)
+#define BCD_EN_MASK                     (1 << BCD_EN_SHIFT)
 #define MODEL24_SHIFT                   1
 #define MODEL24_MASK                    (1 << MODEL24_SHIFT)
 /* RTC Update Register1 */
@@ -33,12 +33,12 @@
 #define RTC_RBUDR_SHIFT                 4
 #define RTC_RBUDR_MASK                  (1 << RTC_RBUDR_SHIFT)
 /* WTSR and SMPL Register */
-#define WTSRT_SHIFT                             0
+#define WTSRT_SHIFT                     0
-#define SMPLT_SHIFT                             2
+#define SMPLT_SHIFT                     2
 #define WTSR_EN_SHIFT                   6
 #define SMPL_EN_SHIFT                   7
-#define WTSRT_MASK                              (3 << WTSRT_SHIFT)
+#define WTSRT_MASK                      (3 << WTSRT_SHIFT)
-#define SMPLT_MASK                              (3 << SMPLT_SHIFT)
+#define SMPLT_MASK                      (3 << SMPLT_SHIFT)
 #define WTSR_EN_MASK                    (1 << WTSR_EN_SHIFT)
 #define SMPL_EN_MASK                    (1 << SMPL_EN_SHIFT)
 /* RTC Hour register */
@@ -466,7 +466,7 @@ static void max77686_rtc_enable_smpl(struct max77686_rtc_info *info, bool enable
        val = 0;
        regmap_read(info->max77686->rtc_regmap, MAX77686_WTSR_SMPL_CNTL, &val);
-        pr_info("%s: WTSR_SMPL(0x%02x)\n", __func__, val);
+        dev_info(info->dev, "%s: WTSR_SMPL(0x%02x)\n", __func__, val);
 }
 #endif /* MAX77686_RTC_WTSR_SMPL */
@@ -505,7 +505,8 @@ static int max77686_rtc_probe(struct platform_device *pdev)
        dev_info(&pdev->dev, "%s\n", __func__);
-        info = kzalloc(sizeof(struct max77686_rtc_info), GFP_KERNEL);
+        info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info),
+                                GFP_KERNEL);
        if (!info)
                return -ENOMEM;
@@ -513,13 +514,12 @@ static int max77686_rtc_probe(struct platform_device *pdev)
        info->dev = &pdev->dev;
        info->max77686 = max77686;
        info->rtc = max77686->rtc;
-        info->max77686->rtc_regmap = regmap_init_i2c(info->max77686->rtc,
+        info->max77686->rtc_regmap = devm_regmap_init_i2c(info->max77686->rtc,
                                         &max77686_rtc_regmap_config);
        if (IS_ERR(info->max77686->rtc_regmap)) {
                ret = PTR_ERR(info->max77686->rtc_regmap);
                dev_err(info->max77686->dev, "Failed to allocate register map: %d\n",
                                ret);
-                kfree(info);
                return ret;
        }
        platform_set_drvdata(pdev, info);
@@ -538,8 +538,8 @@ static int max77686_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        info->rtc_dev = rtc_device_register("max77686-rtc", &pdev->dev,
+        info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max77686-rtc",
-                        &max77686_rtc_ops, THIS_MODULE);
+                                        &max77686_rtc_ops, THIS_MODULE);
        if (IS_ERR(info->rtc_dev)) {
                dev_info(&pdev->dev, "%s: fail\n", __func__);
@@ -551,36 +551,24 @@ static int max77686_rtc_probe(struct platform_device *pdev)
                goto err_rtc;
        }
        virq = irq_create_mapping(max77686->irq_domain, MAX77686_RTCIRQ_RTCA1);
-        if (!virq)
+        if (!virq) {
+                ret = -ENXIO;
                goto err_rtc;
+        }
        info->virq = virq;
-        ret = request_threaded_irq(virq, NULL, max77686_rtc_alarm_irq, 0,
+        ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
-                        "rtc-alarm0", info);
+                                max77686_rtc_alarm_irq, 0, "rtc-alarm0", info);
-        if (ret < 0) {
+        if (ret < 0)
                dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
                        info->virq, ret);
-                goto err_rtc;
-        }
-        goto out;
 err_rtc:
-        kfree(info);
-        return ret;
-out:
        return ret;
 }
 static int max77686_rtc_remove(struct platform_device *pdev)
 {
-        struct max77686_rtc_info *info = platform_get_drvdata(pdev);
-        if (info) {
-                free_irq(info->virq, info);
-                rtc_device_unregister(info->rtc_dev);
-                kfree(info);
-        }
        return 0;
 }
@@ -594,11 +582,14 @@ static void max77686_rtc_shutdown(struct platform_device *pdev)
        for (i = 0; i < 3; i++) {
                max77686_rtc_enable_wtsr(info, false);
                regmap_read(info->max77686->rtc_regmap, MAX77686_WTSR_SMPL_CNTL, &val);
-                pr_info("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val);
+                dev_info(info->dev, "%s: WTSR_SMPL reg(0x%02x)\n", __func__,
-                if (val & WTSR_EN_MASK)
+                                val);
-                        pr_emerg("%s: fail to disable WTSR\n", __func__);
+                if (val & WTSR_EN_MASK) {
-                else {
+                        dev_emerg(info->dev, "%s: fail to disable WTSR\n",
-                        pr_info("%s: success to disable WTSR\n", __func__);
+                                        __func__);
+                } else {
+                        dev_info(info->dev, "%s: success to disable WTSR\n",
+                                        __func__);
                        break;
                }
        }
@@ -624,18 +615,8 @@ static struct platform_driver max77686_rtc_driver = {
        .id_table       = rtc_id,
 };
-static int __init max77686_rtc_init(void)
+module_platform_driver(max77686_rtc_driver);
-{
-        return platform_driver_register(&max77686_rtc_driver);
-}
-module_init(max77686_rtc_init);
-static void __exit max77686_rtc_exit(void)
-{
-        platform_driver_unregister(&max77686_rtc_driver);
-}
-module_exit(max77686_rtc_exit);
 MODULE_DESCRIPTION("Maxim MAX77686 RTC driver");
-MODULE_AUTHOR("<woong.byun@samsung.com>");
+MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-max8907.c b/drivers/rtc/rtc-max8907.c
index 31ca8faf9f05..86afb797125d 100644
--- a/drivers/rtc/rtc-max8907.c
+++ b/drivers/rtc/rtc-max8907.c
@@ -190,7 +190,7 @@ static int max8907_rtc_probe(struct platform_device *pdev)
        rtc->max8907 = max8907;
        rtc->regmap = max8907->regmap_rtc;
-        rtc->rtc_dev = rtc_device_register("max8907-rtc", &pdev->dev,
+        rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8907-rtc",
                                        &max8907_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc_dev)) {
                ret = PTR_ERR(rtc->rtc_dev);
@@ -200,33 +200,21 @@ static int max8907_rtc_probe(struct platform_device *pdev)
        rtc->irq = regmap_irq_get_virq(max8907->irqc_rtc,
                                       MAX8907_IRQ_RTC_ALARM0);
-        if (rtc->irq < 0) {
+        if (rtc->irq < 0)
-                ret = rtc->irq;
+                return rtc->irq;
-                goto err_unregister;
-        }
        ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
                                max8907_irq_handler,
                                IRQF_ONESHOT, "max8907-alarm0", rtc);
-        if (ret < 0) {
+        if (ret < 0)
                dev_err(&pdev->dev, "Failed to request IRQ%d: %d\n",
                        rtc->irq, ret);
-                goto err_unregister;
-        }
-        return 0;
-err_unregister:
-        rtc_device_unregister(rtc->rtc_dev);
        return ret;
 }
 static int max8907_rtc_remove(struct platform_device *pdev)
 {
-        struct max8907_rtc *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc->rtc_dev);
        return 0;
 }
diff --git a/drivers/rtc/rtc-max8925.c b/drivers/rtc/rtc-max8925.c
index a0c8265646d2..7c90f4e45e27 100644
--- a/drivers/rtc/rtc-max8925.c
+++ b/drivers/rtc/rtc-max8925.c
@@ -253,7 +253,8 @@ static int max8925_rtc_probe(struct platform_device *pdev)
        struct max8925_rtc_info *info;
        int ret;
-        info = kzalloc(sizeof(struct max8925_rtc_info), GFP_KERNEL);
+        info = devm_kzalloc(&pdev->dev, sizeof(struct max8925_rtc_info),
+                            GFP_KERNEL);
        if (!info)
                return -ENOMEM;
        info->chip = chip;
@@ -261,12 +262,13 @@ static int max8925_rtc_probe(struct platform_device *pdev)
        info->dev = &pdev->dev;
        info->irq = platform_get_irq(pdev, 0);
-        ret = request_threaded_irq(info->irq, NULL, rtc_update_handler,
+        ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
-                                   IRQF_ONESHOT, "rtc-alarm0", info);
+                                        rtc_update_handler, IRQF_ONESHOT,
+                                        "rtc-alarm0", info);
        if (ret < 0) {
                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
                        info->irq, ret);
-                goto out_irq;
+                goto err;
        }
        dev_set_drvdata(&pdev->dev, info);
@@ -275,32 +277,22 @@ static int max8925_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
+        info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8925-rtc",
                                        &max8925_rtc_ops, THIS_MODULE);
        ret = PTR_ERR(info->rtc_dev);
        if (IS_ERR(info->rtc_dev)) {
                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
-                goto out_rtc;
+                goto err;
        }
        return 0;
-out_rtc:
+err:
        platform_set_drvdata(pdev, NULL);
-        free_irq(info->irq, info);
-out_irq:
-        kfree(info);
        return ret;
 }
 static int max8925_rtc_remove(struct platform_device *pdev)
 {
-        struct max8925_rtc_info *info = platform_get_drvdata(pdev);
-        if (info) {
-                free_irq(info->irq, info);
-                rtc_device_unregister(info->rtc_dev);
-                kfree(info);
-        }
        return 0;
 }
diff --git a/drivers/rtc/rtc-max8997.c b/drivers/rtc/rtc-max8997.c
index 00e505b6bee3..dacf48db7925 100644
--- a/drivers/rtc/rtc-max8997.c
+++ b/drivers/rtc/rtc-max8997.c
@@ -24,7 +24,7 @@
 /* Module parameter for WTSR function control */
 static int wtsr_en = 1;
 module_param(wtsr_en, int, 0444);
-MODULE_PARM_DESC(wtsr_en, "Wachdog Timeout & Sofware Reset (default=on)");
+MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)");
 /* Module parameter for SMPL function control */
 static int smpl_en = 1;
 module_param(smpl_en, int, 0444);
@@ -479,8 +479,8 @@ static int max8997_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        info->rtc_dev = rtc_device_register("max8997-rtc", &pdev->dev,
+        info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",
-                        &max8997_rtc_ops, THIS_MODULE);
+                                        &max8997_rtc_ops, THIS_MODULE);
        if (IS_ERR(info->rtc_dev)) {
                ret = PTR_ERR(info->rtc_dev);
@@ -491,6 +491,7 @@ static int max8997_rtc_probe(struct platform_device *pdev)
        virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);
        if (!virq) {
                dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");
+                ret = -ENXIO;
                goto err_out;
        }
        info->virq = virq;
@@ -498,26 +499,16 @@ static int max8997_rtc_probe(struct platform_device *pdev)
        ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
                                max8997_rtc_alarm_irq, 0,
                                "rtc-alarm0", info);
-        if (ret < 0) {
+        if (ret < 0)
                dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
                        info->virq, ret);
-                goto err_out;
-        }
-        return ret;
 err_out:
-        rtc_device_unregister(info->rtc_dev);
        return ret;
 }
 static int max8997_rtc_remove(struct platform_device *pdev)
 {
-        struct max8997_rtc_info *info = platform_get_drvdata(pdev);
-        if (info)
-                rtc_device_unregister(info->rtc_dev);
        return 0;
 }
diff --git a/drivers/rtc/rtc-max8998.c b/drivers/rtc/rtc-max8998.c
index 8f234a075e8f..48b6612fae7f 100644
--- a/drivers/rtc/rtc-max8998.c
+++ b/drivers/rtc/rtc-max8998.c
@@ -256,7 +256,8 @@ static int max8998_rtc_probe(struct platform_device *pdev)
        struct max8998_rtc_info *info;
        int ret;
-        info = kzalloc(sizeof(struct max8998_rtc_info), GFP_KERNEL);
+        info = devm_kzalloc(&pdev->dev, sizeof(struct max8998_rtc_info),
+                        GFP_KERNEL);
        if (!info)
                return -ENOMEM;
@@ -267,7 +268,7 @@ static int max8998_rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, info);
-        info->rtc_dev = rtc_device_register("max8998-rtc", &pdev->dev,
+        info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8998-rtc",
                        &max8998_rtc_ops, THIS_MODULE);
        if (IS_ERR(info->rtc_dev)) {
@@ -276,8 +277,8 @@ static int max8998_rtc_probe(struct platform_device *pdev)
                goto out_rtc;
        }
-        ret = request_threaded_irq(info->irq, NULL, max8998_rtc_alarm_irq, 0,
+        ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
-                        "rtc-alarm0", info);
+                                max8998_rtc_alarm_irq, 0, "rtc-alarm0", info);
        if (ret < 0)
                dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
@@ -294,20 +295,11 @@ static int max8998_rtc_probe(struct platform_device *pdev)
 out_rtc:
        platform_set_drvdata(pdev, NULL);
-        kfree(info);
        return ret;
 }
 static int max8998_rtc_remove(struct platform_device *pdev)
 {
-        struct max8998_rtc_info *info = platform_get_drvdata(pdev);
-        if (info) {
-                free_irq(info->irq, info);
-                rtc_device_unregister(info->rtc_dev);
-                kfree(info);
-        }
        return 0;
 }
diff --git a/drivers/rtc/rtc-mc13xxx.c b/drivers/rtc/rtc-mc13xxx.c
index 2643d8874925..7a8ed27a5f2e 100644
--- a/drivers/rtc/rtc-mc13xxx.c
+++ b/drivers/rtc/rtc-mc13xxx.c
@@ -316,7 +316,7 @@ static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
        struct mc13xxx *mc13xxx;
        int rtcrst_pending;
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
@@ -351,8 +351,8 @@ static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
        mc13xxx_unlock(mc13xxx);
-        priv->rtc = rtc_device_register(pdev->name,
+        priv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                        &pdev->dev, &mc13xxx_rtc_ops, THIS_MODULE);
+                                        &mc13xxx_rtc_ops, THIS_MODULE);
        if (IS_ERR(priv->rtc)) {
                ret = PTR_ERR(priv->rtc);
@@ -372,7 +372,6 @@ err_reset_irq_request:
                mc13xxx_unlock(mc13xxx);
                platform_set_drvdata(pdev, NULL);
-                kfree(priv);
        }
        return ret;
@@ -384,8 +383,6 @@ static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
        mc13xxx_lock(priv->mc13xxx);
-        rtc_device_unregister(priv->rtc);
        mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
        mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_1HZ, priv);
        mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
@@ -394,8 +391,6 @@ static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
        platform_set_drvdata(pdev, NULL);
-        kfree(priv);
        return 0;
 }
@@ -420,17 +415,7 @@ static struct platform_driver mc13xxx_rtc_driver = {
        },
 };
-static int __init mc13xxx_rtc_init(void)
+module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
-{
-        return platform_driver_probe(&mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
-}
-module_init(mc13xxx_rtc_init);
-static void __exit mc13xxx_rtc_exit(void)
-{
-        platform_driver_unregister(&mc13xxx_rtc_driver);
-}
-module_exit(mc13xxx_rtc_exit);
 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
 MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
diff --git a/drivers/rtc/rtc-msm6242.c b/drivers/rtc/rtc-msm6242.c
index fcb113c11122..771f86a05d14 100644
--- a/drivers/rtc/rtc-msm6242.c
+++ b/drivers/rtc/rtc-msm6242.c
@@ -194,30 +194,28 @@ static const struct rtc_class_ops msm6242_rtc_ops = {
        .set_time       = msm6242_set_time,
 };
-static int __init msm6242_rtc_probe(struct platform_device *dev)
+static int __init msm6242_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct msm6242_priv *priv;
        struct rtc_device *rtc;
        int error;
-        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res)
                return -ENODEV;
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
-        priv->regs = ioremap(res->start, resource_size(res));
+        priv->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
-        if (!priv->regs) {
+        if (!priv->regs)
-                error = -ENOMEM;
+                return -ENOMEM;
-                goto out_free_priv;
+        platform_set_drvdata(pdev, priv);
-        }
-        platform_set_drvdata(dev, priv);
-        rtc = rtc_device_register("rtc-msm6242", &dev->dev, &msm6242_rtc_ops,
+        rtc = devm_rtc_device_register(&pdev->dev, "rtc-msm6242",
-                                  THIS_MODULE);
+                                &msm6242_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                error = PTR_ERR(rtc);
                goto out_unmap;
@@ -227,20 +225,12 @@ static int __init msm6242_rtc_probe(struct platform_device *dev)
        return 0;
 out_unmap:
-        platform_set_drvdata(dev, NULL);
+        platform_set_drvdata(pdev, NULL);
-        iounmap(priv->regs);
-out_free_priv:
-        kfree(priv);
        return error;
 }
-static int __exit msm6242_rtc_remove(struct platform_device *dev)
+static int __exit msm6242_rtc_remove(struct platform_device *pdev)
 {
-        struct msm6242_priv *priv = platform_get_drvdata(dev);
-        rtc_device_unregister(priv->rtc);
-        iounmap(priv->regs);
-        kfree(priv);
        return 0;
 }
@@ -252,18 +242,7 @@ static struct platform_driver msm6242_rtc_driver = {
        .remove = __exit_p(msm6242_rtc_remove),
 };
-static int __init msm6242_rtc_init(void)
+module_platform_driver_probe(msm6242_rtc_driver, msm6242_rtc_probe);
-{
-        return platform_driver_probe(&msm6242_rtc_driver, msm6242_rtc_probe);
-}
-static void __exit msm6242_rtc_fini(void)
-{
-        platform_driver_unregister(&msm6242_rtc_driver);
-}
-module_init(msm6242_rtc_init);
-module_exit(msm6242_rtc_fini);
 MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-mv.c b/drivers/rtc/rtc-mv.c
index 57233c885998..baab802f2153 100644
--- a/drivers/rtc/rtc-mv.c
+++ b/drivers/rtc/rtc-mv.c
@@ -14,6 +14,7 @@
 #include <linux/platform_device.h>
 #include <linux/of.h>
 #include <linux/delay.h>
+#include <linux/clk.h>
 #include <linux/gfp.h>
 #include <linux/module.h>
@@ -41,6 +42,7 @@ struct rtc_plat_data {
        struct rtc_device *rtc;
        void __iomem *ioaddr;
        int             irq;
+        struct clk      *clk;
 };
 static int mv_rtc_set_time(struct device *dev, struct rtc_time *tm)
@@ -215,12 +217,13 @@ static const struct rtc_class_ops mv_rtc_alarm_ops = {
        .alarm_irq_enable = mv_rtc_alarm_irq_enable,
 };
-static int mv_rtc_probe(struct platform_device *pdev)
+static int __init mv_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct rtc_plat_data *pdata;
        resource_size_t size;
        u32 rtc_time;
+        int ret = 0;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res)
@@ -239,11 +242,17 @@ static int mv_rtc_probe(struct platform_device *pdev)
        if (!pdata->ioaddr)
                return -ENOMEM;
+        pdata->clk = devm_clk_get(&pdev->dev, NULL);
+        /* Not all SoCs require a clock.*/
+        if (!IS_ERR(pdata->clk))
+                clk_prepare_enable(pdata->clk);
        /* make sure the 24 hours mode is enabled */
        rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS);
        if (rtc_time & RTC_HOURS_12H_MODE) {
                dev_err(&pdev->dev, "24 Hours mode not supported.\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
        }
        /* make sure it is actually functional */
@@ -252,7 +261,8 @@ static int mv_rtc_probe(struct platform_device *pdev)
                rtc_time = readl(pdata->ioaddr + RTC_TIME_REG_OFFS);
                if (rtc_time == 0x01000000) {
                        dev_err(&pdev->dev, "internal RTC not ticking\n");
-                        return -ENODEV;
+                        ret = -ENODEV;
+                        goto out;
                }
        }
@@ -262,14 +272,17 @@ static int mv_rtc_probe(struct platform_device *pdev)
        if (pdata->irq >= 0) {
                device_init_wakeup(&pdev->dev, 1);
-                pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                                 &mv_rtc_alarm_ops,
                                                 THIS_MODULE);
-        } else
+        } else {
-                pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                                 &mv_rtc_ops, THIS_MODULE);
-        if (IS_ERR(pdata->rtc))
+        }
-                return PTR_ERR(pdata->rtc);
+        if (IS_ERR(pdata->rtc)) {
+                ret = PTR_ERR(pdata->rtc);
+                goto out;
+        }
        if (pdata->irq >= 0) {
                writel(0, pdata->ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
@@ -282,6 +295,11 @@ static int mv_rtc_probe(struct platform_device *pdev)
        }
        return 0;
+out:
+        if (!IS_ERR(pdata->clk))
+                clk_disable_unprepare(pdata->clk);
+        return ret;
 }
 static int __exit mv_rtc_remove(struct platform_device *pdev)
@@ -291,7 +309,9 @@ static int __exit mv_rtc_remove(struct platform_device *pdev)
        if (pdata->irq >= 0)
                device_init_wakeup(&pdev->dev, 0);
-        rtc_device_unregister(pdata->rtc);
+        if (!IS_ERR(pdata->clk))
+                clk_disable_unprepare(pdata->clk);
        return 0;
 }
@@ -311,18 +331,7 @@ static struct platform_driver mv_rtc_driver = {
        },
 };
-static __init int mv_init(void)
+module_platform_driver_probe(mv_rtc_driver, mv_rtc_probe);
-{
-        return platform_driver_probe(&mv_rtc_driver, mv_rtc_probe);
-}
-static __exit void mv_exit(void)
-{
-        platform_driver_unregister(&mv_rtc_driver);
-}
-module_init(mv_init);
-module_exit(mv_exit);
 MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>");
 MODULE_DESCRIPTION("Marvell RTC driver");
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 1c3ef7289565..9a3895bc4f4d 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -439,7 +439,7 @@ static int mxc_rtc_probe(struct platform_device *pdev)
        if (pdata->irq >=0)
                device_init_wakeup(&pdev->dev, 1);
-        rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &mxc_rtc_ops,
                                  THIS_MODULE);
        if (IS_ERR(rtc)) {
                ret = PTR_ERR(rtc);
@@ -464,15 +464,13 @@ static int mxc_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        rtc_device_unregister(pdata->rtc);
        clk_disable_unprepare(pdata->clk);
        platform_set_drvdata(pdev, NULL);
        return 0;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int mxc_rtc_suspend(struct device *dev)
 {
        struct rtc_plat_data *pdata = dev_get_drvdata(dev);
@@ -492,19 +490,14 @@ static int mxc_rtc_resume(struct device *dev)
        return 0;
 }
-static struct dev_pm_ops mxc_rtc_pm_ops = {
-        .suspend        = mxc_rtc_suspend,
-        .resume         = mxc_rtc_resume,
-};
 #endif
+static SIMPLE_DEV_PM_OPS(mxc_rtc_pm_ops, mxc_rtc_suspend, mxc_rtc_resume);
 static struct platform_driver mxc_rtc_driver = {
        .driver = {
                   .name        = "mxc_rtc",
-#ifdef CONFIG_PM
                   .pm          = &mxc_rtc_pm_ops,
-#endif
                   .owner       = THIS_MODULE,
        },
        .id_table = imx_rtc_devtype,
diff --git a/drivers/rtc/rtc-nuc900.c b/drivers/rtc/rtc-nuc900.c
index a63680850fef..f5dfb6e5e7d9 100644
--- a/drivers/rtc/rtc-nuc900.c
+++ b/drivers/rtc/rtc-nuc900.c
@@ -222,13 +222,13 @@ static struct rtc_class_ops nuc900_rtc_ops = {
        .alarm_irq_enable = nuc900_alarm_irq_enable,
 };
-static int nuc900_rtc_probe(struct platform_device *pdev)
+static int __init nuc900_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct nuc900_rtc *nuc900_rtc;
-        int err = 0;
-        nuc900_rtc = kzalloc(sizeof(struct nuc900_rtc), GFP_KERNEL);
+        nuc900_rtc = devm_kzalloc(&pdev->dev, sizeof(struct nuc900_rtc),
+                                GFP_KERNEL);
        if (!nuc900_rtc) {
                dev_err(&pdev->dev, "kzalloc nuc900_rtc failed\n");
                return -ENOMEM;
@@ -236,93 +236,51 @@ static int nuc900_rtc_probe(struct platform_device *pdev)
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res) {
                dev_err(&pdev->dev, "platform_get_resource failed\n");
-                err = -ENXIO;
+                return -ENXIO;
-                goto fail1;
        }
-        if (!request_mem_region(res->start, resource_size(res),
+        nuc900_rtc->rtc_reg = devm_ioremap_resource(&pdev->dev, res);
-                                pdev->name)) {
+        if (IS_ERR(nuc900_rtc->rtc_reg))
-                dev_err(&pdev->dev, "request_mem_region failed\n");
+                return PTR_ERR(nuc900_rtc->rtc_reg);
-                err = -EBUSY;
-                goto fail1;
-        }
-        nuc900_rtc->rtc_reg = ioremap(res->start, resource_size(res));
-        if (!nuc900_rtc->rtc_reg) {
-                dev_err(&pdev->dev, "ioremap rtc_reg failed\n");
-                err = -ENOMEM;
-                goto fail2;
-        }
        platform_set_drvdata(pdev, nuc900_rtc);
-        nuc900_rtc->rtcdev = rtc_device_register(pdev->name, &pdev->dev,
+        nuc900_rtc->rtcdev = devm_rtc_device_register(&pdev->dev, pdev->name,
                                                &nuc900_rtc_ops, THIS_MODULE);
        if (IS_ERR(nuc900_rtc->rtcdev)) {
                dev_err(&pdev->dev, "rtc device register failed\n");
-                err = PTR_ERR(nuc900_rtc->rtcdev);
+                return PTR_ERR(nuc900_rtc->rtcdev);
-                goto fail3;
        }
        __raw_writel(__raw_readl(nuc900_rtc->rtc_reg + REG_RTC_TSSR) | MODE24,
                                        nuc900_rtc->rtc_reg + REG_RTC_TSSR);
        nuc900_rtc->irq_num = platform_get_irq(pdev, 0);
-        if (request_irq(nuc900_rtc->irq_num, nuc900_rtc_interrupt,
+        if (devm_request_irq(&pdev->dev, nuc900_rtc->irq_num,
-                                0, "nuc900rtc", nuc900_rtc)) {
+                        nuc900_rtc_interrupt, 0, "nuc900rtc", nuc900_rtc)) {
                dev_err(&pdev->dev, "NUC900 RTC request irq failed\n");
-                err = -EBUSY;
+                return -EBUSY;
-                goto fail4;
        }
        return 0;
-fail4:  rtc_device_unregister(nuc900_rtc->rtcdev);
-fail3:  iounmap(nuc900_rtc->rtc_reg);
-fail2:  release_mem_region(res->start, resource_size(res));
-fail1:  kfree(nuc900_rtc);
-        return err;
 }
-static int nuc900_rtc_remove(struct platform_device *pdev)
+static int __exit nuc900_rtc_remove(struct platform_device *pdev)
 {
-        struct nuc900_rtc *nuc900_rtc = platform_get_drvdata(pdev);
-        struct resource *res;
-        free_irq(nuc900_rtc->irq_num, nuc900_rtc);
-        rtc_device_unregister(nuc900_rtc->rtcdev);
-        iounmap(nuc900_rtc->rtc_reg);
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, resource_size(res));
-        kfree(nuc900_rtc);
        platform_set_drvdata(pdev, NULL);
        return 0;
 }
 static struct platform_driver nuc900_rtc_driver = {
-        .remove         = nuc900_rtc_remove,
+        .remove         = __exit_p(nuc900_rtc_remove),
        .driver         = {
                .name   = "nuc900-rtc",
                .owner  = THIS_MODULE,
        },
 };
-static int __init nuc900_rtc_init(void)
+module_platform_driver_probe(nuc900_rtc_driver, nuc900_rtc_probe);
-{
-        return platform_driver_probe(&nuc900_rtc_driver, nuc900_rtc_probe);
-}
-static void __exit nuc900_rtc_exit(void)
-{
-        platform_driver_unregister(&nuc900_rtc_driver);
-}
-module_init(nuc900_rtc_init);
-module_exit(nuc900_rtc_exit);
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
 MODULE_DESCRIPTION("nuc910/nuc920 RTC driver");
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 600971407aac..4e1bdb832e37 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -324,7 +324,7 @@ MODULE_DEVICE_TABLE(of, omap_rtc_of_match);
 static int __init omap_rtc_probe(struct platform_device *pdev)
 {
-        struct resource         *res, *mem;
+        struct resource         *res;
        struct rtc_device       *rtc;
        u8                      reg, new_ctrl;
        const struct platform_device_id *id_entry;
@@ -352,18 +352,9 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                return -ENOENT;
        }
-        mem = request_mem_region(res->start, resource_size(res), pdev->name);
+        rtc_base = devm_ioremap_resource(&pdev->dev, res);
-        if (!mem) {
+        if (IS_ERR(rtc_base))
-                pr_debug("%s: RTC registers at %08x are not free\n",
+                return PTR_ERR(rtc_base);
-                        pdev->name, res->start);
-                return -EBUSY;
-        }
-        rtc_base = ioremap(res->start, resource_size(res));
-        if (!rtc_base) {
-                pr_debug("%s: RTC registers can't be mapped\n", pdev->name);
-                goto fail;
-        }
        /* Enable the clock/module so that we can access the registers */
        pm_runtime_enable(&pdev->dev);
@@ -375,7 +366,7 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                rtc_writel(KICK1_VALUE, OMAP_RTC_KICK1_REG);
        }
-        rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                        &omap_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                pr_debug("%s: can't register RTC device, err %ld\n",
@@ -383,7 +374,6 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                goto fail0;
        }
        platform_set_drvdata(pdev, rtc);
-        dev_set_drvdata(&rtc->dev, mem);
        /* clear pending irqs, and set 1/second periodic,
         * which we'll use instead of update irqs
@@ -401,18 +391,18 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
        /* handle periodic and alarm irqs */
-        if (request_irq(omap_rtc_timer, rtc_irq, 0,
+        if (devm_request_irq(&pdev->dev, omap_rtc_timer, rtc_irq, 0,
                        dev_name(&rtc->dev), rtc)) {
                pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
                        pdev->name, omap_rtc_timer);
-                goto fail1;
+                goto fail0;
        }
        if ((omap_rtc_timer != omap_rtc_alarm) &&
-                (request_irq(omap_rtc_alarm, rtc_irq, 0,
+                (devm_request_irq(&pdev->dev, omap_rtc_alarm, rtc_irq, 0,
                        dev_name(&rtc->dev), rtc))) {
                pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
                        pdev->name, omap_rtc_alarm);
-                goto fail2;
+                goto fail0;
        }
        /* On boards with split power, RTC_ON_NOFF won't reset the RTC */
@@ -446,25 +436,16 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
        return 0;
-fail2:
-        free_irq(omap_rtc_timer, rtc);
-fail1:
-        rtc_device_unregister(rtc);
 fail0:
        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
                rtc_writel(0, OMAP_RTC_KICK0_REG);
        pm_runtime_put_sync(&pdev->dev);
        pm_runtime_disable(&pdev->dev);
-        iounmap(rtc_base);
-fail:
-        release_mem_region(mem->start, resource_size(mem));
        return -EIO;
 }
 static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device       *rtc = platform_get_drvdata(pdev);
-        struct resource         *mem = dev_get_drvdata(&rtc->dev);
        const struct platform_device_id *id_entry =
                                platform_get_device_id(pdev);
@@ -473,12 +454,6 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
        /* leave rtc running, but disable irqs */
        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
-        free_irq(omap_rtc_timer, rtc);
-        if (omap_rtc_timer != omap_rtc_alarm)
-                free_irq(omap_rtc_alarm, rtc);
-        rtc_device_unregister(rtc);
        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
                rtc_writel(0, OMAP_RTC_KICK0_REG);
@@ -486,16 +461,13 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
        pm_runtime_put_sync(&pdev->dev);
        pm_runtime_disable(&pdev->dev);
-        iounmap(rtc_base);
-        release_mem_region(mem->start, resource_size(mem));
        return 0;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static u8 irqstat;
-static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int omap_rtc_suspend(struct device *dev)
 {
        irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
@@ -503,34 +475,32 @@ static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
         * source, and in fact this enable() call is just saving a flag
         * that's never used...
         */
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(dev))
                enable_irq_wake(omap_rtc_alarm);
        else
                rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
        /* Disable the clock/module */
-        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_put_sync(dev);
        return 0;
 }
-static int omap_rtc_resume(struct platform_device *pdev)
+static int omap_rtc_resume(struct device *dev)
 {
        /* Enable the clock/module so that we can access the registers */
-        pm_runtime_get_sync(&pdev->dev);
+        pm_runtime_get_sync(dev);
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(dev))
                disable_irq_wake(omap_rtc_alarm);
        else
                rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
        return 0;
 }
-#else
-#define omap_rtc_suspend NULL
-#define omap_rtc_resume  NULL
 #endif
+static SIMPLE_DEV_PM_OPS(omap_rtc_pm_ops, omap_rtc_suspend, omap_rtc_resume);
 static void omap_rtc_shutdown(struct platform_device *pdev)
 {
        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
@@ -539,28 +509,17 @@ static void omap_rtc_shutdown(struct platform_device *pdev)
 MODULE_ALIAS("platform:omap_rtc");
 static struct platform_driver omap_rtc_driver = {
        .remove         = __exit_p(omap_rtc_remove),
-        .suspend        = omap_rtc_suspend,
-        .resume         = omap_rtc_resume,
        .shutdown       = omap_rtc_shutdown,
        .driver         = {
                .name   = DRIVER_NAME,
                .owner  = THIS_MODULE,
+                .pm     = &omap_rtc_pm_ops,
                .of_match_table = of_match_ptr(omap_rtc_of_match),
        },
        .id_table       = omap_rtc_devtype,
 };
-static int __init rtc_init(void)
+module_platform_driver_probe(omap_rtc_driver, omap_rtc_probe);
-{
-        return platform_driver_probe(&omap_rtc_driver, omap_rtc_probe);
-}
-module_init(rtc_init);
-static void __exit rtc_exit(void)
-{
-        platform_driver_unregister(&omap_rtc_driver);
-}
-module_exit(rtc_exit);
 MODULE_AUTHOR("George G. Davis (and others)");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-palmas.c b/drivers/rtc/rtc-palmas.c
index 59c42986254e..50204d474eb7 100644
--- a/drivers/rtc/rtc-palmas.c
+++ b/drivers/rtc/rtc-palmas.c
@@ -30,6 +30,7 @@
 #include <linux/kernel.h>
 #include <linux/mfd/palmas.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/rtc.h>
 #include <linux/types.h>
 #include <linux/platform_device.h>
@@ -264,7 +265,7 @@ static int palmas_rtc_probe(struct platform_device *pdev)
        palmas_rtc->irq = platform_get_irq(pdev, 0);
-        palmas_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        palmas_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                &palmas_rtc_ops, THIS_MODULE);
        if (IS_ERR(palmas_rtc->rtc)) {
                ret = PTR_ERR(palmas_rtc->rtc);
@@ -272,14 +273,13 @@ static int palmas_rtc_probe(struct platform_device *pdev)
                return ret;
        }
-        ret = request_threaded_irq(palmas_rtc->irq, NULL,
+        ret = devm_request_threaded_irq(&pdev->dev, palmas_rtc->irq, NULL,
                        palmas_rtc_interrupt,
                        IRQF_TRIGGER_LOW | IRQF_ONESHOT |
                        IRQF_EARLY_RESUME,
                        dev_name(&pdev->dev), palmas_rtc);
        if (ret < 0) {
                dev_err(&pdev->dev, "IRQ request failed, err = %d\n", ret);
-                rtc_device_unregister(palmas_rtc->rtc);
                return ret;
        }
@@ -289,11 +289,7 @@ static int palmas_rtc_probe(struct platform_device *pdev)
 static int palmas_rtc_remove(struct platform_device *pdev)
 {
-        struct palmas_rtc *palmas_rtc = platform_get_drvdata(pdev);
        palmas_rtc_alarm_irq_enable(&pdev->dev, 0);
-        free_irq(palmas_rtc->irq, palmas_rtc);
-        rtc_device_unregister(palmas_rtc->rtc);
        return 0;
 }
@@ -321,6 +317,14 @@ static const struct dev_pm_ops palmas_rtc_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(palmas_rtc_suspend, palmas_rtc_resume)
 };
+#ifdef CONFIG_OF
+static struct of_device_id of_palmas_rtc_match[] = {
+        { .compatible = "ti,palmas-rtc"},
+        { },
+};
+MODULE_DEVICE_TABLE(of, of_palmas_rtc_match);
+#endif
 static struct platform_driver palmas_rtc_driver = {
        .probe          = palmas_rtc_probe,
        .remove         = palmas_rtc_remove,
@@ -328,6 +332,7 @@ static struct platform_driver palmas_rtc_driver = {
                .owner  = THIS_MODULE,
                .name   = "palmas-rtc",
                .pm     = &palmas_rtc_pm_ops,
+                .of_match_table = of_match_ptr(of_palmas_rtc_match),
        },
 };
diff --git a/drivers/rtc/rtc-pcap.c b/drivers/rtc/rtc-pcap.c
index e0019cd0bf71..539a90b98bc5 100644
--- a/drivers/rtc/rtc-pcap.c
+++ b/drivers/rtc/rtc-pcap.c
@@ -139,13 +139,14 @@ static const struct rtc_class_ops pcap_rtc_ops = {
        .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
 };
-static int pcap_rtc_probe(struct platform_device *pdev)
+static int __init pcap_rtc_probe(struct platform_device *pdev)
 {
        struct pcap_rtc *pcap_rtc;
        int timer_irq, alarm_irq;
        int err = -ENOMEM;
-        pcap_rtc = kmalloc(sizeof(struct pcap_rtc), GFP_KERNEL);
+        pcap_rtc = devm_kzalloc(&pdev->dev, sizeof(struct pcap_rtc),
+                                GFP_KERNEL);
        if (!pcap_rtc)
                return err;
@@ -153,68 +154,46 @@ static int pcap_rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, pcap_rtc);
-        pcap_rtc->rtc = rtc_device_register("pcap", &pdev->dev,
+        pcap_rtc->rtc = devm_rtc_device_register(&pdev->dev, "pcap",
-                                  &pcap_rtc_ops, THIS_MODULE);
+                                        &pcap_rtc_ops, THIS_MODULE);
        if (IS_ERR(pcap_rtc->rtc)) {
                err = PTR_ERR(pcap_rtc->rtc);
-                goto fail_rtc;
+                goto fail;
        }
        timer_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ);
        alarm_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA);
-        err = request_irq(timer_irq, pcap_rtc_irq, 0, "RTC Timer", pcap_rtc);
+        err = devm_request_irq(&pdev->dev, timer_irq, pcap_rtc_irq, 0,
+                                "RTC Timer", pcap_rtc);
        if (err)
-                goto fail_timer;
+                goto fail;
-        err = request_irq(alarm_irq, pcap_rtc_irq, 0, "RTC Alarm", pcap_rtc);
+        err = devm_request_irq(&pdev->dev, alarm_irq, pcap_rtc_irq, 0,
+                                "RTC Alarm", pcap_rtc);
        if (err)
-                goto fail_alarm;
+                goto fail;
        return 0;
-fail_alarm:
+fail:
-        free_irq(timer_irq, pcap_rtc);
-fail_timer:
-        rtc_device_unregister(pcap_rtc->rtc);
-fail_rtc:
        platform_set_drvdata(pdev, NULL);
-        kfree(pcap_rtc);
        return err;
 }
-static int pcap_rtc_remove(struct platform_device *pdev)
+static int __exit pcap_rtc_remove(struct platform_device *pdev)
 {
-        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
-        free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ), pcap_rtc);
-        free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA), pcap_rtc);
-        rtc_device_unregister(pcap_rtc->rtc);
-        kfree(pcap_rtc);
        return 0;
 }
 static struct platform_driver pcap_rtc_driver = {
-        .remove = pcap_rtc_remove,
+        .remove = __exit_p(pcap_rtc_remove),
        .driver = {
                .name  = "pcap-rtc",
                .owner = THIS_MODULE,
        },
 };
-static int __init rtc_pcap_init(void)
+module_platform_driver_probe(pcap_rtc_driver, pcap_rtc_probe);
-{
-        return platform_driver_probe(&pcap_rtc_driver, pcap_rtc_probe);
-}
-static void __exit rtc_pcap_exit(void)
-{
-        platform_driver_unregister(&pcap_rtc_driver);
-}
-module_init(rtc_pcap_init);
-module_exit(rtc_pcap_exit);
 MODULE_DESCRIPTION("Motorola pcap rtc driver");
 MODULE_AUTHOR("guiming zhuo <gmzhuo@gmail.com>");
diff --git a/drivers/rtc/rtc-pcf2123.c b/drivers/rtc/rtc-pcf2123.c
index 02b742afa761..796a6c5067dd 100644
--- a/drivers/rtc/rtc-pcf2123.c
+++ b/drivers/rtc/rtc-pcf2123.c
@@ -226,7 +226,8 @@ static int pcf2123_probe(struct spi_device *spi)
        u8 txbuf[2], rxbuf[2];
        int ret, i;
-        pdata = kzalloc(sizeof(struct pcf2123_plat_data), GFP_KERNEL);
+        pdata = devm_kzalloc(&spi->dev, sizeof(struct pcf2123_plat_data),
+                                GFP_KERNEL);
        if (!pdata)
                return -ENOMEM;
        spi->dev.platform_data = pdata;
@@ -265,6 +266,7 @@ static int pcf2123_probe(struct spi_device *spi)
        if (!(rxbuf[0] & 0x20)) {
                dev_err(&spi->dev, "chip not found\n");
+                ret = -ENODEV;
                goto kfree_exit;
        }
@@ -281,7 +283,7 @@ static int pcf2123_probe(struct spi_device *spi)
        pcf2123_delay_trec();
        /* Finalize the initialization */
-        rtc = rtc_device_register(pcf2123_driver.driver.name, &spi->dev,
+        rtc = devm_rtc_device_register(&spi->dev, pcf2123_driver.driver.name,
                        &pcf2123_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
@@ -314,7 +316,6 @@ sysfs_exit:
                device_remove_file(&spi->dev, &pdata->regs[i].attr);
 kfree_exit:
-        kfree(pdata);
        spi->dev.platform_data = NULL;
        return ret;
 }
@@ -325,15 +326,10 @@ static int pcf2123_remove(struct spi_device *spi)
        int i;
        if (pdata) {
-                struct rtc_device *rtc = pdata->rtc;
-                if (rtc)
-                        rtc_device_unregister(rtc);
                for (i = 0; i < 16; i++)
                        if (pdata->regs[i].name[0])
                                device_remove_file(&spi->dev,
                                                   &pdata->regs[i].attr);
-                kfree(pdata);
        }
        return 0;
diff --git a/drivers/rtc/rtc-pcf50633.c b/drivers/rtc/rtc-pcf50633.c
index e9f3135d305f..e6b6911c8e05 100644
--- a/drivers/rtc/rtc-pcf50633.c
+++ b/drivers/rtc/rtc-pcf50633.c
@@ -252,20 +252,17 @@ static int pcf50633_rtc_probe(struct platform_device *pdev)
 {
        struct pcf50633_rtc *rtc;
-        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
        if (!rtc)
                return -ENOMEM;
        rtc->pcf = dev_to_pcf50633(pdev->dev.parent);
        platform_set_drvdata(pdev, rtc);
-        rtc->rtc_dev = rtc_device_register("pcf50633-rtc", &pdev->dev,
+        rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, "pcf50633-rtc",
                                &pcf50633_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
+        if (IS_ERR(rtc->rtc_dev))
-                int ret =  PTR_ERR(rtc->rtc_dev);
+                return PTR_ERR(rtc->rtc_dev);
-                kfree(rtc);
-                return ret;
-        }
        pcf50633_register_irq(rtc->pcf, PCF50633_IRQ_ALARM,
                                        pcf50633_rtc_irq, rtc);
@@ -277,12 +274,8 @@ static int pcf50633_rtc_remove(struct platform_device *pdev)
        struct pcf50633_rtc *rtc;
        rtc = platform_get_drvdata(pdev);
        pcf50633_free_irq(rtc->pcf, PCF50633_IRQ_ALARM);
-        rtc_device_unregister(rtc->rtc_dev);
-        kfree(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-pcf8523.c b/drivers/rtc/rtc-pcf8523.c
index 889e3160e701..305c9515e5bb 100644
--- a/drivers/rtc/rtc-pcf8523.c
+++ b/drivers/rtc/rtc-pcf8523.c
@@ -307,7 +307,7 @@ static int pcf8523_probe(struct i2c_client *client,
        if (err < 0)
                return err;
-        pcf->rtc = rtc_device_register(DRIVER_NAME, &client->dev,
+        pcf->rtc = devm_rtc_device_register(&client->dev, DRIVER_NAME,
                                       &pcf8523_rtc_ops, THIS_MODULE);
        if (IS_ERR(pcf->rtc))
                return PTR_ERR(pcf->rtc);
@@ -319,10 +319,6 @@ static int pcf8523_probe(struct i2c_client *client,
 static int pcf8523_remove(struct i2c_client *client)
 {
-        struct pcf8523 *pcf = i2c_get_clientdata(client);
-        rtc_device_unregister(pcf->rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index f7daf18a112e..97b354a26a44 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -245,14 +245,13 @@ static int pcf8563_probe(struct i2c_client *client,
 {
        struct pcf8563 *pcf8563;
-        int err = 0;
        dev_dbg(&client->dev, "%s\n", __func__);
        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
                return -ENODEV;
-        pcf8563 = kzalloc(sizeof(struct pcf8563), GFP_KERNEL);
+        pcf8563 = devm_kzalloc(&client->dev, sizeof(struct pcf8563),
+                                GFP_KERNEL);
        if (!pcf8563)
                return -ENOMEM;
@@ -260,31 +259,18 @@ static int pcf8563_probe(struct i2c_client *client,
        i2c_set_clientdata(client, pcf8563);
-        pcf8563->rtc = rtc_device_register(pcf8563_driver.driver.name,
+        pcf8563->rtc = devm_rtc_device_register(&client->dev,
-                                &client->dev, &pcf8563_rtc_ops, THIS_MODULE);
+                                pcf8563_driver.driver.name,
+                                &pcf8563_rtc_ops, THIS_MODULE);
-        if (IS_ERR(pcf8563->rtc)) {
+        if (IS_ERR(pcf8563->rtc))
-                err = PTR_ERR(pcf8563->rtc);
+                return PTR_ERR(pcf8563->rtc);
-                goto exit_kfree;
-        }
        return 0;
-exit_kfree:
-        kfree(pcf8563);
-        return err;
 }
 static int pcf8563_remove(struct i2c_client *client)
 {
-        struct pcf8563 *pcf8563 = i2c_get_clientdata(client);
-        if (pcf8563->rtc)
-                rtc_device_unregister(pcf8563->rtc);
-        kfree(pcf8563);
        return 0;
 }
diff --git a/drivers/rtc/rtc-pcf8583.c b/drivers/rtc/rtc-pcf8583.c
index 5f97c61247d5..95886dcf4a39 100644
--- a/drivers/rtc/rtc-pcf8583.c
+++ b/drivers/rtc/rtc-pcf8583.c
@@ -268,39 +268,29 @@ static int pcf8583_probe(struct i2c_client *client,
                                const struct i2c_device_id *id)
 {
        struct pcf8583 *pcf8583;
-        int err;
        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
                return -ENODEV;
-        pcf8583 = kzalloc(sizeof(struct pcf8583), GFP_KERNEL);
+        pcf8583 = devm_kzalloc(&client->dev, sizeof(struct pcf8583),
+                                GFP_KERNEL);
        if (!pcf8583)
                return -ENOMEM;
        i2c_set_clientdata(client, pcf8583);
-        pcf8583->rtc = rtc_device_register(pcf8583_driver.driver.name,
+        pcf8583->rtc = devm_rtc_device_register(&client->dev,
-                        &client->dev, &pcf8583_rtc_ops, THIS_MODULE);
+                                pcf8583_driver.driver.name,
+                                &pcf8583_rtc_ops, THIS_MODULE);
-        if (IS_ERR(pcf8583->rtc)) {
+        if (IS_ERR(pcf8583->rtc))
-                err = PTR_ERR(pcf8583->rtc);
+                return PTR_ERR(pcf8583->rtc);
-                goto exit_kfree;
-        }
        return 0;
-exit_kfree:
-        kfree(pcf8583);
-        return err;
 }
 static int pcf8583_remove(struct i2c_client *client)
 {
-        struct pcf8583 *pcf8583 = i2c_get_clientdata(client);
-        if (pcf8583->rtc)
-                rtc_device_unregister(pcf8583->rtc);
-        kfree(pcf8583);
        return 0;
 }
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
index e96236ac2e78..ffa69e1c9245 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -110,7 +110,7 @@ static int rtc_proc_show(struct seq_file *seq, void *offset)
 static int rtc_proc_open(struct inode *inode, struct file *file)
 {
        int ret;
-        struct rtc_device *rtc = PDE(inode)->data;
+        struct rtc_device *rtc = PDE_DATA(inode);
        if (!try_module_get(THIS_MODULE))
                return -ENODEV;
diff --git a/drivers/rtc/rtc-ps3.c b/drivers/rtc/rtc-ps3.c
index 968133ce1ee8..4bb825bb5804 100644
--- a/drivers/rtc/rtc-ps3.c
+++ b/drivers/rtc/rtc-ps3.c
@@ -62,7 +62,7 @@ static int __init ps3_rtc_probe(struct platform_device *dev)
 {
        struct rtc_device *rtc;
-        rtc = rtc_device_register("rtc-ps3", &dev->dev, &ps3_rtc_ops,
+        rtc = devm_rtc_device_register(&dev->dev, "rtc-ps3", &ps3_rtc_ops,
                                  THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -73,7 +73,6 @@ static int __init ps3_rtc_probe(struct platform_device *dev)
 static int __exit ps3_rtc_remove(struct platform_device *dev)
 {
-        rtc_device_unregister(platform_get_drvdata(dev));
        return 0;
 }
@@ -85,18 +84,7 @@ static struct platform_driver ps3_rtc_driver = {
        .remove = __exit_p(ps3_rtc_remove),
 };
-static int __init ps3_rtc_init(void)
+module_platform_driver_probe(ps3_rtc_driver, ps3_rtc_probe);
-{
-        return platform_driver_probe(&ps3_rtc_driver, ps3_rtc_probe);
-}
-static void __exit ps3_rtc_fini(void)
-{
-        platform_driver_unregister(&ps3_rtc_driver);
-}
-module_init(ps3_rtc_init);
-module_exit(ps3_rtc_fini);
 MODULE_AUTHOR("Sony Corporation");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-puv3.c b/drivers/rtc/rtc-puv3.c
index 0407e13d4de4..72f437170d2e 100644
--- a/drivers/rtc/rtc-puv3.c
+++ b/drivers/rtc/rtc-puv3.c
@@ -207,14 +207,14 @@ static const struct rtc_class_ops puv3_rtcops = {
        .proc           = puv3_rtc_proc,
 };
-static void puv3_rtc_enable(struct platform_device *pdev, int en)
+static void puv3_rtc_enable(struct device *dev, int en)
 {
        if (!en) {
                writel(readl(RTC_RTSR) & ~RTC_RTSR_HZE, RTC_RTSR);
        } else {
                /* re-enable the device, and check it is ok */
                if ((readl(RTC_RTSR) & RTC_RTSR_HZE) == 0) {
-                        dev_info(&pdev->dev, "rtc disabled, re-enabling\n");
+                        dev_info(dev, "rtc disabled, re-enabling\n");
                        writel(readl(RTC_RTSR) | RTC_RTSR_HZE, RTC_RTSR);
                }
        }
@@ -276,7 +276,7 @@ static int puv3_rtc_probe(struct platform_device *pdev)
                goto err_nores;
        }
-        puv3_rtc_enable(pdev, 1);
+        puv3_rtc_enable(&pdev->dev, 1);
        /* register RTC and exit */
        rtc = rtc_device_register("pkunity", &pdev->dev, &puv3_rtcops,
@@ -296,44 +296,41 @@ static int puv3_rtc_probe(struct platform_device *pdev)
        return 0;
 err_nortc:
-        puv3_rtc_enable(pdev, 0);
+        puv3_rtc_enable(&pdev->dev, 0);
        release_resource(puv3_rtc_mem);
 err_nores:
        return ret;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int ticnt_save;
-static int puv3_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int puv3_rtc_suspend(struct device *dev)
 {
        /* save RTAR for anyone using periodic interrupts */
        ticnt_save = readl(RTC_RTAR);
-        puv3_rtc_enable(pdev, 0);
+        puv3_rtc_enable(dev, 0);
        return 0;
 }
-static int puv3_rtc_resume(struct platform_device *pdev)
+static int puv3_rtc_resume(struct device *dev)
 {
-        puv3_rtc_enable(pdev, 1);
+        puv3_rtc_enable(dev, 1);
        writel(ticnt_save, RTC_RTAR);
        return 0;
 }
-#else
-#define puv3_rtc_suspend NULL
-#define puv3_rtc_resume  NULL
 #endif
+static SIMPLE_DEV_PM_OPS(puv3_rtc_pm_ops, puv3_rtc_suspend, puv3_rtc_resume);
 static struct platform_driver puv3_rtc_driver = {
        .probe          = puv3_rtc_probe,
        .remove         = puv3_rtc_remove,
-        .suspend        = puv3_rtc_suspend,
-        .resume         = puv3_rtc_resume,
        .driver         = {
                .name   = "PKUnity-v3-RTC",
                .owner  = THIS_MODULE,
+                .pm     = &puv3_rtc_pm_ops,
        }
 };
diff --git a/drivers/rtc/rtc-pxa.c b/drivers/rtc/rtc-pxa.c
index 03c85ee719a7..ed037ae91c5f 100644
--- a/drivers/rtc/rtc-pxa.c
+++ b/drivers/rtc/rtc-pxa.c
@@ -416,7 +416,7 @@ static struct of_device_id pxa_rtc_dt_ids[] = {
 MODULE_DEVICE_TABLE(of, pxa_rtc_dt_ids);
 #endif
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int pxa_rtc_suspend(struct device *dev)
 {
        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
@@ -434,36 +434,20 @@ static int pxa_rtc_resume(struct device *dev)
                disable_irq_wake(pxa_rtc->irq_Alrm);
        return 0;
 }
-static const struct dev_pm_ops pxa_rtc_pm_ops = {
-        .suspend        = pxa_rtc_suspend,
-        .resume         = pxa_rtc_resume,
-};
 #endif
+static SIMPLE_DEV_PM_OPS(pxa_rtc_pm_ops, pxa_rtc_suspend, pxa_rtc_resume);
 static struct platform_driver pxa_rtc_driver = {
        .remove         = __exit_p(pxa_rtc_remove),
        .driver         = {
                .name   = "pxa-rtc",
                .of_match_table = of_match_ptr(pxa_rtc_dt_ids),
-#ifdef CONFIG_PM
                .pm     = &pxa_rtc_pm_ops,
-#endif
        },
 };
-static int __init pxa_rtc_init(void)
+module_platform_driver_probe(pxa_rtc_driver, pxa_rtc_probe);
-{
-        return platform_driver_probe(&pxa_rtc_driver, pxa_rtc_probe);
-}
-static void __exit pxa_rtc_exit(void)
-{
-        platform_driver_unregister(&pxa_rtc_driver);
-}
-module_init(pxa_rtc_init);
-module_exit(pxa_rtc_exit);
 MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");
 MODULE_DESCRIPTION("PXA27x/PXA3xx Realtime Clock Driver (RTC)");
diff --git a/drivers/rtc/rtc-r9701.c b/drivers/rtc/rtc-r9701.c
index 7726f4a4f2d0..feeedbd82000 100644
--- a/drivers/rtc/rtc-r9701.c
+++ b/drivers/rtc/rtc-r9701.c
@@ -154,21 +154,18 @@ static int r9701_probe(struct spi_device *spi)
                }
        }
-        rtc = rtc_device_register("r9701",
+        rtc = devm_rtc_device_register(&spi->dev, "r9701",
-                                &spi->dev, &r9701_rtc_ops, THIS_MODULE);
+                                &r9701_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
-        dev_set_drvdata(&spi->dev, rtc);
+        spi_set_drvdata(spi, rtc);
        return 0;
 }
 static int r9701_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rc5t583.c b/drivers/rtc/rtc-rc5t583.c
index eb3194d664a8..8eabcf51b35a 100644
--- a/drivers/rtc/rtc-rc5t583.c
+++ b/drivers/rtc/rtc-rc5t583.c
@@ -256,7 +256,7 @@ static int rc5t583_rtc_probe(struct platform_device *pdev)
        }
        device_init_wakeup(&pdev->dev, 1);
-        ricoh_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        ricoh_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                &rc5t583_rtc_ops, THIS_MODULE);
        if (IS_ERR(ricoh_rtc->rtc)) {
                ret = PTR_ERR(ricoh_rtc->rtc);
@@ -276,13 +276,10 @@ static int rc5t583_rtc_remove(struct platform_device *pdev)
        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(&pdev->dev);
        rc5t583_rtc_alarm_irq_enable(&rc5t583_rtc->rtc->dev, 0);
-        rtc_device_unregister(rc5t583_rtc->rtc);
        return 0;
 }
 #ifdef CONFIG_PM_SLEEP
 static int rc5t583_rtc_suspend(struct device *dev)
 {
        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
@@ -304,24 +301,18 @@ static int rc5t583_rtc_resume(struct device *dev)
        return regmap_write(rc5t583->regmap, RC5T583_RTC_CTL1,
                rc5t583_rtc->irqen);
 }
-static const struct dev_pm_ops rc5t583_rtc_pm_ops = {
-        .suspend        = rc5t583_rtc_suspend,
-        .resume         = rc5t583_rtc_resume,
-};
-#define DEV_PM_OPS     (&rc5t583_rtc_pm_ops)
-#else
-#define DEV_PM_OPS     NULL
 #endif
+static SIMPLE_DEV_PM_OPS(rc5t583_rtc_pm_ops, rc5t583_rtc_suspend,
+                        rc5t583_rtc_resume);
 static struct platform_driver rc5t583_rtc_driver = {
        .probe          = rc5t583_rtc_probe,
        .remove         = rc5t583_rtc_remove,
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = "rtc-rc5t583",
-                .pm     = DEV_PM_OPS,
+                .pm     = &rc5t583_rtc_pm_ops,
        },
 };
diff --git a/drivers/rtc/rtc-rp5c01.c b/drivers/rtc/rtc-rp5c01.c
index 359da6d020b9..873c689f01c3 100644
--- a/drivers/rtc/rtc-rp5c01.c
+++ b/drivers/rtc/rtc-rp5c01.c
@@ -230,15 +230,13 @@ static int __init rp5c01_rtc_probe(struct platform_device *dev)
        if (!res)
                return -ENODEV;
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
-        priv->regs = ioremap(res->start, resource_size(res));
+        priv->regs = devm_ioremap(&dev->dev, res->start, resource_size(res));
-        if (!priv->regs) {
+        if (!priv->regs)
-                error = -ENOMEM;
+                return -ENOMEM;
-                goto out_free_priv;
-        }
        sysfs_bin_attr_init(&priv->nvram_attr);
        priv->nvram_attr.attr.name = "nvram";
@@ -251,27 +249,22 @@ static int __init rp5c01_rtc_probe(struct platform_device *dev)
        platform_set_drvdata(dev, priv);
-        rtc = rtc_device_register("rtc-rp5c01", &dev->dev, &rp5c01_rtc_ops,
+        rtc = devm_rtc_device_register(&dev->dev, "rtc-rp5c01", &rp5c01_rtc_ops,
                                  THIS_MODULE);
        if (IS_ERR(rtc)) {
                error = PTR_ERR(rtc);
-                goto out_unmap;
+                goto out;
        }
        priv->rtc = rtc;
        error = sysfs_create_bin_file(&dev->dev.kobj, &priv->nvram_attr);
        if (error)
-                goto out_unregister;
+                goto out;
        return 0;
-out_unregister:
+out:
-        rtc_device_unregister(rtc);
-out_unmap:
        platform_set_drvdata(dev, NULL);
-        iounmap(priv->regs);
-out_free_priv:
-        kfree(priv);
        return error;
 }
@@ -280,9 +273,6 @@ static int __exit rp5c01_rtc_remove(struct platform_device *dev)
        struct rp5c01_priv *priv = platform_get_drvdata(dev);
        sysfs_remove_bin_file(&dev->dev.kobj, &priv->nvram_attr);
-        rtc_device_unregister(priv->rtc);
-        iounmap(priv->regs);
-        kfree(priv);
        return 0;
 }
@@ -294,18 +284,7 @@ static struct platform_driver rp5c01_rtc_driver = {
        .remove = __exit_p(rp5c01_rtc_remove),
 };
-static int __init rp5c01_rtc_init(void)
+module_platform_driver_probe(rp5c01_rtc_driver, rp5c01_rtc_probe);
-{
-        return platform_driver_probe(&rp5c01_rtc_driver, rp5c01_rtc_probe);
-}
-static void __exit rp5c01_rtc_fini(void)
-{
-        platform_driver_unregister(&rp5c01_rtc_driver);
-}
-module_init(rp5c01_rtc_init);
-module_exit(rp5c01_rtc_fini);
 MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-rs5c313.c b/drivers/rtc/rtc-rs5c313.c
index d98ea5b759c8..8089fc63e403 100644
--- a/drivers/rtc/rtc-rs5c313.c
+++ b/drivers/rtc/rtc-rs5c313.c
@@ -367,7 +367,7 @@ static const struct rtc_class_ops rs5c313_rtc_ops = {
 static int rs5c313_rtc_probe(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = rtc_device_register("rs5c313", &pdev->dev,
+        struct rtc_device *rtc = devm_rtc_device_register(&pdev->dev, "rs5c313",
                                &rs5c313_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
@@ -380,10 +380,6 @@ static int rs5c313_rtc_probe(struct platform_device *pdev)
 static int rs5c313_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata( pdev );
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
index 72ef10be8662..2c37df3586c7 100644
--- a/drivers/rtc/rtc-rs5c348.c
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -158,7 +158,8 @@ static int rs5c348_probe(struct spi_device *spi)
        struct rtc_device *rtc;
        struct rs5c348_plat_data *pdata;
-        pdata = kzalloc(sizeof(struct rs5c348_plat_data), GFP_KERNEL);
+        pdata = devm_kzalloc(&spi->dev, sizeof(struct rs5c348_plat_data),
+                                GFP_KERNEL);
        if (!pdata)
                return -ENOMEM;
        spi->dev.platform_data = pdata;
@@ -202,7 +203,7 @@ static int rs5c348_probe(struct spi_device *spi)
        if (ret & RS5C348_BIT_24H)
                pdata->rtc_24h = 1;
-        rtc = rtc_device_register(rs5c348_driver.driver.name, &spi->dev,
+        rtc = devm_rtc_device_register(&spi->dev, rs5c348_driver.driver.name,
                                  &rs5c348_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
@@ -214,18 +215,11 @@ static int rs5c348_probe(struct spi_device *spi)
        return 0;
 kfree_exit:
-        kfree(pdata);
        return ret;
 }
 static int rs5c348_remove(struct spi_device *spi)
 {
-        struct rs5c348_plat_data *pdata = spi->dev.platform_data;
-        struct rtc_device *rtc = pdata->rtc;
-        if (rtc)
-                rtc_device_unregister(rtc);
-        kfree(pdata);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index 581739f40097..ccf54f06396b 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -68,6 +68,7 @@
 enum rtc_type {
        rtc_undef = 0,
        rtc_r2025sd,
+        rtc_r2221tl,
        rtc_rs5c372a,
        rtc_rs5c372b,
        rtc_rv5c386,
@@ -76,6 +77,7 @@ enum rtc_type {
 static const struct i2c_device_id rs5c372_id[] = {
        { "r2025sd", rtc_r2025sd },
+        { "r2221tl", rtc_r2221tl },
        { "rs5c372a", rtc_rs5c372a },
        { "rs5c372b", rtc_rs5c372b },
        { "rv5c386", rtc_rv5c386 },
@@ -529,6 +531,7 @@ static int rs5c_oscillator_setup(struct rs5c372 *rs5c372)
                rs5c372->time24 = 1;
                break;
        case rtc_r2025sd:
+        case rtc_r2221tl:
        case rtc_rv5c386:
        case rtc_rv5c387a:
                buf[0] |= RV5C387_CTRL1_24;
@@ -579,7 +582,9 @@ static int rs5c372_probe(struct i2c_client *client,
                }
        }
-        if (!(rs5c372 = kzalloc(sizeof(struct rs5c372), GFP_KERNEL))) {
+        rs5c372 = devm_kzalloc(&client->dev, sizeof(struct rs5c372),
+                                GFP_KERNEL);
+        if (!rs5c372) {
                err = -ENOMEM;
                goto exit;
        }
@@ -594,7 +599,7 @@ static int rs5c372_probe(struct i2c_client *client,
        err = rs5c_get_regs(rs5c372);
        if (err < 0)
-                goto exit_kfree;
+                goto exit;
        /* clock may be set for am/pm or 24 hr time */
        switch (rs5c372->type) {
@@ -607,6 +612,7 @@ static int rs5c372_probe(struct i2c_client *client,
                        rs5c372->time24 = 1;
                break;
        case rtc_r2025sd:
+        case rtc_r2221tl:
        case rtc_rv5c386:
        case rtc_rv5c387a:
                if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24)
@@ -617,7 +623,7 @@ static int rs5c372_probe(struct i2c_client *client,
                break;
        default:
                dev_err(&client->dev, "unknown RTC type\n");
-                goto exit_kfree;
+                goto exit;
        }
        /* if the oscillator lost power and no other software (like
@@ -629,7 +635,7 @@ static int rs5c372_probe(struct i2c_client *client,
        err = rs5c_oscillator_setup(rs5c372);
        if (unlikely(err < 0)) {
                dev_err(&client->dev, "setup error\n");
-                goto exit_kfree;
+                goto exit;
        }
        if (rs5c372_get_datetime(client, &tm) < 0)
@@ -638,6 +644,7 @@ static int rs5c372_probe(struct i2c_client *client,
        dev_info(&client->dev, "%s found, %s, driver version " DRV_VERSION "\n",
                        ({ char *s; switch (rs5c372->type) {
                        case rtc_r2025sd:       s = "r2025sd"; break;
+                        case rtc_r2221tl:       s = "r2221tl"; break;
                        case rtc_rs5c372a:      s = "rs5c372a"; break;
                        case rtc_rs5c372b:      s = "rs5c372b"; break;
                        case rtc_rv5c386:       s = "rv5c386"; break;
@@ -648,38 +655,28 @@ static int rs5c372_probe(struct i2c_client *client,
                        );
        /* REVISIT use client->irq to register alarm irq ... */
+        rs5c372->rtc = devm_rtc_device_register(&client->dev,
-        rs5c372->rtc = rtc_device_register(rs5c372_driver.driver.name,
+                                        rs5c372_driver.driver.name,
-                                &client->dev, &rs5c372_rtc_ops, THIS_MODULE);
+                                        &rs5c372_rtc_ops, THIS_MODULE);
        if (IS_ERR(rs5c372->rtc)) {
                err = PTR_ERR(rs5c372->rtc);
-                goto exit_kfree;
+                goto exit;
        }
        err = rs5c_sysfs_register(&client->dev);
        if (err)
-                goto exit_devreg;
+                goto exit;
        return 0;
-exit_devreg:
-        rtc_device_unregister(rs5c372->rtc);
-exit_kfree:
-        kfree(rs5c372);
 exit:
        return err;
 }
 static int rs5c372_remove(struct i2c_client *client)
 {
-        struct rs5c372 *rs5c372 = i2c_get_clientdata(client);
-        rtc_device_unregister(rs5c372->rtc);
        rs5c_sysfs_unregister(&client->dev);
-        kfree(rs5c372);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rv3029c2.c b/drivers/rtc/rtc-rv3029c2.c
index f8ee8ad7825e..5032c24ec159 100644
--- a/drivers/rtc/rtc-rv3029c2.c
+++ b/drivers/rtc/rtc-rv3029c2.c
@@ -395,9 +395,8 @@ static int rv3029c2_probe(struct i2c_client *client,
        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_EMUL))
                return -ENODEV;
-        rtc = rtc_device_register(client->name,
+        rtc = devm_rtc_device_register(&client->dev, client->name,
-                                &client->dev, &rv3029c2_rtc_ops,
+                                        &rv3029c2_rtc_ops, THIS_MODULE);
-                                THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -407,23 +406,14 @@ static int rv3029c2_probe(struct i2c_client *client,
        rc = rv3029c2_i2c_get_sr(client, buf);
        if (rc < 0) {
                dev_err(&client->dev, "reading status failed\n");
-                goto exit_unregister;
+                return rc;
        }
        return 0;
-exit_unregister:
-        rtc_device_unregister(rtc);
-        return rc;
 }
 static int rv3029c2_remove(struct i2c_client *client)
 {
-        struct rtc_device *rtc = i2c_get_clientdata(client);
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rx4581.c b/drivers/rtc/rtc-rx4581.c
index 599ec73ec886..84eb08d65d30 100644
--- a/drivers/rtc/rtc-rx4581.c
+++ b/drivers/rtc/rtc-rx4581.c
@@ -273,20 +273,17 @@ static int rx4581_probe(struct spi_device *spi)
        if (res != 0)
                return res;
-        rtc = rtc_device_register("rx4581",
+        rtc = devm_rtc_device_register(&spi->dev, "rx4581",
-                                &spi->dev, &rx4581_rtc_ops, THIS_MODULE);
+                                &rx4581_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
-        dev_set_drvdata(&spi->dev, rtc);
+        spi_set_drvdata(spi, rtc);
        return 0;
 }
 static int rx4581_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rx8581.c b/drivers/rtc/rtc-rx8581.c
index b0c272658fa2..07f3037b18f4 100644
--- a/drivers/rtc/rtc-rx8581.c
+++ b/drivers/rtc/rtc-rx8581.c
@@ -240,8 +240,8 @@ static int rx8581_probe(struct i2c_client *client,
        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
-        rtc = rtc_device_register(rx8581_driver.driver.name,
+        rtc = devm_rtc_device_register(&client->dev, rx8581_driver.driver.name,
-                                &client->dev, &rx8581_rtc_ops, THIS_MODULE);
+                                        &rx8581_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -253,10 +253,6 @@ static int rx8581_probe(struct i2c_client *client,
 static int rx8581_remove(struct i2c_client *client)
 {
-        struct rtc_device *rtc = i2c_get_clientdata(client);
-        rtc_device_unregister(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-s35390a.c b/drivers/rtc/rtc-s35390a.c
index 8a092325188d..f40afdd0e5f5 100644
--- a/drivers/rtc/rtc-s35390a.c
+++ b/drivers/rtc/rtc-s35390a.c
@@ -338,7 +338,8 @@ static int s35390a_probe(struct i2c_client *client,
                goto exit;
        }
-        s35390a = kzalloc(sizeof(struct s35390a), GFP_KERNEL);
+        s35390a = devm_kzalloc(&client->dev, sizeof(struct s35390a),
+                                GFP_KERNEL);
        if (!s35390a) {
                err = -ENOMEM;
                goto exit;
@@ -386,8 +387,9 @@ static int s35390a_probe(struct i2c_client *client,
        device_set_wakeup_capable(&client->dev, 1);
-        s35390a->rtc = rtc_device_register(s35390a_driver.driver.name,
+        s35390a->rtc = devm_rtc_device_register(&client->dev,
-                                &client->dev, &s35390a_rtc_ops, THIS_MODULE);
+                                        s35390a_driver.driver.name,
+                                        &s35390a_rtc_ops, THIS_MODULE);
        if (IS_ERR(s35390a->rtc)) {
                err = PTR_ERR(s35390a->rtc);
@@ -399,7 +401,6 @@ exit_dummy:
        for (i = 1; i < 8; ++i)
                if (s35390a->client[i])
                        i2c_unregister_device(s35390a->client[i]);
-        kfree(s35390a);
 exit:
        return err;
@@ -408,15 +409,12 @@ exit:
 static int s35390a_remove(struct i2c_client *client)
 {
        unsigned int i;
        struct s35390a *s35390a = i2c_get_clientdata(client);
        for (i = 1; i < 8; ++i)
                if (s35390a->client[i])
                        i2c_unregister_device(s35390a->client[i]);
-        rtc_device_unregister(s35390a->rtc);
-        kfree(s35390a);
        return 0;
 }
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index fb994e9ddc15..14040b22888d 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -29,9 +29,8 @@
 #include <linux/uaccess.h>
 #include <linux/io.h>
-#include <mach/hardware.h>
 #include <asm/irq.h>
-#include <plat/regs-rtc.h>
+#include "rtc-s3c.h"
 enum s3c_cpu_type {
        TYPE_S3C2410,
@@ -51,7 +50,6 @@ static struct clk *rtc_clk;
 static void __iomem *s3c_rtc_base;
 static int s3c_rtc_alarmno = NO_IRQ;
 static int s3c_rtc_tickno  = NO_IRQ;
-static bool wake_en;
 static enum s3c_cpu_type s3c_rtc_cpu_type;
 static DEFINE_SPINLOCK(s3c_rtc_pie_lock);
@@ -423,13 +421,11 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
 static int s3c_rtc_remove(struct platform_device *dev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(dev);
        platform_set_drvdata(dev, NULL);
-        rtc_device_unregister(rtc);
        s3c_rtc_setaie(&dev->dev, 0);
+        clk_unprepare(rtc_clk);
        rtc_clk = NULL;
        return 0;
@@ -498,7 +494,7 @@ static int s3c_rtc_probe(struct platform_device *pdev)
                return ret;
        }
-        clk_enable(rtc_clk);
+        clk_prepare_enable(rtc_clk);
        /* check to see if everything is setup correctly */
@@ -511,7 +507,7 @@ static int s3c_rtc_probe(struct platform_device *pdev)
        /* register RTC and exit */
-        rtc = rtc_device_register("s3c", &pdev->dev, &s3c_rtcops,
+        rtc = devm_rtc_device_register(&pdev->dev, "s3c", &s3c_rtcops,
                                  THIS_MODULE);
        if (IS_ERR(rtc)) {
@@ -574,23 +570,24 @@ static int s3c_rtc_probe(struct platform_device *pdev)
 err_alarm_irq:
        platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(rtc);
 err_nortc:
        s3c_rtc_enable(pdev, 0);
-        clk_disable(rtc_clk);
+        clk_disable_unprepare(rtc_clk);
        return ret;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 /* RTC Power management control */
 static int ticnt_save, ticnt_en_save;
+static bool wake_en;
-static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int s3c_rtc_suspend(struct device *dev)
 {
+        struct platform_device *pdev = to_platform_device(dev);
        clk_enable(rtc_clk);
        /* save TICNT for anyone using periodic interrupts */
        ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT);
@@ -600,19 +597,20 @@ static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state)
        }
        s3c_rtc_enable(pdev, 0);
-        if (device_may_wakeup(&pdev->dev) && !wake_en) {
+        if (device_may_wakeup(dev) && !wake_en) {
                if (enable_irq_wake(s3c_rtc_alarmno) == 0)
                        wake_en = true;
                else
-                        dev_err(&pdev->dev, "enable_irq_wake failed\n");
+                        dev_err(dev, "enable_irq_wake failed\n");
        }
        clk_disable(rtc_clk);
        return 0;
 }
-static int s3c_rtc_resume(struct platform_device *pdev)
+static int s3c_rtc_resume(struct device *dev)
 {
+        struct platform_device *pdev = to_platform_device(dev);
        unsigned int tmp;
        clk_enable(rtc_clk);
@@ -623,7 +621,7 @@ static int s3c_rtc_resume(struct platform_device *pdev)
                writew(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
        }
-        if (device_may_wakeup(&pdev->dev) && wake_en) {
+        if (device_may_wakeup(dev) && wake_en) {
                disable_irq_wake(s3c_rtc_alarmno);
                wake_en = false;
        }
@@ -631,11 +629,10 @@ static int s3c_rtc_resume(struct platform_device *pdev)
        return 0;
 }
-#else
-#define s3c_rtc_suspend NULL
-#define s3c_rtc_resume  NULL
 #endif
+static SIMPLE_DEV_PM_OPS(s3c_rtc_pm_ops, s3c_rtc_suspend, s3c_rtc_resume);
 #ifdef CONFIG_OF
 static struct s3c_rtc_drv_data s3c_rtc_drv_data_array[] = {
        [TYPE_S3C2410] = { TYPE_S3C2410 },
@@ -685,12 +682,11 @@ MODULE_DEVICE_TABLE(platform, s3c_rtc_driver_ids);
 static struct platform_driver s3c_rtc_driver = {
        .probe          = s3c_rtc_probe,
        .remove         = s3c_rtc_remove,
-        .suspend        = s3c_rtc_suspend,
-        .resume         = s3c_rtc_resume,
        .id_table       = s3c_rtc_driver_ids,
        .driver         = {
                .name   = "s3c-rtc",
                .owner  = THIS_MODULE,
+                .pm     = &s3c_rtc_pm_ops,
                .of_match_table = of_match_ptr(s3c_rtc_dt_match),
        },
 };
diff --git a/drivers/rtc/rtc-s3c.h b/drivers/rtc/rtc-s3c.h
new file mode 100644
index 000000000000..004b61a8343f
--- /dev/null
+++ b/drivers/rtc/rtc-s3c.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2003 Simtec Electronics <linux@simtec.co.uk>
+ *                    http://www.simtec.co.uk/products/SWLINUX/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * S3C2410 Internal RTC register definition
+*/
+#ifndef __ASM_ARCH_REGS_RTC_H
+#define __ASM_ARCH_REGS_RTC_H __FILE__
+#define S3C2410_RTCREG(x) (x)
+#define S3C2410_INTP            S3C2410_RTCREG(0x30)
+#define S3C2410_INTP_ALM        (1 << 1)
+#define S3C2410_INTP_TIC        (1 << 0)
+#define S3C2410_RTCCON          S3C2410_RTCREG(0x40)
+#define S3C2410_RTCCON_RTCEN    (1 << 0)
+#define S3C2410_RTCCON_CNTSEL   (1 << 2)
+#define S3C2410_RTCCON_CLKRST   (1 << 3)
+#define S3C2443_RTCCON_TICSEL   (1 << 4)
+#define S3C64XX_RTCCON_TICEN    (1 << 8)
+#define S3C2410_TICNT           S3C2410_RTCREG(0x44)
+#define S3C2410_TICNT_ENABLE    (1 << 7)
+/* S3C2443: tick count is 15 bit wide
+ * TICNT[6:0] contains upper 7 bits
+ * TICNT1[7:0] contains lower 8 bits
+ */
+#define S3C2443_TICNT_PART(x)   ((x & 0x7f00) >> 8)
+#define S3C2443_TICNT1          S3C2410_RTCREG(0x4C)
+#define S3C2443_TICNT1_PART(x)  (x & 0xff)
+/* S3C2416: tick count is 32 bit wide
+ * TICNT[6:0] contains bits [14:8]
+ * TICNT1[7:0] contains lower 8 bits
+ * TICNT2[16:0] contains upper 17 bits
+ */
+#define S3C2416_TICNT2          S3C2410_RTCREG(0x48)
+#define S3C2416_TICNT2_PART(x)  ((x & 0xffff8000) >> 15)
+#define S3C2410_RTCALM          S3C2410_RTCREG(0x50)
+#define S3C2410_RTCALM_ALMEN    (1 << 6)
+#define S3C2410_RTCALM_YEAREN   (1 << 5)
+#define S3C2410_RTCALM_MONEN    (1 << 4)
+#define S3C2410_RTCALM_DAYEN    (1 << 3)
+#define S3C2410_RTCALM_HOUREN   (1 << 2)
+#define S3C2410_RTCALM_MINEN    (1 << 1)
+#define S3C2410_RTCALM_SECEN    (1 << 0)
+#define S3C2410_ALMSEC          S3C2410_RTCREG(0x54)
+#define S3C2410_ALMMIN          S3C2410_RTCREG(0x58)
+#define S3C2410_ALMHOUR         S3C2410_RTCREG(0x5c)
+#define S3C2410_ALMDATE         S3C2410_RTCREG(0x60)
+#define S3C2410_ALMMON          S3C2410_RTCREG(0x64)
+#define S3C2410_ALMYEAR         S3C2410_RTCREG(0x68)
+#define S3C2410_RTCSEC          S3C2410_RTCREG(0x70)
+#define S3C2410_RTCMIN          S3C2410_RTCREG(0x74)
+#define S3C2410_RTCHOUR         S3C2410_RTCREG(0x78)
+#define S3C2410_RTCDATE         S3C2410_RTCREG(0x7c)
+#define S3C2410_RTCMON          S3C2410_RTCREG(0x84)
+#define S3C2410_RTCYEAR         S3C2410_RTCREG(0x88)
+#endif /* __ASM_ARCH_REGS_RTC_H */
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 5ec5036df0bc..00605601dbf7 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -234,14 +234,13 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
        if (irq_1hz < 0 || irq_alarm < 0)
                return -ENODEV;
-        info = kzalloc(sizeof(struct sa1100_rtc), GFP_KERNEL);
+        info = devm_kzalloc(&pdev->dev, sizeof(struct sa1100_rtc), GFP_KERNEL);
        if (!info)
                return -ENOMEM;
-        info->clk = clk_get(&pdev->dev, NULL);
+        info->clk = devm_clk_get(&pdev->dev, NULL);
        if (IS_ERR(info->clk)) {
                dev_err(&pdev->dev, "failed to find rtc clock source\n");
-                ret = PTR_ERR(info->clk);
+                return PTR_ERR(info->clk);
-                goto err_clk;
        }
        info->irq_1hz = irq_1hz;
        info->irq_alarm = irq_alarm;
@@ -268,8 +267,8 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &sa1100_rtc_ops,
-                THIS_MODULE);
+                                        THIS_MODULE);
        if (IS_ERR(rtc)) {
                ret = PTR_ERR(rtc);
@@ -306,9 +305,6 @@ err_dev:
        clk_disable_unprepare(info->clk);
 err_enable_clk:
        platform_set_drvdata(pdev, NULL);
-        clk_put(info->clk);
-err_clk:
-        kfree(info);
        return ret;
 }
@@ -317,17 +313,14 @@ static int sa1100_rtc_remove(struct platform_device *pdev)
        struct sa1100_rtc *info = platform_get_drvdata(pdev);
        if (info) {
-                rtc_device_unregister(info->rtc);
                clk_disable_unprepare(info->clk);
-                clk_put(info->clk);
                platform_set_drvdata(pdev, NULL);
-                kfree(info);
        }
        return 0;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int sa1100_rtc_suspend(struct device *dev)
 {
        struct sa1100_rtc *info = dev_get_drvdata(dev);
@@ -343,13 +336,11 @@ static int sa1100_rtc_resume(struct device *dev)
                disable_irq_wake(info->irq_alarm);
        return 0;
 }
-static const struct dev_pm_ops sa1100_rtc_pm_ops = {
-        .suspend        = sa1100_rtc_suspend,
-        .resume         = sa1100_rtc_resume,
-};
 #endif
+static SIMPLE_DEV_PM_OPS(sa1100_rtc_pm_ops, sa1100_rtc_suspend,
+                        sa1100_rtc_resume);
 #ifdef CONFIG_OF
 static struct of_device_id sa1100_rtc_dt_ids[] = {
        { .compatible = "mrvl,sa1100-rtc", },
@@ -364,9 +355,7 @@ static struct platform_driver sa1100_rtc_driver = {
        .remove         = sa1100_rtc_remove,
        .driver         = {
                .name   = "sa1100-rtc",
-#ifdef CONFIG_PM
                .pm     = &sa1100_rtc_pm_ops,
-#endif
                .of_match_table = of_match_ptr(sa1100_rtc_dt_ids),
        },
 };
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index e55a7635ae5f..8d5bd2e36776 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -790,6 +790,7 @@ static void sh_rtc_set_irq_wake(struct device *dev, int enabled)
        }
 }
+#ifdef CONFIG_PM_SLEEP
 static int sh_rtc_suspend(struct device *dev)
 {
        if (device_may_wakeup(dev))
@@ -805,33 +806,20 @@ static int sh_rtc_resume(struct device *dev)
        return 0;
 }
+#endif
-static const struct dev_pm_ops sh_rtc_dev_pm_ops = {
+static SIMPLE_DEV_PM_OPS(sh_rtc_pm_ops, sh_rtc_suspend, sh_rtc_resume);
-        .suspend = sh_rtc_suspend,
-        .resume = sh_rtc_resume,
-};
 static struct platform_driver sh_rtc_platform_driver = {
        .driver         = {
                .name   = DRV_NAME,
                .owner  = THIS_MODULE,
-                .pm     = &sh_rtc_dev_pm_ops,
+                .pm     = &sh_rtc_pm_ops,
        },
        .remove         = __exit_p(sh_rtc_remove),
 };
-static int __init sh_rtc_init(void)
+module_platform_driver_probe(sh_rtc_platform_driver, sh_rtc_probe);
-{
-        return platform_driver_probe(&sh_rtc_platform_driver, sh_rtc_probe);
-}
-static void __exit sh_rtc_exit(void)
-{
-        platform_driver_unregister(&sh_rtc_platform_driver);
-}
-module_init(sh_rtc_init);
-module_exit(sh_rtc_exit);
 MODULE_DESCRIPTION("SuperH on-chip RTC driver");
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-snvs.c b/drivers/rtc/rtc-snvs.c
index f7d90703db5e..b04f09a1df2a 100644
--- a/drivers/rtc/rtc-snvs.c
+++ b/drivers/rtc/rtc-snvs.c
@@ -283,7 +283,7 @@ static int snvs_rtc_probe(struct platform_device *pdev)
                return ret;
        }
-        data->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        data->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                        &snvs_rtc_ops, THIS_MODULE);
        if (IS_ERR(data->rtc)) {
                ret = PTR_ERR(data->rtc);
@@ -296,10 +296,6 @@ static int snvs_rtc_probe(struct platform_device *pdev)
 static int snvs_rtc_remove(struct platform_device *pdev)
 {
-        struct snvs_rtc_data *data = platform_get_drvdata(pdev);
-        rtc_device_unregister(data->rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
index a18c3192ed40..574359c48f65 100644
--- a/drivers/rtc/rtc-spear.c
+++ b/drivers/rtc/rtc-spear.c
@@ -400,8 +400,8 @@ static int spear_rtc_probe(struct platform_device *pdev)
        spin_lock_init(&config->lock);
        platform_set_drvdata(pdev, config);
-        config->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        config->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                        &spear_rtc_ops, THIS_MODULE);
+                                        &spear_rtc_ops, THIS_MODULE);
        if (IS_ERR(config->rtc)) {
                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
                                PTR_ERR(config->rtc));
@@ -427,7 +427,6 @@ static int spear_rtc_remove(struct platform_device *pdev)
 {
        struct spear_rtc_config *config = platform_get_drvdata(pdev);
-        rtc_device_unregister(config->rtc);
        spear_rtc_disable_interrupt(config);
        clk_disable_unprepare(config->clk);
        device_init_wakeup(&pdev->dev, 0);
@@ -435,10 +434,10 @@ static int spear_rtc_remove(struct platform_device *pdev)
        return 0;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
+static int spear_rtc_suspend(struct device *dev)
-static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
+        struct platform_device *pdev = to_platform_device(dev);
        struct spear_rtc_config *config = platform_get_drvdata(pdev);
        int irq;
@@ -454,8 +453,9 @@ static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
        return 0;
 }
-static int spear_rtc_resume(struct platform_device *pdev)
+static int spear_rtc_resume(struct device *dev)
 {
+        struct platform_device *pdev = to_platform_device(dev);
        struct spear_rtc_config *config = platform_get_drvdata(pdev);
        int irq;
@@ -473,12 +473,10 @@ static int spear_rtc_resume(struct platform_device *pdev)
        return 0;
 }
-#else
-#define spear_rtc_suspend       NULL
-#define spear_rtc_resume        NULL
 #endif
+static SIMPLE_DEV_PM_OPS(spear_rtc_pm_ops, spear_rtc_suspend, spear_rtc_resume);
 static void spear_rtc_shutdown(struct platform_device *pdev)
 {
        struct spear_rtc_config *config = platform_get_drvdata(pdev);
@@ -498,11 +496,10 @@ MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
 static struct platform_driver spear_rtc_driver = {
        .probe = spear_rtc_probe,
        .remove = spear_rtc_remove,
-        .suspend = spear_rtc_suspend,
-        .resume = spear_rtc_resume,
        .shutdown = spear_rtc_shutdown,
        .driver = {
                .name = "rtc-spear",
+                .pm = &spear_rtc_pm_ops,
                .of_match_table = of_match_ptr(spear_rtc_id_table),
        },
 };
diff --git a/drivers/rtc/rtc-starfire.c b/drivers/rtc/rtc-starfire.c
index 5be98bfd7ed3..987b5ec0ae56 100644
--- a/drivers/rtc/rtc-starfire.c
+++ b/drivers/rtc/rtc-starfire.c
@@ -39,8 +39,10 @@ static const struct rtc_class_ops starfire_rtc_ops = {
 static int __init starfire_rtc_probe(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = rtc_device_register("starfire", &pdev->dev,
+        struct rtc_device *rtc;
-                                     &starfire_rtc_ops, THIS_MODULE);
+        rtc = devm_rtc_device_register(&pdev->dev, "starfire",
+                                &starfire_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -51,10 +53,6 @@ static int __init starfire_rtc_probe(struct platform_device *pdev)
 static int __exit starfire_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc);
        return 0;
 }
@@ -66,15 +64,4 @@ static struct platform_driver starfire_rtc_driver = {
        .remove         = __exit_p(starfire_rtc_remove),
 };
-static int __init starfire_rtc_init(void)
+module_platform_driver_probe(starfire_rtc_driver, starfire_rtc_probe);
-{
-        return platform_driver_probe(&starfire_rtc_driver, starfire_rtc_probe);
-}
-static void __exit starfire_rtc_exit(void)
-{
-        platform_driver_unregister(&starfire_rtc_driver);
-}
-module_init(starfire_rtc_init);
-module_exit(starfire_rtc_exit);
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
index 7e4a6f65cb91..af5e97e3f272 100644
--- a/drivers/rtc/rtc-stk17ta8.c
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -336,14 +336,13 @@ static int stk17ta8_rtc_probe(struct platform_device *pdev)
                }
        }
-        pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                  &stk17ta8_rtc_ops, THIS_MODULE);
        if (IS_ERR(pdata->rtc))
                return PTR_ERR(pdata->rtc);
        ret = sysfs_create_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
-        if (ret)
-                rtc_device_unregister(pdata->rtc);
        return ret;
 }
@@ -352,7 +351,6 @@ static int stk17ta8_rtc_remove(struct platform_device *pdev)
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        sysfs_remove_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
-        rtc_device_unregister(pdata->rtc);
        if (pdata->irq > 0)
                writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
        return 0;
diff --git a/drivers/rtc/rtc-stmp3xxx.c b/drivers/rtc/rtc-stmp3xxx.c
index 98f0d3c30738..483ce086990b 100644
--- a/drivers/rtc/rtc-stmp3xxx.c
+++ b/drivers/rtc/rtc-stmp3xxx.c
@@ -30,8 +30,6 @@
 #include <linux/stmp_device.h>
 #include <linux/stmp3xxx_rtc_wdt.h>
-#include <mach/common.h>
 #define STMP3XXX_RTC_CTRL                       0x0
 #define STMP3XXX_RTC_CTRL_SET                   0x4
 #define STMP3XXX_RTC_CTRL_CLR                   0x8
@@ -227,11 +225,7 @@ static int stmp3xxx_rtc_remove(struct platform_device *pdev)
        writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
                        rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
-        free_irq(rtc_data->irq_alarm, &pdev->dev);
-        rtc_device_unregister(rtc_data->rtc);
        platform_set_drvdata(pdev, NULL);
-        iounmap(rtc_data->io);
-        kfree(rtc_data);
        return 0;
 }
@@ -242,22 +236,20 @@ static int stmp3xxx_rtc_probe(struct platform_device *pdev)
        struct resource *r;
        int err;
-        rtc_data = kzalloc(sizeof *rtc_data, GFP_KERNEL);
+        rtc_data = devm_kzalloc(&pdev->dev, sizeof(*rtc_data), GFP_KERNEL);
        if (!rtc_data)
                return -ENOMEM;
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!r) {
                dev_err(&pdev->dev, "failed to get resource\n");
-                err = -ENXIO;
+                return -ENXIO;
-                goto out_free;
        }
-        rtc_data->io = ioremap(r->start, resource_size(r));
+        rtc_data->io = devm_ioremap(&pdev->dev, r->start, resource_size(r));
        if (!rtc_data->io) {
                dev_err(&pdev->dev, "ioremap failed\n");
-                err = -EIO;
+                return -EIO;
-                goto out_free;
        }
        rtc_data->irq_alarm = platform_get_irq(pdev, 0);
@@ -265,13 +257,12 @@ static int stmp3xxx_rtc_probe(struct platform_device *pdev)
        if (!(readl(STMP3XXX_RTC_STAT + rtc_data->io) &
                        STMP3XXX_RTC_STAT_RTC_PRESENT)) {
                dev_err(&pdev->dev, "no device onboard\n");
-                err = -ENODEV;
+                return -ENODEV;
-                goto out_remap;
        }
        platform_set_drvdata(pdev, rtc_data);
-        mxs_reset_block(rtc_data->io);
+        stmp_reset_block(rtc_data->io);
        writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
                        STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN |
                        STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
@@ -281,56 +272,51 @@ static int stmp3xxx_rtc_probe(struct platform_device *pdev)
                        STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
                        rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
-        rtc_data->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc_data->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                &stmp3xxx_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc_data->rtc)) {
                err = PTR_ERR(rtc_data->rtc);
-                goto out_remap;
+                goto out;
        }
-        err = request_irq(rtc_data->irq_alarm, stmp3xxx_rtc_interrupt, 0,
+        err = devm_request_irq(&pdev->dev, rtc_data->irq_alarm,
-                        "RTC alarm", &pdev->dev);
+                        stmp3xxx_rtc_interrupt, 0, "RTC alarm", &pdev->dev);
        if (err) {
                dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
                        rtc_data->irq_alarm);
-                goto out_irq_alarm;
+                goto out;
        }
        stmp3xxx_wdt_register(pdev);
        return 0;
-out_irq_alarm:
+out:
-        rtc_device_unregister(rtc_data->rtc);
-out_remap:
        platform_set_drvdata(pdev, NULL);
-        iounmap(rtc_data->io);
-out_free:
-        kfree(rtc_data);
        return err;
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
-static int stmp3xxx_rtc_suspend(struct platform_device *dev, pm_message_t state)
+static int stmp3xxx_rtc_suspend(struct device *dev)
 {
        return 0;
 }
-static int stmp3xxx_rtc_resume(struct platform_device *dev)
+static int stmp3xxx_rtc_resume(struct device *dev)
 {
-        struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(dev);
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
-        mxs_reset_block(rtc_data->io);
+        stmp_reset_block(rtc_data->io);
        writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
                        STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN |
                        STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
                        rtc_data->io + STMP3XXX_RTC_PERSISTENT0_CLR);
        return 0;
 }
-#else
-#define stmp3xxx_rtc_suspend    NULL
-#define stmp3xxx_rtc_resume     NULL
 #endif
+static SIMPLE_DEV_PM_OPS(stmp3xxx_rtc_pm_ops, stmp3xxx_rtc_suspend,
+                        stmp3xxx_rtc_resume);
 static const struct of_device_id rtc_dt_ids[] = {
        { .compatible = "fsl,stmp3xxx-rtc", },
        { /* sentinel */ }
@@ -340,11 +326,10 @@ MODULE_DEVICE_TABLE(of, rtc_dt_ids);
 static struct platform_driver stmp3xxx_rtcdrv = {
        .probe          = stmp3xxx_rtc_probe,
        .remove         = stmp3xxx_rtc_remove,
-        .suspend        = stmp3xxx_rtc_suspend,
-        .resume         = stmp3xxx_rtc_resume,
        .driver         = {
                .name   = "stmp3xxx-rtc",
                .owner  = THIS_MODULE,
+                .pm     = &stmp3xxx_rtc_pm_ops,
                .of_match_table = of_match_ptr(rtc_dt_ids),
        },
 };
diff --git a/drivers/rtc/rtc-sun4v.c b/drivers/rtc/rtc-sun4v.c
index 59b5c2dcb58c..ce42e5fa9e09 100644
--- a/drivers/rtc/rtc-sun4v.c
+++ b/drivers/rtc/rtc-sun4v.c
@@ -81,8 +81,10 @@ static const struct rtc_class_ops sun4v_rtc_ops = {
 static int __init sun4v_rtc_probe(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = rtc_device_register("sun4v", &pdev->dev,
+        struct rtc_device *rtc;
-                                     &sun4v_rtc_ops, THIS_MODULE);
+        rtc = devm_rtc_device_register(&pdev->dev, "sun4v",
+                                &sun4v_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -92,9 +94,6 @@ static int __init sun4v_rtc_probe(struct platform_device *pdev)
 static int __exit sun4v_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc);
        return 0;
 }
@@ -106,18 +105,7 @@ static struct platform_driver sun4v_rtc_driver = {
        .remove         = __exit_p(sun4v_rtc_remove),
 };
-static int __init sun4v_rtc_init(void)
+module_platform_driver_probe(sun4v_rtc_driver, sun4v_rtc_probe);
-{
-        return platform_driver_probe(&sun4v_rtc_driver, sun4v_rtc_probe);
-}
-static void __exit sun4v_rtc_exit(void)
-{
-        platform_driver_unregister(&sun4v_rtc_driver);
-}
-module_init(sun4v_rtc_init);
-module_exit(sun4v_rtc_exit);
 MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
 MODULE_DESCRIPTION("SUN4V RTC driver");
diff --git a/drivers/rtc/rtc-tegra.c b/drivers/rtc/rtc-tegra.c
index 7c033756d6b5..a34315d25478 100644
--- a/drivers/rtc/rtc-tegra.c
+++ b/drivers/rtc/rtc-tegra.c
@@ -26,6 +26,7 @@
 #include <linux/delay.h>
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
+#include <linux/pm.h>
 /* set to 1 = busy every eight 32kHz clocks during copy of sec+msec to AHB */
 #define TEGRA_RTC_REG_BUSY                      0x004
@@ -309,7 +310,7 @@ static const struct of_device_id tegra_rtc_dt_match[] = {
 };
 MODULE_DEVICE_TABLE(of, tegra_rtc_dt_match);
-static int tegra_rtc_probe(struct platform_device *pdev)
+static int __init tegra_rtc_probe(struct platform_device *pdev)
 {
        struct tegra_rtc_info *info;
        struct resource *res;
@@ -348,53 +349,35 @@ static int tegra_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        info->rtc_dev = rtc_device_register(
+        info->rtc_dev = devm_rtc_device_register(&pdev->dev,
-                pdev->name, &pdev->dev, &tegra_rtc_ops, THIS_MODULE);
+                                dev_name(&pdev->dev), &tegra_rtc_ops,
+                                THIS_MODULE);
        if (IS_ERR(info->rtc_dev)) {
                ret = PTR_ERR(info->rtc_dev);
-                info->rtc_dev = NULL;
+                dev_err(&pdev->dev, "Unable to register device (err=%d).\n",
-                dev_err(&pdev->dev,
-                        "Unable to register device (err=%d).\n",
                        ret);
                return ret;
        }
        ret = devm_request_irq(&pdev->dev, info->tegra_rtc_irq,
                        tegra_rtc_irq_handler, IRQF_TRIGGER_HIGH,
-                        "rtc alarm", &pdev->dev);
+                        dev_name(&pdev->dev), &pdev->dev);
        if (ret) {
                dev_err(&pdev->dev,
                        "Unable to request interrupt for device (err=%d).\n",
                        ret);
-                goto err_dev_unreg;
+                return ret;
        }
        dev_notice(&pdev->dev, "Tegra internal Real Time Clock\n");
        return 0;
-err_dev_unreg:
-        rtc_device_unregister(info->rtc_dev);
-        return ret;
 }
-static int tegra_rtc_remove(struct platform_device *pdev)
+#ifdef CONFIG_PM_SLEEP
+static int tegra_rtc_suspend(struct device *dev)
 {
-        struct tegra_rtc_info *info = platform_get_drvdata(pdev);
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
-        rtc_device_unregister(info->rtc_dev);
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
-#ifdef CONFIG_PM
-static int tegra_rtc_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct device *dev = &pdev->dev;
-        struct tegra_rtc_info *info = platform_get_drvdata(pdev);
        tegra_rtc_wait_while_busy(dev);
@@ -416,10 +399,9 @@ static int tegra_rtc_suspend(struct platform_device *pdev, pm_message_t state)
        return 0;
 }
-static int tegra_rtc_resume(struct platform_device *pdev)
+static int tegra_rtc_resume(struct device *dev)
 {
-        struct device *dev = &pdev->dev;
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
-        struct tegra_rtc_info *info = platform_get_drvdata(pdev);
        dev_vdbg(dev, "Resume (device_may_wakeup=%d)\n",
                device_may_wakeup(dev));
@@ -431,6 +413,8 @@ static int tegra_rtc_resume(struct platform_device *pdev)
 }
 #endif
+static SIMPLE_DEV_PM_OPS(tegra_rtc_pm_ops, tegra_rtc_suspend, tegra_rtc_resume);
 static void tegra_rtc_shutdown(struct platform_device *pdev)
 {
        dev_vdbg(&pdev->dev, "disabling interrupts.\n");
@@ -439,30 +423,16 @@ static void tegra_rtc_shutdown(struct platform_device *pdev)
 MODULE_ALIAS("platform:tegra_rtc");
 static struct platform_driver tegra_rtc_driver = {
-        .remove         = tegra_rtc_remove,
        .shutdown       = tegra_rtc_shutdown,
        .driver         = {
                .name   = "tegra_rtc",
                .owner  = THIS_MODULE,
                .of_match_table = tegra_rtc_dt_match,
+                .pm     = &tegra_rtc_pm_ops,
        },
-#ifdef CONFIG_PM
-        .suspend        = tegra_rtc_suspend,
-        .resume         = tegra_rtc_resume,
-#endif
 };
-static int __init tegra_rtc_init(void)
+module_platform_driver_probe(tegra_rtc_driver, tegra_rtc_probe);
-{
-        return platform_driver_probe(&tegra_rtc_driver, tegra_rtc_probe);
-}
-module_init(tegra_rtc_init);
-static void __exit tegra_rtc_exit(void)
-{
-        platform_driver_unregister(&tegra_rtc_driver);
-}
-module_exit(tegra_rtc_exit);
 MODULE_AUTHOR("Jon Mayo <jmayo@nvidia.com>");
 MODULE_DESCRIPTION("driver for Tegra internal RTC");
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index b92e0f6383e6..7746e65b93f2 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -99,8 +99,10 @@ static DEVICE_ATTR(irq, S_IRUGO | S_IWUSR, test_irq_show, test_irq_store);
 static int test_probe(struct platform_device *plat_dev)
 {
        int err;
-        struct rtc_device *rtc = rtc_device_register("test", &plat_dev->dev,
+        struct rtc_device *rtc;
-                                                &test_rtc_ops, THIS_MODULE);
+        rtc = devm_rtc_device_register(&plat_dev->dev, "test",
+                                &test_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                err = PTR_ERR(rtc);
                return err;
@@ -115,15 +117,11 @@ static int test_probe(struct platform_device *plat_dev)
        return 0;
 err:
-        rtc_device_unregister(rtc);
        return err;
 }
 static int test_remove(struct platform_device *plat_dev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
-        rtc_device_unregister(rtc);
        device_remove_file(&plat_dev->dev, &dev_attr_irq);
        return 0;
diff --git a/drivers/rtc/rtc-tile.c b/drivers/rtc/rtc-tile.c
index 62db4841078b..249b6531f119 100644
--- a/drivers/rtc/rtc-tile.c
+++ b/drivers/rtc/rtc-tile.c
@@ -80,8 +80,8 @@ static int tile_rtc_probe(struct platform_device *dev)
 {
        struct rtc_device *rtc;
-        rtc = rtc_device_register("tile",
+        rtc = devm_rtc_device_register(&dev->dev, "tile",
-                                  &dev->dev, &tile_rtc_ops, THIS_MODULE);
+                                &tile_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -96,11 +96,6 @@ static int tile_rtc_probe(struct platform_device *dev)
 */
 static int tile_rtc_remove(struct platform_device *dev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(dev);
-        if (rtc)
-                rtc_device_unregister(rtc);
        platform_set_drvdata(dev, NULL);
        return 0;
diff --git a/drivers/rtc/rtc-tps6586x.c b/drivers/rtc/rtc-tps6586x.c
index aab4e8c93622..459c2ffc95a6 100644
--- a/drivers/rtc/rtc-tps6586x.c
+++ b/drivers/rtc/rtc-tps6586x.c
@@ -274,7 +274,7 @@ static int tps6586x_rtc_probe(struct platform_device *pdev)
        }
        platform_set_drvdata(pdev, rtc);
-        rtc->rtc = rtc_device_register(dev_name(&pdev->dev), &pdev->dev,
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, dev_name(&pdev->dev),
                                       &tps6586x_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
                ret = PTR_ERR(rtc->rtc);
@@ -289,15 +289,12 @@ static int tps6586x_rtc_probe(struct platform_device *pdev)
        if (ret < 0) {
                dev_err(&pdev->dev, "request IRQ(%d) failed with ret %d\n",
                                rtc->irq, ret);
-                goto fail_req_irq;
+                goto fail_rtc_register;
        }
        disable_irq(rtc->irq);
        device_set_wakeup_capable(&pdev->dev, 1);
        return 0;
-fail_req_irq:
-        rtc_device_unregister(rtc->rtc);
 fail_rtc_register:
        tps6586x_update(tps_dev, RTC_CTRL, 0,
                RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
@@ -306,12 +303,10 @@ fail_rtc_register:
 static int tps6586x_rtc_remove(struct platform_device *pdev)
 {
-        struct tps6586x_rtc *rtc = platform_get_drvdata(pdev);
        struct device *tps_dev = to_tps6586x_dev(&pdev->dev);
        tps6586x_update(tps_dev, RTC_CTRL, 0,
                RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
-        rtc_device_unregister(rtc->rtc);
        return 0;
 }
@@ -335,9 +330,8 @@ static int tps6586x_rtc_resume(struct device *dev)
 }
 #endif
-static const struct dev_pm_ops tps6586x_pm_ops = {
+static SIMPLE_DEV_PM_OPS(tps6586x_pm_ops, tps6586x_rtc_suspend,
-        SET_SYSTEM_SLEEP_PM_OPS(tps6586x_rtc_suspend, tps6586x_rtc_resume)
+                        tps6586x_rtc_resume);
-};
 static struct platform_driver tps6586x_rtc_driver = {
        .driver = {
diff --git a/drivers/rtc/rtc-tps65910.c b/drivers/rtc/rtc-tps65910.c
index 8bd8115329b5..a9caf043b0ce 100644
--- a/drivers/rtc/rtc-tps65910.c
+++ b/drivers/rtc/rtc-tps65910.c
@@ -263,7 +263,7 @@ static int tps65910_rtc_probe(struct platform_device *pdev)
        if (irq <= 0) {
                dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
                        irq);
-                return ret;
+                return -ENXIO;
        }
        ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
@@ -276,7 +276,7 @@ static int tps65910_rtc_probe(struct platform_device *pdev)
        tps_rtc->irq = irq;
        device_set_wakeup_capable(&pdev->dev, 1);
-        tps_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        tps_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                &tps65910_rtc_ops, THIS_MODULE);
        if (IS_ERR(tps_rtc->rtc)) {
                ret = PTR_ERR(tps_rtc->rtc);
@@ -295,12 +295,8 @@ static int tps65910_rtc_probe(struct platform_device *pdev)
 */
 static int tps65910_rtc_remove(struct platform_device *pdev)
 {
-        /* leave rtc running, but disable irqs */
-        struct tps65910_rtc *tps_rtc = platform_get_drvdata(pdev);
        tps65910_rtc_alarm_irq_enable(&pdev->dev, 0);
-        rtc_device_unregister(tps_rtc->rtc);
        return 0;
 }
@@ -324,9 +320,8 @@ static int tps65910_rtc_resume(struct device *dev)
 }
 #endif
-static const struct dev_pm_ops tps65910_rtc_pm_ops = {
+static SIMPLE_DEV_PM_OPS(tps65910_rtc_pm_ops, tps65910_rtc_suspend,
-        SET_SYSTEM_SLEEP_PM_OPS(tps65910_rtc_suspend, tps65910_rtc_resume)
+                        tps65910_rtc_resume);
-};
 static struct platform_driver tps65910_rtc_driver = {
        .probe          = tps65910_rtc_probe,
diff --git a/drivers/rtc/rtc-tps80031.c b/drivers/rtc/rtc-tps80031.c
index 9aaf8aaebae9..72662eafb938 100644
--- a/drivers/rtc/rtc-tps80031.c
+++ b/drivers/rtc/rtc-tps80031.c
@@ -277,7 +277,7 @@ static int tps80031_rtc_probe(struct platform_device *pdev)
                return ret;
        }
-        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                               &tps80031_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
                ret = PTR_ERR(rtc->rtc);
@@ -292,7 +292,6 @@ static int tps80031_rtc_probe(struct platform_device *pdev)
        if (ret < 0) {
                dev_err(&pdev->dev, "request IRQ:%d failed, err = %d\n",
                         rtc->irq, ret);
-                rtc_device_unregister(rtc->rtc);
                return ret;
        }
        device_set_wakeup_capable(&pdev->dev, 1);
@@ -301,9 +300,6 @@ static int tps80031_rtc_probe(struct platform_device *pdev)
 static int tps80031_rtc_remove(struct platform_device *pdev)
 {
-        struct tps80031_rtc *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc->rtc);
        return 0;
 }
@@ -327,9 +323,8 @@ static int tps80031_rtc_resume(struct device *dev)
 };
 #endif
-static const struct dev_pm_ops tps80031_pm_ops = {
+static SIMPLE_DEV_PM_OPS(tps80031_pm_ops, tps80031_rtc_suspend,
-        SET_SYSTEM_SLEEP_PM_OPS(tps80031_rtc_suspend, tps80031_rtc_resume)
+                        tps80031_rtc_resume);
-};
 static struct platform_driver tps80031_rtc_driver = {
        .driver = {
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index 8bc6c80b184c..8751a5240c99 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -566,11 +566,10 @@ static void twl_rtc_shutdown(struct platform_device *pdev)
        mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
 }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static unsigned char irqstat;
-static int twl_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int twl_rtc_suspend(struct device *dev)
 {
        irqstat = rtc_irq_bits;
@@ -578,17 +577,15 @@ static int twl_rtc_suspend(struct platform_device *pdev, pm_message_t state)
        return 0;
 }
-static int twl_rtc_resume(struct platform_device *pdev)
+static int twl_rtc_resume(struct device *dev)
 {
        set_rtc_irq_bit(irqstat);
        return 0;
 }
-#else
-#define twl_rtc_suspend NULL
-#define twl_rtc_resume  NULL
 #endif
+static SIMPLE_DEV_PM_OPS(twl_rtc_pm_ops, twl_rtc_suspend, twl_rtc_resume);
 #ifdef CONFIG_OF
 static const struct of_device_id twl_rtc_of_match[] = {
        {.compatible = "ti,twl4030-rtc", },
@@ -603,11 +600,10 @@ static struct platform_driver twl4030rtc_driver = {
        .probe          = twl_rtc_probe,
        .remove         = twl_rtc_remove,
        .shutdown       = twl_rtc_shutdown,
-        .suspend        = twl_rtc_suspend,
-        .resume         = twl_rtc_resume,
        .driver         = {
                .owner          = THIS_MODULE,
                .name           = "twl_rtc",
+                .pm             = &twl_rtc_pm_ops,
                .of_match_table = of_match_ptr(twl_rtc_of_match),
        },
 };
diff --git a/drivers/rtc/rtc-tx4939.c b/drivers/rtc/rtc-tx4939.c
index a12bfac49d36..f9a0677e4e3b 100644
--- a/drivers/rtc/rtc-tx4939.c
+++ b/drivers/rtc/rtc-tx4939.c
@@ -268,14 +268,13 @@ static int __init tx4939_rtc_probe(struct platform_device *pdev)
        if (devm_request_irq(&pdev->dev, irq, tx4939_rtc_interrupt,
                             0, pdev->name, &pdev->dev) < 0)
                return -EBUSY;
-        rtc = rtc_device_register(pdev->name, &pdev->dev,
+        rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                  &tx4939_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
        pdata->rtc = rtc;
        ret = sysfs_create_bin_file(&pdev->dev.kobj, &tx4939_rtc_nvram_attr);
-        if (ret)
-                rtc_device_unregister(rtc);
        return ret;
 }
@@ -284,7 +283,6 @@ static int __exit tx4939_rtc_remove(struct platform_device *pdev)
        struct tx4939rtc_plat_data *pdata = platform_get_drvdata(pdev);
        sysfs_remove_bin_file(&pdev->dev.kobj, &tx4939_rtc_nvram_attr);
-        rtc_device_unregister(pdata->rtc);
        spin_lock_irq(&pdata->lock);
        tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
        spin_unlock_irq(&pdata->lock);
@@ -299,18 +297,7 @@ static struct platform_driver tx4939_rtc_driver = {
        },
 };
-static int __init tx4939rtc_init(void)
+module_platform_driver_probe(tx4939_rtc_driver, tx4939_rtc_probe);
-{
-        return platform_driver_probe(&tx4939_rtc_driver, tx4939_rtc_probe);
-}
-static void __exit tx4939rtc_exit(void)
-{
-        platform_driver_unregister(&tx4939_rtc_driver);
-}
-module_init(tx4939rtc_init);
-module_exit(tx4939rtc_exit);
 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
 MODULE_DESCRIPTION("TX4939 internal RTC driver");
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
index bca5d677bc85..6e0cba8f47d5 100644
--- a/drivers/rtc/rtc-v3020.c
+++ b/drivers/rtc/rtc-v3020.c
@@ -309,7 +309,7 @@ static int rtc_probe(struct platform_device *pdev)
        int i;
        int temp;
-        chip = kzalloc(sizeof *chip, GFP_KERNEL);
+        chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL);
        if (!chip)
                return -ENOMEM;
@@ -353,8 +353,8 @@ static int rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, chip);
-        chip->rtc = rtc_device_register("v3020",
+        chip->rtc = devm_rtc_device_register(&pdev->dev, "v3020",
-                                &pdev->dev, &v3020_rtc_ops, THIS_MODULE);
+                                        &v3020_rtc_ops, THIS_MODULE);
        if (IS_ERR(chip->rtc)) {
                retval = PTR_ERR(chip->rtc);
                goto err_io;
@@ -365,21 +365,14 @@ static int rtc_probe(struct platform_device *pdev)
 err_io:
        chip->ops->unmap_io(chip);
 err_chip:
-        kfree(chip);
        return retval;
 }
 static int rtc_remove(struct platform_device *dev)
 {
        struct v3020 *chip = platform_get_drvdata(dev);
-        struct rtc_device *rtc = chip->rtc;
-        if (rtc)
-                rtc_device_unregister(rtc);
        chip->ops->unmap_io(chip);
-        kfree(chip);
        return 0;
 }
diff --git a/drivers/rtc/rtc-vt8500.c b/drivers/rtc/rtc-vt8500.c
index a000bc0a8bff..d89efee6d29e 100644
--- a/drivers/rtc/rtc-vt8500.c
+++ b/drivers/rtc/rtc-vt8500.c
@@ -252,7 +252,7 @@ static int vt8500_rtc_probe(struct platform_device *pdev)
        writel(VT8500_RTC_CR_ENABLE,
               vt8500_rtc->regbase + VT8500_RTC_CR);
-        vt8500_rtc->rtc = rtc_device_register("vt8500-rtc", &pdev->dev,
+        vt8500_rtc->rtc = devm_rtc_device_register(&pdev->dev, "vt8500-rtc",
                                              &vt8500_rtc_ops, THIS_MODULE);
        if (IS_ERR(vt8500_rtc->rtc)) {
                ret = PTR_ERR(vt8500_rtc->rtc);
@@ -266,13 +266,11 @@ static int vt8500_rtc_probe(struct platform_device *pdev)
        if (ret < 0) {
                dev_err(&pdev->dev, "can't get irq %i, err %d\n",
                        vt8500_rtc->irq_alarm, ret);
-                goto err_unreg;
+                goto err_return;
        }
        return 0;
-err_unreg:
-        rtc_device_unregister(vt8500_rtc->rtc);
 err_return:
        return ret;
 }
@@ -281,8 +279,6 @@ static int vt8500_rtc_remove(struct platform_device *pdev)
 {
        struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(vt8500_rtc->rtc);
        /* Disable alarm matching */
        writel(0, vt8500_rtc->regbase + VT8500_RTC_IS);
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
index 2f0ac7b30a0c..8d65b94e5a7e 100644
--- a/drivers/rtc/rtc-wm831x.c
+++ b/drivers/rtc/rtc-wm831x.c
@@ -436,7 +436,7 @@ static int wm831x_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        wm831x_rtc->rtc = rtc_device_register("wm831x", &pdev->dev,
+        wm831x_rtc->rtc = devm_rtc_device_register(&pdev->dev, "wm831x",
                                              &wm831x_rtc_ops, THIS_MODULE);
        if (IS_ERR(wm831x_rtc->rtc)) {
                ret = PTR_ERR(wm831x_rtc->rtc);
@@ -462,10 +462,6 @@ err:
 static int wm831x_rtc_remove(struct platform_device *pdev)
 {
-        struct wm831x_rtc *wm831x_rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(wm831x_rtc->rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-wm8350.c b/drivers/rtc/rtc-wm8350.c
index 8ad86ae0d30f..fa247deb9cf4 100644
--- a/drivers/rtc/rtc-wm8350.c
+++ b/drivers/rtc/rtc-wm8350.c
@@ -339,7 +339,7 @@ static const struct rtc_class_ops wm8350_rtc_ops = {
        .alarm_irq_enable = wm8350_rtc_alarm_irq_enable,
 };
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int wm8350_rtc_suspend(struct device *dev)
 {
        struct platform_device *pdev = to_platform_device(dev);
@@ -375,10 +375,6 @@ static int wm8350_rtc_resume(struct device *dev)
        return 0;
 }
-#else
-#define wm8350_rtc_suspend NULL
-#define wm8350_rtc_resume NULL
 #endif
 static int wm8350_rtc_probe(struct platform_device *pdev)
@@ -439,8 +435,8 @@ static int wm8350_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        wm_rtc->rtc = rtc_device_register("wm8350", &pdev->dev,
+        wm_rtc->rtc = devm_rtc_device_register(&pdev->dev, "wm8350",
-                                          &wm8350_rtc_ops, THIS_MODULE);
+                                        &wm8350_rtc_ops, THIS_MODULE);
        if (IS_ERR(wm_rtc->rtc)) {
                ret = PTR_ERR(wm_rtc->rtc);
                dev_err(&pdev->dev, "failed to register RTC: %d\n", ret);
@@ -462,20 +458,15 @@ static int wm8350_rtc_probe(struct platform_device *pdev)
 static int wm8350_rtc_remove(struct platform_device *pdev)
 {
        struct wm8350 *wm8350 = platform_get_drvdata(pdev);
-        struct wm8350_rtc *wm_rtc = &wm8350->rtc;
        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);
-        rtc_device_unregister(wm_rtc->rtc);
        return 0;
 }
-static struct dev_pm_ops wm8350_rtc_pm_ops = {
+static SIMPLE_DEV_PM_OPS(wm8350_rtc_pm_ops, wm8350_rtc_suspend,
-        .suspend = wm8350_rtc_suspend,
+                        wm8350_rtc_resume);
-        .resume = wm8350_rtc_resume,
-};
 static struct platform_driver wm8350_rtc_driver = {
        .probe = wm8350_rtc_probe,
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index f36e59c6bc01..fa9b0679fb60 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -630,8 +630,8 @@ static int x1205_probe(struct i2c_client *client,
        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
-        rtc = rtc_device_register(x1205_driver.driver.name, &client->dev,
+        rtc = devm_rtc_device_register(&client->dev, x1205_driver.driver.name,
-                                &x1205_rtc_ops, THIS_MODULE);
+                                        &x1205_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
@@ -653,21 +653,13 @@ static int x1205_probe(struct i2c_client *client,
        err = x1205_sysfs_register(&client->dev);
        if (err)
-                goto exit_devreg;
+                return err;
        return 0;
-exit_devreg:
-        rtc_device_unregister(rtc);
-        return err;
 }
 static int x1205_remove(struct i2c_client *client)
 {
-        struct rtc_device *rtc = i2c_get_clientdata(client);
-        rtc_device_unregister(rtc);
        x1205_sysfs_unregister(&client->dev);
        return 0;
 }