Merge branch 'linus' into perfcounters/rename

Merge reason: pull in all the latest code before doing the rename.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

6 files changed, 873 insertions, 118 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 81adbdbd5042..73771b09fbd3 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -518,6 +518,16 @@ config RTC_DRV_V3020
           This driver can also be built as a module. If so, the module
           will be called rtc-v3020.
 
+config RTC_DRV_WM831X
+        tristate "Wolfson Microelectronics WM831x RTC"
+        depends on MFD_WM831X
+        help
+          If you say yes here you will get support for the RTC subsystem
+          of the Wolfson Microelectronics WM831X series PMICs.
+
+          This driver can also be built as a module. If so, the module
+          will be called "rtc-wm831x".
+
 config RTC_DRV_WM8350
         tristate "Wolfson Microelectronics WM8350 RTC"
         depends on MFD_WM8350
@@ -535,6 +545,15 @@ config RTC_DRV_PCF50633
           If you say yes here you get support for the RTC subsystem of the
           NXP PCF50633 used in embedded systems.
 
+config RTC_DRV_AB3100
+        tristate "ST-Ericsson AB3100 RTC"
+        depends on AB3100_CORE
+        default y if AB3100_CORE
+        help
+          Select this to enable the ST-Ericsson AB3100 Mixed Signal IC RTC
+          support. This chip contains a battery- and capacitor-backed RTC.
+
+
 comment "on-CPU RTC drivers"
 
 config RTC_DRV_OMAP
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 3c0f2b2ac927..5e152ffe5058 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -17,6 +17,7 @@ rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
 
 # Keep the list ordered.
 
+obj-$(CONFIG_RTC_DRV_AB3100)    += rtc-ab3100.o
 obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
 obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
 obj-$(CONFIG_RTC_DRV_AT91SAM9)  += rtc-at91sam9.o
@@ -74,6 +75,7 @@ obj-$(CONFIG_RTC_DRV_TWL4030)	+= rtc-twl4030.o
 obj-$(CONFIG_RTC_DRV_TX4939)    += rtc-tx4939.o
 obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.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_PCF50633)  += rtc-pcf50633.o
