39 files changed, 764 insertions, 540 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index db933decc39c..2e565f8e5165 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -573,6 +573,18 @@ config RTC_DRV_DS1305
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1305.
 
+config RTC_DRV_DS1347
+        tristate "Dallas/Maxim DS1347"
+        help
+          If you say yes here you get support for the
+          Dallas/Maxim DS1347 chips.
+
+          This driver only supports the RTC feature, and not other chip
+          features such as alarms.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1347.
+
 config RTC_DRV_DS1390
         tristate "Dallas/Maxim DS1390/93/94"
         help
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index b427bf7dd20d..40a09915c8f6 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -40,6 +40,7 @@ obj-$(CONFIG_RTC_DRV_DS1286)	+= rtc-ds1286.o
 obj-$(CONFIG_RTC_DRV_DS1302)    += rtc-ds1302.o
 obj-$(CONFIG_RTC_DRV_DS1305)    += rtc-ds1305.o
 obj-$(CONFIG_RTC_DRV_DS1307)    += rtc-ds1307.o
+obj-$(CONFIG_RTC_DRV_DS1347)    += rtc-ds1347.o
 obj-$(CONFIG_RTC_DRV_DS1374)    += rtc-ds1374.o
 obj-$(CONFIG_RTC_DRV_DS1390)    += rtc-ds1390.o
 obj-$(CONFIG_RTC_DRV_DS1511)    += rtc-ds1511.o
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 544be722937c..c2eff6082363 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -584,6 +584,9 @@ enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
 void rtc_update_irq(struct rtc_device *rtc,
                 unsigned long num, unsigned long events)
 {
+        if (unlikely(IS_ERR_OR_NULL(rtc)))
+                return;
+
         pm_stay_awake(rtc->dev.parent);
         schedule_work(&rtc->irqwork);
 }
diff --git a/drivers/rtc/rtc-as3722.c b/drivers/rtc/rtc-as3722.c
index 4af016985890..9f38eda69154 100644
--- a/drivers/rtc/rtc-as3722.c
+++ b/drivers/rtc/rtc-as3722.c
@@ -242,9 +242,8 @@ static int as3722_rtc_resume(struct device *dev)
 }
 #endif
 
-static const struct dev_pm_ops as3722_rtc_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(as3722_rtc_suspend, as3722_rtc_resume)
-};
+static SIMPLE_DEV_PM_OPS(as3722_rtc_pm_ops, as3722_rtc_suspend,
+                         as3722_rtc_resume);
 
 static struct platform_driver as3722_rtc_driver = {
         .probe = as3722_rtc_probe,
diff --git a/drivers/rtc/rtc-at32ap700x.c b/drivers/rtc/rtc-at32ap700x.c
index 3161ab5263ed..aee3387fb099 100644
--- a/drivers/rtc/rtc-at32ap700x.c
+++ b/drivers/rtc/rtc-at32ap700x.c
@@ -204,10 +204,8 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
 
         rtc = devm_kzalloc(&pdev->dev, sizeof(struct rtc_at32ap700x),
                            GFP_KERNEL);
-        if (!rtc) {
-                dev_dbg(&pdev->dev, "out of memory\n");
+        if (!rtc)
                 return -ENOMEM;
-        }
 
         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!regs) {
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index cae212f30d65..0963c9309c74 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -837,7 +837,7 @@ static void __exit cmos_do_remove(struct device *dev)
         cmos->dev = NULL;
 }
 
-#ifdef  CONFIG_PM
+#ifdef  CONFIG_PM_SLEEP
 
 static int cmos_suspend(struct device *dev)
 {
@@ -935,8 +935,6 @@ static int cmos_resume(struct device *dev)
         return 0;
 }
 
-static SIMPLE_DEV_PM_OPS(cmos_pm_ops, cmos_suspend, cmos_resume);
-
 #else
 
 static inline int cmos_poweroff(struct device *dev)
@@ -946,6 +944,8 @@ static inline int cmos_poweroff(struct device *dev)
 
 #endif
 
+static SIMPLE_DEV_PM_OPS(cmos_pm_ops, cmos_suspend, cmos_resume);
+
 /*----------------------------------------------------------------*/
 
 /* On non-x86 systems, a "CMOS" RTC lives most naturally on platform_bus.
@@ -1088,11 +1088,9 @@ static struct pnp_driver cmos_pnp_driver = {
 
         /* flag ensures resume() gets called, and stops syslog spam */
         .flags          = PNP_DRIVER_RES_DO_NOT_CHANGE,
-#ifdef CONFIG_PM_SLEEP
         .driver         = {
                         .pm = &cmos_pm_ops,
         },
