98 files changed, 1216 insertions, 933 deletions
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index b9838130a7b0..9e3498bf302b 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -313,6 +313,15 @@ config RTC_DRV_PALMAS
          This driver can also be built as a module. If so, the module
          will be called rtc-palma.
+config RTC_DRV_PCF2127
+        tristate "NXP PCF2127"
+        help
+          If you say yes here you get support for the NXP PCF2127/29 RTC
+          chips.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-pcf2127.
 config RTC_DRV_PCF8523
        tristate "NXP PCF8523"
        help
@@ -1233,6 +1242,13 @@ config RTC_DRV_SNVS
           This driver can also be built as a module, if so, the module
           will be called "rtc-snvs".
+config RTC_DRV_SIRFSOC
+        tristate "SiRFSOC RTC"
+        depends on ARCH_SIRF
+        help
+          Say "yes" here to support the real time clock on SiRF SOC chips.
+          This driver can also be built as a module called rtc-sirfsoc.
 comment "HID Sensor RTC drivers"
 config RTC_DRV_HID_SENSOR_TIME
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index c33f86f1a69b..d3b4488f48f2 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -83,6 +83,7 @@ obj-$(CONFIG_RTC_DRV_NUC900)	+= rtc-nuc900.o
 obj-$(CONFIG_RTC_DRV_OMAP)      += rtc-omap.o
 obj-$(CONFIG_RTC_DRV_PALMAS)    += rtc-palmas.o
 obj-$(CONFIG_RTC_DRV_PCAP)      += rtc-pcap.o
+obj-$(CONFIG_RTC_DRV_PCF2127)   += rtc-pcf2127.o
 obj-$(CONFIG_RTC_DRV_PCF8523)   += rtc-pcf8523.o
 obj-$(CONFIG_RTC_DRV_PCF8563)   += rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)   += rtc-pcf8583.o
@@ -128,3 +129,4 @@ obj-$(CONFIG_RTC_DRV_VT8500)	+= rtc-vt8500.o
 obj-$(CONFIG_RTC_DRV_WM831X)    += rtc-wm831x.o
 obj-$(CONFIG_RTC_DRV_WM8350)    += rtc-wm8350.o
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
+obj-$(CONFIG_RTC_DRV_SIRFSOC)   += rtc-sirfsoc.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 66385402d20e..02426812bebc 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -38,7 +38,7 @@ static void rtc_device_release(struct device *dev)
 int rtc_hctosys_ret = -ENODEV;
 #endif
-#if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
+#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
 /*
 * On suspend(), measure the delta between one RTC and the
 * system's wall clock; restore it on resume().
@@ -47,7 +47,7 @@ int rtc_hctosys_ret = -ENODEV;
 static struct timespec old_rtc, old_system, old_delta;
-static int rtc_suspend(struct device *dev, pm_message_t mesg)
+static int rtc_suspend(struct device *dev)
 {
        struct rtc_device       *rtc = to_rtc_device(dev);
        struct rtc_time         tm;
@@ -135,9 +135,10 @@ static int rtc_resume(struct device *dev)
        return 0;
 }
+static SIMPLE_DEV_PM_OPS(rtc_class_dev_pm_ops, rtc_suspend, rtc_resume);
+#define RTC_CLASS_DEV_PM_OPS    (&rtc_class_dev_pm_ops)
 #else
-#define rtc_suspend     NULL
+#define RTC_CLASS_DEV_PM_OPS    NULL
-#define rtc_resume      NULL
 #endif
@@ -336,8 +337,7 @@ static int __init rtc_init(void)
                pr_err("couldn't create class\n");
                return PTR_ERR(rtc_class);
        }
-        rtc_class->suspend = rtc_suspend;
+        rtc_class->pm = RTC_CLASS_DEV_PM_OPS;
-        rtc_class->resume = rtc_resume;
        rtc_dev_init();
        rtc_sysfs_init(rtc_class);
        return 0;
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 42bd57da239d..72c5cdbe0791 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -109,9 +109,9 @@ int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
                                err = rtc->ops->set_time(rtc->dev.parent,
                                                &new);
                }
-        }
+        } else {
-        else
                err = -EINVAL;
+        }
        mutex_unlock(&rtc->ops_lock);
        /* A timer might have just expired */
@@ -367,14 +367,14 @@ int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
        err = mutex_lock_interruptible(&rtc->ops_lock);
        if (err)
                return err;
-        if (rtc->aie_timer.enabled) {
+        if (rtc->aie_timer.enabled)
                rtc_timer_remove(rtc, &rtc->aie_timer);
-        }
        rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
        rtc->aie_timer.period = ktime_set(0, 0);
-        if (alarm->enabled) {
+        if (alarm->enabled)
                err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
-        }
        mutex_unlock(&rtc->ops_lock);
        return err;
 }
@@ -698,9 +698,9 @@ retry:
        spin_lock_irqsave(&rtc->irq_task_lock, flags);
        if (rtc->irq_task != NULL && task == NULL)
                err = -EBUSY;
-        if (rtc->irq_task != task)
+        else if (rtc->irq_task != task)
                err = -EACCES;
-        if (!err) {
+        else {
                if (rtc_update_hrtimer(rtc, enabled) < 0) {
                        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
                        cpu_relax();
@@ -734,9 +734,9 @@ retry:
        spin_lock_irqsave(&rtc->irq_task_lock, flags);
        if (rtc->irq_task != NULL && task == NULL)
                err = -EBUSY;
-        if (rtc->irq_task != task)
+        else if (rtc->irq_task != task)
                err = -EACCES;
-        if (!err) {
+        else {
                rtc->irq_freq = freq;
                if (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) {
                        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
@@ -891,7 +891,7 @@ again:
 *
 * Kernel interface to initializing an rtc_timer.
 */
-void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data)
+void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data)
 {
        timerqueue_init(&timer->node);
        timer->enabled = 0;
@@ -907,7 +907,7 @@ void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data)
 *
 * Kernel interface to set an rtc_timer
 */
-int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
+int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
                        ktime_t expires, ktime_t period)
 {
        int ret = 0;
@@ -930,7 +930,7 @@ int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
 *
 * Kernel interface to cancel an rtc_timer
 */
-int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer)
+int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer)
 {
        int ret = 0;
        mutex_lock(&rtc->ops_lock);
diff --git a/drivers/rtc/rtc-88pm80x.c b/drivers/rtc/rtc-88pm80x.c
index f3742f364eb8..354c937a5866 100644
--- a/drivers/rtc/rtc-88pm80x.c
+++ b/drivers/rtc/rtc-88pm80x.c
@@ -345,7 +345,6 @@ out:
 static int pm80x_rtc_remove(struct platform_device *pdev)
 {
        struct pm80x_rtc_info *info = platform_get_drvdata(pdev);
-        platform_set_drvdata(pdev, NULL);
        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 0f2b91bfee37..4e30c85728e5 100644
--- a/drivers/rtc/rtc-88pm860x.c
+++ b/drivers/rtc/rtc-88pm860x.c
@@ -418,7 +418,6 @@ static int pm860x_rtc_remove(struct platform_device *pdev)
        pm860x_set_bits(info->i2c, PM8607_MEAS_EN2, MEAS2_VRTC, 0);
 #endif  /* VRTC_CALIBRATION */
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ab3100.c b/drivers/rtc/rtc-ab3100.c
index 47a4f2c4d30e..ff435343ba9f 100644
--- a/drivers/rtc/rtc-ab3100.c
+++ b/drivers/rtc/rtc-ab3100.c
@@ -240,18 +240,11 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int __exit ab3100_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 static struct platform_driver ab3100_rtc_driver = {
        .driver = {
                .name = "ab3100-rtc",
                .owner = THIS_MODULE,
        },
-        .remove  = __exit_p(ab3100_rtc_remove),
 };
 module_platform_driver_probe(ab3100_rtc_driver, ab3100_rtc_probe);
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index 63cfa314a39f..727e2f5d14d9 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -35,6 +35,10 @@
 #define AB8500_RTC_FORCE_BKUP_REG       0x0D
 #define AB8500_RTC_CALIB_REG            0x0E
 #define AB8500_RTC_SWITCH_STAT_REG      0x0F
+#define AB8540_RTC_ALRM_SEC             0x22
+#define AB8540_RTC_ALRM_MIN_LOW_REG     0x23
+#define AB8540_RTC_ALRM_MIN_MID_REG     0x24
+#define AB8540_RTC_ALRM_MIN_HI_REG      0x25
 /* RtcReadRequest bits */
 #define RTC_READ_REQUEST                0x01
@@ -58,6 +62,11 @@ static const u8 ab8500_rtc_alarm_regs[] = {
        AB8500_RTC_ALRM_MIN_LOW_REG
 };
+static const u8 ab8540_rtc_alarm_regs[] = {
+        AB8540_RTC_ALRM_MIN_HI_REG, AB8540_RTC_ALRM_MIN_MID_REG,
+        AB8540_RTC_ALRM_MIN_LOW_REG, AB8540_RTC_ALRM_SEC
+};
 /* Calculate the seconds from 1970 to 01-01-2000 00:00:00 */
 static unsigned long get_elapsed_seconds(int year)
 {
@@ -267,6 +276,42 @@ static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
        return ab8500_rtc_irq_enable(dev, alarm->enabled);
 }
+static int ab8540_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        int retval, i;
+        unsigned char buf[ARRAY_SIZE(ab8540_rtc_alarm_regs)];
+        unsigned long mins, secs = 0;
+        if (alarm->time.tm_year < (AB8500_RTC_EPOCH - 1900)) {
+                dev_dbg(dev, "year should be equal to or greater than %d\n",
+                                AB8500_RTC_EPOCH);
+                return -EINVAL;
+        }
+        /* Get the number of seconds since 1970 */
+        rtc_tm_to_time(&alarm->time, &secs);
+        /*
+         * Convert it to the number of seconds since 01-01-2000 00:00:00
+         */
+        secs -= get_elapsed_seconds(AB8500_RTC_EPOCH);
+        mins = secs / 60;
+        buf[3] = secs % 60;
+        buf[2] = mins & 0xFF;
+        buf[1] = (mins >> 8) & 0xFF;
+        buf[0] = (mins >> 16) & 0xFF;
+        /* Set the alarm time */
+        for (i = 0; i < ARRAY_SIZE(ab8540_rtc_alarm_regs); i++) {
+                retval = abx500_set_register_interruptible(dev, AB8500_RTC,
+                        ab8540_rtc_alarm_regs[i], buf[i]);
+                if (retval < 0)
+                        return retval;
+        }
+        return ab8500_rtc_irq_enable(dev, alarm->enabled);
+}
 static int ab8500_rtc_set_calibration(struct device *dev, int calibration)
 {
@@ -389,8 +434,22 @@ static const struct rtc_class_ops ab8500_rtc_ops = {
        .alarm_irq_enable       = ab8500_rtc_irq_enable,
 };
+static const struct rtc_class_ops ab8540_rtc_ops = {
+        .read_time              = ab8500_rtc_read_time,
+        .set_time               = ab8500_rtc_set_time,
+        .read_alarm             = ab8500_rtc_read_alarm,
+        .set_alarm              = ab8540_rtc_set_alarm,
+        .alarm_irq_enable       = ab8500_rtc_irq_enable,
+};
+static struct platform_device_id ab85xx_rtc_ids[] = {
+        { "ab8500-rtc", (kernel_ulong_t)&ab8500_rtc_ops, },
+        { "ab8540-rtc", (kernel_ulong_t)&ab8540_rtc_ops, },
+};
 static int ab8500_rtc_probe(struct platform_device *pdev)
 {
+        const struct platform_device_id *platid = platform_get_device_id(pdev);
        int err;
        struct rtc_device *rtc;
        u8 rtc_ctrl;
@@ -423,7 +482,8 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, true);
        rtc = devm_rtc_device_register(&pdev->dev, "ab8500-rtc",
-                                        &ab8500_rtc_ops, THIS_MODULE);
+                                (struct rtc_class_ops *)platid->driver_data,
+                                THIS_MODULE);
        if (IS_ERR(rtc)) {
                dev_err(&pdev->dev, "Registration failed\n");
                err = PTR_ERR(rtc);
@@ -451,8 +511,6 @@ static int ab8500_rtc_remove(struct platform_device *pdev)
 {
        ab8500_sysfs_rtc_unregister(&pdev->dev);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
@@ -463,6 +521,7 @@ static struct platform_driver ab8500_rtc_driver = {
        },
        .probe  = ab8500_rtc_probe,
        .remove = ab8500_rtc_remove,
+        .id_table = ab85xx_rtc_ids,
 };
 module_platform_driver(ab8500_rtc_driver);
diff --git a/drivers/rtc/rtc-at32ap700x.c b/drivers/rtc/rtc-at32ap700x.c
index f47fbb5eee8b..3161ab5263ed 100644
--- a/drivers/rtc/rtc-at32ap700x.c
+++ b/drivers/rtc/rtc-at32ap700x.c
@@ -141,7 +141,7 @@ static int at32_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
        spin_lock_irq(&rtc->lock);
-        if(enabled) {
+        if (enabled) {
                if (rtc_readl(rtc, VAL) > rtc->alarm_time) {
                        ret = -EINVAL;
                        goto out;
@@ -212,23 +212,20 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!regs) {
                dev_dbg(&pdev->dev, "no mmio resource defined\n");
-                ret = -ENXIO;
+                return -ENXIO;
-                goto out;
        }
        irq = platform_get_irq(pdev, 0);
        if (irq <= 0) {
                dev_dbg(&pdev->dev, "could not get irq\n");
-                ret = -ENXIO;
+                return -ENXIO;
-                goto out;
        }
        rtc->irq = irq;
        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");
-                goto out;
+                return -ENOMEM;
        }
        spin_lock_init(&rtc->lock);
@@ -249,7 +246,7 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
                                "rtc", rtc);
        if (ret) {
                dev_dbg(&pdev->dev, "could not request irq %d\n", irq);
-                goto out;
+                return ret;
        }
        platform_set_drvdata(pdev, rtc);
@@ -258,8 +255,7 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
                                &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);
+                return PTR_ERR(rtc->rtc);
-                goto out;
        }
        device_init_wakeup(&pdev->dev, 1);
@@ -268,18 +264,12 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
                        (unsigned long)rtc->regs, rtc->irq);
        return 0;
-out:
-        platform_set_drvdata(pdev, NULL);
-        return ret;
 }
 static int __exit at32_rtc_remove(struct platform_device *pdev)
 {
        device_init_wakeup(&pdev->dev, 0);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index f296f3f7db9b..741892632ae0 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -31,8 +31,7 @@
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/uaccess.h>
-#include <asm/uaccess.h>
 #include "rtc-at91rm9200.h"
@@ -439,7 +438,6 @@ static int __exit at91_rtc_remove(struct platform_device *pdev)
        rtc_device_unregister(rtc);
        iounmap(at91_rtc_regs);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index b60a34cb145a..309b8b342d9c 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -324,16 +324,14 @@ static int at91_rtc_probe(struct platform_device *pdev)
        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;
+                return -ENOMEM;
-                goto fail;
        }
        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;
+                return -ENOMEM;
-                goto fail;
        }
        mr = rtt_readl(rtc, MR);
@@ -350,17 +348,15 @@ static int at91_rtc_probe(struct platform_device *pdev)
        rtc->rtcdev = devm_rtc_device_register(&pdev->dev, pdev->name,
                                        &at91_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtcdev)) {
+        if (IS_ERR(rtc->rtcdev))
-                ret = PTR_ERR(rtc->rtcdev);
+                return PTR_ERR(rtc->rtcdev);
-                goto fail;
-        }
        /* register irq handler after we know what name we'll use */
        ret = devm_request_irq(&pdev->dev, rtc->irq, at91_rtc_interrupt,
                                IRQF_SHARED, dev_name(&rtc->rtcdev->dev), rtc);
        if (ret) {
                dev_dbg(&pdev->dev, "can't share IRQ %d?\n", rtc->irq);
-                goto fail;
+                return ret;
        }
        /* NOTE:  sam9260 rev A silicon has a ROM bug which resets the
@@ -374,10 +370,6 @@ static int at91_rtc_probe(struct platform_device *pdev)
                                dev_name(&rtc->rtcdev->dev));
        return 0;
-fail:
-        platform_set_drvdata(pdev, NULL);
-        return ret;
 }
 /*
@@ -391,7 +383,6 @@ static int at91_rtc_remove(struct platform_device *pdev)
        /* disable all interrupts */
        rtt_writel(rtc, MR, mr & ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN));
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-au1xxx.c b/drivers/rtc/rtc-au1xxx.c
index 7995abc391fc..ed526a192ce0 100644
--- a/drivers/rtc/rtc-au1xxx.c
+++ b/drivers/rtc/rtc-au1xxx.c
@@ -116,19 +116,11 @@ out_err:
        return ret;
 }
-static int au1xtoy_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 static struct platform_driver au1xrtc_driver = {
        .driver         = {
                .name   = "rtc-au1xxx",
                .owner  = THIS_MODULE,
        },
-        .remove         = au1xtoy_rtc_remove,
 };
 module_platform_driver_probe(au1xrtc_driver, au1xtoy_rtc_probe);
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index ad44ec5dc29a..0c53f452849d 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -391,7 +391,6 @@ static int bfin_rtc_remove(struct platform_device *pdev)
        struct device *dev = &pdev->dev;
        bfin_rtc_reset(dev, 0);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-bq32k.c b/drivers/rtc/rtc-bq32k.c
index fea78bc713ca..c74bf0dc52cc 100644
--- a/drivers/rtc/rtc-bq32k.c
+++ b/drivers/rtc/rtc-bq32k.c
@@ -163,11 +163,6 @@ static int bq32k_probe(struct i2c_client *client,
        return 0;
 }
-static int bq32k_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static const struct i2c_device_id bq32k_id[] = {
        { "bq32000", 0 },
        { }
@@ -180,7 +175,6 @@ static struct i2c_driver bq32k_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = bq32k_probe,
-        .remove         = bq32k_remove,
        .id_table       = bq32k_id,
 };
diff --git a/drivers/rtc/rtc-bq4802.c b/drivers/rtc/rtc-bq4802.c
index af2886784a7b..fc0ff87aa5df 100644
--- a/drivers/rtc/rtc-bq4802.c
+++ b/drivers/rtc/rtc-bq4802.c
@@ -186,13 +186,6 @@ out:
 }
-static int bq4802_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 /* work with hotplug and coldplug */
 MODULE_ALIAS("platform:rtc-bq4802");
@@ -202,7 +195,6 @@ static struct platform_driver bq4802_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = bq4802_probe,
-        .remove         = bq4802_remove,
 };
 module_platform_driver(bq4802_driver);
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index f1cb706445c7..be06d7150de5 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -326,7 +326,7 @@ static void cmos_irq_disable(struct cmos_rtc *cmos, unsigned char mask)
 static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
        struct cmos_rtc *cmos = dev_get_drvdata(dev);
-       unsigned char   mon, mday, hrs, min, sec, rtc_control;
+        unsigned char mon, mday, hrs, min, sec, rtc_control;
        if (!is_valid_irq(cmos->irq))
                return -EIO;
@@ -556,17 +556,24 @@ static irqreturn_t cmos_interrupt(int irq, void *p)
        rtc_control = CMOS_READ(RTC_CONTROL);
        if (is_hpet_enabled())
                irqstat = (unsigned long)irq & 0xF0;
-        irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
+        /* If we were suspended, RTC_CONTROL may not be accurate since the
+         * bios may have cleared it.
+         */
+        if (!cmos_rtc.suspend_ctrl)
+                irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
+        else
+                irqstat &= (cmos_rtc.suspend_ctrl & RTC_IRQMASK) | RTC_IRQF;
        /* All Linux RTC alarms should be treated as if they were oneshot.
         * Similar code may be needed in system wakeup paths, in case the
         * alarm woke the system.
         */
        if (irqstat & RTC_AIE) {
+                cmos_rtc.suspend_ctrl &= ~RTC_AIE;
                rtc_control &= ~RTC_AIE;
                CMOS_WRITE(rtc_control, RTC_CONTROL);
                hpet_mask_rtc_irq_bit(RTC_AIE);
                CMOS_READ(RTC_INTR_FLAGS);
        }
        spin_unlock(&rtc_lock);
@@ -691,7 +698,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
        /* FIXME:
         * <asm-generic/rtc.h> doesn't know 12-hour mode either.
         */