diff --git a/drivers/rtc/rtc-ab3100.c b/drivers/rtc/rtc-ab3100.c
new file mode 100644
index 000000000000..4704aac2b5af
--- /dev/null
+++ b/drivers/rtc/rtc-ab3100.c
@@ -0,0 +1,281 @@
+/*
+ * Copyright (C) 2007-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * RTC clock driver for the AB3100 Analog Baseband Chip
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/mfd/ab3100.h>
+
+/* Clock rate in Hz */
+#define AB3100_RTC_CLOCK_RATE   32768
+
+/*
+ * The AB3100 RTC registers. These are the same for
+ * AB3000 and AB3100.
+ * Control register:
+ * Bit 0: RTC Monitor cleared=0, active=1, if you set it
+ *        to 1 it remains active until RTC power is lost.
+ * Bit 1: 32 kHz Oscillator, 0 = on, 1 = bypass
+ * Bit 2: Alarm on, 0 = off, 1 = on
+ * Bit 3: 32 kHz buffer disabling, 0 = enabled, 1 = disabled
+ */
+#define AB3100_RTC              0x53
+/* default setting, buffer disabled, alarm on */
+#define RTC_SETTING             0x30
+/* Alarm when AL0-AL3 == TI0-TI3  */
+#define AB3100_AL0              0x56
+#define AB3100_AL1              0x57
+#define AB3100_AL2              0x58
+#define AB3100_AL3              0x59
+/* This 48-bit register that counts up at 32768 Hz */
+#define AB3100_TI0              0x5a
+#define AB3100_TI1              0x5b
+#define AB3100_TI2              0x5c
+#define AB3100_TI3              0x5d
+#define AB3100_TI4              0x5e
+#define AB3100_TI5              0x5f
+
+/*
+ * RTC clock functions and device struct declaration
+ */
+static int ab3100_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        u8 regs[] = {AB3100_TI0, AB3100_TI1, AB3100_TI2,
+                     AB3100_TI3, AB3100_TI4, AB3100_TI5};
+        unsigned char buf[6];
+        u64 fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
+        int err = 0;
+        int i;
+
+        buf[0] = (fat_time) & 0xFF;
+        buf[1] = (fat_time >> 8) & 0xFF;
+        buf[2] = (fat_time >> 16) & 0xFF;
+        buf[3] = (fat_time >> 24) & 0xFF;
+        buf[4] = (fat_time >> 32) & 0xFF;
+        buf[5] = (fat_time >> 40) & 0xFF;
+
+        for (i = 0; i < 6; i++) {
+                err = ab3100_set_register_interruptible(ab3100_data,
+                                                        regs[i], buf[i]);
+                if (err)
+                        return err;
+        }
+
+        /* Set the flag to mark that the clock is now set */
+        return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                          AB3100_RTC,
+                                                          0xFE, 0x01);
+
+}
+
+static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        unsigned long time;
+        u8 rtcval;
+        int err;
+
+        err = ab3100_get_register_interruptible(ab3100_data,
+                                                AB3100_RTC, &rtcval);
+        if (err)
+                return err;
+
+        if (!(rtcval & 0x01)) {
+                dev_info(dev, "clock not set (lost power)");
+                return -EINVAL;
+        } else {
+                u64 fat_time;
+                u8 buf[6];
+
+                /* Read out time registers */
+                err = ab3100_get_register_page_interruptible(ab3100_data,
+                                                             AB3100_TI0,
+                                                             buf, 6);
+                if (err != 0)
+                        return err;
+
+                fat_time = ((u64) buf[5] << 40) | ((u64) buf[4] << 32) |
+                        ((u64) buf[3] << 24) | ((u64) buf[2] << 16) |
+                        ((u64) buf[1] << 8) | (u64) buf[0];
+                time = (unsigned long) (fat_time /
+                                        (u64) (AB3100_RTC_CLOCK_RATE * 2));
+        }
+
+        rtc_time_to_tm(time, tm);
+
+        return rtc_valid_tm(tm);
+}
+
+static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        unsigned long time;
+        u64 fat_time;
+        u8 buf[6];
+        u8 rtcval;
+        int err;
+
+        /* Figure out if alarm is enabled or not */
+        err = ab3100_get_register_interruptible(ab3100_data,
+                                                AB3100_RTC, &rtcval);
+        if (err)
+                return err;
+        if (rtcval & 0x04)
+                alarm->enabled = 1;
+        else
+                alarm->enabled = 0;
+        /* No idea how this could be represented */
+        alarm->pending = 0;
+        /* Read out alarm registers, only 4 bytes */
+        err = ab3100_get_register_page_interruptible(ab3100_data,
+                                                     AB3100_AL0, buf, 4);
+        if (err)
+                return err;
+        fat_time = ((u64) buf[3] << 40) | ((u64) buf[2] << 32) |
+                ((u64) buf[1] << 24) | ((u64) buf[0] << 16);
+        time = (unsigned long) (fat_time / (u64) (AB3100_RTC_CLOCK_RATE * 2));
+
+        rtc_time_to_tm(time, &alarm->time);
+
+        return rtc_valid_tm(&alarm->time);
+}
+
+static int ab3100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        u8 regs[] = {AB3100_AL0, AB3100_AL1, AB3100_AL2, AB3100_AL3};
+        unsigned char buf[4];
+        unsigned long secs;
+        u64 fat_time;
+        int err;
+        int i;
+
+        rtc_tm_to_time(&alarm->time, &secs);
+        fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
+        buf[0] = (fat_time >> 16) & 0xFF;
+        buf[1] = (fat_time >> 24) & 0xFF;
+        buf[2] = (fat_time >> 32) & 0xFF;
+        buf[3] = (fat_time >> 40) & 0xFF;
+
+        /* Set the alarm */
+        for (i = 0; i < 4; i++) {
+                err = ab3100_set_register_interruptible(ab3100_data,
+                                                        regs[i], buf[i]);
+                if (err)
+                        return err;
+        }
+        /* Then enable the alarm */
+        return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                          AB3100_RTC, ~(1 << 2),
+                                                          alarm->enabled << 2);
+}
+
+static int ab3100_rtc_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+
+        /*
+         * It's not possible to enable/disable the alarm IRQ for this RTC.
+         * It does not actually trigger any IRQ: instead its only function is
+         * to power up the system, if it wasn't on. This will manifest as
+         * a "power up cause" in the AB3100 power driver (battery charging etc)
+         * and need to be handled there instead.
+         */
+        if (enabled)
+                return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                    AB3100_RTC, ~(1 << 2),
+                                                    1 << 2);
+        else
+                return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                    AB3100_RTC, ~(1 << 2),
+                                                    0);
+}
+
+static const struct rtc_class_ops ab3100_rtc_ops = {
+        .read_time      = ab3100_rtc_read_time,
+        .set_mmss       = ab3100_rtc_set_mmss,
+        .read_alarm     = ab3100_rtc_read_alarm,
+        .set_alarm      = ab3100_rtc_set_alarm,
+        .alarm_irq_enable = ab3100_rtc_irq_enable,
+};
+
+static int __init ab3100_rtc_probe(struct platform_device *pdev)
+{
+        int err;
+        u8 regval;
+        struct rtc_device *rtc;
+        struct ab3100 *ab3100_data = platform_get_drvdata(pdev);
+
+        /* The first RTC register needs special treatment */
+        err = ab3100_get_register_interruptible(ab3100_data,
+                                                AB3100_RTC, &regval);
+        if (err) {
+                dev_err(&pdev->dev, "unable to read RTC register\n");
+                return -ENODEV;
+        }
+
+        if ((regval & 0xFE) != RTC_SETTING) {
+                dev_warn(&pdev->dev, "not default value in RTC reg 0x%x\n",
+                         regval);
+        }
+
+        if ((regval & 1) == 0) {
+                /*
+                 * Set bit to detect power loss.
+                 * This bit remains until RTC power is lost.
+                 */
+                regval = 1 | RTC_SETTING;
+                err = ab3100_set_register_interruptible(ab3100_data,
+                                                        AB3100_RTC, regval);
+                /* Ignore any error on this write */
+        }
+
+        rtc = rtc_device_register("ab3100-rtc", &pdev->dev, &ab3100_rtc_ops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                return err;
+        }
+
+        return 0;
+}
+
+static int __exit ab3100_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(rtc);
+        return 0;
+}
+
+static struct platform_driver ab3100_rtc_driver = {
+        .driver = {
+                .name = "ab3100-rtc",
+                .owner = THIS_MODULE,
+        },
+        .remove  = __exit_p(ab3100_rtc_remove),
+};
+
+static int __init ab3100_rtc_init(void)
+{
+        return platform_driver_probe(&ab3100_rtc_driver,
+                                     ab3100_rtc_probe);
+}
+
+static void __exit ab3100_rtc_exit(void)
+{
+        platform_driver_unregister(&ab3100_rtc_driver);
+}
+
+module_init(ab3100_rtc_init);
+module_exit(ab3100_rtc_exit);
+
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+MODULE_DESCRIPTION("AB3100 RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index 184556620778..d490628b64da 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -1,26 +1,25 @@
 /*
  * Dallas DS1302 RTC Support
  *
- *  Copyright (C) 2002  David McCullough
- *  Copyright (C) 2003 - 2007  Paul Mundt
+ *  Copyright (C) 2002 David McCullough
+ *  Copyright (C) 2003 - 2007 Paul Mundt
  *
  * This file is subject to the terms and conditions of the GNU General Public
- * License version 2.  See the file "COPYING" in the main directory of
+ * License version 2. See the file "COPYING" in the main directory of
  * this archive for more details.
  */
+
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
-#include <linux/time.h>
 #include <linux/rtc.h>
-#include <linux/spinlock.h>
 #include <linux/io.h>
 #include <linux/bcd.h>
 #include <asm/rtc.h>
 
 #define DRV_NAME        "rtc-ds1302"
-#define DRV_VERSION     "0.1.0"
+#define DRV_VERSION     "0.1.1"
 
 #define RTC_CMD_READ    0x81            /* Read command */
 #define RTC_CMD_WRITE   0x80            /* Write command */
@@ -47,11 +46,6 @@
 #error "Add support for your platform"
 #endif
 
-struct ds1302_rtc {
-        struct rtc_device *rtc_dev;
-        spinlock_t lock;
-};
-
 static void ds1302_sendbits(unsigned int val)
 {
         int i;
@@ -103,10 +97,6 @@ static void ds1302_writebyte(unsigned int addr, unsigned int val)
 
 static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ds1302_rtc *rtc = dev_get_drvdata(dev);
-
-        spin_lock_irq(&rtc->lock);
-
         tm->tm_sec      = bcd2bin(ds1302_readbyte(RTC_ADDR_SEC));
         tm->tm_min      = bcd2bin(ds1302_readbyte(RTC_ADDR_MIN));
         tm->tm_hour     = bcd2bin(ds1302_readbyte(RTC_ADDR_HOUR));
@@ -118,26 +108,17 @@ static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
 
-        spin_unlock_irq(&rtc->lock);
-
         dev_dbg(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 + 1, tm->tm_year, tm->tm_wday);
 
-        if (rtc_valid_tm(tm) < 0)
-                dev_err(dev, "invalid date\n");
-
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ds1302_rtc *rtc = dev_get_drvdata(dev);
-
-        spin_lock_irq(&rtc->lock);
-
         /* Stop RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) | 0x80);
 
@@ -152,8 +133,6 @@ 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);
 
-        spin_unlock_irq(&rtc->lock);
-
         return 0;
 }
 
@@ -170,9 +149,7 @@ static int ds1302_rtc_ioctl(struct device *dev, unsigned int cmd,
                 if (copy_from_user(&tcs_val, (int __user *)arg, sizeof(int)))
                         return -EFAULT;
 
-                spin_lock_irq(&rtc->lock);
                 ds1302_writebyte(RTC_ADDR_TCR, (0xa0 | tcs_val * 0xf));
-                spin_unlock_irq(&rtc->lock);
                 return 0;
         }
 #endif
@@ -187,10 +164,9 @@ static struct rtc_class_ops ds1302_rtc_ops = {
         .ioctl          = ds1302_rtc_ioctl,
 };
 
-static int __devinit ds1302_rtc_probe(struct platform_device *pdev)
+static int __init ds1302_rtc_probe(struct platform_device *pdev)
 {
-        struct ds1302_rtc *rtc;
-        int ret;
+        struct rtc_device *rtc;
 
         /* Reset */
         set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
@@ -200,37 +176,23 @@ static int __devinit ds1302_rtc_probe(struct platform_device *pdev)
         if (ds1302_readbyte(RTC_ADDR_RAM0) != 0x42)
                 return -ENODEV;
 
-        rtc = kzalloc(sizeof(struct ds1302_rtc), GFP_KERNEL);
-        if (unlikely(!rtc))
-                return -ENOMEM;
-
-        spin_lock_init(&rtc->lock);
-        rtc->rtc_dev = rtc_device_register("ds1302", &pdev->dev,
+        rtc = rtc_device_register("ds1302", &pdev->dev,
                                            &ds1302_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto out;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
 
         platform_set_drvdata(pdev, rtc);
 
         return 0;
-out:
-        kfree(rtc);
-        return ret;
 }
 
 static int __devexit ds1302_rtc_remove(struct platform_device *pdev)
 {
-        struct ds1302_rtc *rtc = platform_get_drvdata(pdev);
-
-        if (likely(rtc->rtc_dev))
-                rtc_device_unregister(rtc->rtc_dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
 
+        rtc_device_unregister(rtc);
         platform_set_drvdata(pdev, NULL);
 
-        kfree(rtc);
-
         return 0;
 }
 
@@ -239,13 +201,12 @@ static struct platform_driver ds1302_platform_driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
         },
-        .probe          = ds1302_rtc_probe,
-        .remove         = __devexit_p(ds1302_rtc_remove),
+        .remove         = __exit_p(ds1302_rtc_remove),
 };
 
 static int __init ds1302_rtc_init(void)
 {
-        return platform_driver_register(&ds1302_platform_driver);
+        return platform_driver_probe(&ds1302_platform_driver, ds1302_rtc_probe);
 }
 
 static void __exit ds1302_rtc_exit(void)
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index d7310adb7152..e6ed5404bca0 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -29,7 +29,7 @@
 #include <asm/rtc.h>
 
 #define DRV_NAME        "sh-rtc"
-#define DRV_VERSION     "0.2.2"
+#define DRV_VERSION     "0.2.3"
 
 #define RTC_REG(r)      ((r) * rtc_reg_size)
 
@@ -215,7 +215,7 @@ static irqreturn_t sh_rtc_shared(int irq, void *dev_id)
         return IRQ_RETVAL(ret);
 }
 
-static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
+static int sh_rtc_irq_set_state(struct device *dev, int enable)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
         unsigned int tmp;
@@ -225,17 +225,22 @@ static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
         tmp = readb(rtc->regbase + RCR2);
 
         if (enable) {
+                rtc->periodic_freq |= PF_KOU;
                 tmp &= ~RCR2_PEF;       /* Clear PES bit */
                 tmp |= (rtc->periodic_freq & ~PF_HP);   /* Set PES2-0 */
-        } else
+        } else {
+                rtc->periodic_freq &= ~PF_KOU;
                 tmp &= ~(RCR2_PESMASK | RCR2_PEF);
+        }
 
         writeb(tmp, rtc->regbase + RCR2);
 
         spin_unlock_irq(&rtc->lock);