-#endif
 };
 
 #endif  /* CONFIG_PNP */
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index 73f157519dff..869cae273799 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -43,8 +43,6 @@
 struct coh901331_port {
         struct rtc_device *rtc;
         struct clk *clk;
-        u32 phybase;
-        u32 physize;
         void __iomem *virtbase;
         int irq;
 #ifdef CONFIG_PM_SLEEP
@@ -173,19 +171,9 @@ static int __init coh901331_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -ENOENT;
-
-        rtap->phybase = res->start;
-        rtap->physize = resource_size(res);
-
-        if (devm_request_mem_region(&pdev->dev, rtap->phybase, rtap->physize,
-                                    "rtc-coh901331") == NULL)
-                return -EBUSY;
-
-        rtap->virtbase = devm_ioremap(&pdev->dev, rtap->phybase, rtap->physize);
-        if (!rtap->virtbase)
-                return -ENOMEM;
+        rtap->virtbase  = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(rtap->virtbase))
+                return PTR_ERR(rtap->virtbase);
 
         rtap->irq = platform_get_irq(pdev, 0);
         if (devm_request_irq(&pdev->dev, rtap->irq, coh901331_interrupt, 0,
diff --git a/drivers/rtc/rtc-da9052.c b/drivers/rtc/rtc-da9052.c
index 4385ca4503da..a1cbf64242a5 100644
--- a/drivers/rtc/rtc-da9052.c
+++ b/drivers/rtc/rtc-da9052.c
@@ -26,7 +26,6 @@
 struct da9052_rtc {
         struct rtc_device *rtc;
         struct da9052 *da9052;
-        int irq;
 };
 
 static int da9052_rtc_enable_alarm(struct da9052 *da9052, bool enable)
@@ -240,8 +239,7 @@ static int da9052_rtc_probe(struct platform_device *pdev)
 
         rtc->da9052 = dev_get_drvdata(pdev->dev.parent);
         platform_set_drvdata(pdev, rtc);
-        rtc->irq =  DA9052_IRQ_ALARM;
-        ret = da9052_request_irq(rtc->da9052, rtc->irq, "ALM",
+        ret = da9052_request_irq(rtc->da9052, DA9052_IRQ_ALARM, "ALM",
                                 da9052_rtc_irq, rtc);
         if (ret != 0) {
                 rtc_err(rtc->da9052, "irq registration failed: %d\n", ret);
diff --git a/drivers/rtc/rtc-da9055.c b/drivers/rtc/rtc-da9055.c
index 48cb2ac3bd3e..a825491331c8 100644
--- a/drivers/rtc/rtc-da9055.c
+++ b/drivers/rtc/rtc-da9055.c
@@ -302,7 +302,9 @@ static int da9055_rtc_probe(struct platform_device *pdev)
         }
 
         alm_irq = platform_get_irq_byname(pdev, "ALM");
-        alm_irq = regmap_irq_get_virq(rtc->da9055->irq_data, alm_irq);
+        if (alm_irq < 0)
+                return alm_irq;
+
         ret = devm_request_threaded_irq(&pdev->dev, alm_irq, NULL,
                                         da9055_rtc_alm_irq,
                                         IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
diff --git a/drivers/rtc/rtc-davinci.c b/drivers/rtc/rtc-davinci.c
index 24677ef8c39a..c0a3b59f65a2 100644
--- a/drivers/rtc/rtc-davinci.c
+++ b/drivers/rtc/rtc-davinci.c
@@ -119,8 +119,6 @@ static DEFINE_SPINLOCK(davinci_rtc_lock);
 struct davinci_rtc {
         struct rtc_device               *rtc;
         void __iomem                    *base;
-        resource_size_t                 pbase;
-        size_t                          base_size;
         int                             irq;
 };
 
@@ -482,14 +480,12 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct davinci_rtc *davinci_rtc;
-        struct resource *res, *mem;
+        struct resource *res;
         int ret = 0;
 
         davinci_rtc = devm_kzalloc(&pdev->dev, sizeof(struct davinci_rtc), GFP_KERNEL);
-        if (!davinci_rtc) {
-                dev_dbg(dev, "could not allocate memory for private data\n");
+        if (!davinci_rtc)
                 return -ENOMEM;
-        }
 
         davinci_rtc->irq = platform_get_irq(pdev, 0);
         if (davinci_rtc->irq < 0) {
@@ -498,28 +494,9 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(dev, "no mem resource\n");
-                return -EINVAL;
-        }
-
-        davinci_rtc->pbase = res->start;
-        davinci_rtc->base_size = resource_size(res);
-
-        mem = devm_request_mem_region(dev, davinci_rtc->pbase,
-                                davinci_rtc->base_size, pdev->name);
-        if (!mem) {
-                dev_err(dev, "RTC registers at %08x are not free\n",
-                        davinci_rtc->pbase);
-                return -EBUSY;
-        }
-
-        davinci_rtc->base = devm_ioremap(dev, davinci_rtc->pbase,
-                                        davinci_rtc->base_size);
-        if (!davinci_rtc->base) {
-                dev_err(dev, "unable to ioremap MEM resource\n");
-                return -ENOMEM;
-        }
+        davinci_rtc->base = devm_ioremap_resource(dev, res);
+        if (IS_ERR(davinci_rtc->base))
+                return PTR_ERR(davinci_rtc->base);
 
         platform_set_drvdata(pdev, davinci_rtc);
 
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index 2dd586a19b59..129add77065d 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -756,19 +756,17 @@ static int ds1305_probe(struct spi_device *spi)
                 status = devm_request_irq(&spi->dev, spi->irq, ds1305_irq,
                                 0, dev_name(&ds1305->rtc->dev), ds1305);
                 if (status < 0) {
-                        dev_dbg(&spi->dev, "request_irq %d --> %d\n",
+                        dev_err(&spi->dev, "request_irq %d --> %d\n",
                                         spi->irq, status);
-                        return status;
+                } else {
+                        device_set_wakeup_capable(&spi->dev, 1);
                 }
-
-                device_set_wakeup_capable(&spi->dev, 1);
         }
 
         /* export NVRAM */
         status = sysfs_create_bin_file(&spi->dev.kobj, &nvram);
         if (status < 0) {
-                dev_dbg(&spi->dev, "register nvram --> %d\n", status);
-                return status;
+                dev_err(&spi->dev, "register nvram --> %d\n", status);
         }
 
         return 0;
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index 4e75345a559a..f03d5ba96db1 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -154,6 +154,7 @@ static const struct chip_desc chips[last_ds_type] = {
                 .alarm          = 1,
         },
         [mcp7941x] = {
+                .alarm          = 1,
                 /* this is battery backed SRAM */
                 .nvram_offset   = 0x20,
                 .nvram_size     = 0x40,
@@ -606,6 +607,178 @@ static const struct rtc_class_ops ds13xx_rtc_ops = {
 
 /*----------------------------------------------------------------------*/
 
+/*
+ * Alarm support for mcp7941x devices.
+ */
+
+#define MCP7941X_REG_CONTROL            0x07
+#       define MCP7941X_BIT_ALM0_EN     0x10
+#       define MCP7941X_BIT_ALM1_EN     0x20
+#define MCP7941X_REG_ALARM0_BASE        0x0a
+#define MCP7941X_REG_ALARM0_CTRL        0x0d
+#define MCP7941X_REG_ALARM1_BASE        0x11
+#define MCP7941X_REG_ALARM1_CTRL        0x14
+#       define MCP7941X_BIT_ALMX_IF     (1 << 3)
+#       define MCP7941X_BIT_ALMX_C0     (1 << 4)
+#       define MCP7941X_BIT_ALMX_C1     (1 << 5)
+#       define MCP7941X_BIT_ALMX_C2     (1 << 6)
+#       define MCP7941X_BIT_ALMX_POL    (1 << 7)
+#       define MCP7941X_MSK_ALMX_MATCH  (MCP7941X_BIT_ALMX_C0 | \
+                                         MCP7941X_BIT_ALMX_C1 | \
+                                         MCP7941X_BIT_ALMX_C2)
+
+static void mcp7941x_work(struct work_struct *work)
+{
+        struct ds1307 *ds1307 = container_of(work, struct ds1307, work);
+        struct i2c_client *client = ds1307->client;
+        int reg, ret;
+
+        mutex_lock(&ds1307->rtc->ops_lock);
+
+        /* Check and clear alarm 0 interrupt flag. */
+        reg = i2c_smbus_read_byte_data(client, MCP7941X_REG_ALARM0_CTRL);
+        if (reg < 0)
+                goto out;
+        if (!(reg & MCP7941X_BIT_ALMX_IF))
+                goto out;
+        reg &= ~MCP7941X_BIT_ALMX_IF;
+        ret = i2c_smbus_write_byte_data(client, MCP7941X_REG_ALARM0_CTRL, reg);
+        if (ret < 0)
+                goto out;
+
+        /* Disable alarm 0. */
+        reg = i2c_smbus_read_byte_data(client, MCP7941X_REG_CONTROL);
+        if (reg < 0)
+                goto out;
+        reg &= ~MCP7941X_BIT_ALM0_EN;
+        ret = i2c_smbus_write_byte_data(client, MCP7941X_REG_CONTROL, reg);
+        if (ret < 0)
+                goto out;
+
+        rtc_update_irq(ds1307->rtc, 1, RTC_AF | RTC_IRQF);
+
+out:
+        if (test_bit(HAS_ALARM, &ds1307->flags))
+                enable_irq(client->irq);
+        mutex_unlock(&ds1307->rtc->ops_lock);
+}
+
+static int mcp7941x_read_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ds1307 *ds1307 = i2c_get_clientdata(client);
+        u8 *regs = ds1307->regs;
+        int ret;
+
+        if (!test_bit(HAS_ALARM, &ds1307->flags))
+                return -EINVAL;
+
+        /* Read control and alarm 0 registers. */
+        ret = ds1307->read_block_data(client, MCP7941X_REG_CONTROL, 10, regs);
+        if (ret < 0)
+                return ret;
+
+        t->enabled = !!(regs[0] & MCP7941X_BIT_ALM0_EN);
+
+        /* Report alarm 0 time assuming 24-hour and day-of-month modes. */
+        t->time.tm_sec = bcd2bin(ds1307->regs[3] & 0x7f);
+        t->time.tm_min = bcd2bin(ds1307->regs[4] & 0x7f);
+        t->time.tm_hour = bcd2bin(ds1307->regs[5] & 0x3f);
+        t->time.tm_wday = bcd2bin(ds1307->regs[6] & 0x7) - 1;
+        t->time.tm_mday = bcd2bin(ds1307->regs[7] & 0x3f);
+        t->time.tm_mon = bcd2bin(ds1307->regs[8] & 0x1f) - 1;
+        t->time.tm_year = -1;
+        t->time.tm_yday = -1;
+        t->time.tm_isdst = -1;
+
+        dev_dbg(dev, "%s, sec=%d min=%d hour=%d wday=%d mday=%d mon=%d "
+                "enabled=%d polarity=%d irq=%d match=%d\n", __func__,
+                t->time.tm_sec, t->time.tm_min, t->time.tm_hour,
+                t->time.tm_wday, t->time.tm_mday, t->time.tm_mon, t->enabled,
+                !!(ds1307->regs[6] & MCP7941X_BIT_ALMX_POL),
+                !!(ds1307->regs[6] & MCP7941X_BIT_ALMX_IF),
+                (ds1307->regs[6] & MCP7941X_MSK_ALMX_MATCH) >> 4);
+
+        return 0;
+}
+
+static int mcp7941x_set_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ds1307 *ds1307 = i2c_get_clientdata(client);
+        unsigned char *regs = ds1307->regs;
+        int ret;
+
+        if (!test_bit(HAS_ALARM, &ds1307->flags))
+                return -EINVAL;
+
+        dev_dbg(dev, "%s, sec=%d min=%d hour=%d wday=%d mday=%d mon=%d "
+                "enabled=%d pending=%d\n", __func__,
+                t->time.tm_sec, t->time.tm_min, t->time.tm_hour,
+                t->time.tm_wday, t->time.tm_mday, t->time.tm_mon,
+                t->enabled, t->pending);
+
+        /* Read control and alarm 0 registers. */
+        ret = ds1307->read_block_data(client, MCP7941X_REG_CONTROL, 10, regs);
+        if (ret < 0)
+                return ret;
+
+        /* Set alarm 0, using 24-hour and day-of-month modes. */
+        regs[3] = bin2bcd(t->time.tm_sec);
+        regs[4] = bin2bcd(t->time.tm_min);
+        regs[5] = bin2bcd(t->time.tm_hour);
+        regs[6] = bin2bcd(t->time.tm_wday) + 1;
+        regs[7] = bin2bcd(t->time.tm_mday);
+        regs[8] = bin2bcd(t->time.tm_mon) + 1;
+
+        /* Clear the alarm 0 interrupt flag. */
+        regs[6] &= ~MCP7941X_BIT_ALMX_IF;
+        /* Set alarm match: second, minute, hour, day, date, month. */
+        regs[6] |= MCP7941X_MSK_ALMX_MATCH;
+
+        if (t->enabled)
+                regs[0] |= MCP7941X_BIT_ALM0_EN;
+        else
+                regs[0] &= ~MCP7941X_BIT_ALM0_EN;
+
+        ret = ds1307->write_block_data(client, MCP7941X_REG_CONTROL, 10, regs);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int mcp7941x_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ds1307 *ds1307 = i2c_get_clientdata(client);
+        int reg;
+
+        if (!test_bit(HAS_ALARM, &ds1307->flags))
+                return -EINVAL;
+
+        reg = i2c_smbus_read_byte_data(client, MCP7941X_REG_CONTROL);
+        if (reg < 0)
+                return reg;
+
+        if (enabled)
+                reg |= MCP7941X_BIT_ALM0_EN;
+        else
+                reg &= ~MCP7941X_BIT_ALM0_EN;
+
+        return i2c_smbus_write_byte_data(client, MCP7941X_REG_CONTROL, reg);
+}
+
+static const struct rtc_class_ops mcp7941x_rtc_ops = {
+        .read_time      = ds1307_get_time,
+        .set_time       = ds1307_set_time,
+        .read_alarm     = mcp7941x_read_alarm,
+        .set_alarm      = mcp7941x_set_alarm,
+        .alarm_irq_enable = mcp7941x_alarm_irq_enable,
+};
+
+/*----------------------------------------------------------------------*/
+
 static ssize_t
 ds1307_nvram_read(struct file *filp, struct kobject *kobj,
                 struct bin_attribute *attr,
@@ -678,6 +851,7 @@ static int ds1307_probe(struct i2c_client *client,
                 [ds_1339] = DS1339_BIT_BBSQI,
                 [ds_3231] = DS3231_BIT_BBSQW,
         };
+        const struct rtc_class_ops *rtc_ops = &ds13xx_rtc_ops;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)
             && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
@@ -816,6 +990,13 @@ static int ds1307_probe(struct i2c_client *client,
         case ds_1388:
                 ds1307->offset = 1; /* Seconds starts at 1 */
                 break;
+        case mcp7941x:
+                rtc_ops = &mcp7941x_rtc_ops;
+                if (ds1307->client->irq > 0 && chip->alarm) {
+                        INIT_WORK(&ds1307->work, mcp7941x_work);
+                        want_irq = true;
+                }
+                break;
         default:
                 break;
         }
@@ -927,55 +1108,61 @@ read_rtc:
                                 bin2bcd(tmp));
         }
 
+        device_set_wakeup_capable(&client->dev, want_irq);
         ds1307->rtc = devm_rtc_device_register(&client->dev, client->name,
-                                &ds13xx_rtc_ops, THIS_MODULE);
+                                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;
+                return PTR_ERR(ds1307->rtc);
         }
 
         if (want_irq) {
                 err = request_irq(client->irq, ds1307_irq, IRQF_SHARED,
                           ds1307->rtc->name, client);
                 if (err) {
-                        dev_err(&client->dev,
-                                "unable to request IRQ!\n");
-                        goto exit;
-                }
+                        client->irq = 0;
+                        dev_err(&client->dev, "unable to request IRQ!\n");
+                } else {
 
-                device_set_wakeup_capable(&client->dev, 1);
-                set_bit(HAS_ALARM, &ds1307->flags);
-                dev_dbg(&client->dev, "got IRQ %d\n", client->irq);
+                        set_bit(HAS_ALARM, &ds1307->flags);
+                        dev_dbg(&client->dev, "got IRQ %d\n", client->irq);
+                }
         }
 
         if (chip->nvram_size) {
+
                 ds1307->nvram = devm_kzalloc(&client->dev,
                                         sizeof(struct bin_attribute),
                                         GFP_KERNEL);
                 if (!ds1307->nvram) {
-                        err = -ENOMEM;
-                        goto err_irq;
+                        dev_err(&client->dev, "cannot allocate memory for nvram sysfs\n");
+                } else {
+
+                        ds1307->nvram->attr.name = "nvram";
+                        ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
+
+                        sysfs_bin_attr_init(ds1307->nvram);
+
+                        ds1307->nvram->read = ds1307_nvram_read;
+                        ds1307->nvram->write = ds1307_nvram_write;
+                        ds1307->nvram->size = chip->nvram_size;
+                        ds1307->nvram_offset = chip->nvram_offset;
+
+                        err = sysfs_create_bin_file(&client->dev.kobj,
+                                                    ds1307->nvram);
+                        if (err) {
+                                dev_err(&client->dev,
+                                        "unable to create sysfs file: %s\n",
+                                        ds1307->nvram->attr.name);
+                        } else {
+                                set_bit(HAS_NVRAM, &ds1307->flags);
+                                dev_info(&client->dev, "%zu bytes nvram\n",
+                                         ds1307->nvram->size);
+                        }
                 }
-                ds1307->nvram->attr.name = "nvram";
-                ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
-                sysfs_bin_attr_init(ds1307->nvram);
-                ds1307->nvram->read = ds1307_nvram_read;
-                ds1307->nvram->write = ds1307_nvram_write;
-                ds1307->nvram->size = chip->nvram_size;
-                ds1307->nvram_offset = chip->nvram_offset;
-                err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram);
-                if (err)
-                        goto err_irq;
-                set_bit(HAS_NVRAM, &ds1307->flags);
-                dev_info(&client->dev, "%zu bytes nvram\n", ds1307->nvram->size);
         }
 
         return 0;
 