-       if (is_valid_irq(rtc_irq) && !(rtc_control & RTC_24H)) {
+        if (is_valid_irq(rtc_irq) && !(rtc_control & RTC_24H)) {
                dev_warn(dev, "only 24-hr supported\n");
                retval = -ENXIO;
                goto cleanup1;
@@ -839,21 +846,23 @@ static inline int cmos_poweroff(struct device *dev)
 static int cmos_resume(struct device *dev)
 {
        struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        unsigned char   tmp = cmos->suspend_ctrl;
+        unsigned char tmp;
+        if (cmos->enabled_wake) {
+                if (cmos->wake_off)
+                        cmos->wake_off(dev);
+                else
+                        disable_irq_wake(cmos->irq);
+                cmos->enabled_wake = 0;
+        }
+        spin_lock_irq(&rtc_lock);
+        tmp = cmos->suspend_ctrl;
+        cmos->suspend_ctrl = 0;
        /* re-enable any irqs previously active */
        if (tmp & RTC_IRQMASK) {
                unsigned char   mask;
-                if (cmos->enabled_wake) {
-                        if (cmos->wake_off)
-                                cmos->wake_off(dev);
-                        else
-                                disable_irq_wake(cmos->irq);
-                        cmos->enabled_wake = 0;
-                }
-                spin_lock_irq(&rtc_lock);
                if (device_may_wakeup(dev))
                        hpet_rtc_timer_init();
@@ -873,8 +882,8 @@ static int cmos_resume(struct device *dev)
                        tmp &= ~RTC_AIE;
                        hpet_mask_rtc_irq_bit(RTC_AIE);
                } while (mask & RTC_AIE);
-                spin_unlock_irq(&rtc_lock);
        }
+        spin_unlock_irq(&rtc_lock);
        dev_dbg(dev, "resume, ctrl %02x\n", tmp);
@@ -991,7 +1000,7 @@ static int cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
 {
        cmos_wake_setup(&pnp->dev);
-        if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
+        if (pnp_port_start(pnp, 0) == 0x70 && !pnp_irq_valid(pnp, 0))
                /* Some machines contain a PNP entry for the RTC, but
                 * don't define the IRQ. It should always be safe to
                 * hardcode it in these cases
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index ad6863a76af9..73f157519dff 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -152,12 +152,10 @@ static struct rtc_class_ops coh901331_ops = {
 static int __exit coh901331_remove(struct platform_device *pdev)
 {
-        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
+        struct coh901331_port *rtap = platform_get_drvdata(pdev);
-        if (rtap) {
+        if (rtap)
                clk_unprepare(rtap->clk);
-                platform_set_drvdata(pdev, NULL);
-        }
        return 0;
 }
@@ -220,7 +218,6 @@ static int __init coh901331_probe(struct platform_device *pdev)
        return 0;
 out_no_rtc:
-        platform_set_drvdata(pdev, NULL);
        clk_unprepare(rtap->clk);
        return ret;
 }
@@ -267,7 +264,7 @@ 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);
+        struct coh901331_port *rtap = platform_get_drvdata(pdev);
        clk_enable(rtap->clk);
        writel(0, rtap->virtbase + COH901331_IRQ_MASK);
diff --git a/drivers/rtc/rtc-da9052.c b/drivers/rtc/rtc-da9052.c
index 7286b279cf2d..9c8c19441cc6 100644
--- a/drivers/rtc/rtc-da9052.c
+++ b/drivers/rtc/rtc-da9052.c
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
+#include <linux/err.h>
 #include <linux/mfd/da9052/da9052.h>
 #include <linux/mfd/da9052/reg.h>
@@ -249,22 +250,11 @@ static int da9052_rtc_probe(struct platform_device *pdev)
        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                       &da9052_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc))
+        return PTR_RET(rtc->rtc);
-                return PTR_ERR(rtc->rtc);
-        return 0;
-}
-static int da9052_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
 }
 static struct platform_driver da9052_rtc_driver = {
        .probe  = da9052_rtc_probe,
-        .remove = da9052_rtc_remove,
        .driver = {
                .name   = "da9052-rtc",
                .owner  = THIS_MODULE,
diff --git a/drivers/rtc/rtc-da9055.c b/drivers/rtc/rtc-da9055.c
index 73858ca9709a..e00642b61076 100644
--- a/drivers/rtc/rtc-da9055.c
+++ b/drivers/rtc/rtc-da9055.c
@@ -315,13 +315,6 @@ err_rtc:
 }
-static int da9055_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 #ifdef CONFIG_PM
 /* Turn off the alarm if it should not be a wake source. */
 static int da9055_rtc_suspend(struct device *dev)
@@ -394,7 +387,6 @@ static const struct dev_pm_ops da9055_rtc_pm_ops = {
 static struct platform_driver da9055_rtc_driver = {
        .probe  = da9055_rtc_probe,
-        .remove = da9055_rtc_remove,
        .driver = {
                .name   = "da9055-rtc",
                .owner  = THIS_MODULE,
diff --git a/drivers/rtc/rtc-davinci.c b/drivers/rtc/rtc-davinci.c
index a55048c3e26f..24677ef8c39a 100644
--- a/drivers/rtc/rtc-davinci.c
+++ b/drivers/rtc/rtc-davinci.c
@@ -117,7 +117,7 @@
 static DEFINE_SPINLOCK(davinci_rtc_lock);
 struct davinci_rtc {
-        struct rtc_device               *rtc;
+        struct rtc_device               *rtc;
        void __iomem                    *base;
        resource_size_t                 pbase;
        size_t                          base_size;
@@ -526,10 +526,9 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
        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);
                dev_err(dev, "unable to register RTC device, err %d\n",
                                ret);
-                goto fail1;
+                return PTR_ERR(davinci_rtc->rtc);
        }
        rtcif_write(davinci_rtc, PRTCIF_INTFLG_RTCSS, PRTCIF_INTFLG);
@@ -543,7 +542,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 fail1;
+                return ret;
        }
        /* Enable interrupts */
@@ -556,10 +555,6 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 0);
        return 0;
-fail1:
-        platform_set_drvdata(pdev, NULL);
-        return ret;
 }
 static int __exit davinci_rtc_remove(struct platform_device *pdev)
@@ -570,8 +565,6 @@ static int __exit davinci_rtc_remove(struct platform_device *pdev)
        rtcif_write(davinci_rtc, 0, PRTCIF_INTEN);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-dm355evm.c b/drivers/rtc/rtc-dm355evm.c
index 1e1ca63d58a9..1aca08394c47 100644
--- a/drivers/rtc/rtc-dm355evm.c
+++ b/drivers/rtc/rtc-dm355evm.c
@@ -139,19 +139,12 @@ static int dm355evm_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int dm355evm_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 /*
 * I2C is used to talk to the MSP430, but this platform device is
 * exposed by an MFD driver that manages I2C communications.
 */
 static struct platform_driver rtc_dm355evm_driver = {
        .probe          = dm355evm_rtc_probe,
-        .remove         = dm355evm_rtc_remove,
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = "rtc-dm355evm",
diff --git a/drivers/rtc/rtc-ds1216.c b/drivers/rtc/rtc-ds1216.c
index c7702b7269f7..9c04fd2bc209 100644
--- a/drivers/rtc/rtc-ds1216.c
+++ b/drivers/rtc/rtc-ds1216.c
@@ -167,34 +167,17 @@ static int __init ds1216_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int __exit ds1216_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static struct platform_driver ds1216_rtc_platform_driver = {
        .driver         = {
                .name   = "rtc-ds1216",
                .owner  = THIS_MODULE,
        },
-        .remove         = __exit_p(ds1216_rtc_remove),
 };
-static int __init ds1216_rtc_init(void)
+module_platform_driver_probe(ds1216_rtc_platform_driver, ds1216_rtc_probe);
-{
-        return platform_driver_probe(&ds1216_rtc_platform_driver, ds1216_rtc_probe);
-}
-static void __exit ds1216_rtc_exit(void)
-{
-        platform_driver_unregister(&ds1216_rtc_platform_driver);
-}
 MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
 MODULE_DESCRIPTION("DS1216 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 MODULE_ALIAS("platform:rtc-ds1216");
-module_init(ds1216_rtc_init);
-module_exit(ds1216_rtc_exit);
diff --git a/drivers/rtc/rtc-ds1286.c b/drivers/rtc/rtc-ds1286.c
index 398c96a98fc4..50e109b78252 100644
--- a/drivers/rtc/rtc-ds1286.c
+++ b/drivers/rtc/rtc-ds1286.c
@@ -353,18 +353,12 @@ static int ds1286_probe(struct platform_device *pdev)
        return 0;
 }
-static int ds1286_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static struct platform_driver ds1286_platform_driver = {
        .driver         = {
                .name   = "rtc-ds1286",
                .owner  = THIS_MODULE,
        },
        .probe          = ds1286_probe,
-        .remove         = ds1286_remove,
 };
 module_platform_driver(ds1286_platform_driver);
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index d13954346286..07e8d79b4a09 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -23,8 +23,12 @@
 #define RTC_CMD_READ    0x81            /* Read command */
 #define RTC_CMD_WRITE   0x80            /* Write command */
+#define RTC_CMD_WRITE_ENABLE    0x00            /* Write enable */
+#define RTC_CMD_WRITE_DISABLE   0x80            /* Write disable */
 #define RTC_ADDR_RAM0   0x20            /* Address of RAM0 */
 #define RTC_ADDR_TCR    0x08            /* Address of trickle charge register */
+#define RTC_ADDR_CTRL   0x07            /* Address of control register */
 #define RTC_ADDR_YEAR   0x06            /* Address of year register */
 #define RTC_ADDR_DAY    0x05            /* Address of day of week register */
 #define RTC_ADDR_MON    0x04            /* Address of month register */
@@ -161,6 +165,7 @@ static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
 static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
+        ds1302_writebyte(RTC_ADDR_CTRL, RTC_CMD_WRITE_ENABLE);
        /* Stop RTC */
        ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) | 0x80);
@@ -175,6 +180,8 @@ static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
        /* Start RTC */
        ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) & ~0x80);
+        ds1302_writebyte(RTC_ADDR_CTRL, RTC_CMD_WRITE_DISABLE);
        return 0;
 }
@@ -234,19 +241,11 @@ static int __init ds1302_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int __exit ds1302_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 static struct platform_driver ds1302_platform_driver = {
        .driver         = {
                .name   = DRV_NAME,
                .owner  = THIS_MODULE,
        },
-        .remove         = __exit_p(ds1302_rtc_remove),
 };
 module_platform_driver_probe(ds1302_platform_driver, ds1302_rtc_probe);
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index bb5f13f63630..dd6170acde95 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -158,7 +158,7 @@ static int ds1305_alarm_irq_enable(struct device *dev, unsigned int enabled)
                        goto done;
                buf[1] &= ~DS1305_AEI0;
        }
-        err = spi_write_then_read(ds1305->spi, buf, sizeof buf, NULL, 0);
+        err = spi_write_then_read(ds1305->spi, buf, sizeof(buf), NULL, 0);
        if (err >= 0)
                ds1305->ctrl[0] = buf[1];
 done:
@@ -181,8 +181,8 @@ static int ds1305_get_time(struct device *dev, struct rtc_time *time)
        /* Use write-then-read to get all the date/time registers
         * since dma from stack is nonportable
         */
-        status = spi_write_then_read(ds1305->spi, &addr, sizeof addr,
+        status = spi_write_then_read(ds1305->spi, &addr, sizeof(addr),
-                        buf, sizeof buf);
+                        buf, sizeof(buf));
        if (status < 0)
                return status;
@@ -237,7 +237,7 @@ static int ds1305_set_time(struct device *dev, struct rtc_time *time)
                buf[4], buf[5], buf[6], buf[7]);
        /* use write-then-read since dma from stack is nonportable */
-        return spi_write_then_read(ds1305->spi, buf, sizeof buf,
+        return spi_write_then_read(ds1305->spi, buf, sizeof(buf),
                        NULL, 0);
 }
@@ -286,8 +286,8 @@ static int ds1305_get_alarm(struct device *dev, struct rtc_wkalrm *alm)
         * of EFI status is at best fragile anyway (given IRQ handlers).
         */
        addr = DS1305_CONTROL;
-        status = spi_write_then_read(spi, &addr, sizeof addr,
+        status = spi_write_then_read(spi, &addr, sizeof(addr),
-                        ds1305->ctrl, sizeof ds1305->ctrl);
+                        ds1305->ctrl, sizeof(ds1305->ctrl));
        if (status < 0)
                return status;
@@ -296,8 +296,8 @@ static int ds1305_get_alarm(struct device *dev, struct rtc_wkalrm *alm)
        /* get and check ALM0 registers */
        addr = DS1305_ALM0(DS1305_SEC);
-        status = spi_write_then_read(spi, &addr, sizeof addr,
+        status = spi_write_then_read(spi, &addr, sizeof(addr),
-                        buf, sizeof buf);
+                        buf, sizeof(buf));
        if (status < 0)
                return status;
@@ -381,7 +381,7 @@ static int ds1305_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
                "alm0 write", buf[1 + DS1305_SEC], buf[1 + DS1305_MIN],
                buf[1 + DS1305_HOUR], buf[1 + DS1305_WDAY]);
-        status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0);
+        status = spi_write_then_read(spi, buf, sizeof(buf), NULL, 0);
        if (status < 0)
                return status;
@@ -474,7 +474,7 @@ static void ds1305_work(struct work_struct *work)
        buf[1] = ds1305->ctrl[0];
        buf[2] = 0;
-        status = spi_write_then_read(spi, buf, sizeof buf,
+        status = spi_write_then_read(spi, buf, sizeof(buf),
                        NULL, 0);
        if (status < 0)
                dev_dbg(&spi->dev, "clear irq --> %d\n", status);
@@ -627,8 +627,8 @@ static int ds1305_probe(struct spi_device *spi)
        /* read and cache control registers */
        addr = DS1305_CONTROL;
-        status = spi_write_then_read(spi, &addr, sizeof addr,
+        status = spi_write_then_read(spi, &addr, sizeof(addr),
-                        ds1305->ctrl, sizeof ds1305->ctrl);
+                        ds1305->ctrl, sizeof(ds1305->ctrl));
        if (status < 0) {
                dev_dbg(&spi->dev, "can't %s, %d\n",
                                "read", status);
@@ -659,7 +659,7 @@ static int ds1305_probe(struct spi_device *spi)
                buf[0] = DS1305_WRITE | DS1305_CONTROL;
                buf[1] = ds1305->ctrl[0];
-                status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0);
+                status = spi_write_then_read(spi, buf, sizeof(buf), NULL, 0);
                dev_dbg(&spi->dev, "clear WP --> %d\n", status);
                if (status < 0)
@@ -713,7 +713,7 @@ static int ds1305_probe(struct spi_device *spi)
                buf[1] = ds1305->ctrl[0];
                buf[2] = ds1305->ctrl[1];
                buf[3] = ds1305->ctrl[2];
-                status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0);
+                status = spi_write_then_read(spi, buf, sizeof(buf), NULL, 0);
                if (status < 0) {
                        dev_dbg(&spi->dev, "can't %s, %d\n",
                                        "write", status);
@@ -725,8 +725,8 @@ static int ds1305_probe(struct spi_device *spi)
        /* see if non-Linux software set up AM/PM mode */
        addr = DS1305_HOUR;
-        status = spi_write_then_read(spi, &addr, sizeof addr,
+        status = spi_write_then_read(spi, &addr, sizeof(addr),
-                                &value, sizeof value);
+                                &value, sizeof(value));
        if (status < 0) {
                dev_dbg(&spi->dev, "read HOUR --> %d\n", status);
                return status;
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index b53992ab3090..ca18fd1433b3 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -683,7 +683,7 @@ static int ds1307_probe(struct i2c_client *client,
            && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
                return -EIO;
-        ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL);
+        ds1307 = devm_kzalloc(&client->dev, sizeof(struct ds1307), GFP_KERNEL);
        if (!ds1307)
                return -ENOMEM;
@@ -715,7 +715,7 @@ static int ds1307_probe(struct i2c_client *client,
                if (tmp != 2) {
                        dev_dbg(&client->dev, "read error %d\n", tmp);
                        err = -EIO;
-                        goto exit_free;
+                        goto exit;
                }
                /* oscillator off?  turn it on, so clock can tick. */
@@ -754,7 +754,7 @@ static int ds1307_probe(struct i2c_client *client,
                if (tmp != 2) {
                        dev_dbg(&client->dev, "read error %d\n", tmp);
                        err = -EIO;
-                        goto exit_free;
+                        goto exit;
                }
                /* oscillator off?  turn it on, so clock can tick. */
@@ -798,7 +798,7 @@ static int ds1307_probe(struct i2c_client *client,
                        if (tmp != 2) {
                                dev_dbg(&client->dev, "read error %d\n", tmp);
                                err = -EIO;
-                                goto exit_free;
+                                goto exit;
                        }
                        /* correct hour */
@@ -826,7 +826,7 @@ read_rtc:
        if (tmp != 8) {
                dev_dbg(&client->dev, "read error %d\n", tmp);
                err = -EIO;
-                goto exit_free;
+                goto exit;
        }
        /*
@@ -868,7 +868,7 @@ read_rtc:
                if (tmp < 0) {
                        dev_dbg(&client->dev, "read error %d\n", tmp);
                        err = -EIO;
-                        goto exit_free;
+                        goto exit;
                }
                /* oscillator fault?  clear flag, and warn */
@@ -927,13 +927,13 @@ read_rtc:
                                bin2bcd(tmp));
        }
-        ds1307->rtc = rtc_device_register(client->name, &client->dev,
+        ds1307->rtc = devm_rtc_device_register(&client->dev, client->name,
                                &ds13xx_rtc_ops, THIS_MODULE);
        if (IS_ERR(ds1307->rtc)) {
                err = PTR_ERR(ds1307->rtc);
                dev_err(&client->dev,
                        "unable to register the class device\n");
-                goto exit_free;
+                goto exit;
        }
        if (want_irq) {
@@ -942,7 +942,7 @@ read_rtc:
                if (err) {
                        dev_err(&client->dev,
                                "unable to request IRQ!\n");
-                        goto exit_irq;
+                        goto exit;
                }
                device_set_wakeup_capable(&client->dev, 1);
@@ -951,11 +951,12 @@ read_rtc:
        }
        if (chip->nvram_size) {
-                ds1307->nvram = kzalloc(sizeof(struct bin_attribute),
+                ds1307->nvram = devm_kzalloc(&client->dev,
-                                                        GFP_KERNEL);
+                                        sizeof(struct bin_attribute),
+                                        GFP_KERNEL);
                if (!ds1307->nvram) {
                        err = -ENOMEM;
-                        goto exit_nvram;
+                        goto exit;
                }
                ds1307->nvram->attr.name = "nvram";
                ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
@@ -965,21 +966,15 @@ read_rtc:
                ds1307->nvram->size = chip->nvram_size;
                ds1307->nvram_offset = chip->nvram_offset;
                err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram);
-                if (err) {
+                if (err)
-                        kfree(ds1307->nvram);
+                        goto exit;
-                        goto exit_nvram;
-                }
                set_bit(HAS_NVRAM, &ds1307->flags);
                dev_info(&client->dev, "%zu bytes nvram\n", ds1307->nvram->size);
        }
        return 0;
-exit_nvram:
+exit:
-exit_irq:
-        rtc_device_unregister(ds1307->rtc);
-exit_free:
-        kfree(ds1307);
        return err;
 }
@@ -992,13 +987,9 @@ static int ds1307_remove(struct i2c_client *client)
                cancel_work_sync(&ds1307->work);
        }
-        if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags)) {
+        if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags))
                sysfs_remove_bin_file(&client->dev.kobj, ds1307->nvram);
-                kfree(ds1307->nvram);
-        }
-        rtc_device_unregister(ds1307->rtc);
-        kfree(ds1307);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 94366e12f40f..9e6e14fb53d7 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -65,7 +65,7 @@ struct ds1374 {
 static struct i2c_driver ds1374_driver;
 static int ds1374_read_rtc(struct i2c_client *client, u32 *time,
-                           int reg, int nbytes)
+                           int reg, int nbytes)
 {
        u8 buf[4];
        int ret;
@@ -90,7 +90,7 @@ static int ds1374_read_rtc(struct i2c_client *client, u32 *time,
 }
 static int ds1374_write_rtc(struct i2c_client *client, u32 time,
-                            int reg, int nbytes)
+                            int reg, int nbytes)
 {
        u8 buf[4];
        int i;
@@ -119,8 +119,7 @@ static int ds1374_check_rtc_status(struct i2c_client *client)
        if (stat & DS1374_REG_SR_OSF)
                dev_warn(&client->dev,
-                         "oscillator discontinuity flagged, "
+                         "oscillator discontinuity flagged, time unreliable\n");
-                         "time unreliable\n");
        stat &= ~(DS1374_REG_SR_OSF | DS1374_REG_SR_AF);
@@ -363,7 +362,7 @@ static int ds1374_probe(struct i2c_client *client,
        if (client->irq > 0) {
                ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0,
-                                  "ds1374", client);
+                                        "ds1374", client);
                if (ret) {
                        dev_err(&client->dev, "unable to request IRQ\n");
                        return ret;
@@ -373,7 +372,7 @@ static int ds1374_probe(struct i2c_client *client,
        }
        ds1374->rtc = devm_rtc_device_register(&client->dev, client->name,
-                                          &ds1374_rtc_ops, THIS_MODULE);
+                                                &ds1374_rtc_ops, THIS_MODULE);
        if (IS_ERR(ds1374->rtc)) {
                dev_err(&client->dev, "unable to register the class device\n");
                return PTR_ERR(ds1374->rtc);
diff --git a/drivers/rtc/rtc-ds1390.c b/drivers/rtc/rtc-ds1390.c
index 289af419dff4..be9d8c0a7e3a 100644
--- a/drivers/rtc/rtc-ds1390.c
+++ b/drivers/rtc/rtc-ds1390.c
@@ -154,18 +154,12 @@ static int ds1390_probe(struct spi_device *spi)
        return res;
 }