+
+        return 0;
 }
 
-static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
+static int sh_rtc_irq_set_freq(struct device *dev, int freq)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
         int tmp, ret = 0;
@@ -278,10 +283,8 @@ static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
                 ret = -ENOTSUPP;
         }
 
-        if (ret == 0) {
+        if (ret == 0)
                 rtc->periodic_freq |= tmp;
-                rtc->rtc_dev->irq_freq = freq;
-        }
 
         spin_unlock_irq(&rtc->lock);
         return ret;
@@ -346,10 +349,6 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         unsigned int ret = 0;
 
         switch (cmd) {
-        case RTC_PIE_OFF:
-        case RTC_PIE_ON:
-                sh_rtc_setpie(dev, cmd == RTC_PIE_ON);
-                break;
         case RTC_AIE_OFF:
         case RTC_AIE_ON:
                 sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
@@ -362,13 +361,6 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
                 rtc->periodic_freq |= PF_OXS;
                 sh_rtc_setcie(dev, 1);
                 break;
-        case RTC_IRQP_READ:
-                ret = put_user(rtc->rtc_dev->irq_freq,
-                               (unsigned long __user *)arg);
-                break;
-        case RTC_IRQP_SET:
-                ret = sh_rtc_setfreq(dev, arg);
-                break;
         default:
                 ret = -ENOIOCTLCMD;
         }