-err_irq:
-        free_irq(client->irq, client);
 exit:
         return err;
 }
diff --git a/drivers/rtc/rtc-ds1347.c b/drivers/rtc/rtc-ds1347.c
new file mode 100644
index 000000000000..c82b4c050326
--- /dev/null
+++ b/drivers/rtc/rtc-ds1347.c
@@ -0,0 +1,166 @@
+/* rtc-ds1347.c
+ *
+ * Driver for Dallas Semiconductor DS1347 Low Current, SPI Compatible
+ * Real Time Clock
+ *
+ * Author : Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>
+ *
+ * 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/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/spi/spi.h>
+#include <linux/bcd.h>
+
+/* Registers in ds1347 rtc */
+
+#define DS1347_SECONDS_REG      0x01
+#define DS1347_MINUTES_REG      0x03
+#define DS1347_HOURS_REG        0x05
+#define DS1347_DATE_REG         0x07
+#define DS1347_MONTH_REG        0x09
+#define DS1347_DAY_REG          0x0B
+#define DS1347_YEAR_REG         0x0D
+#define DS1347_CONTROL_REG      0x0F
+#define DS1347_STATUS_REG       0x17
+#define DS1347_CLOCK_BURST      0x3F
+
+static int ds1347_read_reg(struct device *dev, unsigned char address,
+                                unsigned char *data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+
+        *data = address | 0x80;
+
+        return spi_write_then_read(spi, data, 1, data, 1);
+}
+
+static int ds1347_write_reg(struct device *dev, unsigned char address,
+                                unsigned char data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned char buf[2];
+
+        buf[0] = address & 0x7F;
+        buf[1] = data;
+
+        return spi_write_then_read(spi, buf, 2, NULL, 0);
+}
+
+static int ds1347_read_time(struct device *dev, struct rtc_time *dt)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        int err;
+        unsigned char buf[8];
+
+        buf[0] = DS1347_CLOCK_BURST | 0x80;
+
+        err = spi_write_then_read(spi, buf, 1, buf, 8);
+        if (err)
+                return err;
+
+        dt->tm_sec = bcd2bin(buf[0]);
+        dt->tm_min = bcd2bin(buf[1]);
+        dt->tm_hour = bcd2bin(buf[2] & 0x3F);
+        dt->tm_mday = bcd2bin(buf[3]);
+        dt->tm_mon = bcd2bin(buf[4]) - 1;
+        dt->tm_wday = bcd2bin(buf[5]) - 1;
+        dt->tm_year = bcd2bin(buf[6]) + 100;
+
+        return rtc_valid_tm(dt);
+}
+
+static int ds1347_set_time(struct device *dev, struct rtc_time *dt)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned char buf[9];
+
+        buf[0] = DS1347_CLOCK_BURST & 0x7F;
+        buf[1] = bin2bcd(dt->tm_sec);
+        buf[2] = bin2bcd(dt->tm_min);
+        buf[3] = (bin2bcd(dt->tm_hour) & 0x3F);
+        buf[4] = bin2bcd(dt->tm_mday);
+        buf[5] = bin2bcd(dt->tm_mon + 1);
+        buf[6] = bin2bcd(dt->tm_wday + 1);
+
+        /* year in linux is from 1900 i.e in range of 100
+        in rtc it is from 00 to 99 */
+        dt->tm_year = dt->tm_year % 100;
+
+        buf[7] = bin2bcd(dt->tm_year);
+        buf[8] = bin2bcd(0x00);
+
+        /* write the rtc settings */
+        return spi_write_then_read(spi, buf, 9, NULL, 0);
+}
+
+static const struct rtc_class_ops ds1347_rtc_ops = {
+        .read_time = ds1347_read_time,
+        .set_time = ds1347_set_time,
+};
+
+static int ds1347_probe(struct spi_device *spi)
+{
+        struct rtc_device *rtc;
+        unsigned char data;
+        int res;
+
+        /* spi setup with ds1347 in mode 3 and bits per word as 8 */
+        spi->mode = SPI_MODE_3;
+        spi->bits_per_word = 8;
+        spi_setup(spi);
+
+        /* RTC Settings */
+        res = ds1347_read_reg(&spi->dev, DS1347_SECONDS_REG, &data);
+        if (res)
+                return res;
+
+        /* Disable the write protect of rtc */
+        ds1347_read_reg(&spi->dev, DS1347_CONTROL_REG, &data);
+        data = data & ~(1<<7);
+        ds1347_write_reg(&spi->dev, DS1347_CONTROL_REG, data);
+
+        /* Enable the oscillator , disable the oscillator stop flag,
+         and glitch filter to reduce current consumption */
+        ds1347_read_reg(&spi->dev, DS1347_STATUS_REG, &data);
+        data = data & 0x1B;
+        ds1347_write_reg(&spi->dev, DS1347_STATUS_REG, data);
+
+        /* display the settings */
+        ds1347_read_reg(&spi->dev, DS1347_CONTROL_REG, &data);
+        dev_info(&spi->dev, "DS1347 RTC CTRL Reg = 0x%02x\n", data);
+
+        ds1347_read_reg(&spi->dev, DS1347_STATUS_REG, &data);
+        dev_info(&spi->dev, "DS1347 RTC Status Reg = 0x%02x\n", data);
+
+        rtc = devm_rtc_device_register(&spi->dev, "ds1347",
+                                &ds1347_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        spi_set_drvdata(spi, rtc);
+
+        return 0;
+}
+
+static struct spi_driver ds1347_driver = {
+        .driver = {
+                .name = "ds1347",
+                .owner = THIS_MODULE,
+        },
+        .probe = ds1347_probe,
+};
+
+module_spi_driver(ds1347_driver);
+
+MODULE_DESCRIPTION("DS1347 SPI RTC DRIVER");
+MODULE_AUTHOR("Raghavendra C Ganiga <ravi23ganiga@gmail.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-ds1390.c b/drivers/rtc/rtc-ds1390.c
index be9d8c0a7e3a..e67bfcb3a1aa 100644
--- a/drivers/rtc/rtc-ds1390.c
+++ b/drivers/rtc/rtc-ds1390.c
@@ -132,10 +132,9 @@ static int ds1390_probe(struct spi_device *spi)
         spi_setup(spi);
 
         chip = devm_kzalloc(&spi->dev, sizeof(*chip), GFP_KERNEL);
-        if (!chip) {
-                dev_err(&spi->dev, "unable to allocate device memory\n");
+        if (!chip)
                 return -ENOMEM;
-        }
+
         spi_set_drvdata(spi, chip);
 
         res = ds1390_get_reg(&spi->dev, DS1390_REG_SECONDS, &tmp);
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index bc7b4fcf603c..b13d1399b81a 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -371,8 +371,7 @@ ds1511_interrupt(int irq, void *dev_id)
                         events |= RTC_UF;
                 else
                         events |= RTC_AF;
-                if (likely(pdata->rtc))
-                        rtc_update_irq(pdata->rtc, 1, events);
+                rtc_update_irq(pdata->rtc, 1, events);
         }
         spin_unlock(&pdata->lock);
         return events ? IRQ_HANDLED : IRQ_NONE;
@@ -473,7 +472,6 @@ static struct bin_attribute ds1511_nvram_attr = {
 
 static int ds1511_rtc_probe(struct platform_device *pdev)
 {
-        struct rtc_device *rtc;
         struct resource *res;
         struct rtc_plat_data *pdata;
         int ret = 0;
@@ -512,6 +510,12 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
 
         spin_lock_init(&pdata->lock);
         platform_set_drvdata(pdev, pdata);
+
+        pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
+                                              &ds1511_rtc_ops, THIS_MODULE);
+        if (IS_ERR(pdata->rtc))
+                return PTR_ERR(pdata->rtc);
+
         /*
          * if the platform has an interrupt in mind for this device,
          * then by all means, set it
@@ -526,15 +530,12 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
                 }
         }
 
-        rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &ds1511_rtc_ops,
-                                        THIS_MODULE);
-        if (IS_ERR(rtc))
-                return PTR_ERR(rtc);
-        pdata->rtc = rtc;
-
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1511_nvram_attr);
+        if (ret)
+                dev_err(&pdev->dev, "Unable to create sysfs entry: %s\n",
+                        ds1511_nvram_attr.attr.name);
 
-        return ret;
+        return 0;
 }
 
 static int ds1511_rtc_remove(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index fd31571941f5..ab56893aac73 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -206,8 +206,7 @@ static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id)
                         events |= RTC_UF;
                 else
                         events |= RTC_AF;
-                if (likely(pdata->rtc))
-                        rtc_update_irq(pdata->rtc, 1, events);
+                rtc_update_irq(pdata->rtc, 1, events);
         }
         spin_unlock(&pdata->lock);
         return events ? IRQ_HANDLED : IRQ_NONE;
@@ -278,7 +277,6 @@ static struct bin_attribute ds1553_nvram_attr = {
 
 static int ds1553_rtc_probe(struct platform_device *pdev)
 {
-        struct rtc_device *rtc;
         struct resource *res;
         unsigned int cen, sec;
         struct rtc_plat_data *pdata;
@@ -311,6 +309,12 @@ static int ds1553_rtc_probe(struct platform_device *pdev)
         spin_lock_init(&pdata->lock);
         pdata->last_jiffies = jiffies;
         platform_set_drvdata(pdev, pdata);
+
+        pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
+                                  &ds1553_rtc_ops, THIS_MODULE);
+        if (IS_ERR(pdata->rtc))
+                return PTR_ERR(pdata->rtc);
+
         if (pdata->irq > 0) {
                 writeb(0, ioaddr + RTC_INTERRUPTS);
                 if (devm_request_irq(&pdev->dev, pdata->irq,
@@ -321,15 +325,12 @@ static int ds1553_rtc_probe(struct platform_device *pdev)
                 }
         }
 
-        rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                                  &ds1553_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc))
-                return PTR_ERR(rtc);
-        pdata->rtc = rtc;
-
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
+        if (ret)
+                dev_err(&pdev->dev, "unable to create sysfs file: %s\n",
+                        ds1553_nvram_attr.attr.name);
 
-        return ret;
+        return 0;
 }
 
 static int ds1553_rtc_remove(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 18e2d8471472..a4888dbca2e1 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -177,8 +177,9 @@ static int ds1672_probe(struct i2c_client *client,
 
         /* read control register */
         err = ds1672_get_control(client, &control);
-        if (err)
-                goto exit_devreg;
+        if (err) {
+                dev_warn(&client->dev, "Unable to read the control register\n");
+        }
 
         if (control & DS1672_REG_CONTROL_EOSC)
                 dev_warn(&client->dev, "Oscillator not enabled. "
@@ -187,12 +188,10 @@ static int ds1672_probe(struct i2c_client *client,
         /* Register sysfs hooks */
         err = device_create_file(&client->dev, &dev_attr_control);
         if (err)
-                goto exit_devreg;
+                dev_err(&client->dev, "Unable to create sysfs entry: %s\n",
+                        dev_attr_control.attr.name);
 
         return 0;
-
- exit_devreg:
-        return err;
 }
 
 static struct i2c_device_id ds1672_id[] = {
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 5a1f3b2a8f1e..942103dac30f 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -204,8 +204,11 @@ static int ds1742_rtc_probe(struct platform_device *pdev)
                 return PTR_ERR(rtc);
 
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
+        if (ret)
+                dev_err(&pdev->dev, "Unable to create sysfs entry: %s\n",
+                        pdata->nvram_attr.attr.name);
 
-        return ret;
+        return 0;
 }
 
 static int ds1742_rtc_remove(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-ds3232.c b/drivers/rtc/rtc-ds3232.c
index b83bb5a527f8..adaf06c41479 100644
--- a/drivers/rtc/rtc-ds3232.c
+++ b/drivers/rtc/rtc-ds3232.c
@@ -57,6 +57,7 @@ struct ds3232 {
          * in the remove function.
          */
         struct mutex mutex;
+        bool suspended;
         int exiting;
 };
 
@@ -345,7 +346,15 @@ static irqreturn_t ds3232_irq(int irq, void *dev_id)
         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 
         disable_irq_nosync(irq);
-        schedule_work(&ds3232->work);
+
+        /*
+         * If rtc as a wakeup source, can't schedule the work
+         * at system resume flow, because at this time the i2c bus
+         * has not been resumed.
+         */
+        if (!ds3232->suspended)
+                schedule_work(&ds3232->work);
+
         return IRQ_HANDLED;
 }
 
@@ -363,22 +372,26 @@ static void ds3232_work(struct work_struct *work)
 
         if (stat & DS3232_REG_SR_A1F) {
                 control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
-                if (control < 0)
-                        goto out;
-                /* disable alarm1 interrupt */
-                control &= ~(DS3232_REG_CR_A1IE);
-                i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
-
-                /* clear the alarm pend flag */
-                stat &= ~DS3232_REG_SR_A1F;
-                i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
-
-                rtc_update_irq(ds3232->rtc, 1, RTC_AF | RTC_IRQF);
+                if (control < 0) {
+                        pr_warn("Read DS3232 Control Register error."
+                                "Disable IRQ%d.\n", client->irq);
+                } else {
+                        /* disable alarm1 interrupt */
+                        control &= ~(DS3232_REG_CR_A1IE);
+                        i2c_smbus_write_byte_data(client, DS3232_REG_CR,
+                                                control);
+
+                        /* clear the alarm pend flag */
+                        stat &= ~DS3232_REG_SR_A1F;
+                        i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
+
+                        rtc_update_irq(ds3232->rtc, 1, RTC_AF | RTC_IRQF);
+
+                        if (!ds3232->exiting)
+                                enable_irq(client->irq);
+                }
         }
 
-out:
-        if (!ds3232->exiting)
-                enable_irq(client->irq);
 unlock:
         mutex_unlock(&ds3232->mutex);
 }
@@ -411,23 +424,17 @@ static int ds3232_probe(struct i2c_client *client,
         if (ret)
                 return ret;
 
-        ds3232->rtc = devm_rtc_device_register(&client->dev, client->name,
-                                          &ds3232_rtc_ops, THIS_MODULE);
-        if (IS_ERR(ds3232->rtc)) {
-                dev_err(&client->dev, "unable to register the class device\n");
-                return PTR_ERR(ds3232->rtc);
-        }
-
-        if (client->irq >= 0) {
-                ret = devm_request_irq(&client->dev, client->irq, ds3232_irq, 0,
-                                 "ds3232", client);
+        if (client->irq > 0) {
+                ret = devm_request_irq(&client->dev, client->irq, ds3232_irq,
+                                       IRQF_SHARED, "ds3232", client);
                 if (ret) {
                         dev_err(&client->dev, "unable to request IRQ\n");
-                        return ret;
                 }
+                device_init_wakeup(&client->dev, 1);
         }
-
-        return 0;
+        ds3232->rtc = devm_rtc_device_register(&client->dev, client->name,
+                                          &ds3232_rtc_ops, THIS_MODULE);
+        return PTR_ERR_OR_ZERO(ds3232->rtc);
 }
 
 static int ds3232_remove(struct i2c_client *client)
@@ -446,6 +453,42 @@ static int ds3232_remove(struct i2c_client *client)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int ds3232_suspend(struct device *dev)
+{
+        struct ds3232 *ds3232 = dev_get_drvdata(dev);
+        struct i2c_client *client = to_i2c_client(dev);
+
+        if (device_can_wakeup(dev)) {
+                ds3232->suspended = true;
+                irq_set_irq_wake(client->irq, 1);
+        }
+
+        return 0;
+}
+
+static int ds3232_resume(struct device *dev)
+{
+        struct ds3232 *ds3232 = dev_get_drvdata(dev);
+        struct i2c_client *client = to_i2c_client(dev);
+
+        if (ds3232->suspended) {
+                ds3232->suspended = false;
+
+                /* Clear the hardware alarm pend flag */
+                schedule_work(&ds3232->work);
+
+                irq_set_irq_wake(client->irq, 0);
+        }
+
+        return 0;
+}
+#endif
+
+static const struct dev_pm_ops ds3232_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(ds3232_suspend, ds3232_resume)
+};
+
 static const struct i2c_device_id ds3232_id[] = {
         { "ds3232", 0 },
         { }
@@ -456,6 +499,7 @@ static struct i2c_driver ds3232_driver = {
         .driver = {
                 .name = "rtc-ds3232",
                 .owner = THIS_MODULE,
+                .pm     = &ds3232_pm_ops,
         },
         .probe = ds3232_probe,
         .remove = ds3232_remove,
diff --git a/drivers/rtc/rtc-imxdi.c b/drivers/rtc/rtc-imxdi.c
index abd7f9091f34..cd741c77e085 100644
--- a/drivers/rtc/rtc-imxdi.c
+++ b/drivers/rtc/rtc-imxdi.c
@@ -401,7 +401,9 @@ static int __init dryice_rtc_probe(struct platform_device *pdev)
         imxdi->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(imxdi->clk))
                 return PTR_ERR(imxdi->clk);
-        clk_prepare_enable(imxdi->clk);
+        rc = clk_prepare_enable(imxdi->clk);
+        if (rc)
+                return rc;
 
         /*
          * Initialize dryice hardware
diff --git a/drivers/rtc/rtc-isl12057.c b/drivers/rtc/rtc-isl12057.c
index 7854a656628f..7e5ead936a04 100644
--- a/drivers/rtc/rtc-isl12057.c
+++ b/drivers/rtc/rtc-isl12057.c
@@ -26,7 +26,6 @@
 #include <linux/rtc.h>
 #include <linux/i2c.h>
 #include <linux/bcd.h>
-#include <linux/rtc.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/regmap.h>
diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
index 1b126d2513de..08f5160fb6d4 100644
--- a/drivers/rtc/rtc-jz4740.c
+++ b/drivers/rtc/rtc-jz4740.c
@@ -38,7 +38,6 @@
 #define JZ_RTC_CTRL_ENABLE      BIT(0)
 
 struct jz4740_rtc {
-        struct resource *mem;
         void __iomem *base;
 
         struct rtc_device *rtc;
@@ -216,6 +215,7 @@ static int jz4740_rtc_probe(struct platform_device *pdev)
         int ret;
         struct jz4740_rtc *rtc;
         uint32_t scratchpad;
+        struct resource *mem;
 
         rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
         if (!rtc)
@@ -227,25 +227,10 @@ static int jz4740_rtc_probe(struct platform_device *pdev)
                 return -ENOENT;
         }
 
-        rtc->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!rtc->mem) {
-                dev_err(&pdev->dev, "Failed to get platform mmio memory\n");
-                return -ENOENT;
-        }
-
-        rtc->mem = devm_request_mem_region(&pdev->dev, rtc->mem->start,
-                                        resource_size(rtc->mem), pdev->name);
-        if (!rtc->mem) {
-                dev_err(&pdev->dev, "Failed to request mmio memory region\n");
-                return -EBUSY;
-        }
-
-        rtc->base = devm_ioremap_nocache(&pdev->dev, rtc->mem->start,
-                                        resource_size(rtc->mem));
-        if (!rtc->base) {
-                dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
-                return -EBUSY;
-        }
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        rtc->base = devm_ioremap_resource(&pdev->dev, mem);
+        if (IS_ERR(rtc->base))
+                return PTR_ERR(rtc->base);
 
         spin_lock_init(&rtc->lock);
 
diff --git a/drivers/rtc/rtc-lpc32xx.c b/drivers/rtc/rtc-lpc32xx.c
index bfdbcb82d069..f130c08c98f8 100644
--- a/drivers/rtc/rtc-lpc32xx.c
+++ b/drivers/rtc/rtc-lpc32xx.c
@@ -211,10 +211,9 @@ static int lpc32xx_rtc_probe(struct platform_device *pdev)
         }
 
         rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
-        if (unlikely(!rtc)) {
-                dev_err(&pdev->dev, "Can't allocate memory\n");
+        if (unlikely(!rtc))
                 return -ENOMEM;
-        }
+
         rtc->irq = rtcirq;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/rtc/rtc-mc13xxx.c b/drivers/rtc/rtc-mc13xxx.c
index 77ea9896b5ba..0765606a2d14 100644
--- a/drivers/rtc/rtc-mc13xxx.c
+++ b/drivers/rtc/rtc-mc13xxx.c
@@ -23,6 +23,8 @@
 #define MC13XXX_RTCDAY  22
 #define MC13XXX_RTCDAYA 23
 
+#define SEC_PER_DAY     (24 * 60 * 60)
+
 struct mc13xxx_rtc {
         struct rtc_device *rtc;
         struct mc13xxx *mc13xxx;
@@ -42,15 +44,15 @@ static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev,
         return func(priv->mc13xxx, irq);
 }
 
-static int mc13xxx_rtc_irq_enable(struct device *dev,
-                unsigned int enabled, int irq)
+static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
+                                        unsigned int enabled)
 {
         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
         int ret;
 
         mc13xxx_lock(priv->mc13xxx);
 
-        ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, irq);
+        ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, MC13XXX_IRQ_TODA);
 
         mc13xxx_unlock(priv->mc13xxx);
 
@@ -61,44 +63,27 @@ static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
         unsigned int seconds, days1, days2;
-        unsigned long s1970;
-        int ret;
-
-        mc13xxx_lock(priv->mc13xxx);
-
-        if (!priv->valid) {
-                ret = -ENODATA;
-                goto out;
-        }
 
-        ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
-        if (unlikely(ret))
-                goto out;
-
-        ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
-        if (unlikely(ret))
-                goto out;
-
-        ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
-out:
-        mc13xxx_unlock(priv->mc13xxx);
+        if (!priv->valid)
+                return -ENODATA;
 
-        if (ret)
-                return ret;
+        do {
+                int ret;
 
-        if (days2 == days1 + 1) {
-                if (seconds >= 86400 / 2)
-                        days2 = days1;
-                else
-                        days1 = days2;
-        }
+                ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
+                if (ret)
+                        return ret;
 
-        if (days1 != days2)
-                return -EIO;
+                ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
+                if (ret)
+                        return ret;
 
-        s1970 = days1 * 86400 + seconds;
+                ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
+                if (ret)
+                        return ret;
+        } while (days1 != days2);
 
-        rtc_time_to_tm(s1970, tm);
+        rtc_time_to_tm(days1 * SEC_PER_DAY + seconds, tm);
 
         return rtc_valid_tm(tm);
 }
@@ -110,8 +95,8 @@ static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
         unsigned int alarmseconds;
         int ret;
 
-        seconds = secs % 86400;
-        days = secs / 86400;
+        seconds = secs % SEC_PER_DAY;
+        days = secs / SEC_PER_DAY;
 
         mc13xxx_lock(priv->mc13xxx);
 
@@ -123,7 +108,7 @@ static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
         if (unlikely(ret))
                 goto out;
 
-        if (alarmseconds < 86400) {
+        if (alarmseconds < SEC_PER_DAY) {
                 ret = mc13xxx_reg_write(priv->mc13xxx,
                                 MC13XXX_RTCTODA, 0x1ffff);
                 if (unlikely(ret))
@@ -147,18 +132,21 @@ static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
                 goto out;
 
         /* restore alarm */
-        if (alarmseconds < 86400) {
+        if (alarmseconds < SEC_PER_DAY) {
                 ret = mc13xxx_reg_write(priv->mc13xxx,
                                 MC13XXX_RTCTODA, alarmseconds);
                 if (unlikely(ret))
                         goto out;
         }
 
-        ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
-        if (unlikely(ret))
-                goto out;
+        if (!priv->valid) {
+                ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
+                if (unlikely(ret))
+                        goto out;
+
+                ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
+        }
 
-        ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
 out:
         priv->valid = !ret;
 
@@ -180,7 +168,7 @@ static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
         if (unlikely(ret))
                 goto out;
-        if (seconds >= 86400) {
+        if (seconds >= SEC_PER_DAY) {
                 ret = -ENODATA;
                 goto out;
         }
@@ -201,7 +189,7 @@ out:
         alarm->enabled = enabled;
         alarm->pending = pending;
 
-        s1970 = days * 86400 + seconds;
+        s1970 = days * SEC_PER_DAY + seconds;
 
         rtc_time_to_tm(s1970, &alarm->time);
         dev_dbg(dev, "%s: %lu\n", __func__, s1970);
@@ -239,8 +227,8 @@ static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         if (unlikely(ret))
                 goto out;
 
-        seconds = s1970 % 86400;
-        days = s1970 / 86400;
+        seconds = s1970 % SEC_PER_DAY;
+        days = s1970 / SEC_PER_DAY;
 
         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
         if (unlikely(ret))
@@ -259,8 +247,6 @@ static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
         struct mc13xxx_rtc *priv = dev;
         struct mc13xxx *mc13xxx = priv->mc13xxx;
 
-        dev_dbg(&priv->rtc->dev, "Alarm\n");
-
         rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
 
         mc13xxx_irq_ack(mc13xxx, irq);
@@ -273,8 +259,6 @@ static irqreturn_t mc13xxx_rtc_update_handler(int irq, void *dev)
         struct mc13xxx_rtc *priv = dev;
         struct mc13xxx *mc13xxx = priv->mc13xxx;
 
-        dev_dbg(&priv->rtc->dev, "1HZ\n");
-
         rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF);
 
         mc13xxx_irq_ack(mc13xxx, irq);
@@ -282,12 +266,6 @@ static irqreturn_t mc13xxx_rtc_update_handler(int irq, void *dev)
         return IRQ_HANDLED;
 }
 
-static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
-                unsigned int enabled)
-{
-        return mc13xxx_rtc_irq_enable(dev, enabled, MC13XXX_IRQ_TODA);
-}
-
 static const struct rtc_class_ops mc13xxx_rtc_ops = {
         .read_time = mc13xxx_rtc_read_time,
         .set_mmss = mc13xxx_rtc_set_mmss,
@@ -301,7 +279,6 @@ static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
         struct mc13xxx_rtc *priv = dev;
         struct mc13xxx *mc13xxx = priv->mc13xxx;
 
-        dev_dbg(&priv->rtc->dev, "RTCRST\n");
         priv->valid = 0;
 
         mc13xxx_irq_mask(mc13xxx, irq);
@@ -314,7 +291,6 @@ static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
         int ret;
         struct mc13xxx_rtc *priv;
         struct mc13xxx *mc13xxx;
-        int rtcrst_pending;
 
         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
         if (!priv)
@@ -322,60 +298,47 @@ static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
 
         mc13xxx = dev_get_drvdata(pdev->dev.parent);
         priv->mc13xxx = mc13xxx;
+        priv->valid = 1;
 
         platform_set_drvdata(pdev, priv);
 
         mc13xxx_lock(mc13xxx);
 
+        mc13xxx_irq_ack(mc13xxx, MC13XXX_IRQ_RTCRST);
+
         ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
                         mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
         if (ret)
-                goto err_reset_irq_request;
-
-        ret = mc13xxx_irq_status(mc13xxx, MC13XXX_IRQ_RTCRST,
-                        NULL, &rtcrst_pending);
-        if (ret)
-                goto err_reset_irq_status;
-
-        priv->valid = !rtcrst_pending;
+                goto err_irq_request;
 
-        ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_1HZ,
+        ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_1HZ,
                         mc13xxx_rtc_update_handler, DRIVER_NAME, priv);
         if (ret)
-                goto err_update_irq_request;
+                goto err_irq_request;
 
         ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
                         mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
         if (ret)
-                goto err_alarm_irq_request;
+                goto err_irq_request;
 
         mc13xxx_unlock(mc13xxx);
 
         priv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                                        &mc13xxx_rtc_ops, THIS_MODULE);
-        if (IS_ERR(priv->rtc)) {
-                ret = PTR_ERR(priv->rtc);
+                                             &mc13xxx_rtc_ops, THIS_MODULE);
 
-                mc13xxx_lock(mc13xxx);
-
-                mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
-err_alarm_irq_request:
-
-                mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_1HZ, priv);
-err_update_irq_request:
-
-err_reset_irq_status:
+        return 0;
 