-static int ds1390_remove(struct spi_device *spi)
-{
-        return 0;
-}
 static struct spi_driver ds1390_driver = {
        .driver = {
                .name   = "rtc-ds1390",
                .owner  = THIS_MODULE,
        },
        .probe  = ds1390_probe,
-        .remove = ds1390_remove,
 };
 module_spi_driver(ds1390_driver);
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 6ce8a997cf51..308a8fefe76f 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -104,31 +104,31 @@ static DEFINE_SPINLOCK(ds1511_lock);
 static __iomem char *ds1511_base;
 static u32 reg_spacing = 1;
- static noinline void
+static noinline void
 rtc_write(uint8_t val, uint32_t reg)
 {
        writeb(val, ds1511_base + (reg * reg_spacing));
 }
- static inline void
+static inline void
 rtc_write_alarm(uint8_t val, enum ds1511reg reg)
 {
        rtc_write((val | 0x80), reg);
 }
- static noinline uint8_t
+static noinline uint8_t
 rtc_read(enum ds1511reg reg)
 {
        return readb(ds1511_base + (reg * reg_spacing));
 }
- static inline void
+static inline void
 rtc_disable_update(void)
 {
        rtc_write((rtc_read(RTC_CMD) & ~RTC_TE), RTC_CMD);
 }
- static void
+static void
 rtc_enable_update(void)
 {
        rtc_write((rtc_read(RTC_CMD) | RTC_TE), RTC_CMD);
@@ -145,7 +145,7 @@ rtc_enable_update(void)
 * just enough code to set the watchdog timer so that it
 * will reboot the system
 */
- void
+void
 ds1511_wdog_set(unsigned long deciseconds)
 {
        /*
@@ -163,7 +163,7 @@ ds1511_wdog_set(unsigned long deciseconds)
        rtc_write(DS1511_WDE | DS1511_WDS, RTC_CMD);
 }
- void
+void
 ds1511_wdog_disable(void)
 {
        /*
@@ -191,13 +191,12 @@ static int ds1511_rtc_set_time(struct device *dev, struct rtc_time *rtc_tm)
        /*
         * won't have to change this for a while
         */
-        if (rtc_tm->tm_year < 1900) {
+        if (rtc_tm->tm_year < 1900)
                rtc_tm->tm_year += 1900;
-        }
-        if (rtc_tm->tm_year < 1970) {
+        if (rtc_tm->tm_year < 1970)
                return -EINVAL;
-        }
        yrs = rtc_tm->tm_year % 100;
        cen = rtc_tm->tm_year / 100;
        mon = rtc_tm->tm_mon + 1;   /* tm_mon starts at zero */
@@ -207,17 +206,14 @@ static int ds1511_rtc_set_time(struct device *dev, struct rtc_time *rtc_tm)
        min = rtc_tm->tm_min;
        sec = rtc_tm->tm_sec;
-        if ((mon > 12) || (day == 0)) {
+        if ((mon > 12) || (day == 0))
                return -EINVAL;
-        }
-        if (day > rtc_month_days(rtc_tm->tm_mon, rtc_tm->tm_year)) {
+        if (day > rtc_month_days(rtc_tm->tm_mon, rtc_tm->tm_year))
                return -EINVAL;
-        }
-        if ((hrs >= 24) || (min >= 60) || (sec >= 60)) {
+        if ((hrs >= 24) || (min >= 60) || (sec >= 60))
                return -EINVAL;
-        }
        /*
         * each register is a different number of valid bits
@@ -299,7 +295,7 @@ static int ds1511_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
 * date/hours/mins/secs matches.  the ds1511 has many more
 * permutations, but the kernel doesn't.
 */
- static void
+static void
 ds1511_rtc_update_alarm(struct rtc_plat_data *pdata)
 {
        unsigned long flags;
@@ -322,7 +318,7 @@ ds1511_rtc_update_alarm(struct rtc_plat_data *pdata)
        spin_unlock_irqrestore(&pdata->lock, flags);
 }
- static int
+static int
 ds1511_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
        struct platform_device *pdev = to_platform_device(dev);
@@ -335,14 +331,14 @@ ds1511_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
        pdata->alrm_hour = alrm->time.tm_hour;
        pdata->alrm_min = alrm->time.tm_min;
        pdata->alrm_sec = alrm->time.tm_sec;
-        if (alrm->enabled) {
+        if (alrm->enabled)
                pdata->irqen |= RTC_AF;
-        }
        ds1511_rtc_update_alarm(pdata);
        return 0;
 }
- static int
+static int
 ds1511_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
        struct platform_device *pdev = to_platform_device(dev);
@@ -359,7 +355,7 @@ ds1511_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
        return 0;
 }
- static irqreturn_t
+static irqreturn_t
 ds1511_interrupt(int irq, void *dev_id)
 {
        struct platform_device *pdev = dev_id;
@@ -406,7 +402,7 @@ static const struct rtc_class_ops ds1511_rtc_ops = {
        .alarm_irq_enable       = ds1511_rtc_alarm_irq_enable,
 };
- static ssize_t
+static ssize_t
 ds1511_nvram_read(struct file *filp, struct kobject *kobj,
                  struct bin_attribute *ba,
                  char *buf, loff_t pos, size_t size)
@@ -417,26 +413,26 @@ ds1511_nvram_read(struct file *filp, struct kobject *kobj,
         * if count is more than one, turn on "burst" mode
         * turn it off when you're done
         */
-        if (size > 1) {
+        if (size > 1)
                rtc_write((rtc_read(RTC_CMD) | DS1511_BME), RTC_CMD);
-        }
-        if (pos > DS1511_RAM_MAX) {
+        if (pos > DS1511_RAM_MAX)
                pos = DS1511_RAM_MAX;
-        }
-        if (size + pos > DS1511_RAM_MAX + 1) {
+        if (size + pos > DS1511_RAM_MAX + 1)
                size = DS1511_RAM_MAX - pos + 1;
-        }
        rtc_write(pos, DS1511_RAMADDR_LSB);
-        for (count = 0; size > 0; count++, size--) {
+        for (count = 0; size > 0; count++, size--)
                *buf++ = rtc_read(DS1511_RAMDATA);
-        }
-        if (count > 1) {
+        if (count > 1)
                rtc_write((rtc_read(RTC_CMD) & ~DS1511_BME), RTC_CMD);
-        }
        return count;
 }
- static ssize_t
+static ssize_t
 ds1511_nvram_write(struct file *filp, struct kobject *kobj,
                   struct bin_attribute *bin_attr,
                   char *buf, loff_t pos, size_t size)
@@ -447,22 +443,22 @@ ds1511_nvram_write(struct file *filp, struct kobject *kobj,
         * if count is more than one, turn on "burst" mode
         * turn it off when you're done
         */
-        if (size > 1) {
+        if (size > 1)
                rtc_write((rtc_read(RTC_CMD) | DS1511_BME), RTC_CMD);
-        }
-        if (pos > DS1511_RAM_MAX) {
+        if (pos > DS1511_RAM_MAX)
                pos = DS1511_RAM_MAX;
-        }
-        if (size + pos > DS1511_RAM_MAX + 1) {
+        if (size + pos > DS1511_RAM_MAX + 1)
                size = DS1511_RAM_MAX - pos + 1;
-        }
        rtc_write(pos, DS1511_RAMADDR_LSB);
-        for (count = 0; size > 0; count++, size--) {
+        for (count = 0; size > 0; count++, size--)
                rtc_write(*buf++, DS1511_RAMDATA);
-        }
-        if (count > 1) {
+        if (count > 1)
                rtc_write((rtc_read(RTC_CMD) & ~DS1511_BME), RTC_CMD);
-        }
        return count;
 }
@@ -484,9 +480,9 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
        int ret = 0;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
+        if (!res)
                return -ENODEV;
-        }
        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
        if (!pdata)
                return -ENOMEM;
@@ -518,9 +514,8 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
        /*
         * check for a dying bat-tree
         */
-        if (rtc_read(RTC_CMD1) & DS1511_BLF1) {
+        if (rtc_read(RTC_CMD1) & DS1511_BLF1)
                dev_warn(&pdev->dev, "voltage-low detected.\n");
-        }
        spin_lock_init(&pdata->lock);
        platform_set_drvdata(pdev, pdata);
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 3fc2a4738027..18e2d8471472 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -153,11 +153,6 @@ static const struct rtc_class_ops ds1672_rtc_ops = {
        .set_mmss = ds1672_rtc_set_mmss,
 };
-static int ds1672_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static int ds1672_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
 {
@@ -210,7 +205,6 @@ static struct i2c_driver ds1672_driver = {
                   .name = "rtc-ds1672",
                   },
        .probe = &ds1672_probe,
-        .remove = &ds1672_remove,
        .id_table = ds1672_id,
 };
diff --git a/drivers/rtc/rtc-ds3234.c b/drivers/rtc/rtc-ds3234.c
index ba98c0e9580d..4c9ba5368464 100644
--- a/drivers/rtc/rtc-ds3234.c
+++ b/drivers/rtc/rtc-ds3234.c
@@ -73,7 +73,7 @@ static int ds3234_read_time(struct device *dev, struct rtc_time *dt)
        dt->tm_wday     = bcd2bin(buf[3]) - 1; /* 0 = Sun */
        dt->tm_mday     = bcd2bin(buf[4]);
        dt->tm_mon      = bcd2bin(buf[5] & 0x1f) - 1; /* 0 = Jan */
-        dt->tm_year     = bcd2bin(buf[6] & 0xff) + 100; /* Assume 20YY */
+        dt->tm_year     = bcd2bin(buf[6] & 0xff) + 100; /* Assume 20YY */
        return rtc_valid_tm(dt);
 }
@@ -156,18 +156,12 @@ static int ds3234_probe(struct spi_device *spi)
        return 0;
 }
-static int ds3234_remove(struct spi_device *spi)
-{
-        return 0;
-}
 static struct spi_driver ds3234_driver = {
        .driver = {
                .name    = "ds3234",
                .owner  = THIS_MODULE,
        },
        .probe   = ds3234_probe,
-        .remove = ds3234_remove,
 };
 module_spi_driver(ds3234_driver);
diff --git a/drivers/rtc/rtc-efi.c b/drivers/rtc/rtc-efi.c
index b3c8c0b1709d..797aa0252ba9 100644
--- a/drivers/rtc/rtc-efi.c
+++ b/drivers/rtc/rtc-efi.c
@@ -201,17 +201,11 @@ static int __init efi_rtc_probe(struct platform_device *dev)
        return 0;
 }
-static int __exit efi_rtc_remove(struct platform_device *dev)
-{
-        return 0;
-}
 static struct platform_driver efi_rtc_driver = {
        .driver = {
                .name = "rtc-efi",
                .owner = THIS_MODULE,
        },
-        .remove = __exit_p(efi_rtc_remove),
 };
 module_platform_driver_probe(efi_rtc_driver, efi_rtc_probe);
diff --git a/drivers/rtc/rtc-em3027.c b/drivers/rtc/rtc-em3027.c
index 3f9eb57d0486..fccf36699245 100644
--- a/drivers/rtc/rtc-em3027.c
+++ b/drivers/rtc/rtc-em3027.c
@@ -131,11 +131,6 @@ static int em3027_probe(struct i2c_client *client,
        return 0;
 }
-static int em3027_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static struct i2c_device_id em3027_id[] = {
        { "em3027", 0 },
        { }
@@ -146,7 +141,6 @@ static struct i2c_driver em3027_driver = {
                   .name = "rtc-em3027",
        },
        .probe = &em3027_probe,
-        .remove = &em3027_remove,
        .id_table = em3027_id,
 };
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 5807b77c444a..549b3c3792d2 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -167,7 +167,6 @@ static int ep93xx_rtc_probe(struct platform_device *pdev)
        return 0;
 exit:
-        platform_set_drvdata(pdev, NULL);
        pdev->dev.platform_data = NULL;
        return err;
 }
@@ -175,7 +174,6 @@ exit:
 static int ep93xx_rtc_remove(struct platform_device *pdev)
 {
        sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
-        platform_set_drvdata(pdev, NULL);
        pdev->dev.platform_data = NULL;
        return 0;
diff --git a/drivers/rtc/rtc-fm3130.c b/drivers/rtc/rtc-fm3130.c
index 2835fb6c1965..83c3b3029fa7 100644
--- a/drivers/rtc/rtc-fm3130.c
+++ b/drivers/rtc/rtc-fm3130.c
@@ -47,7 +47,7 @@
 struct fm3130 {
        u8                      reg_addr_time;
-        u8                      reg_addr_alarm;
+        u8                      reg_addr_alarm;
        u8                      regs[15];
        struct i2c_msg          msg[4];
        struct i2c_client       *client;
@@ -520,18 +520,12 @@ exit_free:
        return err;
 }
-static int fm3130_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static struct i2c_driver fm3130_driver = {
        .driver = {
                .name   = "rtc-fm3130",
                .owner  = THIS_MODULE,
        },
        .probe          = fm3130_probe,
-        .remove         = fm3130_remove,
        .id_table       = fm3130_id,
 };
diff --git a/drivers/rtc/rtc-generic.c b/drivers/rtc/rtc-generic.c
index 06279ce6bff2..9b6725ebbfb2 100644
--- a/drivers/rtc/rtc-generic.c
+++ b/drivers/rtc/rtc-generic.c
@@ -48,17 +48,11 @@ static int __init generic_rtc_probe(struct platform_device *dev)
        return 0;
 }
-static int __exit generic_rtc_remove(struct platform_device *dev)
-{
-        return 0;
-}
 static struct platform_driver generic_rtc_driver = {
        .driver = {
                .name = "rtc-generic",
                .owner = THIS_MODULE,
        },
-        .remove = __exit_p(generic_rtc_remove),
 };
 module_platform_driver_probe(generic_rtc_driver, generic_rtc_probe);
diff --git a/drivers/rtc/rtc-hid-sensor-time.c b/drivers/rtc/rtc-hid-sensor-time.c
index 63024505dddc..7273b0139e5c 100644
--- a/drivers/rtc/rtc-hid-sensor-time.c
+++ b/drivers/rtc/rtc-hid-sensor-time.c
@@ -76,6 +76,20 @@ static int hid_time_proc_event(struct hid_sensor_hub_device *hsdev,
        return 0;
 }
+static u32 hid_time_value(size_t raw_len, char *raw_data)
+{
+        switch (raw_len) {
+        case 1:
+                return *(u8 *)raw_data;
+        case 2:
+                return *(u16 *)raw_data;
+        case 4:
+                return *(u32 *)raw_data;
+        default:
+                return (u32)(~0U); /* 0xff... or -1 to denote an error */
+        }
+}
 static int hid_time_capture_sample(struct hid_sensor_hub_device *hsdev,
                                unsigned usage_id, size_t raw_len,
                                char *raw_data, void *priv)
@@ -85,26 +99,35 @@ static int hid_time_capture_sample(struct hid_sensor_hub_device *hsdev,
        switch (usage_id) {
        case HID_USAGE_SENSOR_TIME_YEAR:
-                time_buf->tm_year = *(u8 *)raw_data;
+                /*
-                if (time_buf->tm_year < 70)
+                 * The draft for HID-sensors (HUTRR39) currently doesn't define
-                        /* assume we are in 1970...2069 */
+                 * the range for the year attribute. Therefor we support
-                        time_buf->tm_year += 100;
+                 * 8 bit (0-99) and 16 or 32 bits (full) as size for the year.
+                 */
+                if (raw_len == 1) {
+                        time_buf->tm_year = *(u8 *)raw_data;
+                        if (time_buf->tm_year < 70)
+                                /* assume we are in 1970...2069 */
+                                time_buf->tm_year += 100;
+                } else
+                        time_buf->tm_year =
+                                (int)hid_time_value(raw_len, raw_data)-1900;
                break;
        case HID_USAGE_SENSOR_TIME_MONTH:
-                /* sensor sending the month as 1-12, we need 0-11 */
+                /* sensors are sending the month as 1-12, we need 0-11 */
-                time_buf->tm_mon = *(u8 *)raw_data-1;
+                time_buf->tm_mon = (int)hid_time_value(raw_len, raw_data)-1;
                break;
        case HID_USAGE_SENSOR_TIME_DAY:
-                time_buf->tm_mday = *(u8 *)raw_data;
+                time_buf->tm_mday = (int)hid_time_value(raw_len, raw_data);
                break;
        case HID_USAGE_SENSOR_TIME_HOUR:
-                time_buf->tm_hour = *(u8 *)raw_data;
+                time_buf->tm_hour = (int)hid_time_value(raw_len, raw_data);
                break;
        case HID_USAGE_SENSOR_TIME_MINUTE:
-                time_buf->tm_min = *(u8 *)raw_data;
+                time_buf->tm_min = (int)hid_time_value(raw_len, raw_data);
                break;
        case HID_USAGE_SENSOR_TIME_SECOND:
-                time_buf->tm_sec = *(u8 *)raw_data;
+                time_buf->tm_sec = (int)hid_time_value(raw_len, raw_data);
                break;
        default:
                return -EINVAL;
@@ -150,9 +173,10 @@ static int hid_time_parse_report(struct platform_device *pdev,
                                "not all needed attributes inside the same report!\n");
                        return -EINVAL;
                }
-                if (time_state->info[i].size != 1) {
+                if (time_state->info[i].size == 3 ||
+                                time_state->info[i].size > 4) {
                        dev_err(&pdev->dev,
-                                "attribute '%s' not 8 bits wide!\n",
+                                "attribute '%s' not 8, 16 or 32 bits wide!\n",
                                hid_time_attrib_name(
                                        time_state->info[i].attrib_id));
                        return -EINVAL;
diff --git a/drivers/rtc/rtc-isl12022.c b/drivers/rtc/rtc-isl12022.c
index a1bbbb8de029..5dbdc4405718 100644
--- a/drivers/rtc/rtc-isl12022.c
+++ b/drivers/rtc/rtc-isl12022.c
@@ -16,6 +16,7 @@
 #include <linux/rtc.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/err.h>
 #define DRV_VERSION "0.1"
@@ -267,15 +268,7 @@ static int isl12022_probe(struct i2c_client *client,
        isl12022->rtc = devm_rtc_device_register(&client->dev,
                                        isl12022_driver.driver.name,
                                        &isl12022_rtc_ops, THIS_MODULE);
-        if (IS_ERR(isl12022->rtc))
+        return PTR_RET(isl12022->rtc);
-                return PTR_ERR(isl12022->rtc);
-        return 0;
-}
-static int isl12022_remove(struct i2c_client *client)
-{
-        return 0;
 }
 static const struct i2c_device_id isl12022_id[] = {
@@ -289,7 +282,6 @@ static struct i2c_driver isl12022_driver = {
                .name   = "rtc-isl12022",
        },
        .probe          = isl12022_probe,
-        .remove         = isl12022_remove,
        .id_table       = isl12022_id,
 };
diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
index 1e48686ca6d2..1b126d2513de 100644
--- a/drivers/rtc/rtc-jz4740.c
+++ b/drivers/rtc/rtc-jz4740.c
@@ -14,6 +14,7 @@
 *
 */
+#include <linux/io.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
@@ -216,37 +217,34 @@ static int jz4740_rtc_probe(struct platform_device *pdev)
        struct jz4740_rtc *rtc;
        uint32_t scratchpad;
-        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
        if (!rtc)
                return -ENOMEM;
        rtc->irq = platform_get_irq(pdev, 0);
        if (rtc->irq < 0) {
-                ret = -ENOENT;
                dev_err(&pdev->dev, "Failed to get platform irq\n");
-                goto err_free;
+                return -ENOENT;
        }
        rtc->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!rtc->mem) {
-                ret = -ENOENT;
                dev_err(&pdev->dev, "Failed to get platform mmio memory\n");
-                goto err_free;
+                return -ENOENT;
        }
-        rtc->mem = request_mem_region(rtc->mem->start, resource_size(rtc->mem),
+        rtc->mem = devm_request_mem_region(&pdev->dev, rtc->mem->start,
-                                        pdev->name);
+                                        resource_size(rtc->mem), pdev->name);
        if (!rtc->mem) {
-                ret = -EBUSY;
                dev_err(&pdev->dev, "Failed to request mmio memory region\n");
-                goto err_free;
+                return -EBUSY;
        }
-        rtc->base = ioremap_nocache(rtc->mem->start, resource_size(rtc->mem));
+        rtc->base = devm_ioremap_nocache(&pdev->dev, rtc->mem->start,
+                                        resource_size(rtc->mem));
        if (!rtc->base) {
-                ret = -EBUSY;
                dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
-                goto err_release_mem_region;
+                return -EBUSY;
        }
        spin_lock_init(&rtc->lock);
@@ -255,19 +253,19 @@ static int jz4740_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
-        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev, &jz4740_rtc_ops,
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                                        THIS_MODULE);
+                                        &jz4740_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
                ret = PTR_ERR(rtc->rtc);
                dev_err(&pdev->dev, "Failed to register rtc device: %d\n", ret);
-                goto err_iounmap;
+                return ret;
        }