@@ -602,28 +594,6 @@ static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
         return 0;
 }
 
-static int sh_rtc_irq_set_state(struct device *dev, int enabled)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct sh_rtc *rtc = platform_get_drvdata(pdev);
-
-        if (enabled) {
-                rtc->periodic_freq |= PF_KOU;
-                return sh_rtc_ioctl(dev, RTC_PIE_ON, 0);
-        } else {
-                rtc->periodic_freq &= ~PF_KOU;
-                return sh_rtc_ioctl(dev, RTC_PIE_OFF, 0);
-        }
-}
-
-static int sh_rtc_irq_set_freq(struct device *dev, int freq)
-{
-        if (!is_power_of_2(freq))
-                return -EINVAL;
-
-        return sh_rtc_ioctl(dev, RTC_IRQP_SET, freq);
-}
-
 static struct rtc_class_ops sh_rtc_ops = {
         .ioctl          = sh_rtc_ioctl,
         .read_time      = sh_rtc_read_time,
@@ -635,7 +605,7 @@ static struct rtc_class_ops sh_rtc_ops = {
         .proc           = sh_rtc_proc,
 };
 
-static int __devinit sh_rtc_probe(struct platform_device *pdev)
+static int __init sh_rtc_probe(struct platform_device *pdev)
 {
         struct sh_rtc *rtc;
         struct resource *res;
@@ -702,13 +672,6 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
 
         clk_enable(rtc->clk);
 
-        rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
-                                           &sh_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto err_unmap;
-        }
-
         rtc->capabilities = RTC_DEF_CAPABILITIES;
         if (pdev->dev.platform_data) {
                 struct sh_rtc_platform_info *pinfo = pdev->dev.platform_data;
@@ -720,10 +683,6 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 rtc->capabilities |= pinfo->capabilities;
         }
 
-        rtc->rtc_dev->max_user_freq = 256;
-
-        platform_set_drvdata(pdev, rtc);
-
         if (rtc->carry_irq <= 0) {
                 /* register shared periodic/carry/alarm irq */
                 ret = request_irq(rtc->periodic_irq, sh_rtc_shared,
@@ -767,13 +726,26 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 }
         }
 
+        platform_set_drvdata(pdev, rtc);
+
         /* everything disabled by default */
-        rtc->periodic_freq = 0;
-        rtc->rtc_dev->irq_freq = 0;
-        sh_rtc_setpie(&pdev->dev, 0);
+        sh_rtc_irq_set_freq(&pdev->dev, 0);
+        sh_rtc_irq_set_state(&pdev->dev, 0);
         sh_rtc_setaie(&pdev->dev, 0);
         sh_rtc_setcie(&pdev->dev, 0);
 
+        rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
+                                           &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;
+        }
+
+        rtc->rtc_dev->max_user_freq = 256;
+
         /* reset rtc to epoch 0 if time is invalid */
         if (rtc_read_time(rtc->rtc_dev, &r) < 0) {
                 rtc_time_to_tm(0, &r);
@@ -795,14 +767,13 @@ err_badres:
         return ret;
 }
 