-                mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
-err_reset_irq_request:
+err_irq_request:
+        mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
+        mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_1HZ, priv);
+        mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
 
-                mc13xxx_unlock(mc13xxx);
-        }
+        mc13xxx_unlock(mc13xxx);
 
         return ret;
 }
 
-static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
+static int mc13xxx_rtc_remove(struct platform_device *pdev)
 {
         struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
 
@@ -404,7 +367,7 @@ MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);
 
 static struct platform_driver mc13xxx_rtc_driver = {
         .id_table = mc13xxx_rtc_idtable,
-        .remove = __exit_p(mc13xxx_rtc_remove),
+        .remove = mc13xxx_rtc_remove,
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
diff --git a/drivers/rtc/rtc-moxart.c b/drivers/rtc/rtc-moxart.c
index c29dee0946e6..c31846238871 100644
--- a/drivers/rtc/rtc-moxart.c
+++ b/drivers/rtc/rtc-moxart.c
@@ -247,10 +247,8 @@ static int moxart_rtc_probe(struct platform_device *pdev)
         int ret = 0;
 
         moxart_rtc = devm_kzalloc(&pdev->dev, sizeof(*moxart_rtc), GFP_KERNEL);
-        if (!moxart_rtc) {
-                dev_err(&pdev->dev, "devm_kzalloc failed\n");
+        if (!moxart_rtc)
                 return -ENOMEM;
-        }
 
         moxart_rtc->gpio_data = of_get_named_gpio(pdev->dev.of_node,
                                                   "gpio-rtc-data", 0);
diff --git a/drivers/rtc/rtc-nuc900.c b/drivers/rtc/rtc-nuc900.c
index 248653c74b80..a53da0958e95 100644
--- a/drivers/rtc/rtc-nuc900.c
+++ b/drivers/rtc/rtc-nuc900.c
@@ -229,10 +229,9 @@ static int __init nuc900_rtc_probe(struct platform_device *pdev)
 
         nuc900_rtc = devm_kzalloc(&pdev->dev, sizeof(struct nuc900_rtc),
                                 GFP_KERNEL);
-        if (!nuc900_rtc) {
-                dev_err(&pdev->dev, "kzalloc nuc900_rtc failed\n");
+        if (!nuc900_rtc)
                 return -ENOMEM;
-        }
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         nuc900_rtc->rtc_reg = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(nuc900_rtc->rtc_reg))
diff --git a/drivers/rtc/rtc-palmas.c b/drivers/rtc/rtc-palmas.c
index fffb7d3449d7..c360d62fb3f6 100644
--- a/drivers/rtc/rtc-palmas.c
+++ b/drivers/rtc/rtc-palmas.c
@@ -348,9 +348,8 @@ static int palmas_rtc_resume(struct device *dev)
 }
 #endif
 