-        ret = request_irq(rtc->irq, jz4740_rtc_irq, 0,
+        ret = devm_request_irq(&pdev->dev, rtc->irq, jz4740_rtc_irq, 0,
                                pdev->name, rtc);
        if (ret) {
                dev_err(&pdev->dev, "Failed to request rtc irq: %d\n", ret);
-                goto err_unregister_rtc;
+                return ret;
        }
        scratchpad = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_SCRATCHPAD);
@@ -276,46 +274,13 @@ static int jz4740_rtc_probe(struct platform_device *pdev)
                ret = jz4740_rtc_reg_write(rtc, JZ_REG_RTC_SEC, 0);
                if (ret) {
                        dev_err(&pdev->dev, "Could not write write to RTC registers\n");
-                        goto err_free_irq;
+                        return ret;
                }
        }
        return 0;
-err_free_irq:
-        free_irq(rtc->irq, rtc);
-err_unregister_rtc:
-        rtc_device_unregister(rtc->rtc);
-err_iounmap:
-        platform_set_drvdata(pdev, NULL);
-        iounmap(rtc->base);
-err_release_mem_region:
-        release_mem_region(rtc->mem->start, resource_size(rtc->mem));
-err_free:
-        kfree(rtc);
-        return ret;
-}
-static int jz4740_rtc_remove(struct platform_device *pdev)
-{
-        struct jz4740_rtc *rtc = platform_get_drvdata(pdev);
-        free_irq(rtc->irq, rtc);
-        rtc_device_unregister(rtc->rtc);
-        iounmap(rtc->base);
-        release_mem_region(rtc->mem->start, resource_size(rtc->mem));
-        kfree(rtc);
-        platform_set_drvdata(pdev, NULL);
-        return 0;
 }
 #ifdef CONFIG_PM
 static int jz4740_rtc_suspend(struct device *dev)
 {
@@ -347,7 +312,6 @@ static const struct dev_pm_ops jz4740_pm_ops = {
 static struct platform_driver jz4740_rtc_driver = {
        .probe   = jz4740_rtc_probe,
-        .remove  = jz4740_rtc_remove,
        .driver  = {
                .name  = "jz4740-rtc",
                .owner = THIS_MODULE,
diff --git a/drivers/rtc/rtc-lp8788.c b/drivers/rtc/rtc-lp8788.c
index 9853ac15b296..4ff6c73253b3 100644
--- a/drivers/rtc/rtc-lp8788.c
+++ b/drivers/rtc/rtc-lp8788.c
@@ -312,16 +312,8 @@ static int lp8788_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int lp8788_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 static struct platform_driver lp8788_rtc_driver = {
        .probe = lp8788_rtc_probe,
-        .remove = lp8788_rtc_remove,
        .driver = {
                .name = LP8788_DEV_RTC,
                .owner = THIS_MODULE,
diff --git a/drivers/rtc/rtc-lpc32xx.c b/drivers/rtc/rtc-lpc32xx.c
index 787550d756e9..8276ae94a2a9 100644
--- a/drivers/rtc/rtc-lpc32xx.c
+++ b/drivers/rtc/rtc-lpc32xx.c
@@ -277,7 +277,6 @@ static int lpc32xx_rtc_probe(struct platform_device *pdev)
                                        &lpc32xx_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
                dev_err(&pdev->dev, "Can't get RTC\n");
-                platform_set_drvdata(pdev, NULL);
                return PTR_ERR(rtc->rtc);
        }
@@ -306,8 +305,6 @@ static int lpc32xx_rtc_remove(struct platform_device *pdev)
        if (rtc->irq >= 0)
                device_init_wakeup(&pdev->dev, 0);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ls1x.c b/drivers/rtc/rtc-ls1x.c
index db82f91f4562..682ecb094839 100644
--- a/drivers/rtc/rtc-ls1x.c
+++ b/drivers/rtc/rtc-ls1x.c
@@ -185,19 +185,11 @@ err:
        return ret;
 }
-static int ls1x_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 static struct platform_driver  ls1x_rtc_driver = {
        .driver         = {
                .name   = "ls1x-rtc",
                .owner  = THIS_MODULE,
        },
-        .remove         = ls1x_rtc_remove,
        .probe          = ls1x_rtc_probe,
 };
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index 89674b5e6efd..a5248aa1abf1 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -168,7 +168,7 @@ static int m41t80_set_datetime(struct i2c_client *client, struct rtc_time *tm)
        buf[M41T80_REG_MIN] =
                bin2bcd(tm->tm_min) | (buf[M41T80_REG_MIN] & ~0x7f);
        buf[M41T80_REG_HOUR] =
-                bin2bcd(tm->tm_hour) | (buf[M41T80_REG_HOUR] & ~0x3f) ;
+                bin2bcd(tm->tm_hour) | (buf[M41T80_REG_HOUR] & ~0x3f);
        buf[M41T80_REG_WDAY] =
                (tm->tm_wday & 0x07) | (buf[M41T80_REG_WDAY] & ~0x07);
        buf[M41T80_REG_DAY] =
diff --git a/drivers/rtc/rtc-m41t93.c b/drivers/rtc/rtc-m41t93.c
index 9707d36e8b15..4698c7e344e4 100644
--- a/drivers/rtc/rtc-m41t93.c
+++ b/drivers/rtc/rtc-m41t93.c
@@ -194,19 +194,12 @@ static int m41t93_probe(struct spi_device *spi)
        return 0;
 }
-static int m41t93_remove(struct spi_device *spi)
-{
-        return 0;
-}
 static struct spi_driver m41t93_driver = {
        .driver = {
                .name   = "rtc-m41t93",
                .owner  = THIS_MODULE,
        },
        .probe  = m41t93_probe,
-        .remove = m41t93_remove,
 };
 module_spi_driver(m41t93_driver);
diff --git a/drivers/rtc/rtc-m41t94.c b/drivers/rtc/rtc-m41t94.c
index 7454ef0a4cfa..8d800b1bf87b 100644
--- a/drivers/rtc/rtc-m41t94.c
+++ b/drivers/rtc/rtc-m41t94.c
@@ -134,18 +134,12 @@ static int m41t94_probe(struct spi_device *spi)
        return 0;
 }
-static int m41t94_remove(struct spi_device *spi)
-{
-        return 0;
-}
 static struct spi_driver m41t94_driver = {
        .driver = {
                .name   = "rtc-m41t94",
                .owner  = THIS_MODULE,
        },
        .probe  = m41t94_probe,
-        .remove = m41t94_remove,
 };
 module_spi_driver(m41t94_driver);
diff --git a/drivers/rtc/rtc-m48t35.c b/drivers/rtc/rtc-m48t35.c
index 37444246e5e4..23c3779a5f2b 100644
--- a/drivers/rtc/rtc-m48t35.c
+++ b/drivers/rtc/rtc-m48t35.c
@@ -20,6 +20,7 @@
 #include <linux/platform_device.h>
 #include <linux/bcd.h>
 #include <linux/io.h>
+#include <linux/err.h>
 #define DRV_VERSION             "1.0"
@@ -174,15 +175,7 @@ static int m48t35_probe(struct platform_device *pdev)
        priv->rtc = devm_rtc_device_register(&pdev->dev, "m48t35",
                                  &m48t35_ops, THIS_MODULE);
-        if (IS_ERR(priv->rtc))
+        return PTR_RET(priv->rtc);
-                return PTR_ERR(priv->rtc);
-        return 0;
-}
-static int m48t35_remove(struct platform_device *pdev)
-{
-        return 0;
 }
 static struct platform_driver m48t35_platform_driver = {
@@ -191,7 +184,6 @@ static struct platform_driver m48t35_platform_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = m48t35_probe,
-        .remove         = m48t35_remove,
 };
 module_platform_driver(m48t35_platform_driver);
diff --git a/drivers/rtc/rtc-m48t59.c b/drivers/rtc/rtc-m48t59.c
index 130f29af3869..fcb03291f145 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -409,7 +409,8 @@ static int m48t59_rtc_probe(struct platform_device *pdev)
        } else if (res->flags & IORESOURCE_MEM) {
                /* we are memory-mapped */
                if (!pdata) {
-                        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+                        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata),
+                                                GFP_KERNEL);
                        if (!pdata)
                                return -ENOMEM;
                        /* Ensure we only kmalloc platform data once */
@@ -425,7 +426,7 @@ static int m48t59_rtc_probe(struct platform_device *pdev)
                        pdata->read_byte = m48t59_mem_readb;
        }
-        m48t59 = kzalloc(sizeof(*m48t59), GFP_KERNEL);
+        m48t59 = devm_kzalloc(&pdev->dev, sizeof(*m48t59), GFP_KERNEL);
        if (!m48t59)
                return -ENOMEM;
@@ -433,9 +434,10 @@ static int m48t59_rtc_probe(struct platform_device *pdev)
        if (!m48t59->ioaddr) {
                /* ioaddr not mapped externally */
-                m48t59->ioaddr = ioremap(res->start, resource_size(res));
+                m48t59->ioaddr = devm_ioremap(&pdev->dev, res->start,
+                                                resource_size(res));
                if (!m48t59->ioaddr)
-                        goto out;
+                        return ret;
        }
        /* Try to get irq number. We also can work in
@@ -446,10 +448,11 @@ static int m48t59_rtc_probe(struct platform_device *pdev)
                m48t59->irq = NO_IRQ;
        if (m48t59->irq != NO_IRQ) {
-                ret = request_irq(m48t59->irq, m48t59_rtc_interrupt,
+                ret = devm_request_irq(&pdev->dev, m48t59->irq,
-                        IRQF_SHARED, "rtc-m48t59", &pdev->dev);
+                                m48t59_rtc_interrupt, IRQF_SHARED,
+                                "rtc-m48t59", &pdev->dev);
                if (ret)
-                        goto out;
+                        return ret;
        }
        switch (pdata->type) {
        case M48T59RTC_TYPE_M48T59:
@@ -469,52 +472,29 @@ static int m48t59_rtc_probe(struct platform_device *pdev)
                break;
        default:
                dev_err(&pdev->dev, "Unknown RTC type\n");
-                ret = -ENODEV;
+                return -ENODEV;
-                goto out;
        }
        spin_lock_init(&m48t59->lock);
        platform_set_drvdata(pdev, m48t59);
-        m48t59->rtc = rtc_device_register(name, &pdev->dev, ops, THIS_MODULE);
+        m48t59->rtc = devm_rtc_device_register(&pdev->dev, name, ops,
-        if (IS_ERR(m48t59->rtc)) {
+                                                THIS_MODULE);
-                ret = PTR_ERR(m48t59->rtc);
+        if (IS_ERR(m48t59->rtc))
-                goto out;
+                return PTR_ERR(m48t59->rtc);
-        }
        m48t59_nvram_attr.size = pdata->offset;
        ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
-        if (ret) {
+        if (ret)
-                rtc_device_unregister(m48t59->rtc);
+                return ret;
-                goto out;
-        }
        return 0;
-out:
-        if (m48t59->irq != NO_IRQ)
-                free_irq(m48t59->irq, &pdev->dev);
-        if (m48t59->ioaddr)
-                iounmap(m48t59->ioaddr);
-                kfree(m48t59);
-        return ret;
 }
 static int m48t59_rtc_remove(struct platform_device *pdev)
 {
-        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
-        struct m48t59_plat_data *pdata = pdev->dev.platform_data;
        sysfs_remove_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
-        if (!IS_ERR(m48t59->rtc))
-                rtc_device_unregister(m48t59->rtc);
-        if (m48t59->ioaddr && !pdata->ioaddr)
-                iounmap(m48t59->ioaddr);
-        if (m48t59->irq != NO_IRQ)
-                free_irq(m48t59->irq, &pdev->dev);
-        platform_set_drvdata(pdev, NULL);
-        kfree(m48t59);
        return 0;
 }
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
index 33a91c484533..2d30314fa07f 100644
--- a/drivers/rtc/rtc-m48t86.c
+++ b/drivers/rtc/rtc-m48t86.c
@@ -166,20 +166,12 @@ static int m48t86_rtc_probe(struct platform_device *dev)
        return 0;
 }
-static int m48t86_rtc_remove(struct platform_device *dev)
-{
-        platform_set_drvdata(dev, NULL);
-        return 0;
-}
 static struct platform_driver m48t86_rtc_platform_driver = {
        .driver         = {
                .name   = "rtc-m48t86",
                .owner  = THIS_MODULE,
        },
        .probe          = m48t86_rtc_probe,
-        .remove         = m48t86_rtc_remove,
 };
 module_platform_driver(m48t86_rtc_platform_driver);
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index 8669d6d09a00..55969b1b771a 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -212,11 +212,6 @@ static int max6900_rtc_set_time(struct device *dev, struct rtc_time *tm)
        return max6900_i2c_set_time(to_i2c_client(dev), tm);
 }
-static int max6900_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static const struct rtc_class_ops max6900_rtc_ops = {
        .read_time = max6900_rtc_read_time,
        .set_time = max6900_rtc_set_time,
@@ -252,7 +247,6 @@ static struct i2c_driver max6900_driver = {
                   .name = "rtc-max6900",
                   },
        .probe = max6900_probe,
-        .remove = max6900_remove,
        .id_table = max6900_id,
 };
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index e3aea00c3145..ac3f4191864f 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -143,23 +143,17 @@ static int max6902_probe(struct spi_device *spi)
        return 0;
 }
-static int max6902_remove(struct spi_device *spi)
-{
-        return 0;
-}
 static struct spi_driver max6902_driver = {
        .driver = {
                .name   = "rtc-max6902",
                .owner  = THIS_MODULE,
        },
        .probe  = max6902_probe,
-        .remove = max6902_remove,
 };
 module_spi_driver(max6902_driver);
-MODULE_DESCRIPTION ("max6902 spi RTC driver");
+MODULE_DESCRIPTION("max6902 spi RTC driver");
-MODULE_AUTHOR ("Raphael Assenat");
+MODULE_AUTHOR("Raphael Assenat");
-MODULE_LICENSE ("GPL");
+MODULE_LICENSE("GPL");
 MODULE_ALIAS("spi:rtc-max6902");
diff --git a/drivers/rtc/rtc-max77686.c b/drivers/rtc/rtc-max77686.c
index 771812d62e6b..9915cb96014b 100644
--- a/drivers/rtc/rtc-max77686.c
+++ b/drivers/rtc/rtc-max77686.c
@@ -119,7 +119,7 @@ static int max77686_rtc_tm_to_data(struct rtc_time *tm, u8 *data)
        data[RTC_WEEKDAY] = 1 << tm->tm_wday;
        data[RTC_DATE] = tm->tm_mday;
        data[RTC_MONTH] = tm->tm_mon + 1;
-        data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0 ;
+        data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
        if (tm->tm_year < 100) {
                pr_warn("%s: MAX77686 RTC cannot handle the year %d."
@@ -567,11 +567,6 @@ err_rtc:
        return ret;
 }
-static int max77686_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static void max77686_rtc_shutdown(struct platform_device *pdev)
 {
 #ifdef MAX77686_RTC_WTSR_SMPL
@@ -610,7 +605,6 @@ static struct platform_driver max77686_rtc_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = max77686_rtc_probe,
-        .remove         = max77686_rtc_remove,
        .shutdown       = max77686_rtc_shutdown,
        .id_table       = rtc_id,
 };
diff --git a/drivers/rtc/rtc-max8907.c b/drivers/rtc/rtc-max8907.c
index 86afb797125d..8e45b3c4aa2f 100644
--- a/drivers/rtc/rtc-max8907.c
+++ b/drivers/rtc/rtc-max8907.c
@@ -213,18 +213,12 @@ static int max8907_rtc_probe(struct platform_device *pdev)
        return ret;
 }
-static int max8907_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static struct platform_driver max8907_rtc_driver = {
        .driver = {
                .name = "max8907-rtc",
                .owner = THIS_MODULE,
        },
        .probe = max8907_rtc_probe,
-        .remove = max8907_rtc_remove,
 };
 module_platform_driver(max8907_rtc_driver);
diff --git a/drivers/rtc/rtc-max8925.c b/drivers/rtc/rtc-max8925.c
index 7c90f4e45e27..951d1a78e190 100644
--- a/drivers/rtc/rtc-max8925.c
+++ b/drivers/rtc/rtc-max8925.c
@@ -268,7 +268,7 @@ static int max8925_rtc_probe(struct platform_device *pdev)
        if (ret < 0) {
                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
                        info->irq, ret);
-                goto err;
+                return ret;
        }
        dev_set_drvdata(&pdev->dev, info);
@@ -282,18 +282,10 @@ static int max8925_rtc_probe(struct platform_device *pdev)
        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 err;
+                return ret;
        }
        return 0;
-err:
-        platform_set_drvdata(pdev, NULL);
-        return ret;
-}
-static int max8925_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
 }
 #ifdef CONFIG_PM_SLEEP
@@ -326,7 +318,6 @@ static struct platform_driver max8925_rtc_driver = {
                .pm     = &max8925_rtc_pm_ops,
        },
        .probe          = max8925_rtc_probe,
-        .remove         = max8925_rtc_remove,
 };
 module_platform_driver(max8925_rtc_driver);
diff --git a/drivers/rtc/rtc-max8997.c b/drivers/rtc/rtc-max8997.c
index dacf48db7925..0777c01b58e0 100644
--- a/drivers/rtc/rtc-max8997.c
+++ b/drivers/rtc/rtc-max8997.c
@@ -104,7 +104,7 @@ static int max8997_rtc_tm_to_data(struct rtc_time *tm, u8 *data)
        data[RTC_WEEKDAY] = 1 << tm->tm_wday;
        data[RTC_DATE] = tm->tm_mday;
        data[RTC_MONTH] = tm->tm_mon + 1;
-        data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0 ;
+        data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
        if (tm->tm_year < 100) {
                pr_warn("%s: MAX8997 RTC cannot handle the year %d."
@@ -507,11 +507,6 @@ err_out:
        return ret;
 }
-static int max8997_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static void max8997_rtc_shutdown(struct platform_device *pdev)
 {
        struct max8997_rtc_info *info = platform_get_drvdata(pdev);
@@ -531,7 +526,6 @@ static struct platform_driver max8997_rtc_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = max8997_rtc_probe,
-        .remove         = max8997_rtc_remove,
        .shutdown       = max8997_rtc_shutdown,
        .id_table       = rtc_id,
 };
diff --git a/drivers/rtc/rtc-max8998.c b/drivers/rtc/rtc-max8998.c
index d5af7baa48b5..5388336a2c4c 100644
--- a/drivers/rtc/rtc-max8998.c
+++ b/drivers/rtc/rtc-max8998.c
@@ -274,7 +274,7 @@ static int max8998_rtc_probe(struct platform_device *pdev)
        if (IS_ERR(info->rtc_dev)) {
                ret = PTR_ERR(info->rtc_dev);
                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
-                goto out_rtc;
+                return ret;
        }
        ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
@@ -292,15 +292,6 @@ static int max8998_rtc_probe(struct platform_device *pdev)
        }
        return 0;
-out_rtc:
-        platform_set_drvdata(pdev, NULL);
-        return ret;
-}
-static int max8998_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
 }
 static const struct platform_device_id max8998_rtc_id[] = {
@@ -315,7 +306,6 @@ static struct platform_driver max8998_rtc_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = max8998_rtc_probe,
-        .remove         = max8998_rtc_remove,
        .id_table       = max8998_rtc_id,
 };
diff --git a/drivers/rtc/rtc-mc13xxx.c b/drivers/rtc/rtc-mc13xxx.c
index 7a8ed27a5f2e..77ea9896b5ba 100644
--- a/drivers/rtc/rtc-mc13xxx.c
+++ b/drivers/rtc/rtc-mc13xxx.c
@@ -370,8 +370,6 @@ err_reset_irq_status:
 err_reset_irq_request:
                mc13xxx_unlock(mc13xxx);
-                platform_set_drvdata(pdev, NULL);
        }
        return ret;
@@ -389,8 +387,6 @@ static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
        mc13xxx_unlock(priv->mc13xxx);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
index bdcc60830aec..9c8f60903799 100644
--- a/drivers/rtc/rtc-mpc5121.c
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -68,7 +68,7 @@ struct mpc5121_rtc_regs {
        u32 target_time;        /* RTC + 0x20 */
        /*
         * actual_time:
-         *      readonly time since VBAT_RTC was last connected
+         *      readonly time since VBAT_RTC was last connected
         */
        u32 actual_time;        /* RTC + 0x24 */
        u32 keep_alive;         /* RTC + 0x28 */
@@ -312,20 +312,19 @@ static int mpc5121_rtc_probe(struct platform_device *op)
        struct mpc5121_rtc_data *rtc;
        int err = 0;
-        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        rtc = devm_kzalloc(&op->dev, sizeof(*rtc), GFP_KERNEL);
        if (!rtc)
                return -ENOMEM;
        rtc->regs = of_iomap(op->dev.of_node, 0);
        if (!rtc->regs) {
                dev_err(&op->dev, "%s: couldn't map io space\n", __func__);
-                err = -ENOSYS;
+                return -ENOSYS;
-                goto out_free;
        }
        device_init_wakeup(&op->dev, 1);
-        dev_set_drvdata(&op->dev, rtc);
+        platform_set_drvdata(op, rtc);
        rtc->irq = irq_of_parse_and_map(op->dev.of_node, 1);
        err = request_irq(rtc->irq, mpc5121_rtc_handler, 0,
@@ -354,10 +353,10 @@ static int mpc5121_rtc_probe(struct platform_device *op)
                        out_be32(&rtc->regs->keep_alive, ka);
                }