-static int __devexit sh_rtc_remove(struct platform_device *pdev)
+static int __exit sh_rtc_remove(struct platform_device *pdev)
 {
         struct sh_rtc *rtc = platform_get_drvdata(pdev);
 
-        if (likely(rtc->rtc_dev))
-                rtc_device_unregister(rtc->rtc_dev);
+        rtc_device_unregister(rtc->rtc_dev);
+        sh_rtc_irq_set_state(&pdev->dev, 0);
 
-        sh_rtc_setpie(&pdev->dev, 0);
         sh_rtc_setaie(&pdev->dev, 0);
         sh_rtc_setcie(&pdev->dev, 0);
 
@@ -813,9 +784,8 @@ static int __devexit sh_rtc_remove(struct platform_device *pdev)
                 free_irq(rtc->alarm_irq, rtc);
         }
 
-        release_resource(rtc->res);
-
         iounmap(rtc->regbase);
+        release_resource(rtc->res);
 
         clk_disable(rtc->clk);
         clk_put(rtc->clk);
@@ -867,13 +837,12 @@ static struct platform_driver sh_rtc_platform_driver = {
                 .owner  = THIS_MODULE,
                 .pm     = &sh_rtc_dev_pm_ops,
         },
-        .probe          = sh_rtc_probe,
-        .remove         = __devexit_p(sh_rtc_remove),
+        .remove         = __exit_p(sh_rtc_remove),
 };
 
 static int __init sh_rtc_init(void)
 {
-        return platform_driver_register(&sh_rtc_platform_driver);
+        return platform_driver_probe(&sh_rtc_platform_driver, sh_rtc_probe);
 }
 
 static void __exit sh_rtc_exit(void)
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
new file mode 100644
index 000000000000..79795cdf6ed8
--- /dev/null
+++ b/drivers/rtc/rtc-wm831x.c
@@ -0,0 +1,523 @@
+/*
+ *      Real Time Clock driver for Wolfson Microelectronics WM831x
+ *
+ *      Copyright (C) 2009 Wolfson Microelectronics PLC.
+ *
+ *  Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/time.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/interrupt.h>
+#include <linux/ioctl.h>
+#include <linux/completion.h>
+#include <linux/mfd/wm831x/core.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+
+
+/*
+ * R16416 (0x4020) - RTC Write Counter
+ */
+#define WM831X_RTC_WR_CNT_MASK                  0xFFFF  /* RTC_WR_CNT - [15:0] */
+#define WM831X_RTC_WR_CNT_SHIFT                      0  /* RTC_WR_CNT - [15:0] */
+#define WM831X_RTC_WR_CNT_WIDTH                     16  /* RTC_WR_CNT - [15:0] */
+
+/*
+ * R16417 (0x4021) - RTC Time 1
+ */
+#define WM831X_RTC_TIME_MASK                    0xFFFF  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_SHIFT                        0  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_WIDTH                       16  /* RTC_TIME - [15:0] */
+
+/*
+ * R16418 (0x4022) - RTC Time 2
+ */
+#define WM831X_RTC_TIME_MASK                    0xFFFF  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_SHIFT                        0  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_WIDTH                       16  /* RTC_TIME - [15:0] */
+
+/*
+ * R16419 (0x4023) - RTC Alarm 1
+ */
+#define WM831X_RTC_ALM_MASK                     0xFFFF  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_SHIFT                         0  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_WIDTH                        16  /* RTC_ALM - [15:0] */
+
+/*
+ * R16420 (0x4024) - RTC Alarm 2
+ */
+#define WM831X_RTC_ALM_MASK                     0xFFFF  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_SHIFT                         0  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_WIDTH                        16  /* RTC_ALM - [15:0] */
+
+/*
+ * R16421 (0x4025) - RTC Control
+ */
+#define WM831X_RTC_VALID                        0x8000  /* RTC_VALID */
+#define WM831X_RTC_VALID_MASK                   0x8000  /* RTC_VALID */
+#define WM831X_RTC_VALID_SHIFT                      15  /* RTC_VALID */
+#define WM831X_RTC_VALID_WIDTH                       1  /* RTC_VALID */
+#define WM831X_RTC_SYNC_BUSY                    0x4000  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_MASK               0x4000  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_SHIFT                  14  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_WIDTH                   1  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_ALM_ENA                      0x0400  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_MASK                 0x0400  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_SHIFT                    10  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_WIDTH                     1  /* RTC_ALM_ENA */
+#define WM831X_RTC_PINT_FREQ_MASK               0x0070  /* RTC_PINT_FREQ - [6:4] */
+#define WM831X_RTC_PINT_FREQ_SHIFT                   4  /* RTC_PINT_FREQ - [6:4] */
+#define WM831X_RTC_PINT_FREQ_WIDTH                   3  /* RTC_PINT_FREQ - [6:4] */
+
+/*
+ * R16422 (0x4026) - RTC Trim
+ */
+#define WM831X_RTC_TRIM_MASK                    0x03FF  /* RTC_TRIM - [9:0] */
+#define WM831X_RTC_TRIM_SHIFT                        0  /* RTC_TRIM - [9:0] */
+#define WM831X_RTC_TRIM_WIDTH                       10  /* RTC_TRIM - [9:0] */
+
+#define WM831X_SET_TIME_RETRIES 5
+#define WM831X_GET_TIME_RETRIES 5
+
+struct wm831x_rtc {
+        struct wm831x *wm831x;
+        struct rtc_device *rtc;
+        unsigned int alarm_enabled:1;
+};
+
+/*
+ * Read current time and date in RTC
+ */
+static int wm831x_rtc_readtime(struct device *dev, struct rtc_time *tm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        u16 time1[2], time2[2];
+        int ret;
+        int count = 0;
+
+        /* Has the RTC been programmed? */
+        ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read RTC control: %d\n", ret);
+                return ret;
+        }
+        if (!(ret & WM831X_RTC_VALID)) {
+                dev_dbg(dev, "RTC not yet configured\n");
+                return -EINVAL;
+        }
+
+        /* Read twice to make sure we don't read a corrupt, partially
+         * incremented, value.
+         */
+        do {
+                ret = wm831x_bulk_read(wm831x, WM831X_RTC_TIME_1,
+                                       2, time1);
+                if (ret != 0)
+                        continue;
+
+                ret = wm831x_bulk_read(wm831x, WM831X_RTC_TIME_1,
+                                       2, time2);
+                if (ret != 0)
+                        continue;
+
+                if (memcmp(time1, time2, sizeof(time1)) == 0) {
+                        u32 time = (time1[0] << 16) | time1[1];
+
+                        rtc_time_to_tm(time, tm);
+                        return rtc_valid_tm(tm);
+                }
+
+        } while (++count < WM831X_GET_TIME_RETRIES);
+
+        dev_err(dev, "Timed out reading current time\n");
+
+        return -EIO;
+}
+
+/*
+ * Set current time and date in RTC
+ */
+static int wm831x_rtc_set_mmss(struct device *dev, unsigned long time)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        struct rtc_time new_tm;
+        unsigned long new_time;
+        int ret;
+        int count = 0;
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_TIME_1,
+                               (time >> 16) & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write TIME_1: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_TIME_2, time & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write TIME_2: %d\n", ret);
+                return ret;
+        }
+
+        /* Wait for the update to complete - should happen first time
+         * round but be conservative.
+         */
+        do {
+                msleep(1);
+
+                ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+                if (ret < 0)
+                        ret = WM831X_RTC_SYNC_BUSY;
+        } while (!(ret & WM831X_RTC_SYNC_BUSY) &&
+                 ++count < WM831X_SET_TIME_RETRIES);
+
+        if (ret & WM831X_RTC_SYNC_BUSY) {
+                dev_err(dev, "Timed out writing RTC update\n");
+                return -EIO;
+        }
+
+        /* Check that the update was accepted; security features may
+         * have caused the update to be ignored.
+         */
+        ret = wm831x_rtc_readtime(dev, &new_tm);
+        if (ret < 0)
+                return ret;
+
+        ret = rtc_tm_to_time(&new_tm, &new_time);
+        if (ret < 0) {
+                dev_err(dev, "Failed to convert time: %d\n", ret);
+                return ret;
+        }
+
+        /* Allow a second of change in case of tick */
+        if (new_time - time > 1) {
+                dev_err(dev, "RTC update not permitted by hardware\n");
+                return -EPERM;
+        }
+
+        return 0;
+}
+
+/*
+ * Read alarm time and date in RTC
+ */
+static int wm831x_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        int ret;
+        u16 data[2];
+        u32 time;
+
+        ret = wm831x_bulk_read(wm831x_rtc->wm831x, WM831X_RTC_ALARM_1,
+                               2, data);
+        if (ret != 0) {
+                dev_err(dev, "Failed to read alarm time: %d\n", ret);
+                return ret;
+        }
+
+        time = (data[0] << 16) | data[1];
+
+        rtc_time_to_tm(time, &alrm->time);
+
+        ret = wm831x_reg_read(wm831x_rtc->wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read RTC control: %d\n", ret);
+                return ret;
+        }
+
+        if (ret & WM831X_RTC_ALM_ENA)
+                alrm->enabled = 1;
+        else
+                alrm->enabled = 0;
+
+        return 0;
+}
+
+static int wm831x_rtc_stop_alarm(struct wm831x_rtc *wm831x_rtc)
+{
+        wm831x_rtc->alarm_enabled = 0;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_ALM_ENA, 0);
+}
+
+static int wm831x_rtc_start_alarm(struct wm831x_rtc *wm831x_rtc)
+{
+        wm831x_rtc->alarm_enabled = 1;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_ALM_ENA, WM831X_RTC_ALM_ENA);
+}
+
+static int wm831x_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        int ret;
+        unsigned long time;
+
+        ret = rtc_tm_to_time(&alrm->time, &time);
+        if (ret < 0) {
+                dev_err(dev, "Failed to convert time: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_rtc_stop_alarm(wm831x_rtc);
+        if (ret < 0) {
+                dev_err(dev, "Failed to stop alarm: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_ALARM_1,
+                               (time >> 16) & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write ALARM_1: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_ALARM_2, time & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write ALARM_2: %d\n", ret);
+                return ret;
+        }
+
+        if (alrm->enabled) {
+                ret = wm831x_rtc_start_alarm(wm831x_rtc);
+                if (ret < 0) {
+                        dev_err(dev, "Failed to start alarm: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static int wm831x_rtc_alarm_irq_enable(struct device *dev,
+                                       unsigned int enabled)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+
+        if (enabled)
+                return wm831x_rtc_start_alarm(wm831x_rtc);
+        else
+                return wm831x_rtc_stop_alarm(wm831x_rtc);
+}
+
+static int wm831x_rtc_update_irq_enable(struct device *dev,
+                                        unsigned int enabled)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        int val;
+
+        if (enabled)
+                val = 1 << WM831X_RTC_PINT_FREQ_SHIFT;
+        else
+                val = 0;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_PINT_FREQ_MASK, val);
+}
+
+static irqreturn_t wm831x_alm_irq(int irq, void *data)
+{
+        struct wm831x_rtc *wm831x_rtc = data;
+
+        rtc_update_irq(wm831x_rtc->rtc, 1, RTC_IRQF | RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t wm831x_per_irq(int irq, void *data)
+{
+        struct wm831x_rtc *wm831x_rtc = data;
+
+        rtc_update_irq(wm831x_rtc->rtc, 1, RTC_IRQF | RTC_UF);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops wm831x_rtc_ops = {
+        .read_time = wm831x_rtc_readtime,
+        .set_mmss = wm831x_rtc_set_mmss,
+        .read_alarm = wm831x_rtc_readalarm,
+        .set_alarm = wm831x_rtc_setalarm,
+        .alarm_irq_enable = wm831x_rtc_alarm_irq_enable,
+        .update_irq_enable = wm831x_rtc_update_irq_enable,
+};
+
+#ifdef CONFIG_PM
+/* Turn off the alarm if it should not be a wake source. */
+static int wm831x_rtc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret, enable;
+
+        if (wm831x_rtc->alarm_enabled && device_may_wakeup(&pdev->dev))
+                enable = WM831X_RTC_ALM_ENA;
+        else
+                enable = 0;
+
+        ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                              WM831X_RTC_ALM_ENA, enable);
+        if (ret != 0)
+                dev_err(&pdev->dev, "Failed to update RTC alarm: %d\n", ret);
+
+        return 0;
+}
+
+/* Enable the alarm if it should be enabled (in case it was disabled to
+ * prevent use as a wake source).
+ */
+static int wm831x_rtc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret;
+
+        if (wm831x_rtc->alarm_enabled) {
+                ret = wm831x_rtc_start_alarm(wm831x_rtc);
+                if (ret != 0)
+                        dev_err(&pdev->dev,
+                                "Failed to restart RTC alarm: %d\n", ret);
+        }
+
+        return 0;
+}
+
+/* Unconditionally disable the alarm */
+static int wm831x_rtc_freeze(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret;
+
+        ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                              WM831X_RTC_ALM_ENA, 0);
+        if (ret != 0)
+                dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n", ret);
+
+        return 0;
+}
+#else
+#define wm831x_rtc_suspend NULL
+#define wm831x_rtc_resume NULL
+#define wm831x_rtc_freeze NULL
+#endif
+
+static int wm831x_rtc_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_rtc *wm831x_rtc;
+        int per_irq = platform_get_irq_byname(pdev, "PER");
+        int alm_irq = platform_get_irq_byname(pdev, "ALM");
+        int ret = 0;
+
+        wm831x_rtc = kzalloc(sizeof(*wm831x_rtc), GFP_KERNEL);
+        if (wm831x_rtc == NULL)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, wm831x_rtc);
+        wm831x_rtc->wm831x = wm831x;
+
+        ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to read RTC control: %d\n", ret);
+                goto err;
+        }
+        if (ret & WM831X_RTC_ALM_ENA)
+                wm831x_rtc->alarm_enabled = 1;
+
+        device_init_wakeup(&pdev->dev, 1);
+
+        wm831x_rtc->rtc = rtc_device_register("wm831x", &pdev->dev,
+                                              &wm831x_rtc_ops, THIS_MODULE);
+        if (IS_ERR(wm831x_rtc->rtc)) {
+                ret = PTR_ERR(wm831x_rtc->rtc);
+                goto err;
+        }
+
+        ret = wm831x_request_irq(wm831x, per_irq, wm831x_per_irq,
+                                 IRQF_TRIGGER_RISING, "wm831x_rtc_per",
+                                 wm831x_rtc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request periodic IRQ %d: %d\n",
+                        per_irq, ret);
+        }
+
+        ret = wm831x_request_irq(wm831x, alm_irq, wm831x_alm_irq,
+                                 IRQF_TRIGGER_RISING, "wm831x_rtc_alm",
+                                 wm831x_rtc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
+                        alm_irq, ret);
+        }
+
+        return 0;
+
+err:
+        kfree(wm831x_rtc);
+        return ret;
+}
+
+static int __devexit wm831x_rtc_remove(struct platform_device *pdev)
+{
+        struct wm831x_rtc *wm831x_rtc = platform_get_drvdata(pdev);
+        int per_irq = platform_get_irq_byname(pdev, "PER");
+        int alm_irq = platform_get_irq_byname(pdev, "ALM");
+
+        wm831x_free_irq(wm831x_rtc->wm831x, alm_irq, wm831x_rtc);
+        wm831x_free_irq(wm831x_rtc->wm831x, per_irq, wm831x_rtc);
+        rtc_device_unregister(wm831x_rtc->rtc);
+        kfree(wm831x_rtc);
+
+        return 0;
+}
+
+static struct dev_pm_ops wm831x_rtc_pm_ops = {
+        .suspend = wm831x_rtc_suspend,
+        .resume = wm831x_rtc_resume,
+
+        .freeze = wm831x_rtc_freeze,
+        .thaw = wm831x_rtc_resume,
+        .restore = wm831x_rtc_resume,
+
+        .poweroff = wm831x_rtc_suspend,
+};
+
+static struct platform_driver wm831x_rtc_driver = {
+        .probe = wm831x_rtc_probe,
+        .remove = __devexit_p(wm831x_rtc_remove),
+        .driver = {
+                .name = "wm831x-rtc",
+                .pm = &wm831x_rtc_pm_ops,
+        },
+};
+
+static int __init wm831x_rtc_init(void)
+{
+        return platform_driver_register(&wm831x_rtc_driver);
+}
+module_init(wm831x_rtc_init);
+
+static void __exit wm831x_rtc_exit(void)
+{
+        platform_driver_unregister(&wm831x_rtc_driver);
+}
+module_exit(wm831x_rtc_exit);
+
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("RTC driver for the WM831x series PMICs");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-rtc");