-static const struct dev_pm_ops palmas_rtc_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(palmas_rtc_suspend, palmas_rtc_resume)
-};
+static SIMPLE_DEV_PM_OPS(palmas_rtc_pm_ops, palmas_rtc_suspend,
+                         palmas_rtc_resume);
 
 #ifdef CONFIG_OF
 static struct of_device_id of_palmas_rtc_match[] = {
diff --git a/drivers/rtc/rtc-pm8xxx.c b/drivers/rtc/rtc-pm8xxx.c
index 03f8f75d5af2..197699f358c7 100644
--- a/drivers/rtc/rtc-pm8xxx.c
+++ b/drivers/rtc/rtc-pm8xxx.c
@@ -9,18 +9,16 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */
-
+#include <linux/of.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/rtc.h>
+#include <linux/platform_device.h>
 #include <linux/pm.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 
-#include <linux/mfd/pm8xxx/core.h>
-#include <linux/mfd/pm8xxx/rtc.h>
-
-
 /* RTC Register offsets from RTC CTRL REG */
 #define PM8XXX_ALARM_CTRL_OFFSET        0x01
 #define PM8XXX_RTC_WRITE_OFFSET         0x02
@@ -37,6 +35,8 @@
 /**
  * struct pm8xxx_rtc -  rtc driver internal structure
  * @rtc:                rtc device for this driver.
+ * @regmap:             regmap used to access RTC registers
+ * @allow_set_time:     indicates whether writing to the RTC is allowed
  * @rtc_alarm_irq:      rtc alarm irq number.
  * @rtc_base:           address of rtc control register.
  * @rtc_read_base:      base address of read registers.
@@ -48,55 +48,19 @@
  */
 struct pm8xxx_rtc {
         struct rtc_device *rtc;
+        struct regmap *regmap;
+        bool allow_set_time;
         int rtc_alarm_irq;
         int rtc_base;
         int rtc_read_base;
         int rtc_write_base;
         int alarm_rw_base;
-        u8  ctrl_reg;
+        u8 ctrl_reg;
         struct device *rtc_dev;
         spinlock_t ctrl_reg_lock;
 };
 
 /*
- * The RTC registers need to be read/written one byte at a time. This is a
- * hardware limitation.
- */
-static int pm8xxx_read_wrapper(struct pm8xxx_rtc *rtc_dd, u8 *rtc_val,
-                int base, int count)
-{
-        int i, rc;
-        struct device *parent = rtc_dd->rtc_dev->parent;
-
-        for (i = 0; i < count; i++) {
-                rc = pm8xxx_readb(parent, base + i, &rtc_val[i]);
-                if (rc < 0) {
-                        dev_err(rtc_dd->rtc_dev, "PMIC read failed\n");
-                        return rc;
-                }
-        }
-
-        return 0;
-}
-
-static int pm8xxx_write_wrapper(struct pm8xxx_rtc *rtc_dd, u8 *rtc_val,
-                int base, int count)
-{
-        int i, rc;
-        struct device *parent = rtc_dd->rtc_dev->parent;
-
-        for (i = 0; i < count; i++) {
-                rc = pm8xxx_writeb(parent, base + i, rtc_val[i]);
-                if (rc < 0) {
-                        dev_err(rtc_dd->rtc_dev, "PMIC write failed\n");
-                        return rc;
-                }
-        }
-
-        return 0;
-}
-
-/*
  * Steps to write the RTC registers.
  * 1. Disable alarm if enabled.
  * 2. Write 0x00 to LSB.
@@ -107,9 +71,12 @@ static int pm8xxx_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
         int rc, i;
         unsigned long secs, irq_flags;
-        u8 value[NUM_8_BIT_RTC_REGS], reg = 0, alarm_enabled = 0, ctrl_reg;
+        u8 value[NUM_8_BIT_RTC_REGS], alarm_enabled = 0, ctrl_reg;
         struct pm8xxx_rtc *rtc_dd = dev_get_drvdata(dev);
 
+        if (!rtc_dd->allow_set_time)
+                return -EACCES;
+
         rtc_tm_to_time(tm, &secs);
 
         for (i = 0; i < NUM_8_BIT_RTC_REGS; i++) {
@@ -125,47 +92,43 @@ static int pm8xxx_rtc_set_time(struct device *dev, struct rtc_time *tm)
         if (ctrl_reg & PM8xxx_RTC_ALARM_ENABLE) {
                 alarm_enabled = 1;
                 ctrl_reg &= ~PM8xxx_RTC_ALARM_ENABLE;
-                rc = pm8xxx_write_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base,
-                                1);
-                if (rc < 0) {
-                        dev_err(dev, "Write to RTC control register "
-                                                                "failed\n");
+                rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_base, ctrl_reg);
+                if (rc) {
+                        dev_err(dev, "Write to RTC control register failed\n");
                         goto rtc_rw_fail;
                 }
                 rtc_dd->ctrl_reg = ctrl_reg;
-        } else
+        } else {
                 spin_unlock_irqrestore(&rtc_dd->ctrl_reg_lock, irq_flags);
+        }
 
         /* Write 0 to Byte[0] */
-        reg = 0;
-        rc = pm8xxx_write_wrapper(rtc_dd, &reg, rtc_dd->rtc_write_base, 1);
-        if (rc < 0) {
+        rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_write_base, 0);
+        if (rc) {
                 dev_err(dev, "Write to RTC write data register failed\n");
                 goto rtc_rw_fail;
         }
 
         /* Write Byte[1], Byte[2], Byte[3] */
-        rc = pm8xxx_write_wrapper(rtc_dd, value + 1,
-                                        rtc_dd->rtc_write_base + 1, 3);
-        if (rc < 0) {
+        rc = regmap_bulk_write(rtc_dd->regmap, rtc_dd->rtc_write_base + 1,
+                               &value[1], sizeof(value) - 1);
+        if (rc) {
                 dev_err(dev, "Write to RTC write data register failed\n");
                 goto rtc_rw_fail;
         }
 
         /* Write Byte[0] */
-        rc = pm8xxx_write_wrapper(rtc_dd, value, rtc_dd->rtc_write_base, 1);
-        if (rc < 0) {
+        rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_write_base, value[0]);
+        if (rc) {
                 dev_err(dev, "Write to RTC write data register failed\n");
                 goto rtc_rw_fail;
         }
 
         if (alarm_enabled) {
                 ctrl_reg |= PM8xxx_RTC_ALARM_ENABLE;
-                rc = pm8xxx_write_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base,
-                                                                        1);
-                if (rc < 0) {
-                        dev_err(dev, "Write to RTC control register "
-                                                                "failed\n");
+                rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_base, ctrl_reg);
+                if (rc) {
+                        dev_err(dev, "Write to RTC control register failed\n");
                         goto rtc_rw_fail;
                 }
                 rtc_dd->ctrl_reg = ctrl_reg;
@@ -181,13 +144,14 @@ rtc_rw_fail:
 static int pm8xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         int rc;
-        u8 value[NUM_8_BIT_RTC_REGS], reg;
+        u8 value[NUM_8_BIT_RTC_REGS];
         unsigned long secs;
+        unsigned int reg;
         struct pm8xxx_rtc *rtc_dd = dev_get_drvdata(dev);
 
-        rc = pm8xxx_read_wrapper(rtc_dd, value, rtc_dd->rtc_read_base,
-                                                        NUM_8_BIT_RTC_REGS);
-        if (rc < 0) {
+        rc = regmap_bulk_read(rtc_dd->regmap, rtc_dd->rtc_read_base,
+                              value, sizeof(value));
+        if (rc) {
                 dev_err(dev, "RTC read data register failed\n");
                 return rc;
         }
@@ -196,16 +160,16 @@ static int pm8xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
          * Read the LSB again and check if there has been a carry over.
          * If there is, redo the read operation.
          */
-        rc = pm8xxx_read_wrapper(rtc_dd, &reg, rtc_dd->rtc_read_base, 1);
+        rc = regmap_read(rtc_dd->regmap, rtc_dd->rtc_read_base, &reg);
         if (rc < 0) {
                 dev_err(dev, "RTC read data register failed\n");
                 return rc;
         }
 
         if (unlikely(reg < value[0])) {
-                rc = pm8xxx_read_wrapper(rtc_dd, value,
-                                rtc_dd->rtc_read_base, NUM_8_BIT_RTC_REGS);
-                if (rc < 0) {
+                rc = regmap_bulk_read(rtc_dd->regmap, rtc_dd->rtc_read_base,
+                                      value, sizeof(value));
+                if (rc) {
                         dev_err(dev, "RTC read data register failed\n");
                         return rc;
                 }
@@ -222,8 +186,8 @@ static int pm8xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
         }
 
         dev_dbg(dev, "secs = %lu, h:m:s == %d:%d:%d, d/m/y = %d/%d/%d\n",
-                                secs, tm->tm_hour, tm->tm_min, tm->tm_sec,
-                                tm->tm_mday, tm->tm_mon, tm->tm_year);
+                secs, tm->tm_hour, tm->tm_min, tm->tm_sec,
+                tm->tm_mday, tm->tm_mon, tm->tm_year);
 
         return 0;
 }
@@ -244,19 +208,22 @@ static int pm8xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 
         spin_lock_irqsave(&rtc_dd->ctrl_reg_lock, irq_flags);
 
-        rc = pm8xxx_write_wrapper(rtc_dd, value, rtc_dd->alarm_rw_base,
-                                                        NUM_8_BIT_RTC_REGS);
-        if (rc < 0) {
+        rc = regmap_bulk_write(rtc_dd->regmap, rtc_dd->alarm_rw_base, value,
+                               sizeof(value));
+        if (rc) {
                 dev_err(dev, "Write to RTC ALARM register failed\n");
                 goto rtc_rw_fail;
         }
 
         ctrl_reg = rtc_dd->ctrl_reg;
-        ctrl_reg = alarm->enabled ? (ctrl_reg | PM8xxx_RTC_ALARM_ENABLE) :
-                                        (ctrl_reg & ~PM8xxx_RTC_ALARM_ENABLE);
 
-        rc = pm8xxx_write_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base, 1);
-        if (rc < 0) {
+        if (alarm->enabled)
+                ctrl_reg |= PM8xxx_RTC_ALARM_ENABLE;
+        else
+                ctrl_reg &= ~PM8xxx_RTC_ALARM_ENABLE;
+
+        rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_base, ctrl_reg);
+        if (rc) {
                 dev_err(dev, "Write to RTC control register failed\n");
                 goto rtc_rw_fail;
         }
@@ -264,9 +231,9 @@ static int pm8xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         rtc_dd->ctrl_reg = ctrl_reg;
 
         dev_dbg(dev, "Alarm Set for h:r:s=%d:%d:%d, d/m/y=%d/%d/%d\n",
-                                alarm->time.tm_hour, alarm->time.tm_min,
-                                alarm->time.tm_sec, alarm->time.tm_mday,
-                                alarm->time.tm_mon, alarm->time.tm_year);
+                alarm->time.tm_hour, alarm->time.tm_min,
+                alarm->time.tm_sec, alarm->time.tm_mday,
+                alarm->time.tm_mon, alarm->time.tm_year);
 rtc_rw_fail:
         spin_unlock_irqrestore(&rtc_dd->ctrl_reg_lock, irq_flags);
         return rc;
@@ -279,9 +246,9 @@ static int pm8xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         unsigned long secs;
         struct pm8xxx_rtc *rtc_dd = dev_get_drvdata(dev);
 
-        rc = pm8xxx_read_wrapper(rtc_dd, value, rtc_dd->alarm_rw_base,
-                        NUM_8_BIT_RTC_REGS);
-        if (rc < 0) {
+        rc = regmap_bulk_read(rtc_dd->regmap, rtc_dd->alarm_rw_base, value,
+                              sizeof(value));
+        if (rc) {
                 dev_err(dev, "RTC alarm time read failed\n");
                 return rc;
         }
@@ -297,9 +264,9 @@ static int pm8xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         }
 
         dev_dbg(dev, "Alarm set for - h:r:s=%d:%d:%d, d/m/y=%d/%d/%d\n",
-                                alarm->time.tm_hour, alarm->time.tm_min,
-                                alarm->time.tm_sec, alarm->time.tm_mday,
-                                alarm->time.tm_mon, alarm->time.tm_year);
+                alarm->time.tm_hour, alarm->time.tm_min,
+                alarm->time.tm_sec, alarm->time.tm_mday,
+                alarm->time.tm_mon, alarm->time.tm_year);
 
         return 0;
 }