-                rtc->rtc = rtc_device_register("mpc5121-rtc", &op->dev,
+                rtc->rtc = devm_rtc_device_register(&op->dev, "mpc5121-rtc",
                                                &mpc5121_rtc_ops, THIS_MODULE);
        } else {
-                rtc->rtc = rtc_device_register("mpc5200-rtc", &op->dev,
+                rtc->rtc = devm_rtc_device_register(&op->dev, "mpc5200-rtc",
                                                &mpc5200_rtc_ops, THIS_MODULE);
        }
@@ -377,29 +376,24 @@ out_dispose2:
 out_dispose:
        irq_dispose_mapping(rtc->irq);
        iounmap(rtc->regs);
-out_free:
-        kfree(rtc);
        return err;
 }
 static int mpc5121_rtc_remove(struct platform_device *op)
 {
-        struct mpc5121_rtc_data *rtc = dev_get_drvdata(&op->dev);
+        struct mpc5121_rtc_data *rtc = platform_get_drvdata(op);
        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
        /* disable interrupt, so there are no nasty surprises */
        out_8(&regs->alm_enable, 0);
        out_8(&regs->int_enable, in_8(&regs->int_enable) & ~0x1);
-        rtc_device_unregister(rtc->rtc);
        iounmap(rtc->regs);
        free_irq(rtc->irq, &op->dev);
        free_irq(rtc->irq_periodic, &op->dev);
        irq_dispose_mapping(rtc->irq);
        irq_dispose_mapping(rtc->irq_periodic);
-        dev_set_drvdata(&op->dev, NULL);
-        kfree(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-msm6242.c b/drivers/rtc/rtc-msm6242.c
index 771f86a05d14..426cb5189daa 100644
--- a/drivers/rtc/rtc-msm6242.c
+++ b/drivers/rtc/rtc-msm6242.c
@@ -111,8 +111,8 @@ static void msm6242_lock(struct msm6242_priv *priv)
        }
        if (!cnt)
-                pr_warning("msm6242: timed out waiting for RTC (0x%x)\n",
+                pr_warn("msm6242: timed out waiting for RTC (0x%x)\n",
-                           msm6242_read(priv, MSM6242_CD));
+                        msm6242_read(priv, MSM6242_CD));
 }
 static void msm6242_unlock(struct msm6242_priv *priv)
@@ -199,7 +199,6 @@ 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(pdev, IORESOURCE_MEM, 0);
        if (!res)
@@ -216,22 +215,11 @@ static int __init msm6242_rtc_probe(struct platform_device *pdev)
        rtc = devm_rtc_device_register(&pdev->dev, "rtc-msm6242",
                                &msm6242_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
+        if (IS_ERR(rtc))
-                error = PTR_ERR(rtc);
+                return PTR_ERR(rtc);
-                goto out_unmap;
-        }
        priv->rtc = rtc;
        return 0;
-out_unmap:
-        platform_set_drvdata(pdev, NULL);
-        return error;
-}
-static int __exit msm6242_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
 }
 static struct platform_driver msm6242_rtc_driver = {
@@ -239,7 +227,6 @@ static struct platform_driver msm6242_rtc_driver = {
                .name   = "rtc-msm6242",
                .owner  = THIS_MODULE,
        },
-        .remove = __exit_p(msm6242_rtc_remove),
 };
 module_platform_driver_probe(msm6242_rtc_driver, msm6242_rtc_probe);
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 9a3895bc4f4d..ab87bacb8f88 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -436,22 +436,20 @@ static int mxc_rtc_probe(struct platform_device *pdev)
                pdata->irq = -1;
        }
-        if (pdata->irq >=0)
+        if (pdata->irq >= 0)
                device_init_wakeup(&pdev->dev, 1);
        rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &mxc_rtc_ops,
                                  THIS_MODULE);
        if (IS_ERR(rtc)) {
                ret = PTR_ERR(rtc);
-                goto exit_clr_drvdata;
+                goto exit_put_clk;
        }
        pdata->rtc = rtc;
        return 0;
-exit_clr_drvdata:
-        platform_set_drvdata(pdev, NULL);
 exit_put_clk:
        clk_disable_unprepare(pdata->clk);