@@ -312,12 +279,16 @@ static int pm8xxx_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
         u8 ctrl_reg;
 
         spin_lock_irqsave(&rtc_dd->ctrl_reg_lock, irq_flags);
+
         ctrl_reg = rtc_dd->ctrl_reg;
-        ctrl_reg = (enable) ? (ctrl_reg | PM8xxx_RTC_ALARM_ENABLE) :
-                                (ctrl_reg & ~PM8xxx_RTC_ALARM_ENABLE);
 
-        rc = pm8xxx_write_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base, 1);
-        if (rc < 0) {
+        if (enable)
+                ctrl_reg |= PM8xxx_RTC_ALARM_ENABLE;
+        else
+                ctrl_reg &= ~PM8xxx_RTC_ALARM_ENABLE;
+
+        rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_base, ctrl_reg);
+        if (rc) {
                 dev_err(dev, "Write to RTC control register failed\n");
                 goto rtc_rw_fail;
         }
@@ -329,8 +300,9 @@ rtc_rw_fail:
         return rc;
 }
 
-static struct rtc_class_ops pm8xxx_rtc_ops = {
+static const struct rtc_class_ops pm8xxx_rtc_ops = {
         .read_time      = pm8xxx_rtc_read_time,
+        .set_time       = pm8xxx_rtc_set_time,
         .set_alarm      = pm8xxx_rtc_set_alarm,
         .read_alarm     = pm8xxx_rtc_read_alarm,
         .alarm_irq_enable = pm8xxx_rtc_alarm_irq_enable,
@@ -339,7 +311,7 @@ static struct rtc_class_ops pm8xxx_rtc_ops = {
 static irqreturn_t pm8xxx_alarm_trigger(int irq, void *dev_id)
 {
         struct pm8xxx_rtc *rtc_dd = dev_id;
-        u8 ctrl_reg;
+        unsigned int ctrl_reg;
         int rc;
         unsigned long irq_flags;
 
@@ -351,11 +323,11 @@ static irqreturn_t pm8xxx_alarm_trigger(int irq, void *dev_id)
         ctrl_reg = rtc_dd->ctrl_reg;
         ctrl_reg &= ~PM8xxx_RTC_ALARM_ENABLE;
 
-        rc = pm8xxx_write_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base, 1);
-        if (rc < 0) {
+        rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_base, ctrl_reg);
+        if (rc) {
                 spin_unlock_irqrestore(&rtc_dd->ctrl_reg_lock, irq_flags);
-                dev_err(rtc_dd->rtc_dev, "Write to RTC control register "
-                                                                "failed\n");
+                dev_err(rtc_dd->rtc_dev,
+                        "Write to RTC control register failed\n");
                 goto rtc_alarm_handled;
         }
 
@@ -363,61 +335,71 @@ static irqreturn_t pm8xxx_alarm_trigger(int irq, void *dev_id)
         spin_unlock_irqrestore(&rtc_dd->ctrl_reg_lock, irq_flags);
 
         /* Clear RTC alarm register */
-        rc = pm8xxx_read_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base +
-                                                PM8XXX_ALARM_CTRL_OFFSET, 1);
-        if (rc < 0) {
-                dev_err(rtc_dd->rtc_dev, "RTC Alarm control register read "
-                                                                "failed\n");
+        rc = regmap_read(rtc_dd->regmap,
+                         rtc_dd->rtc_base + PM8XXX_ALARM_CTRL_OFFSET,
+                         &ctrl_reg);
+        if (rc) {
+                dev_err(rtc_dd->rtc_dev,
+                        "RTC Alarm control register read failed\n");
                 goto rtc_alarm_handled;
         }
 
         ctrl_reg &= ~PM8xxx_RTC_ALARM_CLEAR;
-        rc = pm8xxx_write_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base +
-                                                PM8XXX_ALARM_CTRL_OFFSET, 1);
-        if (rc < 0)
-                dev_err(rtc_dd->rtc_dev, "Write to RTC Alarm control register"
-                                                                " failed\n");
+        rc = regmap_write(rtc_dd->regmap,
+                          rtc_dd->rtc_base + PM8XXX_ALARM_CTRL_OFFSET,
+                          ctrl_reg);
+        if (rc)
+                dev_err(rtc_dd->rtc_dev,
+                        "Write to RTC Alarm control register failed\n");
 
 rtc_alarm_handled:
         return IRQ_HANDLED;
 }
 
+/*
+ * Hardcoded RTC bases until IORESOURCE_REG mapping is figured out
+ */
+static const struct of_device_id pm8xxx_id_table[] = {
+        { .compatible = "qcom,pm8921-rtc", .data = (void *) 0x11D },
+        { .compatible = "qcom,pm8058-rtc", .data = (void *) 0x1E8 },
+        { },
+};
+MODULE_DEVICE_TABLE(of, pm8xxx_id_table);
+
 static int pm8xxx_rtc_probe(struct platform_device *pdev)
 {
         int rc;
-        u8 ctrl_reg;
-        bool rtc_write_enable = false;
+        unsigned int ctrl_reg;
         struct pm8xxx_rtc *rtc_dd;
-        struct resource *rtc_resource;
-        const struct pm8xxx_rtc_platform_data *pdata =
-                                                dev_get_platdata(&pdev->dev);
+        const struct of_device_id *match;
 
-        if (pdata != NULL)
-                rtc_write_enable = pdata->rtc_write_enable;
+        match = of_match_node(pm8xxx_id_table, pdev->dev.of_node);
+        if (!match)
+                return -ENXIO;
 
         rtc_dd = devm_kzalloc(&pdev->dev, sizeof(*rtc_dd), GFP_KERNEL);
-        if (rtc_dd == NULL) {
-                dev_err(&pdev->dev, "Unable to allocate memory!\n");
+        if (rtc_dd == NULL)
                 return -ENOMEM;
-        }
 
         /* Initialise spinlock to protect RTC control register */
         spin_lock_init(&rtc_dd->ctrl_reg_lock);
 
+        rtc_dd->regmap = dev_get_regmap(pdev->dev.parent, NULL);
+        if (!rtc_dd->regmap) {
+                dev_err(&pdev->dev, "Parent regmap unavailable.\n");
+                return -ENXIO;
+        }
+
         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");
                 return -ENXIO;
         }
 
-        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");
-                return -ENXIO;
-        }
+        rtc_dd->allow_set_time = of_property_read_bool(pdev->dev.of_node,
+                                                      "allow-set-time");
 
-        rtc_dd->rtc_base = rtc_resource->start;
+        rtc_dd->rtc_base = (long) match->data;
 
         /* Setup RTC register addresses */
         rtc_dd->rtc_write_base = rtc_dd->rtc_base + PM8XXX_RTC_WRITE_OFFSET;
@@ -427,64 +409,52 @@ static int pm8xxx_rtc_probe(struct platform_device *pdev)
         rtc_dd->rtc_dev = &pdev->dev;
 
         /* Check if the RTC is on, else turn it on */
-        rc = pm8xxx_read_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base, 1);
-        if (rc < 0) {
+        rc = regmap_read(rtc_dd->regmap, rtc_dd->rtc_base, &ctrl_reg);
+        if (rc) {
                 dev_err(&pdev->dev, "RTC control register read failed!\n");
                 return rc;
         }
 
         if (!(ctrl_reg & PM8xxx_RTC_ENABLE)) {
                 ctrl_reg |= PM8xxx_RTC_ENABLE;
-                rc = pm8xxx_write_wrapper(rtc_dd, &ctrl_reg, rtc_dd->rtc_base,
-                                                                        1);
-                if (rc < 0) {
-                        dev_err(&pdev->dev, "Write to RTC control register "
-                                                                "failed\n");
+                rc = regmap_write(rtc_dd->regmap, rtc_dd->rtc_base, ctrl_reg);
+                if (rc) {
+                        dev_err(&pdev->dev,
+                                "Write to RTC control register failed\n");
                         return rc;
                 }
         }
 
         rtc_dd->ctrl_reg = ctrl_reg;
-        if (rtc_write_enable == true)
-                pm8xxx_rtc_ops.set_time = pm8xxx_rtc_set_time;
 
         platform_set_drvdata(pdev, rtc_dd);
 
+        device_init_wakeup(&pdev->dev, 1);
+
         /* Register the RTC device */
         rtc_dd->rtc = devm_rtc_device_register(&pdev->dev, "pm8xxx_rtc",
-                                &pm8xxx_rtc_ops, THIS_MODULE);
+                                               &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));
+                        __func__, PTR_ERR(rtc_dd->rtc));
                 return PTR_ERR(rtc_dd->rtc);
         }
 
         /* Request the alarm IRQ */
-        rc = request_any_context_irq(rtc_dd->rtc_alarm_irq,
-                                 pm8xxx_alarm_trigger, IRQF_TRIGGER_RISING,
-                                 "pm8xxx_rtc_alarm", rtc_dd);
+        rc = devm_request_any_context_irq(&pdev->dev, rtc_dd->rtc_alarm_irq,
+                                          pm8xxx_alarm_trigger,
+                                          IRQF_TRIGGER_RISING,
+                                          "pm8xxx_rtc_alarm", rtc_dd);
         if (rc < 0) {
                 dev_err(&pdev->dev, "Request IRQ failed (%d)\n", rc);
                 return rc;
         }
 
-        device_init_wakeup(&pdev->dev, 1);
-
         dev_dbg(&pdev->dev, "Probe success !!\n");
 
         return 0;
 }
 
-static int pm8xxx_rtc_remove(struct platform_device *pdev)
-{
-        struct pm8xxx_rtc *rtc_dd = platform_get_drvdata(pdev);
-
-        device_init_wakeup(&pdev->dev, 0);
-        free_irq(rtc_dd->rtc_alarm_irq, rtc_dd);
-
-        return 0;
-}
-
 #ifdef CONFIG_PM_SLEEP
 static int pm8xxx_rtc_resume(struct device *dev)
 {
@@ -507,15 +477,17 @@ static int pm8xxx_rtc_suspend(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(pm8xxx_rtc_pm_ops, pm8xxx_rtc_suspend, pm8xxx_rtc_resume);
+static SIMPLE_DEV_PM_OPS(pm8xxx_rtc_pm_ops,
+                         pm8xxx_rtc_suspend,
+                         pm8xxx_rtc_resume);
 
 static struct platform_driver pm8xxx_rtc_driver = {
         .probe          = pm8xxx_rtc_probe,
-        .remove         = pm8xxx_rtc_remove,
         .driver = {
-                .name   = PM8XXX_RTC_DEV_NAME,
-                .owner  = THIS_MODULE,
-                .pm     = &pm8xxx_rtc_pm_ops,
+                .name           = "rtc-pm8xxx",
+                .owner          = THIS_MODULE,
+                .pm             = &pm8xxx_rtc_pm_ops,
+                .of_match_table = pm8xxx_id_table,
         },
 };
 
diff --git a/drivers/rtc/rtc-rv3029c2.c b/drivers/rtc/rtc-rv3029c2.c
index 1a779a67ff66..e9ac5a43be1a 100644
--- a/drivers/rtc/rtc-rv3029c2.c
+++ b/drivers/rtc/rtc-rv3029c2.c
@@ -395,6 +395,12 @@ static int rv3029c2_probe(struct i2c_client *client,
         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_EMUL))
                 return -ENODEV;
 
+        rc = rv3029c2_i2c_get_sr(client, buf);
+        if (rc < 0) {
+                dev_err(&client->dev, "reading status failed\n");
+                return rc;
+        }
+
         rtc = devm_rtc_device_register(&client->dev, client->name,
                                         &rv3029c2_rtc_ops, THIS_MODULE);
 
@@ -403,12 +409,6 @@ static int rv3029c2_probe(struct i2c_client *client,
 
         i2c_set_clientdata(client, rtc);
 
-        rc = rv3029c2_i2c_get_sr(client, buf);
-        if (rc < 0) {
-                dev_err(&client->dev, "reading status failed\n");
-                return rc;
-        }
-
         return 0;
 }
 
diff --git a/drivers/rtc/rtc-rx8025.c b/drivers/rtc/rtc-rx8025.c
index 8fa23eabcb68..e6298e02b400 100644
--- a/drivers/rtc/rtc-rx8025.c
+++ b/drivers/rtc/rtc-rx8025.c
@@ -551,7 +551,6 @@ static int rx8025_probe(struct i2c_client *client,
 
         rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL);
         if (!rx8025) {
-                dev_err(&adapter->dev, "failed to alloc memory\n");
                 err = -ENOMEM;
                 goto errout;
         }
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index 7afd373b9595..4958a363b2c7 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -48,8 +48,8 @@ struct s3c_rtc_drv_data {
 
 static struct clk *rtc_clk;
 static void __iomem *s3c_rtc_base;
-static int s3c_rtc_alarmno = NO_IRQ;
-static int s3c_rtc_tickno  = NO_IRQ;
+static int s3c_rtc_alarmno;
+static int s3c_rtc_tickno;
 static enum s3c_cpu_type s3c_rtc_cpu_type;
 
 static DEFINE_SPINLOCK(s3c_rtc_pie_lock);
@@ -580,10 +580,12 @@ static int s3c_rtc_suspend(struct device *dev)
 
         clk_enable(rtc_clk);
         /* save TICNT for anyone using periodic interrupts */
-        ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT);
         if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
                 ticnt_en_save = readw(s3c_rtc_base + S3C2410_RTCCON);
                 ticnt_en_save &= S3C64XX_RTCCON_TICEN;
+                ticnt_save = readl(s3c_rtc_base + S3C2410_TICNT);
+        } else {
+                ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT);
         }
         s3c_rtc_enable(pdev, 0);
 