@@ -465,7 +463,6 @@ static int mxc_rtc_remove(struct platform_device *pdev)
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        clk_disable_unprepare(pdata->clk);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-nuc900.c b/drivers/rtc/rtc-nuc900.c
index d592e2fe43f7..22861c5e0c59 100644
--- a/drivers/rtc/rtc-nuc900.c
+++ b/drivers/rtc/rtc-nuc900.c
@@ -260,15 +260,7 @@ static int __init nuc900_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int __exit nuc900_rtc_remove(struct platform_device *pdev)
-{
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
 static struct platform_driver nuc900_rtc_driver = {
-        .remove         = __exit_p(nuc900_rtc_remove),
        .driver         = {
                .name   = "nuc900-rtc",
                .owner  = THIS_MODULE,
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index b0ba3fc991ea..c6ffbaec32a4 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -23,9 +23,7 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/pm_runtime.h>
+#include <linux/io.h>
-#include <asm/io.h>
 /* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
 * with century-range alarm matching, driven by the 32kHz clock.
@@ -423,6 +421,8 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
         *    is write-only, and always reads as zero...)
         */
+        device_init_wakeup(&pdev->dev, true);
        if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
                pr_info("%s: split power mode\n", pdev->name);
diff --git a/drivers/rtc/rtc-palmas.c b/drivers/rtc/rtc-palmas.c
index 50204d474eb7..a1fecc8d97fc 100644
--- a/drivers/rtc/rtc-palmas.c
+++ b/drivers/rtc/rtc-palmas.c
@@ -265,6 +265,7 @@ static int palmas_rtc_probe(struct platform_device *pdev)
        palmas_rtc->irq = platform_get_irq(pdev, 0);
+        device_init_wakeup(&pdev->dev, 1);
        palmas_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                &palmas_rtc_ops, THIS_MODULE);
        if (IS_ERR(palmas_rtc->rtc)) {
@@ -283,7 +284,6 @@ static int palmas_rtc_probe(struct platform_device *pdev)
                return ret;
        }
-        device_set_wakeup_capable(&pdev->dev, 1);
        return 0;
 }
diff --git a/drivers/rtc/rtc-pcap.c b/drivers/rtc/rtc-pcap.c
index 539a90b98bc5..40b5c630bc7d 100644
--- a/drivers/rtc/rtc-pcap.c
+++ b/drivers/rtc/rtc-pcap.c
@@ -156,10 +156,8 @@ static int __init pcap_rtc_probe(struct platform_device *pdev)
        pcap_rtc->rtc = devm_rtc_device_register(&pdev->dev, "pcap",
                                        &pcap_rtc_ops, THIS_MODULE);
-        if (IS_ERR(pcap_rtc->rtc)) {
+        if (IS_ERR(pcap_rtc->rtc))
-                err = PTR_ERR(pcap_rtc->rtc);
+                return PTR_ERR(pcap_rtc->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);
@@ -167,17 +165,14 @@ static int __init pcap_rtc_probe(struct platform_device *pdev)
        err = devm_request_irq(&pdev->dev, timer_irq, pcap_rtc_irq, 0,
                                "RTC Timer", pcap_rtc);
        if (err)
-                goto fail;
+                return err;
        err = devm_request_irq(&pdev->dev, alarm_irq, pcap_rtc_irq, 0,
                                "RTC Alarm", pcap_rtc);
        if (err)
-                goto fail;
+                return err;
        return 0;
-fail:
-        platform_set_drvdata(pdev, NULL);
-        return err;
 }
 static int __exit pcap_rtc_remove(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-pcf2123.c b/drivers/rtc/rtc-pcf2123.c
index 796a6c5067dd..1725b5090e33 100644
--- a/drivers/rtc/rtc-pcf2123.c
+++ b/drivers/rtc/rtc-pcf2123.c
@@ -18,11 +18,11 @@
 * should look something like:
 *
 * static struct spi_board_info ek_spi_devices[] = {
- *      ...
+ *      ...
- *      {
+ *      {
- *              .modalias               = "rtc-pcf2123",
+ *              .modalias               = "rtc-pcf2123",
- *              .chip_select            = 1,
+ *              .chip_select            = 1,
- *              .controller_data        = (void *)AT91_PIN_PA10,
+ *              .controller_data        = (void *)AT91_PIN_PA10,
 *              .max_speed_hz           = 1000 * 1000,
 *              .mode                   = SPI_CS_HIGH,
 *              .bus_num                = 0,
@@ -94,8 +94,9 @@ static ssize_t pcf2123_show(struct device *dev, struct device_attribute *attr,
        r = container_of(attr, struct pcf2123_sysfs_reg, attr);
-        if (strict_strtoul(r->name, 16, &reg))
+        ret = kstrtoul(r->name, 16, &reg);
-                return -EINVAL;
+        if (ret)
+                return ret;
        txbuf[0] = PCF2123_READ | reg;
        ret = spi_write_then_read(spi, txbuf, 1, rxbuf, 1);
@@ -117,9 +118,13 @@ static ssize_t pcf2123_store(struct device *dev, struct device_attribute *attr,
        r = container_of(attr, struct pcf2123_sysfs_reg, attr);
-        if (strict_strtoul(r->name, 16, &reg)
+        ret = kstrtoul(r->name, 16, &reg);
-                || strict_strtoul(buffer, 10, &val))
+        if (ret)
-                return -EINVAL;
+                return ret;
+        ret = kstrtoul(buffer, 10, &val);
+        if (ret)
+                return ret;
        txbuf[0] = PCF2123_WRITE | reg;
        txbuf[1] = val;
diff --git a/drivers/rtc/rtc-pcf2127.c b/drivers/rtc/rtc-pcf2127.c
new file mode 100644
index 000000000000..205b9f7da1b8
--- /dev/null
+++ b/drivers/rtc/rtc-pcf2127.c
@@ -0,0 +1,241 @@
+/*
+ * An I2C driver for the NXP PCF2127 RTC
+ * Copyright 2013 Til-Technologies
+ *
+ * Author: Renaud Cerrato <r.cerrato@til-technologies.fr>
+ *
+ * based on the other drivers in this same directory.
+ *
+ * http://www.nxp.com/documents/data_sheet/PCF2127AT.pdf
+ *
+ * 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.
+ */
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#define DRV_VERSION "0.0.1"
+#define PCF2127_REG_CTRL1       (0x00)  /* Control Register 1 */
+#define PCF2127_REG_CTRL2       (0x01)  /* Control Register 2 */
+#define PCF2127_REG_CTRL3       (0x02)  /* Control Register 3 */
+#define PCF2127_REG_SC          (0x03)  /* datetime */
+#define PCF2127_REG_MN          (0x04)
+#define PCF2127_REG_HR          (0x05)
+#define PCF2127_REG_DM          (0x06)
+#define PCF2127_REG_DW          (0x07)
+#define PCF2127_REG_MO          (0x08)
+#define PCF2127_REG_YR          (0x09)
+static struct i2c_driver pcf2127_driver;
+struct pcf2127 {
+        struct rtc_device *rtc;
+        int voltage_low; /* indicates if a low_voltage was detected */
+};
+/*
+ * In the routines that deal directly with the pcf2127 hardware, we use
+ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
+ */
+static int pcf2127_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        struct pcf2127 *pcf2127 = i2c_get_clientdata(client);
+        unsigned char buf[10] = { PCF2127_REG_CTRL1 };
+        /* read registers */
+        if (i2c_master_send(client, buf, 1) != 1 ||
+                i2c_master_recv(client, buf, sizeof(buf)) != sizeof(buf)) {
+                dev_err(&client->dev, "%s: read error\n", __func__);
+                return -EIO;
+        }
+        if (buf[PCF2127_REG_CTRL3] & 0x04) {
+                pcf2127->voltage_low = 1;
+                dev_info(&client->dev,
+                        "low voltage detected, date/time is not reliable.\n");
+        }
+        dev_dbg(&client->dev,
+                "%s: raw data is cr1=%02x, cr2=%02x, cr3=%02x, "
+                "sec=%02x, min=%02x, hr=%02x, "
+                "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
+                __func__,
+                buf[0], buf[1], buf[2],
+                buf[3], buf[4], buf[5],
+                buf[6], buf[7], buf[8], buf[9]);
+        tm->tm_sec = bcd2bin(buf[PCF2127_REG_SC] & 0x7F);
+        tm->tm_min = bcd2bin(buf[PCF2127_REG_MN] & 0x7F);
+        tm->tm_hour = bcd2bin(buf[PCF2127_REG_HR] & 0x3F); /* rtc hr 0-23 */
+        tm->tm_mday = bcd2bin(buf[PCF2127_REG_DM] & 0x3F);
+        tm->tm_wday = buf[PCF2127_REG_DW] & 0x07;
+        tm->tm_mon = bcd2bin(buf[PCF2127_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
+        tm->tm_year = bcd2bin(buf[PCF2127_REG_YR]);
+        if (tm->tm_year < 70)
+                tm->tm_year += 100;     /* assume we are in 1970...2069 */
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __func__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+        /* the clock can give out invalid datetime, but we cannot return
+         * -EINVAL otherwise hwclock will refuse to set the time on bootup.
+         */
+        if (rtc_valid_tm(tm) < 0)
+                dev_err(&client->dev, "retrieved date/time is not valid.\n");
+        return 0;
+}
+static int pcf2127_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned char buf[8];
+        int i = 0, err;
+        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __func__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+        /* start register address */
+        buf[i++] = PCF2127_REG_SC;
+        /* hours, minutes and seconds */
+        buf[i++] = bin2bcd(tm->tm_sec);
+        buf[i++] = bin2bcd(tm->tm_min);
+        buf[i++] = bin2bcd(tm->tm_hour);
+        buf[i++] = bin2bcd(tm->tm_mday);
+        buf[i++] = tm->tm_wday & 0x07;
+        /* month, 1 - 12 */
+        buf[i++] = bin2bcd(tm->tm_mon + 1);
+        /* year */
+        buf[i++] = bin2bcd(tm->tm_year % 100);
+        /* write register's data */
+        err = i2c_master_send(client, buf, i);
+        if (err != i) {
+                dev_err(&client->dev,
+                        "%s: err=%d", __func__, err);
+                return -EIO;
+        }
+        return 0;
+}
+#ifdef CONFIG_RTC_INTF_DEV
+static int pcf2127_rtc_ioctl(struct device *dev,
+                                unsigned int cmd, unsigned long arg)
+{
+        struct pcf2127 *pcf2127 = i2c_get_clientdata(to_i2c_client(dev));
+        switch (cmd) {
+        case RTC_VL_READ:
+                if (pcf2127->voltage_low)
+                        dev_info(dev, "low voltage detected, date/time is not reliable.\n");
+                if (copy_to_user((void __user *)arg, &pcf2127->voltage_low,
+                                        sizeof(int)))
+                        return -EFAULT;
+                return 0;
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+#else
+#define pcf2127_rtc_ioctl NULL
+#endif
+static int pcf2127_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return pcf2127_get_datetime(to_i2c_client(dev), tm);
+}
+static int pcf2127_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return pcf2127_set_datetime(to_i2c_client(dev), tm);
+}
+static const struct rtc_class_ops pcf2127_rtc_ops = {
+        .ioctl          = pcf2127_rtc_ioctl,
+        .read_time      = pcf2127_rtc_read_time,
+        .set_time       = pcf2127_rtc_set_time,
+};
+static int pcf2127_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
+{
+        struct pcf2127 *pcf2127;
+        dev_dbg(&client->dev, "%s\n", __func__);
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+                return -ENODEV;
+        pcf2127 = devm_kzalloc(&client->dev, sizeof(struct pcf2127),
+                                GFP_KERNEL);
+        if (!pcf2127)
+                return -ENOMEM;
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+        i2c_set_clientdata(client, pcf2127);
+        pcf2127->rtc = devm_rtc_device_register(&client->dev,
+                                pcf2127_driver.driver.name,
+                                &pcf2127_rtc_ops, THIS_MODULE);
+        if (IS_ERR(pcf2127->rtc))
+                return PTR_ERR(pcf2127->rtc);
+        return 0;
+}
+static int pcf2127_remove(struct i2c_client *client)
+{
+        return 0;
+}
+static const struct i2c_device_id pcf2127_id[] = {
+        { "pcf2127", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, pcf2127_id);
+#ifdef CONFIG_OF
+static const struct of_device_id pcf2127_of_match[] = {
+        { .compatible = "nxp,pcf2127" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, pcf2127_of_match);
+#endif
+static struct i2c_driver pcf2127_driver = {
+        .driver         = {
+                .name   = "rtc-pcf2127",
+                .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(pcf2127_of_match),
+        },
+        .probe          = pcf2127_probe,
+        .remove         = pcf2127_remove,
+        .id_table       = pcf2127_id,
+};
+module_i2c_driver(pcf2127_driver);
+MODULE_AUTHOR("Renaud Cerrato <r.cerrato@til-technologies.fr>");
+MODULE_DESCRIPTION("NXP PCF2127 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-pcf8523.c b/drivers/rtc/rtc-pcf8523.c
index 305c9515e5bb..5c8f8226c848 100644
--- a/drivers/rtc/rtc-pcf8523.c
+++ b/drivers/rtc/rtc-pcf8523.c
@@ -317,11 +317,6 @@ static int pcf8523_probe(struct i2c_client *client,
        return 0;
 }
-static int pcf8523_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static const struct i2c_device_id pcf8523_id[] = {
        { "pcf8523", 0 },
        { }
@@ -343,7 +338,6 @@ static struct i2c_driver pcf8523_driver = {
                .of_match_table = of_match_ptr(pcf8523_of_match),
        },
        .probe = pcf8523_probe,
-        .remove = pcf8523_remove,
        .id_table = pcf8523_id,
 };
 module_i2c_driver(pcf8523_driver);
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index 97b354a26a44..710c3a5aa6ff 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -20,6 +20,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/err.h>
 #define DRV_VERSION "0.4.3"
@@ -263,15 +264,7 @@ static int pcf8563_probe(struct i2c_client *client,
                                pcf8563_driver.driver.name,
                                &pcf8563_rtc_ops, THIS_MODULE);
-        if (IS_ERR(pcf8563->rtc))
+        return PTR_RET(pcf8563->rtc);
-                return PTR_ERR(pcf8563->rtc);
-        return 0;
-}
-static int pcf8563_remove(struct i2c_client *client)
-{
-        return 0;
 }
 static const struct i2c_device_id pcf8563_id[] = {
@@ -296,7 +289,6 @@ static struct i2c_driver pcf8563_driver = {
                .of_match_table = of_match_ptr(pcf8563_of_match),
        },
        .probe          = pcf8563_probe,
-        .remove         = pcf8563_remove,
        .id_table       = pcf8563_id,
 };
diff --git a/drivers/rtc/rtc-pcf8583.c b/drivers/rtc/rtc-pcf8583.c
index 95886dcf4a39..843a745c42f3 100644
--- a/drivers/rtc/rtc-pcf8583.c
+++ b/drivers/rtc/rtc-pcf8583.c
@@ -17,6 +17,7 @@
 #include <linux/slab.h>
 #include <linux/rtc.h>
 #include <linux/init.h>
+#include <linux/err.h>
 #include <linux/errno.h>
 #include <linux/bcd.h>
@@ -188,7 +189,8 @@ static int pcf8583_rtc_read_time(struct device *dev, struct rtc_time *tm)
                dev_warn(dev, "resetting control %02x -> %02x\n",
                        ctrl, new_ctrl);
-                if ((err = pcf8583_set_ctrl(client, &new_ctrl)) < 0)
+                err = pcf8583_set_ctrl(client, &new_ctrl);
+                if (err < 0)
                        return err;
        }
@@ -283,15 +285,7 @@ static int pcf8583_probe(struct i2c_client *client,
                                pcf8583_driver.driver.name,
                                &pcf8583_rtc_ops, THIS_MODULE);
-        if (IS_ERR(pcf8583->rtc))
+        return PTR_RET(pcf8583->rtc);
-                return PTR_ERR(pcf8583->rtc);
-        return 0;
-}
-static int pcf8583_remove(struct i2c_client *client)
-{
-        return 0;
 }
 static const struct i2c_device_id pcf8583_id[] = {
@@ -306,7 +300,6 @@ static struct i2c_driver pcf8583_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = pcf8583_probe,
-        .remove         = pcf8583_remove,
        .id_table       = pcf8583_id,
 };
diff --git a/drivers/rtc/rtc-pm8xxx.c b/drivers/rtc/rtc-pm8xxx.c
index f1a6557261f3..03f8f75d5af2 100644
--- a/drivers/rtc/rtc-pm8xxx.c
+++ b/drivers/rtc/rtc-pm8xxx.c
@@ -395,7 +395,7 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
        if (pdata != NULL)
                rtc_write_enable = pdata->rtc_write_enable;
-        rtc_dd = kzalloc(sizeof(*rtc_dd), GFP_KERNEL);
+        rtc_dd = devm_kzalloc(&pdev->dev, sizeof(*rtc_dd), GFP_KERNEL);
        if (rtc_dd == NULL) {
                dev_err(&pdev->dev, "Unable to allocate memory!\n");
                return -ENOMEM;
@@ -407,16 +407,14 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
        rtc_dd->rtc_alarm_irq = platform_get_irq(pdev, 0);
        if (rtc_dd->rtc_alarm_irq < 0) {
                dev_err(&pdev->dev, "Alarm IRQ resource absent!\n");
-                rc = -ENXIO;
+                return -ENXIO;
-                goto fail_rtc_enable;
        }
        rtc_resource = platform_get_resource_byname(pdev, IORESOURCE_IO,
                                                        "pmic_rtc_base");
        if (!(rtc_resource && rtc_resource->start)) {
                dev_err(&pdev->dev, "RTC IO resource absent!\n");
-                rc = -ENXIO;
+                return -ENXIO;
-                goto fail_rtc_enable;
        }
        rtc_dd->rtc_base = rtc_resource->start;
@@ -432,7 +430,7 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
        rc = pm8xxx_read_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base, 1);
        if (rc < 0) {
                dev_err(&pdev->dev, "RTC control register read failed!\n");
-                goto fail_rtc_enable;
+                return rc;
        }
        if (!(ctrl_reg & PM8xxx_RTC_ENABLE)) {
@@ -442,7 +440,7 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
                if (rc < 0) {
                        dev_err(&pdev->dev, "Write to RTC control register "
                                                                "failed\n");
-                        goto fail_rtc_enable;
+                        return rc;
                }
        }
@@ -453,13 +451,12 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, rtc_dd);
        /* Register the RTC device */
-        rtc_dd->rtc = rtc_device_register("pm8xxx_rtc", &pdev->dev,
+        rtc_dd->rtc = devm_rtc_device_register(&pdev->dev, "pm8xxx_rtc",
                                &pm8xxx_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc_dd->rtc)) {
                dev_err(&pdev->dev, "%s: RTC registration failed (%ld)\n",
                                        __func__, PTR_ERR(rtc_dd->rtc));
-                rc = PTR_ERR(rtc_dd->rtc);
+                return PTR_ERR(rtc_dd->rtc);
-                goto fail_rtc_enable;
        }
        /* Request the alarm IRQ */
@@ -468,7 +465,7 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
                                 "pm8xxx_rtc_alarm", rtc_dd);
        if (rc < 0) {
                dev_err(&pdev->dev, "Request IRQ failed (%d)\n", rc);
-                goto fail_req_irq;
+                return rc;
        }
        device_init_wakeup(&pdev->dev, 1);
@@ -476,13 +473,6 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
        dev_dbg(&pdev->dev, "Probe success !!\n");
        return 0;
-fail_req_irq:
-        rtc_device_unregister(rtc_dd->rtc);
-fail_rtc_enable:
-        platform_set_drvdata(pdev, NULL);
-        kfree(rtc_dd);
-        return rc;
 }
 static int pm8xxx_rtc_remove(struct platform_device *pdev)
@@ -491,9 +481,6 @@ static int pm8xxx_rtc_remove(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 0);
        free_irq(rtc_dd->rtc_alarm_irq, rtc_dd);
-        rtc_device_unregister(rtc_dd->rtc);
-        platform_set_drvdata(pdev, NULL);
-        kfree(rtc_dd);
        return 0;
 }
diff --git a/drivers/rtc/rtc-ps3.c b/drivers/rtc/rtc-ps3.c
index 4bb825bb5804..554ada5e9b76 100644
--- a/drivers/rtc/rtc-ps3.c
+++ b/drivers/rtc/rtc-ps3.c
@@ -71,17 +71,11 @@ static int __init ps3_rtc_probe(struct platform_device *dev)
        return 0;
 }
-static int __exit ps3_rtc_remove(struct platform_device *dev)
-{
-        return 0;
-}
 static struct platform_driver ps3_rtc_driver = {
        .driver = {
                .name = "rtc-ps3",
                .owner = THIS_MODULE,
        },
-        .remove = __exit_p(ps3_rtc_remove),
 };
 module_platform_driver_probe(ps3_rtc_driver, ps3_rtc_probe);
diff --git a/drivers/rtc/rtc-puv3.c b/drivers/rtc/rtc-puv3.c
index 72f437170d2e..402732cfb32a 100644
--- a/drivers/rtc/rtc-puv3.c
+++ b/drivers/rtc/rtc-puv3.c
@@ -224,7 +224,6 @@ static int puv3_rtc_remove(struct platform_device *dev)
 {
        struct rtc_device *rtc = platform_get_drvdata(dev);
-        platform_set_drvdata(dev, NULL);
        rtc_device_unregister(rtc);
        puv3_rtc_setpie(&dev->dev, 0);
diff --git a/drivers/rtc/rtc-pxa.c b/drivers/rtc/rtc-pxa.c
index ed037ae91c5f..a355f2b82bb8 100644
--- a/drivers/rtc/rtc-pxa.c
+++ b/drivers/rtc/rtc-pxa.c
@@ -324,37 +324,35 @@ static int __init pxa_rtc_probe(struct platform_device *pdev)
        int ret;
        u32 rttr;
-        pxa_rtc = kzalloc(sizeof(struct pxa_rtc), GFP_KERNEL);
+        pxa_rtc = devm_kzalloc(dev, sizeof(*pxa_rtc), GFP_KERNEL);
        if (!pxa_rtc)
                return -ENOMEM;
        spin_lock_init(&pxa_rtc->lock);
        platform_set_drvdata(pdev, pxa_rtc);
-        ret = -ENXIO;
        pxa_rtc->ress = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!pxa_rtc->ress) {
                dev_err(dev, "No I/O memory resource defined\n");
-                goto err_ress;
+                return -ENXIO;
        }
        pxa_rtc->irq_1Hz = platform_get_irq(pdev, 0);
        if (pxa_rtc->irq_1Hz < 0) {
                dev_err(dev, "No 1Hz IRQ resource defined\n");
-                goto err_ress;
+                return -ENXIO;
        }
        pxa_rtc->irq_Alrm = platform_get_irq(pdev, 1);
        if (pxa_rtc->irq_Alrm < 0) {
                dev_err(dev, "No alarm IRQ resource defined\n");
-                goto err_ress;
+                return -ENXIO;
        }
        pxa_rtc_open(dev);
-        ret = -ENOMEM;
+        pxa_rtc->base = devm_ioremap(dev, pxa_rtc->ress->start,
-        pxa_rtc->base = ioremap(pxa_rtc->ress->start,
                                resource_size(pxa_rtc->ress));
        if (!pxa_rtc->base) {
-                dev_err(&pdev->dev, "Unable to map pxa RTC I/O memory\n");
+                dev_err(dev, "Unable to map pxa RTC I/O memory\n");
-                goto err_map;
+                return -ENOMEM;
        }
        /*
@@ -370,41 +368,24 @@ static int __init pxa_rtc_probe(struct platform_device *pdev)
        rtsr_clear_bits(pxa_rtc, RTSR_PIALE | RTSR_RDALE1 | RTSR_HZE);
-        pxa_rtc->rtc = rtc_device_register("pxa-rtc", &pdev->dev, &pxa_rtc_ops,
+        pxa_rtc->rtc = devm_rtc_device_register(&pdev->dev, "pxa-rtc",
-                                           THIS_MODULE);
+                                                &pxa_rtc_ops, THIS_MODULE);
-        ret = PTR_ERR(pxa_rtc->rtc);
        if (IS_ERR(pxa_rtc->rtc)) {
+                ret = PTR_ERR(pxa_rtc->rtc);
                dev_err(dev, "Failed to register RTC device -> %d\n", ret);
-                goto err_rtc_reg;
+                return ret;
        }
        device_init_wakeup(dev, 1);
        return 0;
-err_rtc_reg:
-         iounmap(pxa_rtc->base);
-err_ress:
-err_map:
-        kfree(pxa_rtc);
-        return ret;
 }
 static int __exit pxa_rtc_remove(struct platform_device *pdev)
 {
-        struct pxa_rtc *pxa_rtc = platform_get_drvdata(pdev);
        struct device *dev = &pdev->dev;
-        pxa_rtc_release(dev);
-        rtc_device_unregister(pxa_rtc->rtc);
-        spin_lock_irq(&pxa_rtc->lock);
-        iounmap(pxa_rtc->base);
-        spin_unlock_irq(&pxa_rtc->lock);
-        kfree(pxa_rtc);
+        pxa_rtc_release(dev);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rc5t583.c b/drivers/rtc/rtc-rc5t583.c
index 8eabcf51b35a..e53e9b1c69b3 100644
--- a/drivers/rtc/rtc-rc5t583.c
+++ b/drivers/rtc/rtc-rc5t583.c
@@ -273,7 +273,7 @@ static int rc5t583_rtc_probe(struct platform_device *pdev)
 */
 static int rc5t583_rtc_remove(struct platform_device *pdev)
 {
-        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(&pdev->dev);
+        struct rc5t583_rtc *rc5t583_rtc = platform_get_drvdata(pdev);
        rc5t583_rtc_alarm_irq_enable(&rc5t583_rtc->rtc->dev, 0);
        return 0;
diff --git a/drivers/rtc/rtc-rp5c01.c b/drivers/rtc/rtc-rp5c01.c
index 873c689f01c3..89d073679267 100644
--- a/drivers/rtc/rtc-rp5c01.c
+++ b/drivers/rtc/rtc-rp5c01.c
@@ -251,21 +251,15 @@ static int __init rp5c01_rtc_probe(struct platform_device *dev)
        rtc = devm_rtc_device_register(&dev->dev, "rtc-rp5c01", &rp5c01_rtc_ops,
                                  THIS_MODULE);
-        if (IS_ERR(rtc)) {
+        if (IS_ERR(rtc))
-                error = PTR_ERR(rtc);
+                return PTR_ERR(rtc);
-                goto out;
-        }
        priv->rtc = rtc;
        error = sysfs_create_bin_file(&dev->dev.kobj, &priv->nvram_attr);
        if (error)
-                goto out;
+                return error;
        return 0;
-out:
-        platform_set_drvdata(dev, NULL);
-        return error;
 }
 static int __exit rp5c01_rtc_remove(struct platform_device *dev)
diff --git a/drivers/rtc/rtc-rs5c313.c b/drivers/rtc/rtc-rs5c313.c
index 8089fc63e403..68f7856422f1 100644
--- a/drivers/rtc/rtc-rs5c313.c
+++ b/drivers/rtc/rtc-rs5c313.c
@@ -47,10 +47,10 @@
 #include <linux/platform_device.h>
 #include <linux/bcd.h>
 #include <linux/delay.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #define DRV_NAME        "rs5c313"
-#define DRV_VERSION     "1.13"
+#define DRV_VERSION     "1.13"
 #ifdef CONFIG_SH_LANDISK
 /*****************************************************/
@@ -301,7 +301,7 @@ static int rs5c313_rtc_set_time(struct device *dev, struct rtc_time *tm)
        rs5c313_write_reg(RS5C313_ADDR_SEC10, (data >> 4));
        data = bin2bcd(tm->tm_min);
-        rs5c313_write_reg(RS5C313_ADDR_MIN, data );
+        rs5c313_write_reg(RS5C313_ADDR_MIN, data);
        rs5c313_write_reg(RS5C313_ADDR_MIN10, (data >> 4));
        data = bin2bcd(tm->tm_hour);
@@ -310,7 +310,7 @@ static int rs5c313_rtc_set_time(struct device *dev, struct rtc_time *tm)
        data = bin2bcd(tm->tm_mday);
        rs5c313_write_reg(RS5C313_ADDR_DAY, data);
-        rs5c313_write_reg(RS5C313_ADDR_DAY10, (data>> 4));
+        rs5c313_write_reg(RS5C313_ADDR_DAY10, (data >> 4));
        data = bin2bcd(tm->tm_mon + 1);
        rs5c313_write_reg(RS5C313_ADDR_MON, data);
@@ -349,9 +349,9 @@ static void rs5c313_check_xstp_bit(void)
                }
                memset(&tm, 0, sizeof(struct rtc_time));
-                tm.tm_mday      = 1;
+                tm.tm_mday      = 1;
-                tm.tm_mon       = 1 - 1;
+                tm.tm_mon       = 1 - 1;
-                tm.tm_year      = 2000 - 1900;
+                tm.tm_year      = 2000 - 1900;
                rs5c313_rtc_set_time(NULL, &tm);
                pr_err("invalid value, resetting to 1 Jan 2000\n");
@@ -378,18 +378,12 @@ static int rs5c313_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int rs5c313_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static struct platform_driver rs5c313_rtc_platform_driver = {
        .driver         = {
                .name   = DRV_NAME,
                .owner  = THIS_MODULE,
        },
-        .probe  = rs5c313_rtc_probe,
+        .probe  = rs5c313_rtc_probe,
-        .remove = rs5c313_rtc_remove,
 };
 static int __init rs5c313_rtc_init(void)
@@ -408,7 +402,7 @@ static int __init rs5c313_rtc_init(void)
 static void __exit rs5c313_rtc_exit(void)
 {
-        platform_driver_unregister( &rs5c313_rtc_platform_driver );
+        platform_driver_unregister(&rs5c313_rtc_platform_driver);
 }
 module_init(rs5c313_rtc_init);
diff --git a/drivers/rtc/rtc-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
index 2c37df3586c7..f7a90a116a39 100644
--- a/drivers/rtc/rtc-rs5c348.c
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -218,18 +218,12 @@ static int rs5c348_probe(struct spi_device *spi)
        return ret;
 }
-static int rs5c348_remove(struct spi_device *spi)
-{
-        return 0;
-}
 static struct spi_driver rs5c348_driver = {
        .driver = {
                .name   = "rtc-rs5c348",
                .owner  = THIS_MODULE,
        },
        .probe  = rs5c348_probe,
-        .remove = rs5c348_remove,
 };
 module_spi_driver(rs5c348_driver);
diff --git a/drivers/rtc/rtc-rv3029c2.c b/drivers/rtc/rtc-rv3029c2.c
index 5032c24ec159..1a779a67ff66 100644
--- a/drivers/rtc/rtc-rv3029c2.c
+++ b/drivers/rtc/rtc-rv3029c2.c
@@ -310,7 +310,7 @@ static int rv3029c2_rtc_i2c_set_alarm(struct i2c_client *client,
                dev_dbg(&client->dev, "alarm IRQ armed\n");
        } else {
                /* disable AIE irq */
-                ret = rv3029c2_rtc_i2c_alarm_set_irq(client, 1);
+                ret = rv3029c2_rtc_i2c_alarm_set_irq(client, 0);
                if (ret)
                        return ret;
@@ -412,17 +412,11 @@ static int rv3029c2_probe(struct i2c_client *client,
        return 0;
 }
-static int rv3029c2_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static struct i2c_driver rv3029c2_driver = {
        .driver = {
                .name = "rtc-rv3029c2",
        },
        .probe = rv3029c2_probe,
-        .remove = rv3029c2_remove,
        .id_table = rv3029c2_id,
 };
diff --git a/drivers/rtc/rtc-rx4581.c b/drivers/rtc/rtc-rx4581.c
index 84eb08d65d30..6889222f9ed6 100644
--- a/drivers/rtc/rtc-rx4581.c
+++ b/drivers/rtc/rtc-rx4581.c
@@ -282,11 +282,6 @@ static int rx4581_probe(struct spi_device *spi)
        return 0;
 }
-static int rx4581_remove(struct spi_device *spi)
-{
-        return 0;
-}
 static const struct spi_device_id rx4581_id[] = {
        { "rx4581", 0 },
        { }
@@ -299,7 +294,6 @@ static struct spi_driver rx4581_driver = {
                .owner  = THIS_MODULE,
        },
        .probe  = rx4581_probe,
-        .remove = rx4581_remove,
        .id_table = rx4581_id,
 };
diff --git a/drivers/rtc/rtc-rx8025.c b/drivers/rtc/rtc-rx8025.c
index 0722d36b9c9a..8fa23eabcb68 100644
--- a/drivers/rtc/rtc-rx8025.c
+++ b/drivers/rtc/rtc-rx8025.c
@@ -549,7 +549,7 @@ static int rx8025_probe(struct i2c_client *client,
                goto errout;
        }
-        rx8025 = kzalloc(sizeof(*rx8025), GFP_KERNEL);
+        rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL);
        if (!rx8025) {
                dev_err(&adapter->dev, "failed to alloc memory\n");
                err = -ENOMEM;
@@ -562,7 +562,7 @@ static int rx8025_probe(struct i2c_client *client,
        err = rx8025_init_client(client, &need_reset);
        if (err)
-                goto errout_free;
+                goto errout;
        if (need_reset) {
                struct rtc_time tm;
@@ -572,12 +572,12 @@ static int rx8025_probe(struct i2c_client *client,
                rx8025_set_time(&client->dev, &tm);
        }
-        rx8025->rtc = rtc_device_register(client->name, &client->dev,
+        rx8025->rtc = devm_rtc_device_register(&client->dev, client->name,
                                          &rx8025_rtc_ops, THIS_MODULE);
        if (IS_ERR(rx8025->rtc)) {
                err = PTR_ERR(rx8025->rtc);
                dev_err(&client->dev, "unable to register the class device\n");
-                goto errout_free;
+                goto errout;
        }
        if (client->irq > 0) {
@@ -586,7 +586,7 @@ static int rx8025_probe(struct i2c_client *client,
                                  0, "rx8025", client);
                if (err) {
                        dev_err(&client->dev, "unable to request IRQ\n");
-                        goto errout_reg;
+                        goto errout;
                }
        }
@@ -603,12 +603,6 @@ errout_irq:
        if (client->irq > 0)
                free_irq(client->irq, client);
-errout_reg:
-        rtc_device_unregister(rx8025->rtc);
-errout_free:
-        kfree(rx8025);
 errout:
        dev_err(&adapter->dev, "probing for rx8025 failed\n");
        return err;
@@ -629,8 +623,6 @@ static int rx8025_remove(struct i2c_client *client)
        }
        rx8025_sysfs_unregister(&client->dev);
-        rtc_device_unregister(rx8025->rtc);
-        kfree(rx8025);
        return 0;
 }
diff --git a/drivers/rtc/rtc-rx8581.c b/drivers/rtc/rtc-rx8581.c
index 07f3037b18f4..00b0eb7fe166 100644
--- a/drivers/rtc/rtc-rx8581.c
+++ b/drivers/rtc/rtc-rx8581.c
@@ -251,11 +251,6 @@ static int rx8581_probe(struct i2c_client *client,
        return 0;
 }
-static int rx8581_remove(struct i2c_client *client)
-{
-        return 0;
-}
 static const struct i2c_device_id rx8581_id[] = {
        { "rx8581", 0 },
        { }
@@ -268,7 +263,6 @@ static struct i2c_driver rx8581_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = rx8581_probe,
-        .remove         = rx8581_remove,
        .id_table       = rx8581_id,
 };
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index 0b495e8b8e66..7afd373b9595 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -421,8 +421,6 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
 static int s3c_rtc_remove(struct platform_device *dev)
 {
-        platform_set_drvdata(dev, NULL);
        s3c_rtc_setaie(&dev->dev, 0);
        clk_unprepare(rtc_clk);
@@ -549,23 +547,20 @@ static int s3c_rtc_probe(struct platform_device *pdev)
                          0,  "s3c2410-rtc alarm", rtc);
        if (ret) {
                dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
-                goto err_alarm_irq;
+                goto err_nortc;
        }
        ret = devm_request_irq(&pdev->dev, s3c_rtc_tickno, s3c_rtc_tickirq,
                          0,  "s3c2410-rtc tick", rtc);
        if (ret) {
                dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
-                goto err_alarm_irq;
+                goto err_nortc;
        }
        clk_disable(rtc_clk);
        return 0;
- err_alarm_irq:
-        platform_set_drvdata(pdev, NULL);
 err_nortc:
        s3c_rtc_enable(pdev, 0);
        clk_disable_unprepare(rtc_clk);
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 00605601dbf7..0f7adeb1944a 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -249,7 +249,7 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
        ret = clk_prepare_enable(info->clk);
        if (ret)
-                goto err_enable_clk;
+                return ret;
        /*
         * According to the manual we should be able to let RTTR be zero
         * and then a default diviser for a 32.768KHz clock is used.
@@ -303,8 +303,6 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
        return 0;
 err_dev:
        clk_disable_unprepare(info->clk);
-err_enable_clk:
-        platform_set_drvdata(pdev, NULL);
        return ret;
 }
@@ -312,10 +310,8 @@ static int sa1100_rtc_remove(struct platform_device *pdev)
 {
        struct sa1100_rtc *info = platform_get_drvdata(pdev);
-        if (info) {
+        if (info)
                clk_disable_unprepare(info->clk);
-                platform_set_drvdata(pdev, NULL);
-        }
        return 0;
 }
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 8d5bd2e36776..6d87e26355a3 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -593,7 +593,7 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
        char clk_name[6];
        int clk_id, ret;
-        rtc = kzalloc(sizeof(struct sh_rtc), GFP_KERNEL);
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
        if (unlikely(!rtc))
                return -ENOMEM;
@@ -602,9 +602,8 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
        /* get periodic/carry/alarm irqs */
        ret = platform_get_irq(pdev, 0);
        if (unlikely(ret <= 0)) {
-                ret = -ENOENT;
                dev_err(&pdev->dev, "No IRQ resource\n");
-                goto err_badres;
+                return -ENOENT;
        }
        rtc->periodic_irq = ret;
@@ -613,24 +612,21 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
        if (unlikely(res == NULL)) {
-                ret = -ENOENT;
                dev_err(&pdev->dev, "No IO resource\n");
-                goto err_badres;
+                return -ENOENT;
        }
        rtc->regsize = resource_size(res);
-        rtc->res = request_mem_region(res->start, rtc->regsize, pdev->name);
+        rtc->res = devm_request_mem_region(&pdev->dev, res->start,
-        if (unlikely(!rtc->res)) {
+                                        rtc->regsize, pdev->name);
-                ret = -EBUSY;
+        if (unlikely(!rtc->res))
-                goto err_badres;
+                return -EBUSY;
-        }
-        rtc->regbase = ioremap_nocache(rtc->res->start, rtc->regsize);
+        rtc->regbase = devm_ioremap_nocache(&pdev->dev, rtc->res->start,
-        if (unlikely(!rtc->regbase)) {
+                                        rtc->regsize);
-                ret = -EINVAL;
+        if (unlikely(!rtc->regbase))
-                goto err_badmap;
+                return -EINVAL;
-        }
        clk_id = pdev->id;
        /* With a single device, the clock id is still "rtc0" */
@@ -639,7 +635,7 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
        snprintf(clk_name, sizeof(clk_name), "rtc%d", clk_id);
-        rtc->clk = clk_get(&pdev->dev, clk_name);
+        rtc->clk = devm_clk_get(&pdev->dev, clk_name);
        if (IS_ERR(rtc->clk)) {
                /*
                 * No error handling for rtc->clk intentionally, not all
@@ -665,8 +661,8 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
        if (rtc->carry_irq <= 0) {
                /* register shared periodic/carry/alarm irq */
-                ret = request_irq(rtc->periodic_irq, sh_rtc_shared,
+                ret = devm_request_irq(&pdev->dev, rtc->periodic_irq,
-                                  0, "sh-rtc", rtc);
+                                sh_rtc_shared, 0, "sh-rtc", rtc);
                if (unlikely(ret)) {
                        dev_err(&pdev->dev,
                                "request IRQ failed with %d, IRQ %d\n", ret,
@@ -675,8 +671,8 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
                }
        } else {
                /* register periodic/carry/alarm irqs */
-                ret = request_irq(rtc->periodic_irq, sh_rtc_periodic,
+                ret = devm_request_irq(&pdev->dev, rtc->periodic_irq,
-                                  0, "sh-rtc period", rtc);
+                                sh_rtc_periodic, 0, "sh-rtc period", rtc);
                if (unlikely(ret)) {
                        dev_err(&pdev->dev,
                                "request period IRQ failed with %d, IRQ %d\n",
@@ -684,24 +680,21 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
                        goto err_unmap;
                }
-                ret = request_irq(rtc->carry_irq, sh_rtc_interrupt,
+                ret = devm_request_irq(&pdev->dev, rtc->carry_irq,
-                                  0, "sh-rtc carry", rtc);
+                                sh_rtc_interrupt, 0, "sh-rtc carry", rtc);
                if (unlikely(ret)) {
                        dev_err(&pdev->dev,
                                "request carry IRQ failed with %d, IRQ %d\n",
                                ret, rtc->carry_irq);
-                        free_irq(rtc->periodic_irq, rtc);
                        goto err_unmap;
                }
-                ret = request_irq(rtc->alarm_irq, sh_rtc_alarm,
+                ret = devm_request_irq(&pdev->dev, rtc->alarm_irq,
-                                  0, "sh-rtc alarm", rtc);
+                                sh_rtc_alarm, 0, "sh-rtc alarm", rtc);
                if (unlikely(ret)) {
                        dev_err(&pdev->dev,
                                "request alarm IRQ failed with %d, IRQ %d\n",
                                ret, rtc->alarm_irq);
-                        free_irq(rtc->carry_irq, rtc);
-                        free_irq(rtc->periodic_irq, rtc);
                        goto err_unmap;
                }
        }
@@ -714,13 +707,10 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
        sh_rtc_setaie(&pdev->dev, 0);
        sh_rtc_setcie(&pdev->dev, 0);
-        rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
+        rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, "sh",
                                           &sh_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc->rtc_dev)) {
                ret = PTR_ERR(rtc->rtc_dev);
-                free_irq(rtc->periodic_irq, rtc);
-                free_irq(rtc->carry_irq, rtc);
-                free_irq(rtc->alarm_irq, rtc);
                goto err_unmap;
        }
@@ -737,12 +727,6 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
 err_unmap:
        clk_disable(rtc->clk);
-        clk_put(rtc->clk);
-        iounmap(rtc->regbase);
-err_badmap:
-        release_mem_region(rtc->res->start, rtc->regsize);
-err_badres:
-        kfree(rtc);
        return ret;
 }
@@ -751,28 +735,12 @@ static int __exit sh_rtc_remove(struct platform_device *pdev)
 {
        struct sh_rtc *rtc = platform_get_drvdata(pdev);
-        rtc_device_unregister(rtc->rtc_dev);
        sh_rtc_irq_set_state(&pdev->dev, 0);
        sh_rtc_setaie(&pdev->dev, 0);
        sh_rtc_setcie(&pdev->dev, 0);
-        free_irq(rtc->periodic_irq, rtc);
-        if (rtc->carry_irq > 0) {
-                free_irq(rtc->carry_irq, rtc);
-                free_irq(rtc->alarm_irq, rtc);
-        }
-        iounmap(rtc->regbase);
-        release_mem_region(rtc->res->start, rtc->regsize);
        clk_disable(rtc->clk);
-        clk_put(rtc->clk);
-        platform_set_drvdata(pdev, NULL);
-        kfree(rtc);
        return 0;
 }
diff --git a/drivers/rtc/rtc-sirfsoc.c b/drivers/rtc/rtc-sirfsoc.c
new file mode 100644
index 000000000000..aa7ed4b5f7f0
--- /dev/null
+++ b/drivers/rtc/rtc-sirfsoc.c
@@ -0,0 +1,475 @@
+/*
+ * SiRFSoC Real Time Clock interface for Linux
+ *
+ * Copyright (c) 2013 Cambridge Silicon Radio Limited, a CSR plc group company.
+ *
+ * Licensed under GPLv2 or later.
+ */
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/rtc/sirfsoc_rtciobrg.h>
+#define RTC_CN                  0x00
+#define RTC_ALARM0              0x04
+#define RTC_ALARM1              0x18
+#define RTC_STATUS              0x08
+#define RTC_SW_VALUE            0x40
+#define SIRFSOC_RTC_AL1E        (1<<6)
+#define SIRFSOC_RTC_AL1         (1<<4)
+#define SIRFSOC_RTC_HZE         (1<<3)
+#define SIRFSOC_RTC_AL0E        (1<<2)
+#define SIRFSOC_RTC_HZ          (1<<1)
+#define SIRFSOC_RTC_AL0         (1<<0)
+#define RTC_DIV                 0x0c
+#define RTC_DEEP_CTRL           0x14
+#define RTC_CLOCK_SWITCH        0x1c
+#define SIRFSOC_RTC_CLK         0x03    /* others are reserved */
+/* Refer to RTC DIV switch */
+#define RTC_HZ                  16
+/* This macro is also defined in arch/arm/plat-sirfsoc/cpu.c */
+#define RTC_SHIFT               4
+#define INTR_SYSRTC_CN          0x48
+struct sirfsoc_rtc_drv {
+        struct rtc_device       *rtc;
+        u32                     rtc_base;
+        u32                     irq;
+        /* Overflow for every 8 years extra time */
+        u32                     overflow_rtc;
+#ifdef CONFIG_PM
+        u32             saved_counter;
+        u32             saved_overflow_rtc;
+#endif
+};
+static int sirfsoc_rtc_read_alarm(struct device *dev,
+                struct rtc_wkalrm *alrm)
+{
+        unsigned long rtc_alarm, rtc_count;
+        struct sirfsoc_rtc_drv *rtcdrv;
+        rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev);
+        local_irq_disable();
+        rtc_count = sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_CN);
+        rtc_alarm = sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_ALARM0);
+        memset(alrm, 0, sizeof(struct rtc_wkalrm));
+        /*
+         * assume alarm interval not beyond one round counter overflow_rtc:
+         * 0->0xffffffff
+         */
+        /* if alarm is in next overflow cycle */
+        if (rtc_count > rtc_alarm)
+                rtc_time_to_tm((rtcdrv->overflow_rtc + 1)
+                                << (BITS_PER_LONG - RTC_SHIFT)
+                                | rtc_alarm >> RTC_SHIFT, &(alrm->time));
+        else
+                rtc_time_to_tm(rtcdrv->overflow_rtc
+                                << (BITS_PER_LONG - RTC_SHIFT)
+                                | rtc_alarm >> RTC_SHIFT, &(alrm->time));
+        if (sirfsoc_rtc_iobrg_readl(
+                        rtcdrv->rtc_base + RTC_STATUS) & SIRFSOC_RTC_AL0E)
+                alrm->enabled = 1;
+        local_irq_enable();
+        return 0;
+}
+static int sirfsoc_rtc_set_alarm(struct device *dev,
+                struct rtc_wkalrm *alrm)
+{
+        unsigned long rtc_status_reg, rtc_alarm;
+        struct sirfsoc_rtc_drv *rtcdrv;
+        rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev);
+        if (alrm->enabled) {
+                rtc_tm_to_time(&(alrm->time), &rtc_alarm);
+                local_irq_disable();
+                rtc_status_reg = sirfsoc_rtc_iobrg_readl(
+                                rtcdrv->rtc_base + RTC_STATUS);
+                if (rtc_status_reg & SIRFSOC_RTC_AL0E) {
+                        /*
+                         * An ongoing alarm in progress - ingore it and not
+                         * to return EBUSY
+                         */
+                        dev_info(dev, "An old alarm was set, will be replaced by a new one\n");
+                }
+                sirfsoc_rtc_iobrg_writel(
+                        rtc_alarm << RTC_SHIFT, rtcdrv->rtc_base + RTC_ALARM0);
+                rtc_status_reg &= ~0x07; /* mask out the lower status bits */
+                /*
+                 * This bit RTC_AL sets it as a wake-up source for Sleep Mode
+                 * Writing 1 into this bit will clear it
+                 */
+                rtc_status_reg |= SIRFSOC_RTC_AL0;
+                /* enable the RTC alarm interrupt */
+                rtc_status_reg |= SIRFSOC_RTC_AL0E;
+                sirfsoc_rtc_iobrg_writel(
+                        rtc_status_reg, rtcdrv->rtc_base + RTC_STATUS);
+                local_irq_enable();
+        } else {
+                /*
+                 * if this function was called with enabled=0
+                 * then it could mean that the application is
+                 * trying to cancel an ongoing alarm
+                 */
+                local_irq_disable();
+                rtc_status_reg = sirfsoc_rtc_iobrg_readl(
+                                rtcdrv->rtc_base + RTC_STATUS);
+                if (rtc_status_reg & SIRFSOC_RTC_AL0E) {
+                        /* clear the RTC status register's alarm bit */
+                        rtc_status_reg &= ~0x07;
+                        /* write 1 into SIRFSOC_RTC_AL0 to force a clear */
+                        rtc_status_reg |= (SIRFSOC_RTC_AL0);
+                        /* Clear the Alarm enable bit */
+                        rtc_status_reg &= ~(SIRFSOC_RTC_AL0E);
+                        sirfsoc_rtc_iobrg_writel(rtc_status_reg,
+                                        rtcdrv->rtc_base + RTC_STATUS);
+                }
+                local_irq_enable();
+        }
+        return 0;
+}
+static int sirfsoc_rtc_read_time(struct device *dev,
+                struct rtc_time *tm)
+{
+        unsigned long tmp_rtc = 0;
+        struct sirfsoc_rtc_drv *rtcdrv;
+        rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev);
+        /*
+         * This patch is taken from WinCE - Need to validate this for
+         * correctness. To work around sirfsoc RTC counter double sync logic
+         * fail, read several times to make sure get stable value.
+         */
+        do {
+                tmp_rtc = sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_CN);
+                cpu_relax();
+        } while (tmp_rtc != sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_CN));
+        rtc_time_to_tm(rtcdrv->overflow_rtc << (BITS_PER_LONG - RTC_SHIFT) |
+                                        tmp_rtc >> RTC_SHIFT, tm);
+        return 0;
+}
+static int sirfsoc_rtc_set_time(struct device *dev,
+                struct rtc_time *tm)
+{
+        unsigned long rtc_time;
+        struct sirfsoc_rtc_drv *rtcdrv;
+        rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev);
+        rtc_tm_to_time(tm, &rtc_time);
+        rtcdrv->overflow_rtc = rtc_time >> (BITS_PER_LONG - RTC_SHIFT);
+        sirfsoc_rtc_iobrg_writel(rtcdrv->overflow_rtc,
+                        rtcdrv->rtc_base + RTC_SW_VALUE);
+        sirfsoc_rtc_iobrg_writel(
+                        rtc_time << RTC_SHIFT, rtcdrv->rtc_base + RTC_CN);
+        return 0;
+}
+static int sirfsoc_rtc_ioctl(struct device *dev, unsigned int cmd,
+                unsigned long arg)
+{
+        switch (cmd) {
+        case RTC_PIE_ON:
+        case RTC_PIE_OFF:
+        case RTC_UIE_ON:
+        case RTC_UIE_OFF:
+        case RTC_AIE_ON:
+        case RTC_AIE_OFF:
+                return 0;
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+static const struct rtc_class_ops sirfsoc_rtc_ops = {
+        .read_time = sirfsoc_rtc_read_time,
+        .set_time = sirfsoc_rtc_set_time,
+        .read_alarm = sirfsoc_rtc_read_alarm,
+        .set_alarm = sirfsoc_rtc_set_alarm,
+        .ioctl = sirfsoc_rtc_ioctl
+};
+static irqreturn_t sirfsoc_rtc_irq_handler(int irq, void *pdata)
+{
+        struct sirfsoc_rtc_drv *rtcdrv = pdata;
+        unsigned long rtc_status_reg = 0x0;
+        unsigned long events = 0x0;
+        rtc_status_reg = sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_STATUS);
+        /* this bit will be set ONLY if an alarm was active
+         * and it expired NOW
+         * So this is being used as an ASSERT
+         */
+        if (rtc_status_reg & SIRFSOC_RTC_AL0) {
+                /*
+                 * clear the RTC status register's alarm bit
+                 * mask out the lower status bits
+                 */
+                rtc_status_reg &= ~0x07;
+                /* write 1 into SIRFSOC_RTC_AL0 to ACK the alarm interrupt */
+                rtc_status_reg |= (SIRFSOC_RTC_AL0);
+                /* Clear the Alarm enable bit */
+                rtc_status_reg &= ~(SIRFSOC_RTC_AL0E);
+        }
+        sirfsoc_rtc_iobrg_writel(rtc_status_reg, rtcdrv->rtc_base + RTC_STATUS);
+        /* this should wake up any apps polling/waiting on the read
+         * after setting the alarm
+         */
+        events |= RTC_IRQF | RTC_AF;
+        rtc_update_irq(rtcdrv->rtc, 1, events);
+        return IRQ_HANDLED;
+}
+static const struct of_device_id sirfsoc_rtc_of_match[] = {
+        { .compatible = "sirf,prima2-sysrtc"},
+        {},
+};
+MODULE_DEVICE_TABLE(of, sirfsoc_rtc_of_match);
+static int sirfsoc_rtc_probe(struct platform_device *pdev)
+{
+        int err;
+        unsigned long rtc_div;
+        struct sirfsoc_rtc_drv *rtcdrv;
+        struct device_node *np = pdev->dev.of_node;
+        rtcdrv = devm_kzalloc(&pdev->dev,
+                sizeof(struct sirfsoc_rtc_drv), GFP_KERNEL);
+        if (rtcdrv == NULL) {
+                dev_err(&pdev->dev,
+                        "%s: can't alloc mem for drv struct\n",
+                        pdev->name);
+                return -ENOMEM;
+        }
+        err = of_property_read_u32(np, "reg", &rtcdrv->rtc_base);
+        if (err) {
+                dev_err(&pdev->dev, "unable to find base address of rtc node in dtb\n");
+                goto error;
+        }
+        platform_set_drvdata(pdev, rtcdrv);
+        /* Register rtc alarm as a wakeup source */
+        device_init_wakeup(&pdev->dev, 1);
+        /*
+         * Set SYS_RTC counter in RTC_HZ HZ Units
+         * We are using 32K RTC crystal (32768 / RTC_HZ / 2) -1
+         * If 16HZ, therefore RTC_DIV = 1023;
+         */
+        rtc_div = ((32768 / RTC_HZ) / 2) - 1;
+        sirfsoc_rtc_iobrg_writel(rtc_div, rtcdrv->rtc_base + RTC_DIV);
+        rtcdrv->rtc = rtc_device_register(pdev->name, &(pdev->dev),
+                        &sirfsoc_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtcdrv->rtc)) {
+                err = PTR_ERR(rtcdrv->rtc);
+                dev_err(&pdev->dev, "can't register RTC device\n");
+                return err;
+        }
+        /* 0x3 -> RTC_CLK */
+        sirfsoc_rtc_iobrg_writel(SIRFSOC_RTC_CLK,
+                        rtcdrv->rtc_base + RTC_CLOCK_SWITCH);
+        /* reset SYS RTC ALARM0 */
+        sirfsoc_rtc_iobrg_writel(0x0, rtcdrv->rtc_base + RTC_ALARM0);
+        /* reset SYS RTC ALARM1 */
+        sirfsoc_rtc_iobrg_writel(0x0, rtcdrv->rtc_base + RTC_ALARM1);
+        /* Restore RTC Overflow From Register After Command Reboot */
+        rtcdrv->overflow_rtc =
+                sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_SW_VALUE);
+        rtcdrv->irq = platform_get_irq(pdev, 0);
+        err = devm_request_irq(
+                        &pdev->dev,
+                        rtcdrv->irq,
+                        sirfsoc_rtc_irq_handler,
+                        IRQF_SHARED,
+                        pdev->name,
+                        rtcdrv);
+        if (err) {
+                dev_err(&pdev->dev, "Unable to register for the SiRF SOC RTC IRQ\n");
+                goto error;
+        }
+        return 0;
+error:
+        if (rtcdrv->rtc)
+                rtc_device_unregister(rtcdrv->rtc);
+        return err;
+}
+static int sirfsoc_rtc_remove(struct platform_device *pdev)
+{
+        struct sirfsoc_rtc_drv *rtcdrv = platform_get_drvdata(pdev);
+        device_init_wakeup(&pdev->dev, 0);
+        rtc_device_unregister(rtcdrv->rtc);
+        return 0;
+}
+#ifdef CONFIG_PM
+static int sirfsoc_rtc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sirfsoc_rtc_drv *rtcdrv = platform_get_drvdata(pdev);
+        rtcdrv->overflow_rtc =
+                sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_SW_VALUE);
+        rtcdrv->saved_counter =
+                sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_CN);
+        rtcdrv->saved_overflow_rtc = rtcdrv->overflow_rtc;
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(rtcdrv->irq);
+        return 0;
+}
+static int sirfsoc_rtc_freeze(struct device *dev)
+{
+        sirfsoc_rtc_suspend(dev);
+        return 0;
+}
+static int sirfsoc_rtc_thaw(struct device *dev)
+{
+        u32 tmp;
+        struct sirfsoc_rtc_drv *rtcdrv;
+        rtcdrv = (struct sirfsoc_rtc_drv *)dev_get_drvdata(dev);
+        /*
+         * if resume from snapshot and the rtc power is losed,
+         * restroe the rtc settings
+         */
+        if (SIRFSOC_RTC_CLK != sirfsoc_rtc_iobrg_readl(
+                        rtcdrv->rtc_base + RTC_CLOCK_SWITCH)) {
+                u32 rtc_div;
+                /* 0x3 -> RTC_CLK */
+                sirfsoc_rtc_iobrg_writel(SIRFSOC_RTC_CLK,
+                        rtcdrv->rtc_base + RTC_CLOCK_SWITCH);
+                /*
+                 * Set SYS_RTC counter in RTC_HZ HZ Units
+                 * We are using 32K RTC crystal (32768 / RTC_HZ / 2) -1
+                 * If 16HZ, therefore RTC_DIV = 1023;
+                 */
+                rtc_div = ((32768 / RTC_HZ) / 2) - 1;
+                sirfsoc_rtc_iobrg_writel(rtc_div, rtcdrv->rtc_base + RTC_DIV);
+                /* reset SYS RTC ALARM0 */
+                sirfsoc_rtc_iobrg_writel(0x0, rtcdrv->rtc_base + RTC_ALARM0);
+                /* reset SYS RTC ALARM1 */
+                sirfsoc_rtc_iobrg_writel(0x0, rtcdrv->rtc_base + RTC_ALARM1);
+        }
+        rtcdrv->overflow_rtc = rtcdrv->saved_overflow_rtc;
+        /*
+         * if current counter is small than previous,
+         * it means overflow in sleep
+         */
+        tmp = sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_CN);
+        if (tmp <= rtcdrv->saved_counter)
+                rtcdrv->overflow_rtc++;
+        /*
+         *PWRC Value Be Changed When Suspend, Restore Overflow
+         * In Memory To Register
+         */
+        sirfsoc_rtc_iobrg_writel(rtcdrv->overflow_rtc,
+                        rtcdrv->rtc_base + RTC_SW_VALUE);
+        return 0;
+}
+static int sirfsoc_rtc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sirfsoc_rtc_drv *rtcdrv = platform_get_drvdata(pdev);
+        sirfsoc_rtc_thaw(dev);
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(rtcdrv->irq);
+        return 0;
+}
+static int sirfsoc_rtc_restore(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sirfsoc_rtc_drv *rtcdrv = platform_get_drvdata(pdev);
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(rtcdrv->irq);
+        return 0;
+}
+#else
+#define sirfsoc_rtc_suspend     NULL
+#define sirfsoc_rtc_resume      NULL
+#define sirfsoc_rtc_freeze      NULL
+#define sirfsoc_rtc_thaw        NULL
+#define sirfsoc_rtc_restore     NULL
+#endif
+static const struct dev_pm_ops sirfsoc_rtc_pm_ops = {
+        .suspend = sirfsoc_rtc_suspend,
+        .resume = sirfsoc_rtc_resume,
+        .freeze = sirfsoc_rtc_freeze,
+        .thaw = sirfsoc_rtc_thaw,
+        .restore = sirfsoc_rtc_restore,
+};
+static struct platform_driver sirfsoc_rtc_driver = {
+        .driver = {
+                .name = "sirfsoc-rtc",
+                .owner = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm = &sirfsoc_rtc_pm_ops,
+#endif
+                .of_match_table = of_match_ptr(sirfsoc_rtc_of_match),
+        },
+        .probe = sirfsoc_rtc_probe,
+        .remove = sirfsoc_rtc_remove,
+};
+module_platform_driver(sirfsoc_rtc_driver);
+MODULE_DESCRIPTION("SiRF SoC rtc driver");
+MODULE_AUTHOR("Xianglong Du <Xianglong.Du@csr.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:sirfsoc-rtc");
diff --git a/drivers/rtc/rtc-snvs.c b/drivers/rtc/rtc-snvs.c
index b04f09a1df2a..316a342115b2 100644
--- a/drivers/rtc/rtc-snvs.c
+++ b/drivers/rtc/rtc-snvs.c
@@ -294,11 +294,6 @@ static int snvs_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int snvs_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 #ifdef CONFIG_PM_SLEEP
 static int snvs_rtc_suspend(struct device *dev)
 {
@@ -337,7 +332,6 @@ static struct platform_driver snvs_rtc_driver = {
                .of_match_table = of_match_ptr(snvs_dt_ids),
        },
        .probe          = snvs_rtc_probe,
-        .remove         = snvs_rtc_remove,
 };
 module_platform_driver(snvs_rtc_driver);
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
index 574359c48f65..c492cf0ab8cd 100644
--- a/drivers/rtc/rtc-spear.c
+++ b/drivers/rtc/rtc-spear.c
@@ -417,7 +417,6 @@ static int spear_rtc_probe(struct platform_device *pdev)
        return 0;
 err_disable_clock:
-        platform_set_drvdata(pdev, NULL);
        clk_disable_unprepare(config->clk);
        return status;
diff --git a/drivers/rtc/rtc-starfire.c b/drivers/rtc/rtc-starfire.c
index 987b5ec0ae56..f7d8a6db8078 100644
--- a/drivers/rtc/rtc-starfire.c
+++ b/drivers/rtc/rtc-starfire.c
@@ -51,17 +51,11 @@ static int __init starfire_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int __exit starfire_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static struct platform_driver starfire_rtc_driver = {
        .driver         = {
                .name   = "rtc-starfire",
                .owner  = THIS_MODULE,
        },
-        .remove         = __exit_p(starfire_rtc_remove),
 };
 module_platform_driver_probe(starfire_rtc_driver, starfire_rtc_probe);
diff --git a/drivers/rtc/rtc-stmp3xxx.c b/drivers/rtc/rtc-stmp3xxx.c
index 483ce086990b..90a3e864b8fe 100644
--- a/drivers/rtc/rtc-stmp3xxx.c
+++ b/drivers/rtc/rtc-stmp3xxx.c
@@ -225,7 +225,6 @@ static int stmp3xxx_rtc_remove(struct platform_device *pdev)
        writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
                        rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
@@ -274,25 +273,19 @@ static int stmp3xxx_rtc_probe(struct platform_device *pdev)
        rtc_data->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                &stmp3xxx_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc_data->rtc)) {
+        if (IS_ERR(rtc_data->rtc))
-                err = PTR_ERR(rtc_data->rtc);
+                return PTR_ERR(rtc_data->rtc);
-                goto out;
-        }
        err = devm_request_irq(&pdev->dev, rtc_data->irq_alarm,
                        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;
+                return err;
        }
        stmp3xxx_wdt_register(pdev);
        return 0;