@@ -605,10 +607,15 @@ static int s3c_rtc_resume(struct device *dev)
 
         clk_enable(rtc_clk);
         s3c_rtc_enable(pdev, 1);
-        writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
-        if (s3c_rtc_cpu_type == TYPE_S3C64XX && ticnt_en_save) {
-                tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
-                writew(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
+                writel(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
+                if (ticnt_en_save) {
+                        tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
+                        writew(tmp | ticnt_en_save,
+                                        s3c_rtc_base + S3C2410_RTCCON);
+                }
+        } else {
+                writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
         }
 
         if (device_may_wakeup(dev) && wake_en) {
diff --git a/drivers/rtc/rtc-sirfsoc.c b/drivers/rtc/rtc-sirfsoc.c
index 3eb3642ae299..76e38007ba90 100644
--- a/drivers/rtc/rtc-sirfsoc.c
+++ b/drivers/rtc/rtc-sirfsoc.c
@@ -264,12 +264,8 @@ static int sirfsoc_rtc_probe(struct platform_device *pdev)
 
         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);
+        if (rtcdrv == NULL)
                 return -ENOMEM;
-        }
 
         err = of_property_read_u32(np, "reg", &rtcdrv->rtc_base);
         if (err) {
@@ -335,39 +331,29 @@ static int sirfsoc_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-
+#ifdef CONFIG_PM_SLEEP
 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);
+        struct sirfsoc_rtc_drv *rtcdrv = dev_get_drvdata(dev);
         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))
+        if (device_may_wakeup(dev) && !enable_irq_wake(rtcdrv->irq))
                 rtcdrv->irq_wake = 1;
 
         return 0;
 }
 
-static int sirfsoc_rtc_freeze(struct device *dev)
-{
-        sirfsoc_rtc_suspend(dev);
-
-        return 0;
-}
-
-static int sirfsoc_rtc_thaw(struct device *dev)
+static int sirfsoc_rtc_resume(struct device *dev)
 {
         u32 tmp;
-        struct sirfsoc_rtc_drv *rtcdrv;
-        rtcdrv = dev_get_drvdata(dev);
+        struct sirfsoc_rtc_drv *rtcdrv = dev_get_drvdata(dev);
 
         /*
-         * if resume from snapshot and the rtc power is losed,
+         * if resume from snapshot and the rtc power is lost,
          * restroe the rtc settings
          */
         if (SIRFSOC_RTC_CLK != sirfsoc_rtc_iobrg_readl(
@@ -407,57 +393,23 @@ static int sirfsoc_rtc_thaw(struct device *dev)
         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) && rtcdrv->irq_wake) {
+        if (device_may_wakeup(dev) && rtcdrv->irq_wake) {
                 disable_irq_wake(rtcdrv->irq);
                 rtcdrv->irq_wake = 0;
         }
 
         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) && rtcdrv->irq_wake) {
-                disable_irq_wake(rtcdrv->irq);
-                rtcdrv->irq_wake = 0;
-        }
-        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 SIMPLE_DEV_PM_OPS(sirfsoc_rtc_pm_ops,
+                sirfsoc_rtc_suspend, sirfsoc_rtc_resume);
 
 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 = sirfsoc_rtc_of_match,
         },
         .probe = sirfsoc_rtc_probe,
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
index c492cf0ab8cd..d2cdb9823a15 100644
--- a/drivers/rtc/rtc-spear.c
+++ b/drivers/rtc/rtc-spear.c
@@ -365,10 +365,8 @@ static int spear_rtc_probe(struct platform_device *pdev)
         }
 
         config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
-        if (!config) {
-                dev_err(&pdev->dev, "out of memory\n");
+        if (!config)
                 return -ENOMEM;
-        }
 
         /* alarm irqs */
         irq = platform_get_irq(pdev, 0);
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
index a176ba614683..35ed49ea1f81 100644
--- a/drivers/rtc/rtc-stk17ta8.c
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -214,8 +214,7 @@ static irqreturn_t stk17ta8_rtc_interrupt(int irq, void *dev_id)
                         events |= RTC_UF;
                 else
                         events |= RTC_AF;
-                if (likely(pdata->rtc))
-                        rtc_update_irq(pdata->rtc, 1, events);
+                rtc_update_irq(pdata->rtc, 1, events);
         }
         spin_unlock(&pdata->lock);
         return events ? IRQ_HANDLED : IRQ_NONE;
diff --git a/drivers/rtc/rtc-sunxi.c b/drivers/rtc/rtc-sunxi.c
index 68a35284e5ad..b6f21f73d508 100644
--- a/drivers/rtc/rtc-sunxi.c
+++ b/drivers/rtc/rtc-sunxi.c
@@ -428,7 +428,7 @@ static const struct rtc_class_ops sunxi_rtc_ops = {
 };
 
 static const struct of_device_id sunxi_rtc_dt_ids[] = {
-        { .compatible = "allwinner,sun4i-rtc", .data = &data_year_param[0] },
+        { .compatible = "allwinner,sun4i-a10-rtc", .data = &data_year_param[0] },
         { .compatible = "allwinner,sun7i-a20-rtc", .data = &data_year_param[1] },
         { /* sentinel */ },
 };
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index 7746e65b93f2..6599c20bc454 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -104,20 +104,17 @@ static int test_probe(struct platform_device *plat_dev)
         rtc = devm_rtc_device_register(&plat_dev->dev, "test",
                                 &test_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
-                err = PTR_ERR(rtc);
-                return err;
+                return PTR_ERR(rtc);
         }
 
         err = device_create_file(&plat_dev->dev, &dev_attr_irq);
         if (err)
-                goto err;
+                dev_err(&plat_dev->dev, "Unable to create sysfs entry: %s\n",
+                        dev_attr_irq.attr.name);
 
         platform_set_drvdata(plat_dev, rtc);
 
         return 0;
-
-err:
-        return err;
 }
 
 static int test_remove(struct platform_device *plat_dev)
diff --git a/drivers/rtc/rtc-tx4939.c b/drivers/rtc/rtc-tx4939.c
index 4f87234e0dee..2e678c681b13 100644
--- a/drivers/rtc/rtc-tx4939.c
+++ b/drivers/rtc/rtc-tx4939.c
@@ -176,8 +176,8 @@ static irqreturn_t tx4939_rtc_interrupt(int irq, void *dev_id)
                 tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_NOP);
         }
         spin_unlock(&pdata->lock);
-        if (likely(pdata->rtc))
-                rtc_update_irq(pdata->rtc, 1, events);
+        rtc_update_irq(pdata->rtc, 1, events);
+
         return IRQ_HANDLED;
 }
 
diff --git a/drivers/rtc/rtc-vt8500.c b/drivers/rtc/rtc-vt8500.c
index df2ef3eba7cd..051da968da6d 100644
--- a/drivers/rtc/rtc-vt8500.c
+++ b/drivers/rtc/rtc-vt8500.c
@@ -79,7 +79,6 @@
 
 struct vt8500_rtc {
         void __iomem            *regbase;
-        struct resource         *res;
         int                     irq_alarm;
         struct rtc_device       *rtc;
         spinlock_t              lock;           /* Protects this structure */
@@ -209,6 +208,7 @@ static const struct rtc_class_ops vt8500_rtc_ops = {
 static int vt8500_rtc_probe(struct platform_device *pdev)
 {
         struct vt8500_rtc *vt8500_rtc;
+        struct resource *res;
         int ret;
 
         vt8500_rtc = devm_kzalloc(&pdev->dev,
@@ -219,34 +219,16 @@ static int vt8500_rtc_probe(struct platform_device *pdev)
         spin_lock_init(&vt8500_rtc->lock);
         platform_set_drvdata(pdev, vt8500_rtc);
 
-        vt8500_rtc->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!vt8500_rtc->res) {
-                dev_err(&pdev->dev, "No I/O memory resource defined\n");
-                return -ENXIO;
-        }
-
         vt8500_rtc->irq_alarm = platform_get_irq(pdev, 0);
         if (vt8500_rtc->irq_alarm < 0) {
                 dev_err(&pdev->dev, "No alarm IRQ resource defined\n");
                 return vt8500_rtc->irq_alarm;
         }
 
-        vt8500_rtc->res = devm_request_mem_region(&pdev->dev,
-                                        vt8500_rtc->res->start,
-                                        resource_size(vt8500_rtc->res),
-                                        "vt8500-rtc");
-        if (vt8500_rtc->res == NULL) {
-                dev_err(&pdev->dev, "failed to request I/O memory\n");
-                return -EBUSY;
-        }
-
-        vt8500_rtc->regbase = devm_ioremap(&pdev->dev, vt8500_rtc->res->start,
-                                      resource_size(vt8500_rtc->res));
-        if (!vt8500_rtc->regbase) {
-                dev_err(&pdev->dev, "Unable to map RTC I/O memory\n");
-                ret = -EBUSY;
-                goto err_return;
-        }
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        vt8500_rtc->regbase = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(vt8500_rtc->regbase))
+                return PTR_ERR(vt8500_rtc->regbase);
 
         /* Enable RTC and set it to 24-hour mode */
         writel(VT8500_RTC_CR_ENABLE,
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index 365dc6505148..b1de58e0b3d0 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -660,7 +660,7 @@ static int x1205_probe(struct i2c_client *client,
 
         err = x1205_sysfs_register(&client->dev);
         if (err)
-                return err;
+                dev_err(&client->dev, "Unable to create sysfs entries\n");
 
         return 0;
 }