-out:
-        platform_set_drvdata(pdev, NULL);
-        return err;
 }
 #ifdef CONFIG_PM_SLEEP
diff --git a/drivers/rtc/rtc-sun4v.c b/drivers/rtc/rtc-sun4v.c
index ce42e5fa9e09..bc97ff91341d 100644
--- a/drivers/rtc/rtc-sun4v.c
+++ b/drivers/rtc/rtc-sun4v.c
@@ -92,17 +92,11 @@ static int __init sun4v_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int __exit sun4v_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static struct platform_driver sun4v_rtc_driver = {
        .driver         = {
                .name   = "rtc-sun4v",
                .owner  = THIS_MODULE,
        },
-        .remove         = __exit_p(sun4v_rtc_remove),
 };
 module_platform_driver_probe(sun4v_rtc_driver, sun4v_rtc_probe);
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index b70e2bb63645..4b26f8672b2d 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -164,6 +164,7 @@ rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr,
 {
        ssize_t retval;
        unsigned long now, alarm;
+        unsigned long push = 0;
        struct rtc_wkalrm alm;
        struct rtc_device *rtc = to_rtc_device(dev);
        char *buf_ptr;
@@ -180,13 +181,17 @@ rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr,
        buf_ptr = (char *)buf;
        if (*buf_ptr == '+') {
                buf_ptr++;
-                adjust = 1;
+                if (*buf_ptr == '=') {
+                        buf_ptr++;
+                        push = 1;
+                } else
+                        adjust = 1;
        }
        alarm = simple_strtoul(buf_ptr, NULL, 0);
        if (adjust) {
                alarm += now;
        }
-        if (alarm > now) {
+        if (alarm > now || push) {
                /* Avoid accidentally clobbering active alarms; we can't
                 * entirely prevent that here, without even the minimal
                 * locking from the /dev/rtcN api.
@@ -194,9 +199,14 @@ rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr,
                retval = rtc_read_alarm(rtc, &alm);
                if (retval < 0)
                        return retval;
-                if (alm.enabled)
+                if (alm.enabled) {
-                        return -EBUSY;
+                        if (push) {
+                                rtc_tm_to_time(&alm.time, &push);
+                                alarm += push;
+                        } else
+                                return -EBUSY;
+                } else if (push)
+                        return -EINVAL;
                alm.enabled = 1;
        } else {
                alm.enabled = 0;
diff --git a/drivers/rtc/rtc-tile.c b/drivers/rtc/rtc-tile.c
index fc3dee95f166..ff9632eb79f2 100644
--- a/drivers/rtc/rtc-tile.c
+++ b/drivers/rtc/rtc-tile.c
@@ -91,23 +91,12 @@ static int tile_rtc_probe(struct platform_device *dev)
        return 0;
 }
-/*
- * Device cleanup routine.
- */
-static int tile_rtc_remove(struct platform_device *dev)
-{
-        platform_set_drvdata(dev, NULL);
-        return 0;
-}
 static struct platform_driver tile_rtc_platform_driver = {
        .driver         = {
                .name   = "rtc-tile",
                .owner  = THIS_MODULE,
        },
        .probe          = tile_rtc_probe,
-        .remove         = tile_rtc_remove,
 };
 /*
diff --git a/drivers/rtc/rtc-tps80031.c b/drivers/rtc/rtc-tps80031.c
index 72662eafb938..3e400dce2d06 100644
--- a/drivers/rtc/rtc-tps80031.c
+++ b/drivers/rtc/rtc-tps80031.c
@@ -298,11 +298,6 @@ static int tps80031_rtc_probe(struct platform_device *pdev)
        return 0;
 }
-static int tps80031_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 #ifdef CONFIG_PM_SLEEP
 static int tps80031_rtc_suspend(struct device *dev)
 {
@@ -333,7 +328,6 @@ static struct platform_driver tps80031_rtc_driver = {
                .pm     = &tps80031_pm_ops,
        },
        .probe  = tps80031_rtc_probe,
-        .remove = tps80031_rtc_remove,
 };
 module_platform_driver(tps80031_rtc_driver);
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index b2eab34f38d9..02faf3c4e0d5 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -213,12 +213,24 @@ static int mask_rtc_irq_bit(unsigned char bit)
 static int twl_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
 {
+        struct platform_device *pdev = to_platform_device(dev);
+        int irq = platform_get_irq(pdev, 0);
+        static bool twl_rtc_wake_enabled;
        int ret;
-        if (enabled)
+        if (enabled) {
                ret = set_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
-        else
+                if (device_can_wakeup(dev) && !twl_rtc_wake_enabled) {
+                        enable_irq_wake(irq);
+                        twl_rtc_wake_enabled = true;
+                }
+        } else {
                ret = mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
+                if (twl_rtc_wake_enabled) {
+                        disable_irq_wake(irq);
+                        twl_rtc_wake_enabled = false;
+                }
+        }
        return ret;
 }
@@ -469,6 +481,12 @@ static int twl_rtc_probe(struct platform_device *pdev)
        if (irq <= 0)
                goto out1;
+        /* Initialize the register map */
+        if (twl_class_is_4030())
+                rtc_reg_map = (u8 *)twl4030_rtc_reg_map;
+        else
+                rtc_reg_map = (u8 *)twl6030_rtc_reg_map;
        ret = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
        if (ret < 0)
                goto out1;
@@ -556,7 +574,6 @@ static int twl_rtc_remove(struct platform_device *pdev)
        free_irq(irq, rtc);
        rtc_device_unregister(rtc);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
@@ -609,22 +626,7 @@ static struct platform_driver twl4030rtc_driver = {
        },
 };
-static int __init twl_rtc_init(void)
+module_platform_driver(twl4030rtc_driver);
-{
-        if (twl_class_is_4030())
-                rtc_reg_map = (u8 *) twl4030_rtc_reg_map;
-        else
-                rtc_reg_map = (u8 *) twl6030_rtc_reg_map;
-        return platform_driver_register(&twl4030rtc_driver);
-}
-module_init(twl_rtc_init);
-static void __exit twl_rtc_exit(void)
-{
-        platform_driver_unregister(&twl4030rtc_driver);
-}
-module_exit(twl_rtc_exit);
 MODULE_AUTHOR("Texas Instruments, MontaVista Software");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
index 6e0cba8f47d5..d07d89823020 100644
--- a/drivers/rtc/rtc-v3020.c
+++ b/drivers/rtc/rtc-v3020.c
@@ -16,7 +16,7 @@
 *                              - Use the generic rtc class
 *
 *  ??-???-2004: Someone at Compulab
- *                      - Initial driver creation.
+ *                      - Initial driver creation.
 *
 */
 #include <linux/platform_device.h>
@@ -278,13 +278,13 @@ static int v3020_set_time(struct device *dev, struct rtc_time *dt)
        dev_dbg(dev, "tm_year: %i\n", dt->tm_year);
        /* Write all the values to ram... */
-        v3020_set_reg(chip, V3020_SECONDS,      bin2bcd(dt->tm_sec));
+        v3020_set_reg(chip, V3020_SECONDS,      bin2bcd(dt->tm_sec));
-        v3020_set_reg(chip, V3020_MINUTES,      bin2bcd(dt->tm_min));
+        v3020_set_reg(chip, V3020_MINUTES,      bin2bcd(dt->tm_min));
-        v3020_set_reg(chip, V3020_HOURS,        bin2bcd(dt->tm_hour));
+        v3020_set_reg(chip, V3020_HOURS,        bin2bcd(dt->tm_hour));
        v3020_set_reg(chip, V3020_MONTH_DAY,    bin2bcd(dt->tm_mday));
-        v3020_set_reg(chip, V3020_MONTH,     bin2bcd(dt->tm_mon + 1));
+        v3020_set_reg(chip, V3020_MONTH,        bin2bcd(dt->tm_mon + 1));
-        v3020_set_reg(chip, V3020_WEEK_DAY,     bin2bcd(dt->tm_wday));
+        v3020_set_reg(chip, V3020_WEEK_DAY,     bin2bcd(dt->tm_wday));
-        v3020_set_reg(chip, V3020_YEAR,         bin2bcd(dt->tm_year % 100));
+        v3020_set_reg(chip, V3020_YEAR,         bin2bcd(dt->tm_year % 100));
        /* ...and set the clock. */
        v3020_set_reg(chip, V3020_CMD_RAM2CLOCK, 0);
@@ -320,7 +320,7 @@ static int rtc_probe(struct platform_device *pdev)
        retval = chip->ops->map_io(chip, pdev, pdata);
        if (retval)
-                goto err_chip;
+                return retval;
        /* Make sure the v3020 expects a communication cycle
         * by reading 8 times */
@@ -364,7 +364,7 @@ static int rtc_probe(struct platform_device *pdev)
 err_io:
        chip->ops->unmap_io(chip);
-err_chip:
        return retval;
 }
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index f91be04b9050..54e104e197e3 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -103,7 +103,7 @@ static inline unsigned long read_elapsed_second(void)
                second_mid = rtc1_read(ETIMEMREG);
                second_high = rtc1_read(ETIMEHREG);
        } while (first_low != second_low || first_mid != second_mid ||
-                 first_high != second_high);
+                 first_high != second_high);
        return (first_high << 17) | (first_mid << 1) | (first_low >> 15);
 }
@@ -154,7 +154,7 @@ static int vr41xx_rtc_set_time(struct device *dev, struct rtc_time *time)
        epoch_sec = mktime(epoch, 1, 1, 0, 0, 0);
        current_sec = mktime(time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
-                             time->tm_hour, time->tm_min, time->tm_sec);
+                             time->tm_hour, time->tm_min, time->tm_sec);
        write_elapsed_second(current_sec - epoch_sec);
@@ -186,7 +186,7 @@ static int vr41xx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
        struct rtc_time *time = &wkalrm->time;
        alarm_sec = mktime(time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
-                           time->tm_hour, time->tm_min, time->tm_sec);
+                           time->tm_hour, time->tm_min, time->tm_sec);
        spin_lock_irq(&rtc_lock);
@@ -334,16 +334,18 @@ static int rtc_probe(struct platform_device *pdev)
        }
        retval = request_irq(aie_irq, elapsedtime_interrupt, 0,
-                             "elapsed_time", pdev);
+                             "elapsed_time", pdev);
        if (retval < 0)
                goto err_device_unregister;
        pie_irq = platform_get_irq(pdev, 1);
-        if (pie_irq <= 0)
+        if (pie_irq <= 0) {
+                retval = -EBUSY;
                goto err_free_irq;
+        }
        retval = request_irq(pie_irq, rtclong1_interrupt, 0,
-                             "rtclong1", pdev);
+                             "rtclong1", pdev);
        if (retval < 0)
                goto err_free_irq;
@@ -381,8 +383,6 @@ static int rtc_remove(struct platform_device *pdev)
        if (rtc)
                rtc_device_unregister(rtc);
-        platform_set_drvdata(pdev, NULL);
        free_irq(aie_irq, pdev);
        free_irq(pie_irq, pdev);
        if (rtc1_base)
diff --git a/drivers/rtc/rtc-vt8500.c b/drivers/rtc/rtc-vt8500.c
index d89efee6d29e..c2d6331fc712 100644
--- a/drivers/rtc/rtc-vt8500.c
+++ b/drivers/rtc/rtc-vt8500.c
@@ -282,8 +282,6 @@ static int vt8500_rtc_remove(struct platform_device *pdev)
        /* Disable alarm matching */
        writel(0, vt8500_rtc->regbase + VT8500_RTC_IS);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
index 8d65b94e5a7e..75aea4c4d334 100644
--- a/drivers/rtc/rtc-wm831x.c
+++ b/drivers/rtc/rtc-wm831x.c
@@ -460,11 +460,6 @@ err:
        return ret;
 }
-static int wm831x_rtc_remove(struct platform_device *pdev)
-{
-        return 0;
-}
 static const struct dev_pm_ops wm831x_rtc_pm_ops = {
        .suspend = wm831x_rtc_suspend,
        .resume = wm831x_rtc_resume,
@@ -478,7 +473,6 @@ static const struct dev_pm_ops wm831x_rtc_pm_ops = {
 static struct platform_driver wm831x_rtc_driver = {
        .probe = wm831x_rtc_probe,
-        .remove = wm831x_rtc_remove,
        .driver = {
                .name = "wm831x-rtc",
                .pm = &wm831x_rtc_pm_ops,
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index fa9b0679fb60..365dc6505148 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -4,7 +4,7 @@
 * Copyright 2005 Alessandro Zummo
 *
 * please send all reports to:
- *      Karen Spearel <kas111 at gmail dot com>
+ *      Karen Spearel <kas111 at gmail dot com>
 *      Alessandro Zummo <a.zummo@towertech.it>
 *
 * based on a lot of other RTC drivers.
@@ -215,12 +215,14 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                        buf[i] |= 0x80;
        /* this sequence is required to unlock the chip */
-        if ((xfer = i2c_master_send(client, wel, 3)) != 3) {
+        xfer = i2c_master_send(client, wel, 3);
+        if (xfer != 3) {
                dev_err(&client->dev, "%s: wel - %d\n", __func__, xfer);
                return -EIO;
        }
-        if ((xfer = i2c_master_send(client, rwel, 3)) != 3) {
+        xfer = i2c_master_send(client, rwel, 3);
+        if (xfer != 3) {
                dev_err(&client->dev, "%s: rwel - %d\n", __func__, xfer);
                return -EIO;
        }
@@ -269,7 +271,8 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
        }
        /* disable further writes */
-        if ((xfer = i2c_master_send(client, diswe, 3)) != 3) {
+        xfer = i2c_master_send(client, diswe, 3);
+        if (xfer != 3) {
                dev_err(&client->dev, "%s: diswe - %d\n", __func__, xfer);
                return -EIO;
        }
@@ -375,8 +378,7 @@ static int x1205_get_atrim(struct i2c_client *client, int *trim)
        return 0;
 }
-struct x1205_limit
+struct x1205_limit {
-{
        unsigned char reg, mask, min, max;
 };
@@ -430,7 +432,8 @@ static int x1205_validate_client(struct i2c_client *client)
                        },
                };
-                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                xfer = i2c_transfer(client->adapter, msgs, 2);
+                if (xfer != 2) {
                        dev_err(&client->dev,
                                "%s: could not read register %x\n",
                                __func__, probe_zero_pattern[i]);
@@ -467,7 +470,8 @@ static int x1205_validate_client(struct i2c_client *client)
                        },
                };
-                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                xfer = i2c_transfer(client->adapter, msgs, 2);
+                if (xfer != 2) {
                        dev_err(&client->dev,
                                "%s: could not read register %x\n",
                                __func__, probe_limits_pattern[i].reg);
@@ -548,10 +552,12 @@ static int x1205_rtc_proc(struct device *dev, struct seq_file *seq)
 {
        int err, dtrim, atrim;
-        if ((err = x1205_get_dtrim(to_i2c_client(dev), &dtrim)) == 0)
+        err = x1205_get_dtrim(to_i2c_client(dev), &dtrim);
+        if (!err)
                seq_printf(seq, "digital_trim\t: %d ppm\n", dtrim);
-        if ((err = x1205_get_atrim(to_i2c_client(dev), &atrim)) == 0)
+        err = x1205_get_atrim(to_i2c_client(dev), &atrim);
+        if (!err)
                seq_printf(seq, "analog_trim\t: %d.%02d pF\n",
                        atrim / 1000, atrim % 1000);
        return 0;
@@ -639,7 +645,8 @@ static int x1205_probe(struct i2c_client *client,
        i2c_set_clientdata(client, rtc);
        /* Check for power failures and eventually enable the osc */
-        if ((err = x1205_get_status(client, &sr)) == 0) {
+        err = x1205_get_status(client, &sr);
+        if (!err) {
                if (sr & X1205_SR_RTCF) {
                        dev_err(&client->dev,
                                "power failure detected, "
@@ -647,9 +654,9 @@ static int x1205_probe(struct i2c_client *client,
                        udelay(50);
                        x1205_fix_osc(client);
                }
-        }
+        } else {
-        else
                dev_err(&client->dev, "couldn't read status\n");
+        }
        err = x1205_sysfs_register(&client->dev);
        if (err)