72 files changed, 6442 insertions, 1794 deletions
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 48ca7132cc05..ce2aabf5c550 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -3,10 +3,10 @@
 #
 config RTC_LIB
-        tristate
+        bool
 menuconfig RTC_CLASS
-        tristate "Real Time Clock"
+        bool "Real Time Clock"
        default n
        depends on !S390
        select RTC_LIB
@@ -15,9 +15,6 @@ menuconfig RTC_CLASS
          be allowed to plug one or more RTCs to your system. You will
          probably want to enable one or more of the interfaces below.
-          This driver can also be built as a module. If so, the module
-          will be called rtc-core.
 if RTC_CLASS
 config RTC_HCTOSYS
@@ -128,6 +125,16 @@ comment "I2C RTC drivers"
 if I2C
+config RTC_DRV_88PM860X
+        tristate "Marvell 88PM860x"
+        depends on RTC_CLASS && I2C && MFD_88PM860X
+        help
+          If you say yes here you get support for RTC function in Marvell
+          88PM860x chips.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-88pm860x.
 config RTC_DRV_DS1307
        tristate "Dallas/Maxim DS1307/37/38/39/40, ST M41T00, EPSON RX-8025"
        help
@@ -171,7 +178,8 @@ config RTC_DRV_DS3232
        depends on RTC_CLASS && I2C
        help
          If you say yes here you get support for Dallas Semiconductor
-          DS3232 real-time clock chips.
+          DS3232 real-time clock chips. If an interrupt is associated
+          with the device, the alarm functionality is supported.
          This driver can also be built as a module.  If so, the module
          will be called rtc-ds3232.
@@ -195,6 +203,16 @@ config RTC_DRV_MAX8925
          This driver can also be built as a module. If so, the module
          will be called rtc-max8925.
+config RTC_DRV_MAX8998
+        tristate "Maxim MAX8998"
+        depends on MFD_MAX8998
+        help
+          If you say yes here you will get support for the
+          RTC of Maxim MAX8998 PMIC.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-max8998.
 config RTC_DRV_RS5C372
        tristate "Ricoh R2025S/D, RS5C372A/B, RV5C386, RV5C387A"
        help
@@ -343,12 +361,39 @@ config RTC_DRV_RX8025
          This driver can also be built as a module. If so, the module
          will be called rtc-rx8025.
+config RTC_DRV_EM3027
+        tristate "EM Microelectronic EM3027"
+        help
+          If you say yes here you get support for the EM
+          Microelectronic EM3027 RTC chips.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-em3027.
+config RTC_DRV_RV3029C2
+        tristate "Micro Crystal RTC"
+        help
+          If you say yes here you get support for the Micro Crystal
+          RV3029-C2 RTC chips.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rv3029c2.
 endif # I2C
 comment "SPI RTC drivers"
 if SPI_MASTER
+config RTC_DRV_M41T93
+        tristate "ST M41T93"
+        help
+          If you say yes here you will get support for the
+          ST M41T93 SPI RTC chip.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-m41t93.
 config RTC_DRV_M41T94
        tristate "ST M41T94"
        help
@@ -452,6 +497,18 @@ config RTC_DRV_CMOS
          This driver can also be built as a module. If so, the module
          will be called rtc-cmos.
+config RTC_DRV_VRTC
+        tristate "Virtual RTC for Moorestown platforms"
+        depends on X86_MRST
+        default y if X86_MRST
+        help
+        Say "yes" here to get direct support for the real time clock
+        found on Moorestown platforms. The VRTC is a emulated RTC that
+        derives its clock source from a real RTC in the PMIC. The MC146818
+        style programming interface is mostly conserved, but any
+        updates are done via IPC calls to the system controller FW.
 config RTC_DRV_DS1216
        tristate "Dallas DS1216"
        depends on SNI_RM
@@ -625,6 +682,14 @@ config RTC_DRV_WM8350
          This driver can also be built as a module. If so, the module
          will be called "rtc-wm8350".
+config RTC_DRV_SPEAR
+        tristate "SPEAR ST RTC"
+        depends on PLAT_SPEAR
+        default y
+        help
+         If you say Y here you will get support for the RTC found on
+         spear
 config RTC_DRV_PCF50633
        depends on MFD_PCF50633
        tristate "NXP PCF50633 RTC"
@@ -765,15 +830,15 @@ config RTC_DRV_AT32AP700X
          AT32AP700x family processors.
 config RTC_DRV_AT91RM9200
-        tristate "AT91RM9200 or AT91SAM9RL"
+        tristate "AT91RM9200 or some AT91SAM9 RTC"
-        depends on ARCH_AT91RM9200 || ARCH_AT91SAM9RL
+        depends on ARCH_AT91RM9200 || ARCH_AT91SAM9RL || ARCH_AT91SAM9G45
        help
          Driver for the internal RTC (Realtime Clock) module found on
-          Atmel AT91RM9200's and AT91SAM9RL chips. On SAM9RL chips
+          Atmel AT91RM9200's and some  AT91SAM9 chips. On AT91SAM9 chips
          this is powered by the backup power supply.
 config RTC_DRV_AT91SAM9
-        tristate "AT91SAM9x/AT91CAP9"
+        tristate "AT91SAM9x/AT91CAP9 RTT as RTC"
        depends on ARCH_AT91 && !(ARCH_AT91RM9200 || ARCH_AT91X40)
        help
          RTC driver for the Atmel AT91SAM9x and AT91CAP9 internal RTT
@@ -781,8 +846,8 @@ config RTC_DRV_AT91SAM9
          supply (such as a small coin cell battery), but do not need to
          be used as RTCs.
-          (On AT91SAM9rl chips you probably want to use the dedicated RTC
+          (On AT91SAM9rl and AT91SAM9G45 chips you probably want to use the
-          module and leave the RTT available for other uses.)
+          dedicated RTC module and leave the RTT available for other uses.)
 config RTC_DRV_AT91SAM9_RTT
        int
@@ -854,6 +919,13 @@ config RTC_DRV_PXA
         This RTC driver uses PXA RTC registers available since pxa27x
         series (RDxR, RYxR) instead of legacy RCNR, RTAR.
+config RTC_DRV_VT8500
+        tristate "VIA/WonderMedia 85xx SoC RTC"
+        depends on ARCH_VT8500
+        help
+          If you say Y here you will get access to the real time clock
+          built into your VIA VT8500 SoC or its relatives.
 config RTC_DRV_SUN4V
        bool "SUN4V Hypervisor RTC"
@@ -925,11 +997,12 @@ config RTC_DRV_PCAP
          If you say Y here you will get support for the RTC found on
          the PCAP2 ASIC used on some Motorola phones.
-config RTC_DRV_MC13783
+config RTC_DRV_MC13XXX
-        depends on MFD_MC13783
+        depends on MFD_MC13XXX
-        tristate "Freescale MC13783 RTC"
+        tristate "Freescale MC13xxx RTC"
        help
-          This enables support for the Freescale MC13783 PMIC RTC
+          This enables support for the RTCs found on Freescale's PMICs
+          MC13783 and MC13892.
 config RTC_DRV_MPC5121
        tristate "Freescale MPC5121 built-in RTC"
@@ -952,4 +1025,39 @@ config RTC_DRV_JZ4740
          This driver can also be buillt as a module. If so, the module
          will be called rtc-jz4740.
+config RTC_DRV_LPC32XX
+        depends on ARCH_LPC32XX
+        tristate "NXP LPC32XX RTC"
+        help
+          This enables support for the NXP RTC in the LPC32XX
+          This driver can also be buillt as a module. If so, the module
+          will be called rtc-lpc32xx.
+config RTC_DRV_TEGRA
+        tristate "NVIDIA Tegra Internal RTC driver"
+        depends on RTC_CLASS && ARCH_TEGRA
+        help
+          If you say yes here you get support for the
+          Tegra 200 series internal RTC module.
+          This drive can also be built as a module. If so, the module
+          will be called rtc-tegra.
+config RTC_DRV_TILE
+        tristate "Tilera hypervisor RTC support"
+        depends on TILE
+        help
+          Enable support for the Linux driver side of the Tilera
+          hypervisor's real-time clock interface.
+config RTC_DRV_PUV3
+        tristate "PKUnity v3 RTC support"
+        depends on ARCH_PUV3
+        help
+          This enables support for the RTC in the PKUnity-v3 SoCs.
+          This drive can also be built as a module. If so, the module
+          will be called rtc-puv3.
 endif # RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 0f207b3b5833..0ffefe877bfa 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -2,9 +2,7 @@
 # Makefile for RTC class/drivers.
 #
-ifeq ($(CONFIG_RTC_DEBUG),y)
+ccflags-$(CONFIG_RTC_DEBUG)     := -DDEBUG
-        EXTRA_CFLAGS            += -DDEBUG
-endif
 obj-$(CONFIG_RTC_LIB)           += rtc-lib.o
 obj-$(CONFIG_RTC_HCTOSYS)       += hctosys.o
@@ -17,6 +15,7 @@ rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
 # Keep the list ordered.
+obj-$(CONFIG_RTC_DRV_88PM860X)  += rtc-88pm860x.o
 obj-$(CONFIG_RTC_DRV_AB3100)    += rtc-ab3100.o
 obj-$(CONFIG_RTC_DRV_AB8500)    += rtc-ab8500.o
 obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
@@ -30,6 +29,7 @@ obj-$(CONFIG_RTC_DRV_CMOS)	+= rtc-cmos.o
 obj-$(CONFIG_RTC_DRV_COH901331) += rtc-coh901331.o
 obj-$(CONFIG_RTC_DRV_DAVINCI)   += rtc-davinci.o
 obj-$(CONFIG_RTC_DRV_DM355EVM)  += rtc-dm355evm.o
+obj-$(CONFIG_RTC_DRV_VRTC)      += rtc-mrst.o
 obj-$(CONFIG_RTC_DRV_DS1216)    += rtc-ds1216.o
 obj-$(CONFIG_RTC_DRV_DS1286)    += rtc-ds1286.o
 obj-$(CONFIG_RTC_DRV_DS1302)    += rtc-ds1302.o
@@ -44,6 +44,7 @@ obj-$(CONFIG_RTC_DRV_DS1742)	+= rtc-ds1742.o
 obj-$(CONFIG_RTC_DRV_DS3232)    += rtc-ds3232.o
 obj-$(CONFIG_RTC_DRV_DS3234)    += rtc-ds3234.o
 obj-$(CONFIG_RTC_DRV_EFI)       += rtc-efi.o
+obj-$(CONFIG_RTC_DRV_EM3027)    += rtc-em3027.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
 obj-$(CONFIG_RTC_DRV_FM3130)    += rtc-fm3130.o
 obj-$(CONFIG_RTC_DRV_GENERIC)   += rtc-generic.o
@@ -51,7 +52,9 @@ obj-$(CONFIG_RTC_DRV_IMXDI)	+= rtc-imxdi.o
 obj-$(CONFIG_RTC_DRV_ISL1208)   += rtc-isl1208.o
 obj-$(CONFIG_RTC_DRV_ISL12022)  += rtc-isl12022.o
 obj-$(CONFIG_RTC_DRV_JZ4740)    += rtc-jz4740.o
+obj-$(CONFIG_RTC_DRV_LPC32XX)   += rtc-lpc32xx.o
 obj-$(CONFIG_RTC_DRV_M41T80)    += rtc-m41t80.o
+obj-$(CONFIG_RTC_DRV_M41T93)    += rtc-m41t93.o
 obj-$(CONFIG_RTC_DRV_M41T94)    += rtc-m41t94.o
 obj-$(CONFIG_RTC_DRV_M48T35)    += rtc-m48t35.o
 obj-$(CONFIG_RTC_DRV_M48T59)    += rtc-m48t59.o
@@ -59,8 +62,9 @@ obj-$(CONFIG_RTC_DRV_M48T86)	+= rtc-m48t86.o
 obj-$(CONFIG_RTC_MXC)           += rtc-mxc.o
 obj-$(CONFIG_RTC_DRV_MAX6900)   += rtc-max6900.o
 obj-$(CONFIG_RTC_DRV_MAX8925)   += rtc-max8925.o
+obj-$(CONFIG_RTC_DRV_MAX8998)   += rtc-max8998.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
-obj-$(CONFIG_RTC_DRV_MC13783)   += rtc-mc13783.o
+obj-$(CONFIG_RTC_DRV_MC13XXX)   += rtc-mc13xxx.o
 obj-$(CONFIG_RTC_DRV_MSM6242)   += rtc-msm6242.o
 obj-$(CONFIG_RTC_DRV_MPC5121)   += rtc-mpc5121.o
 obj-$(CONFIG_RTC_DRV_MV)        += rtc-mv.o
@@ -74,27 +78,33 @@ obj-$(CONFIG_RTC_DRV_PCF50633)	+= rtc-pcf50633.o
 obj-$(CONFIG_RTC_DRV_PL030)     += rtc-pl030.o
 obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
 obj-$(CONFIG_RTC_DRV_PS3)       += rtc-ps3.o
+obj-$(CONFIG_RTC_DRV_PUV3)      += rtc-puv3.o
 obj-$(CONFIG_RTC_DRV_PXA)       += rtc-pxa.o
 obj-$(CONFIG_RTC_DRV_R9701)     += rtc-r9701.o
 obj-$(CONFIG_RTC_DRV_RP5C01)    += rtc-rp5c01.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_RS5C348)   += rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_RS5C372)   += rtc-rs5c372.o
+obj-$(CONFIG_RTC_DRV_RV3029C2)  += rtc-rv3029c2.o
 obj-$(CONFIG_RTC_DRV_RX8025)    += rtc-rx8025.o
 obj-$(CONFIG_RTC_DRV_RX8581)    += rtc-rx8581.o
 obj-$(CONFIG_RTC_DRV_S35390A)   += rtc-s35390a.o
 obj-$(CONFIG_RTC_DRV_S3C)       += rtc-s3c.o
 obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
 obj-$(CONFIG_RTC_DRV_SH)        += rtc-sh.o
+obj-$(CONFIG_RTC_DRV_SPEAR)     += rtc-spear.o
 obj-$(CONFIG_RTC_DRV_STARFIRE)  += rtc-starfire.o
 obj-$(CONFIG_RTC_DRV_STK17TA8)  += rtc-stk17ta8.o
 obj-$(CONFIG_RTC_DRV_STMP)      += rtc-stmp3xxx.o
 obj-$(CONFIG_RTC_DRV_SUN4V)     += rtc-sun4v.o
+obj-$(CONFIG_RTC_DRV_TEGRA)     += rtc-tegra.o
 obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
+obj-$(CONFIG_RTC_DRV_TILE)      += rtc-tile.o
 obj-$(CONFIG_RTC_DRV_TWL4030)   += rtc-twl.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_VT8500)    += rtc-vt8500.o
 obj-$(CONFIG_RTC_DRV_WM831X)    += rtc-wm831x.o
 obj-$(CONFIG_RTC_DRV_WM8350)    += rtc-wm8350.o
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 565562ba6ac9..4194e59e14cd 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -16,6 +16,7 @@
 #include <linux/kdev_t.h>
 #include <linux/idr.h>
 #include <linux/slab.h>
+#include <linux/workqueue.h>
 #include "rtc-core.h"
@@ -40,26 +41,21 @@ static void rtc_device_release(struct device *dev)
 * system's wall clock; restore it on resume().
 */
-static struct timespec  delta;
 static time_t           oldtime;
+static struct timespec  oldts;
 static int rtc_suspend(struct device *dev, pm_message_t mesg)
 {
        struct rtc_device       *rtc = to_rtc_device(dev);
        struct rtc_time         tm;
-        struct timespec         ts = current_kernel_time();
        if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
                return 0;
        rtc_read_time(rtc, &tm);
+        ktime_get_ts(&oldts);
        rtc_tm_to_time(&tm, &oldtime);
-        /* RTC precision is 1 second; adjust delta for avg 1/2 sec err */
-        set_normalized_timespec(&delta,
-                                ts.tv_sec - oldtime,
-                                ts.tv_nsec - (NSEC_PER_SEC >> 1));
        return 0;
 }
@@ -69,10 +65,12 @@ static int rtc_resume(struct device *dev)
        struct rtc_time         tm;
        time_t                  newtime;
        struct timespec         time;
+        struct timespec         newts;
        if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
                return 0;
+        ktime_get_ts(&newts);
        rtc_read_time(rtc, &tm);
        if (rtc_valid_tm(&tm) != 0) {
                pr_debug("%s:  bogus resume time\n", dev_name(&rtc->dev));
@@ -84,15 +82,13 @@ static int rtc_resume(struct device *dev)
                        pr_debug("%s:  time travel!\n", dev_name(&rtc->dev));
                return 0;
        }
+        /* calculate the RTC time delta */
+        set_normalized_timespec(&time, newtime - oldtime, 0);
-        /* restore wall clock using delta against this RTC;
+        /* subtract kernel time between rtc_suspend to rtc_resume */
-         * adjust again for avg 1/2 second RTC sampling error
+        time = timespec_sub(time, timespec_sub(newts, oldts));
-         */
-        set_normalized_timespec(&time,
-                                newtime + delta.tv_sec,
-                                (NSEC_PER_SEC >> 1) + delta.tv_nsec);
-        do_settimeofday(&time);
+        timekeeping_inject_sleeptime(&time);
        return 0;
 }
@@ -116,6 +112,7 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
                                        struct module *owner)
 {
        struct rtc_device *rtc;
+        struct rtc_wkalrm alrm;
        int id, err;
        if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
@@ -142,6 +139,7 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
        rtc->id = id;
        rtc->ops = ops;
        rtc->owner = owner;
+        rtc->irq_freq = 1;
        rtc->max_user_freq = 64;
        rtc->dev.parent = dev;
        rtc->dev.class = rtc_class;
@@ -152,14 +150,34 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
        spin_lock_init(&rtc->irq_task_lock);
        init_waitqueue_head(&rtc->irq_queue);
+        /* Init timerqueue */
+        timerqueue_init_head(&rtc->timerqueue);
+        INIT_WORK(&rtc->irqwork, rtc_timer_do_work);
+        /* Init aie timer */
+        rtc_timer_init(&rtc->aie_timer, rtc_aie_update_irq, (void *)rtc);
+        /* Init uie timer */
+        rtc_timer_init(&rtc->uie_rtctimer, rtc_uie_update_irq, (void *)rtc);
+        /* Init pie timer */
+        hrtimer_init(&rtc->pie_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        rtc->pie_timer.function = rtc_pie_update_irq;
+        rtc->pie_enabled = 0;
+        /* Check to see if there is an ALARM already set in hw */
+        err = __rtc_read_alarm(rtc, &alrm);
+        if (!err && !rtc_valid_tm(&alrm.time))
+                rtc_initialize_alarm(rtc, &alrm);
        strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
        dev_set_name(&rtc->dev, "rtc%d", id);
        rtc_dev_prepare(rtc);
        err = device_register(&rtc->dev);
-        if (err)
+        if (err) {
+                put_device(&rtc->dev);
                goto exit_kfree;
+        }
        rtc_dev_add_device(rtc);
        rtc_sysfs_add_device(rtc);
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index a0c816238aa9..df68618f6dbb 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -14,15 +14,14 @@
 #include <linux/rtc.h>
 #include <linux/sched.h>
 #include <linux/log2.h>
+#include <linux/workqueue.h>
-int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
+static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);
+static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer);
+static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
 {
        int err;
-        err = mutex_lock_interruptible(&rtc->ops_lock);
-        if (err)
-                return err;
        if (!rtc->ops)
                err = -ENODEV;
        else if (!rtc->ops->read_time)
@@ -31,7 +30,18 @@ int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
                memset(tm, 0, sizeof(struct rtc_time));
                err = rtc->ops->read_time(rtc->dev.parent, tm);
        }
+        return err;
+}
+int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
+{
+        int err;
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return err;
+        err = __rtc_read_time(rtc, tm);
        mutex_unlock(&rtc->ops_lock);
        return err;
 }
@@ -127,7 +137,7 @@ static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *al
        return err;
 }
-int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
        int err;
        struct rtc_time before, now;
@@ -190,8 +200,6 @@ int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
                err = rtc_read_alarm_internal(rtc, alarm);
                if (err)
                        return err;
-                if (!alarm->enabled)
-                        return 0;
                /* full-function RTCs won't have such missing fields */
                if (rtc_valid_tm(&alarm->time) == 0)
@@ -287,19 +295,51 @@ int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 done:
        return 0;
 }
-EXPORT_SYMBOL_GPL(rtc_read_alarm);
-int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
        int err;
-        err = rtc_valid_tm(&alarm->time);
+        err = mutex_lock_interruptible(&rtc->ops_lock);
-        if (err != 0)
+        if (err)
                return err;
+        if (rtc->ops == NULL)
+                err = -ENODEV;
+        else if (!rtc->ops->read_alarm)
+                err = -EINVAL;
+        else {
+                memset(alarm, 0, sizeof(struct rtc_wkalrm));
+                alarm->enabled = rtc->aie_timer.enabled;
+                alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
+        }
+        mutex_unlock(&rtc->ops_lock);
-        err = mutex_lock_interruptible(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_read_alarm);
+static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+{
+        struct rtc_time tm;
+        long now, scheduled;
+        int err;
+        err = rtc_valid_tm(&alarm->time);
        if (err)
                return err;
+        rtc_tm_to_time(&alarm->time, &scheduled);
+        /* Make sure we're not setting alarms in the past */
+        err = __rtc_read_time(rtc, &tm);
+        rtc_tm_to_time(&tm, &now);
+        if (scheduled <= now)
+                return -ETIME;
+        /*
+         * XXX - We just checked to make sure the alarm time is not
+         * in the past, but there is still a race window where if
+         * the is alarm set for the next second and the second ticks
+         * over right here, before we set the alarm.
+         */
        if (!rtc->ops)
                err = -ENODEV;
@@ -308,18 +348,75 @@ int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
        else
                err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
+        return err;
+}
+int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+{
+        int err;
+        err = rtc_valid_tm(&alarm->time);
+        if (err != 0)
+                return err;
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return err;
+        if (rtc->aie_timer.enabled) {
+                rtc_timer_remove(rtc, &rtc->aie_timer);
+        }
+        rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
+        rtc->aie_timer.period = ktime_set(0, 0);
+        if (alarm->enabled) {
+                err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
+        }
        mutex_unlock(&rtc->ops_lock);
        return err;
 }
 EXPORT_SYMBOL_GPL(rtc_set_alarm);
+/* Called once per device from rtc_device_register */
+int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+{
+        int err;
+        err = rtc_valid_tm(&alarm->time);
+        if (err != 0)
+                return err;
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return err;
+        rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
+        rtc->aie_timer.period = ktime_set(0, 0);
+        if (alarm->enabled) {
+                rtc->aie_timer.enabled = 1;
+                timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
+        }
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_initialize_alarm);
 int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
 {
        int err = mutex_lock_interruptible(&rtc->ops_lock);
        if (err)
                return err;
-        if (!rtc->ops)
+        if (rtc->aie_timer.enabled != enabled) {
+                if (enabled)
+                        err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
+                else
+                        rtc_timer_remove(rtc, &rtc->aie_timer);
+        }
+        if (err)
+                /* nothing */;
+        else if (!rtc->ops)
                err = -ENODEV;
        else if (!rtc->ops->alarm_irq_enable)
                err = -EINVAL;
@@ -340,19 +437,28 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
        if (enabled == 0 && rtc->uie_irq_active) {
                mutex_unlock(&rtc->ops_lock);
-                return rtc_dev_update_irq_enable_emul(rtc, enabled);
+                return rtc_dev_update_irq_enable_emul(rtc, 0);
        }
 #endif
+        /* make sure we're changing state */
+        if (rtc->uie_rtctimer.enabled == enabled)
+                goto out;
+        if (enabled) {
+                struct rtc_time tm;
+                ktime_t now, onesec;
+                __rtc_read_time(rtc, &tm);
+                onesec = ktime_set(1, 0);
+                now = rtc_tm_to_ktime(tm);
+                rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
+                rtc->uie_rtctimer.period = ktime_set(1, 0);
+                err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
+        } else
+                rtc_timer_remove(rtc, &rtc->uie_rtctimer);
-        if (!rtc->ops)
+out:
-                err = -ENODEV;
-        else if (!rtc->ops->update_irq_enable)
-                err = -EINVAL;
-        else
-                err = rtc->ops->update_irq_enable(rtc->dev.parent, enabled);
        mutex_unlock(&rtc->ops_lock);
 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
        /*
         * Enable emulation if the driver did not provide
@@ -364,25 +470,30 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
                err = rtc_dev_update_irq_enable_emul(rtc, enabled);
 #endif
        return err;
 }
 EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
 /**
- * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
+ * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
- * @rtc: the rtc device
+ * @rtc: pointer to the rtc device
- * @num: how many irqs are being reported (usually one)
+ *
- * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
+ * This function is called when an AIE, UIE or PIE mode interrupt
- * Context: any
+ * has occurred (or been emulated).
+ *
+ * Triggers the registered irq_task function callback.
 */
-void rtc_update_irq(struct rtc_device *rtc,
+void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
-                unsigned long num, unsigned long events)
 {
        unsigned long flags;
+        /* mark one irq of the appropriate mode */
        spin_lock_irqsave(&rtc->irq_lock, flags);
-        rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
+        rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode);
        spin_unlock_irqrestore(&rtc->irq_lock, flags);
+        /* call the task func */
        spin_lock_irqsave(&rtc->irq_task_lock, flags);
        if (rtc->irq_task)
                rtc->irq_task->func(rtc->irq_task->private_data);
@@ -391,6 +502,69 @@ void rtc_update_irq(struct rtc_device *rtc,
        wake_up_interruptible(&rtc->irq_queue);
        kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
 }
+/**
+ * rtc_aie_update_irq - AIE mode rtctimer hook
+ * @private: pointer to the rtc_device
+ *
+ * This functions is called when the aie_timer expires.
+ */
+void rtc_aie_update_irq(void *private)
+{
+        struct rtc_device *rtc = (struct rtc_device *)private;
+        rtc_handle_legacy_irq(rtc, 1, RTC_AF);
+}
+/**
+ * rtc_uie_update_irq - UIE mode rtctimer hook
+ * @private: pointer to the rtc_device
+ *
+ * This functions is called when the uie_timer expires.
+ */
+void rtc_uie_update_irq(void *private)
+{
+        struct rtc_device *rtc = (struct rtc_device *)private;
+        rtc_handle_legacy_irq(rtc, 1,  RTC_UF);
+}
+/**
+ * rtc_pie_update_irq - PIE mode hrtimer hook
+ * @timer: pointer to the pie mode hrtimer
+ *
+ * This function is used to emulate PIE mode interrupts
+ * using an hrtimer. This function is called when the periodic
+ * hrtimer expires.
+ */
+enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
+{
+        struct rtc_device *rtc;
+        ktime_t period;
+        int count;
+        rtc = container_of(timer, struct rtc_device, pie_timer);
+        period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
+        count = hrtimer_forward_now(timer, period);
+        rtc_handle_legacy_irq(rtc, count, RTC_PF);
+        return HRTIMER_RESTART;
+}
+/**
+ * rtc_update_irq - Triggered when a RTC interrupt occurs.
+ * @rtc: the rtc device
+ * @num: how many irqs are being reported (usually one)
+ * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
+ * Context: any
+ */
+void rtc_update_irq(struct rtc_device *rtc,
+                unsigned long num, unsigned long events)
+{
+        schedule_work(&rtc->irqwork);
+}
 EXPORT_SYMBOL_GPL(rtc_update_irq);
 static int __rtc_match(struct device *dev, void *data)
@@ -477,18 +651,20 @@ int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled
        int err = 0;
        unsigned long flags;
-        if (rtc->ops->irq_set_state == NULL)
-                return -ENXIO;
        spin_lock_irqsave(&rtc->irq_task_lock, flags);
        if (rtc->irq_task != NULL && task == NULL)
                err = -EBUSY;
        if (rtc->irq_task != task)
                err = -EACCES;
-        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
-        if (err == 0)
+        if (enabled) {
-                err = rtc->ops->irq_set_state(rtc->dev.parent, enabled);
+                ktime_t period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
+                hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
+        } else {
+                hrtimer_cancel(&rtc->pie_timer);
+        }
+        rtc->pie_enabled = enabled;
+        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
        return err;
 }
@@ -509,21 +685,206 @@ int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
        int err = 0;
        unsigned long flags;
-        if (rtc->ops->irq_set_freq == NULL)
+        if (freq <= 0)
-                return -ENXIO;
+                return -EINVAL;
        spin_lock_irqsave(&rtc->irq_task_lock, flags);
        if (rtc->irq_task != NULL && task == NULL)
                err = -EBUSY;
        if (rtc->irq_task != task)
                err = -EACCES;
-        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
        if (err == 0) {
-                err = rtc->ops->irq_set_freq(rtc->dev.parent, freq);
+                rtc->irq_freq = freq;
-                if (err == 0)
+                if (rtc->pie_enabled) {
-                        rtc->irq_freq = freq;
+                        ktime_t period;
+                        hrtimer_cancel(&rtc->pie_timer);
+                        period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq);
+                        hrtimer_start(&rtc->pie_timer, period,
+                                        HRTIMER_MODE_REL);
+                }
        }
+        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
        return err;
 }
 EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
+/**
+ * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
+ * @rtc rtc device
+ * @timer timer being added.
+ *
+ * Enqueues a timer onto the rtc devices timerqueue and sets
+ * the next alarm event appropriately.
+ *
+ * Sets the enabled bit on the added timer.
+ *
+ * Must hold ops_lock for proper serialization of timerqueue
+ */
+static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
+{
+        timer->enabled = 1;
+        timerqueue_add(&rtc->timerqueue, &timer->node);
+        if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) {
+                struct rtc_wkalrm alarm;
+                int err;
+                alarm.time = rtc_ktime_to_tm(timer->node.expires);
+                alarm.enabled = 1;
+                err = __rtc_set_alarm(rtc, &alarm);
+                if (err == -ETIME)
+                        schedule_work(&rtc->irqwork);
+                else if (err) {
+                        timerqueue_del(&rtc->timerqueue, &timer->node);
+                        timer->enabled = 0;
+                        return err;
+                }
+        }
+        return 0;
+}
+/**
+ * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
+ * @rtc rtc device
+ * @timer timer being removed.
+ *
+ * Removes a timer onto the rtc devices timerqueue and sets
+ * the next alarm event appropriately.
+ *
+ * Clears the enabled bit on the removed timer.
+ *
+ * Must hold ops_lock for proper serialization of timerqueue
+ */
+static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
+{
+        struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
+        timerqueue_del(&rtc->timerqueue, &timer->node);
+        timer->enabled = 0;
+        if (next == &timer->node) {
+                struct rtc_wkalrm alarm;
+                int err;
+                next = timerqueue_getnext(&rtc->timerqueue);
+                if (!next)
+                        return;
+                alarm.time = rtc_ktime_to_tm(next->expires);
+                alarm.enabled = 1;
+                err = __rtc_set_alarm(rtc, &alarm);
+                if (err == -ETIME)
+                        schedule_work(&rtc->irqwork);
+        }
+}
+/**
+ * rtc_timer_do_work - Expires rtc timers
+ * @rtc rtc device
+ * @timer timer being removed.
+ *
+ * Expires rtc timers. Reprograms next alarm event if needed.
+ * Called via worktask.
+ *
+ * Serializes access to timerqueue via ops_lock mutex
+ */
+void rtc_timer_do_work(struct work_struct *work)
+{
+        struct rtc_timer *timer;
+        struct timerqueue_node *next;
+        ktime_t now;
+        struct rtc_time tm;
+        struct rtc_device *rtc =
+                container_of(work, struct rtc_device, irqwork);
+        mutex_lock(&rtc->ops_lock);
+again:
+        __rtc_read_time(rtc, &tm);
+        now = rtc_tm_to_ktime(tm);
+        while ((next = timerqueue_getnext(&rtc->timerqueue))) {
+                if (next->expires.tv64 > now.tv64)
+                        break;
+                /* expire timer */
+                timer = container_of(next, struct rtc_timer, node);
+                timerqueue_del(&rtc->timerqueue, &timer->node);
+                timer->enabled = 0;
+                if (timer->task.func)
+                        timer->task.func(timer->task.private_data);
+                /* Re-add/fwd periodic timers */
+                if (ktime_to_ns(timer->period)) {
+                        timer->node.expires = ktime_add(timer->node.expires,
+                                                        timer->period);
+                        timer->enabled = 1;
+                        timerqueue_add(&rtc->timerqueue, &timer->node);
+                }
+        }
+        /* Set next alarm */
+        if (next) {
+                struct rtc_wkalrm alarm;
+                int err;
+                alarm.time = rtc_ktime_to_tm(next->expires);
+                alarm.enabled = 1;
+                err = __rtc_set_alarm(rtc, &alarm);
+                if (err == -ETIME)
+                        goto again;
+        }
+        mutex_unlock(&rtc->ops_lock);
+}
+/* rtc_timer_init - Initializes an rtc_timer
+ * @timer: timer to be intiialized
+ * @f: function pointer to be called when timer fires
+ * @data: private data passed to function pointer
+ *
+ * Kernel interface to initializing an rtc_timer.
+ */
+void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data)
+{
+        timerqueue_init(&timer->node);
+        timer->enabled = 0;
+        timer->task.func = f;
+        timer->task.private_data = data;
+}
+/* rtc_timer_start - Sets an rtc_timer to fire in the future
+ * @ rtc: rtc device to be used
+ * @ timer: timer being set
+ * @ expires: time at which to expire the timer
+ * @ period: period that the timer will recur
+ *
+ * Kernel interface to set an rtc_timer
+ */
+int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
+                        ktime_t expires, ktime_t period)
+{
+        int ret = 0;
+        mutex_lock(&rtc->ops_lock);
+        if (timer->enabled)
+                rtc_timer_remove(rtc, timer);
+        timer->node.expires = expires;
+        timer->period = period;
+        ret = rtc_timer_enqueue(rtc, timer);
+        mutex_unlock(&rtc->ops_lock);
+        return ret;
+}
+/* rtc_timer_cancel - Stops an rtc_timer
+ * @ rtc: rtc device to be used
+ * @ timer: timer being set
+ *
+ * Kernel interface to cancel an rtc_timer
+ */
+int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer)
+{
+        int ret = 0;
+        mutex_lock(&rtc->ops_lock);
+        if (timer->enabled)
+                rtc_timer_remove(rtc, timer);
+        mutex_unlock(&rtc->ops_lock);
+        return ret;
+}
diff --git a/drivers/rtc/rtc-88pm860x.c b/drivers/rtc/rtc-88pm860x.c
new file mode 100644
index 000000000000..64b847b7f970
--- /dev/null
+++ b/drivers/rtc/rtc-88pm860x.c
@@ -0,0 +1,427 @@
+/*
+ * Real Time Clock driver for Marvell 88PM860x PMIC
+ *
+ * Copyright (c) 2010 Marvell International Ltd.
+ * Author:      Haojian Zhuang <haojian.zhuang@marvell.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/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/rtc.h>
+#include <linux/delay.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/88pm860x.h>
+#define VRTC_CALIBRATION
+struct pm860x_rtc_info {
+        struct pm860x_chip      *chip;
+        struct i2c_client       *i2c;
+        struct rtc_device       *rtc_dev;
+        struct device           *dev;
+        struct delayed_work     calib_work;
+        int                     irq;
+        int                     vrtc;
+        int                     (*sync)(unsigned int ticks);
+};
+#define REG_VRTC_MEAS1          0x7D
+#define REG0_ADDR               0xB0
+#define REG1_ADDR               0xB2
+#define REG2_ADDR               0xB4
+#define REG3_ADDR               0xB6
+#define REG0_DATA               0xB1
+#define REG1_DATA               0xB3
+#define REG2_DATA               0xB5
+#define REG3_DATA               0xB7
+/* bit definitions of Measurement Enable Register 2 (0x51) */
+#define MEAS2_VRTC              (1 << 0)
+/* bit definitions of RTC Register 1 (0xA0) */
+#define ALARM_EN                (1 << 3)
+#define ALARM_WAKEUP            (1 << 4)
+#define ALARM                   (1 << 5)
+#define RTC1_USE_XO             (1 << 7)
+#define VRTC_CALIB_INTERVAL     (HZ * 60 * 10)          /* 10 minutes */
+static irqreturn_t rtc_update_handler(int irq, void *data)
+{
+        struct pm860x_rtc_info *info = (struct pm860x_rtc_info *)data;
+        int mask;
+        mask = ALARM | ALARM_WAKEUP;
+        pm860x_set_bits(info->i2c, PM8607_RTC1, mask | ALARM_EN, mask);
+        rtc_update_irq(info->rtc_dev, 1, RTC_AF);
+        return IRQ_HANDLED;
+}
+static int pm860x_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct pm860x_rtc_info *info = dev_get_drvdata(dev);
+        if (enabled)
+                pm860x_set_bits(info->i2c, PM8607_RTC1, ALARM, ALARM);
+        else
+                pm860x_set_bits(info->i2c, PM8607_RTC1, ALARM, 0);
+        return 0;
+}
+/*
+ * Calculate the next alarm time given the requested alarm time mask
+ * and the current time.
+ */
+static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now,
+                                struct rtc_time *alrm)
+{
+        unsigned long next_time;
+        unsigned long now_time;
+        next->tm_year = now->tm_year;
+        next->tm_mon = now->tm_mon;
+        next->tm_mday = now->tm_mday;
+        next->tm_hour = alrm->tm_hour;
+        next->tm_min = alrm->tm_min;
+        next->tm_sec = alrm->tm_sec;
+        rtc_tm_to_time(now, &now_time);
+        rtc_tm_to_time(next, &next_time);
+        if (next_time < now_time) {
+                /* Advance one day */
+                next_time += 60 * 60 * 24;
+                rtc_time_to_tm(next_time, next);
+        }
+}
+static int pm860x_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pm860x_rtc_info *info = dev_get_drvdata(dev);
+        unsigned char buf[8];
+        unsigned long ticks, base, data;
+        pm860x_page_bulk_read(info->i2c, REG0_ADDR, 8, buf);
+        dev_dbg(info->dev, "%x-%x-%x-%x-%x-%x-%x-%x\n", buf[0], buf[1],
+                buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
+        base = (buf[1] << 24) | (buf[3] << 16) | (buf[5] << 8) | buf[7];
+        /* load 32-bit read-only counter */
+        pm860x_bulk_read(info->i2c, PM8607_RTC_COUNTER1, 4, buf);
+        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
+        ticks = base + data;
+        dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
+                base, data, ticks);
+        rtc_time_to_tm(ticks, tm);
+        return 0;
+}
+static int pm860x_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pm860x_rtc_info *info = dev_get_drvdata(dev);
+        unsigned char buf[4];
+        unsigned long ticks, base, data;
+        if ((tm->tm_year < 70) || (tm->tm_year > 138)) {
+                dev_dbg(info->dev, "Set time %d out of range. "
+                        "Please set time between 1970 to 2038.\n",
+                        1900 + tm->tm_year);
+                return -EINVAL;
+        }
+        rtc_tm_to_time(tm, &ticks);
+        /* load 32-bit read-only counter */
+        pm860x_bulk_read(info->i2c, PM8607_RTC_COUNTER1, 4, buf);
+        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
+        base = ticks - data;
+        dev_dbg(info->dev, "set base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
+                base, data, ticks);
+        pm860x_page_reg_write(info->i2c, REG0_DATA, (base >> 24) & 0xFF);
+        pm860x_page_reg_write(info->i2c, REG1_DATA, (base >> 16) & 0xFF);
+        pm860x_page_reg_write(info->i2c, REG2_DATA, (base >> 8) & 0xFF);
+        pm860x_page_reg_write(info->i2c, REG3_DATA, base & 0xFF);
+        if (info->sync)
+                info->sync(ticks);
+        return 0;
+}
+static int pm860x_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct pm860x_rtc_info *info = dev_get_drvdata(dev);
+        unsigned char buf[8];
+        unsigned long ticks, base, data;
+        int ret;
+        pm860x_page_bulk_read(info->i2c, REG0_ADDR, 8, buf);
+        dev_dbg(info->dev, "%x-%x-%x-%x-%x-%x-%x-%x\n", buf[0], buf[1],
+                buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
+        base = (buf[1] << 24) | (buf[3] << 16) | (buf[5] << 8) | buf[7];
+        pm860x_bulk_read(info->i2c, PM8607_RTC_EXPIRE1, 4, buf);
+        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
+        ticks = base + data;
+        dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
+                base, data, ticks);
+        rtc_time_to_tm(ticks, &alrm->time);
+        ret = pm860x_reg_read(info->i2c, PM8607_RTC1);
+        alrm->enabled = (ret & ALARM_EN) ? 1 : 0;
+        alrm->pending = (ret & (ALARM | ALARM_WAKEUP)) ? 1 : 0;
+        return 0;
+}
+static int pm860x_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct pm860x_rtc_info *info = dev_get_drvdata(dev);
+        struct rtc_time now_tm, alarm_tm;
+        unsigned long ticks, base, data;
+        unsigned char buf[8];
+        int mask;
+        pm860x_set_bits(info->i2c, PM8607_RTC1, ALARM_EN, 0);
+        pm860x_page_bulk_read(info->i2c, REG0_ADDR, 8, buf);
+        dev_dbg(info->dev, "%x-%x-%x-%x-%x-%x-%x-%x\n", buf[0], buf[1],
+                buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
+        base = (buf[1] << 24) | (buf[3] << 16) | (buf[5] << 8) | buf[7];
+        /* load 32-bit read-only counter */
+        pm860x_bulk_read(info->i2c, PM8607_RTC_COUNTER1, 4, buf);
+        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
+        ticks = base + data;
+        dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
+                base, data, ticks);
+        rtc_time_to_tm(ticks, &now_tm);
+        rtc_next_alarm_time(&alarm_tm, &now_tm, &alrm->time);
+        /* get new ticks for alarm in 24 hours */
+        rtc_tm_to_time(&alarm_tm, &ticks);
+        data = ticks - base;
+        buf[0] = data & 0xff;
+        buf[1] = (data >> 8) & 0xff;
+        buf[2] = (data >> 16) & 0xff;
+        buf[3] = (data >> 24) & 0xff;
+        pm860x_bulk_write(info->i2c, PM8607_RTC_EXPIRE1, 4, buf);
+        if (alrm->enabled) {
+                mask = ALARM | ALARM_WAKEUP | ALARM_EN;
+                pm860x_set_bits(info->i2c, PM8607_RTC1, mask, mask);
+        } else {
+                mask = ALARM | ALARM_WAKEUP | ALARM_EN;
+                pm860x_set_bits(info->i2c, PM8607_RTC1, mask,
+                                ALARM | ALARM_WAKEUP);
+        }
+        return 0;
+}
+static const struct rtc_class_ops pm860x_rtc_ops = {
+        .read_time      = pm860x_rtc_read_time,
+        .set_time       = pm860x_rtc_set_time,
+        .read_alarm     = pm860x_rtc_read_alarm,
+        .set_alarm      = pm860x_rtc_set_alarm,
+        .alarm_irq_enable = pm860x_rtc_alarm_irq_enable,
+};
+#ifdef VRTC_CALIBRATION
+static void calibrate_vrtc_work(struct work_struct *work)
+{
+        struct pm860x_rtc_info *info = container_of(work,
+                struct pm860x_rtc_info, calib_work.work);
+        unsigned char buf[2];
+        unsigned int sum, data, mean, vrtc_set;
+        int i;
+        for (i = 0, sum = 0; i < 16; i++) {
+                msleep(100);
+                pm860x_bulk_read(info->i2c, REG_VRTC_MEAS1, 2, buf);
+                data = (buf[0] << 4) | buf[1];
+                data = (data * 5400) >> 12;     /* convert to mv */
+                sum += data;
+        }
+        mean = sum >> 4;
+        vrtc_set = 2700 + (info->vrtc & 0x3) * 200;
+        dev_dbg(info->dev, "mean:%d, vrtc_set:%d\n", mean, vrtc_set);
+        sum = pm860x_reg_read(info->i2c, PM8607_RTC_MISC1);
+        data = sum & 0x3;
+        if ((mean + 200) < vrtc_set) {
+                /* try higher voltage */
+                if (++data == 4)
+                        goto out;
+                data = (sum & 0xf8) | (data & 0x3);
+                pm860x_reg_write(info->i2c, PM8607_RTC_MISC1, data);
+        } else if ((mean - 200) > vrtc_set) {
+                /* try lower voltage */
+                if (data-- == 0)
+                        goto out;
+                data = (sum & 0xf8) | (data & 0x3);
+                pm860x_reg_write(info->i2c, PM8607_RTC_MISC1, data);
+        } else
+                goto out;
+        dev_dbg(info->dev, "set 0x%x to RTC_MISC1\n", data);
+        /* trigger next calibration since VRTC is updated */
+        schedule_delayed_work(&info->calib_work, VRTC_CALIB_INTERVAL);
+        return;
+out:
+        /* disable measurement */
+        pm860x_set_bits(info->i2c, PM8607_MEAS_EN2, MEAS2_VRTC, 0);
+        dev_dbg(info->dev, "finish VRTC calibration\n");
+        return;
+}
+#endif
+static int __devinit pm860x_rtc_probe(struct platform_device *pdev)
+{
+        struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
+        struct pm860x_rtc_pdata *pdata = NULL;
+        struct pm860x_rtc_info *info;
+        struct rtc_time tm;
+        unsigned long ticks = 0;
+        int ret;
+        pdata = pdev->dev.platform_data;
+        if (pdata == NULL)
+                dev_warn(&pdev->dev, "No platform data!\n");
+        info = kzalloc(sizeof(struct pm860x_rtc_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+        info->irq = platform_get_irq(pdev, 0);
+        if (info->irq < 0) {
+                dev_err(&pdev->dev, "No IRQ resource!\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        info->chip = chip;
+        info->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
+        info->dev = &pdev->dev;
+        dev_set_drvdata(&pdev->dev, info);
+        ret = request_threaded_irq(info->irq, NULL, rtc_update_handler,
+                                   IRQF_ONESHOT, "rtc", info);
+        if (ret < 0) {
+                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+                        info->irq, ret);
+                goto out;
+        }
+        /* set addresses of 32-bit base value for RTC time */
+        pm860x_page_reg_write(info->i2c, REG0_ADDR, REG0_DATA);
+        pm860x_page_reg_write(info->i2c, REG1_ADDR, REG1_DATA);
+        pm860x_page_reg_write(info->i2c, REG2_ADDR, REG2_DATA);
+        pm860x_page_reg_write(info->i2c, REG3_ADDR, REG3_DATA);
+        ret = pm860x_rtc_read_time(&pdev->dev, &tm);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to read initial time.\n");
+                goto out_rtc;
+        }
+        if ((tm.tm_year < 70) || (tm.tm_year > 138)) {
+                tm.tm_year = 70;
+                tm.tm_mon = 0;
+                tm.tm_mday = 1;
+                tm.tm_hour = 0;
+                tm.tm_min = 0;
+                tm.tm_sec = 0;
+                ret = pm860x_rtc_set_time(&pdev->dev, &tm);
+                if (ret < 0) {
+                        dev_err(&pdev->dev, "Failed to set initial time.\n");
+                        goto out_rtc;
+                }
+        }
+        rtc_tm_to_time(&tm, &ticks);
+        if (pdata && pdata->sync) {
+                pdata->sync(ticks);
+                info->sync = pdata->sync;
+        }
+        info->rtc_dev = rtc_device_register("88pm860x-rtc", &pdev->dev,
+                                            &pm860x_rtc_ops, THIS_MODULE);
+        ret = PTR_ERR(info->rtc_dev);
+        if (IS_ERR(info->rtc_dev)) {
+                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
+                goto out_rtc;
+        }
+        /*
+         * enable internal XO instead of internal 3.25MHz clock since it can
+         * free running in PMIC power-down state.
+         */
+        pm860x_set_bits(info->i2c, PM8607_RTC1, RTC1_USE_XO, RTC1_USE_XO);
+#ifdef VRTC_CALIBRATION
+        /* <00> -- 2.7V, <01> -- 2.9V, <10> -- 3.1V, <11> -- 3.3V */
+        if (pdata && pdata->vrtc)
+                info->vrtc = pdata->vrtc & 0x3;
+        else
+                info->vrtc = 1;
+        pm860x_set_bits(info->i2c, PM8607_MEAS_EN2, MEAS2_VRTC, MEAS2_VRTC);
+        /* calibrate VRTC */
+        INIT_DELAYED_WORK(&info->calib_work, calibrate_vrtc_work);
+        schedule_delayed_work(&info->calib_work, VRTC_CALIB_INTERVAL);
+#endif  /* VRTC_CALIBRATION */
+        return 0;
+out_rtc:
+        free_irq(info->irq, info);
+out:
+        kfree(info);
+        return ret;
+}
+static int __devexit pm860x_rtc_remove(struct platform_device *pdev)
+{
+        struct pm860x_rtc_info *info = platform_get_drvdata(pdev);
+#ifdef VRTC_CALIBRATION
+        flush_scheduled_work();
+        /* disable measurement */
+        pm860x_set_bits(info->i2c, PM8607_MEAS_EN2, MEAS2_VRTC, 0);
+#endif  /* VRTC_CALIBRATION */
+        platform_set_drvdata(pdev, NULL);
+        rtc_device_unregister(info->rtc_dev);
+        free_irq(info->irq, info);
+        kfree(info);
+        return 0;
+}
+static struct platform_driver pm860x_rtc_driver = {
+        .driver         = {
+                .name   = "88pm860x-rtc",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = pm860x_rtc_probe,
+        .remove         = __devexit_p(pm860x_rtc_remove),
+};
+static int __init pm860x_rtc_init(void)
+{
+        return platform_driver_register(&pm860x_rtc_driver);
+}
+module_init(pm860x_rtc_init);
+static void __exit pm860x_rtc_exit(void)
+{
+        platform_driver_unregister(&pm860x_rtc_driver);
+}
+module_exit(pm860x_rtc_exit);
+MODULE_DESCRIPTION("Marvell 88PM860x RTC driver");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index 2fda03125e55..e346705aae92 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -14,26 +14,26 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
+#include <linux/mfd/abx500.h>
 #include <linux/mfd/ab8500.h>
 #include <linux/delay.h>
-#define AB8500_RTC_SOFF_STAT_REG        0x0F00
+#define AB8500_RTC_SOFF_STAT_REG        0x00
-#define AB8500_RTC_CC_CONF_REG          0x0F01
+#define AB8500_RTC_CC_CONF_REG          0x01
-#define AB8500_RTC_READ_REQ_REG         0x0F02
+#define AB8500_RTC_READ_REQ_REG         0x02
-#define AB8500_RTC_WATCH_TSECMID_REG    0x0F03
+#define AB8500_RTC_WATCH_TSECMID_REG    0x03
-#define AB8500_RTC_WATCH_TSECHI_REG     0x0F04
+#define AB8500_RTC_WATCH_TSECHI_REG     0x04
-#define AB8500_RTC_WATCH_TMIN_LOW_REG   0x0F05
+#define AB8500_RTC_WATCH_TMIN_LOW_REG   0x05
-#define AB8500_RTC_WATCH_TMIN_MID_REG   0x0F06
+#define AB8500_RTC_WATCH_TMIN_MID_REG   0x06
-#define AB8500_RTC_WATCH_TMIN_HI_REG    0x0F07
+#define AB8500_RTC_WATCH_TMIN_HI_REG    0x07
-#define AB8500_RTC_ALRM_MIN_LOW_REG     0x0F08
+#define AB8500_RTC_ALRM_MIN_LOW_REG     0x08
-#define AB8500_RTC_ALRM_MIN_MID_REG     0x0F09
+#define AB8500_RTC_ALRM_MIN_MID_REG     0x09
-#define AB8500_RTC_ALRM_MIN_HI_REG      0x0F0A
+#define AB8500_RTC_ALRM_MIN_HI_REG      0x0A
-#define AB8500_RTC_STAT_REG             0x0F0B
+#define AB8500_RTC_STAT_REG             0x0B
-#define AB8500_RTC_BKUP_CHG_REG         0x0F0C
+#define AB8500_RTC_BKUP_CHG_REG         0x0C
-#define AB8500_RTC_FORCE_BKUP_REG       0x0F0D
+#define AB8500_RTC_FORCE_BKUP_REG       0x0D
-#define AB8500_RTC_CALIB_REG            0x0F0E
+#define AB8500_RTC_CALIB_REG            0x0E
-#define AB8500_RTC_SWITCH_STAT_REG      0x0F0F
+#define AB8500_RTC_SWITCH_STAT_REG      0x0F
-#define AB8500_REV_REG                  0x1080
 /* RtcReadRequest bits */
 #define RTC_READ_REQUEST                0x01
@@ -46,13 +46,13 @@
 #define COUNTS_PER_SEC                  (0xF000 / 60)
 #define AB8500_RTC_EPOCH                2000
-static const unsigned long ab8500_rtc_time_regs[] = {
+static const u8 ab8500_rtc_time_regs[] = {
        AB8500_RTC_WATCH_TMIN_HI_REG, AB8500_RTC_WATCH_TMIN_MID_REG,
        AB8500_RTC_WATCH_TMIN_LOW_REG, AB8500_RTC_WATCH_TSECHI_REG,
        AB8500_RTC_WATCH_TSECMID_REG
 };
-static const unsigned long ab8500_rtc_alarm_regs[] = {
+static const u8 ab8500_rtc_alarm_regs[] = {
        AB8500_RTC_ALRM_MIN_HI_REG, AB8500_RTC_ALRM_MIN_MID_REG,
        AB8500_RTC_ALRM_MIN_LOW_REG
 };
@@ -76,29 +76,30 @@ static unsigned long get_elapsed_seconds(int year)
 static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
        unsigned long timeout = jiffies + HZ;
        int retval, i;
        unsigned long mins, secs;
        unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)];
+        u8 value;
        /* Request a data read */
-        retval = ab8500_write(ab8500, AB8500_RTC_READ_REQ_REG,
+        retval = abx500_set_register_interruptible(dev,
-                              RTC_READ_REQUEST);
+                AB8500_RTC, AB8500_RTC_READ_REQ_REG, RTC_READ_REQUEST);
        if (retval < 0)
                return retval;
        /* Early AB8500 chips will not clear the rtc read request bit */
-        if (ab8500->revision == 0) {
+        if (abx500_get_chip_id(dev) == 0) {
                msleep(1);
        } else {
                /* Wait for some cycles after enabling the rtc read in ab8500 */
                while (time_before(jiffies, timeout)) {
-                        retval = ab8500_read(ab8500, AB8500_RTC_READ_REQ_REG);
+                        retval = abx500_get_register_interruptible(dev,
+                                AB8500_RTC, AB8500_RTC_READ_REQ_REG, &value);
                        if (retval < 0)
                                return retval;
-                        if (!(retval & RTC_READ_REQUEST))
+                        if (!(value & RTC_READ_REQUEST))
                                break;
                        msleep(1);
@@ -107,10 +108,11 @@ static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
        /* Read the Watchtime registers */
        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) {
-                retval = ab8500_read(ab8500, ab8500_rtc_time_regs[i]);
+                retval = abx500_get_register_interruptible(dev,
+                        AB8500_RTC, ab8500_rtc_time_regs[i], &value);
                if (retval < 0)
                        return retval;
-                buf[i] = retval;
+                buf[i] = value;
        }
        mins = (buf[0] << 16) | (buf[1] << 8) | buf[2];
@@ -128,7 +130,6 @@ static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
 static int ab8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
        int retval, i;
        unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)];
        unsigned long no_secs, no_mins, secs = 0;
@@ -162,27 +163,29 @@ static int ab8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
        buf[0] = (no_mins >> 16) & 0xFF;
        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) {
-                retval = ab8500_write(ab8500, ab8500_rtc_time_regs[i], buf[i]);
+                retval = abx500_set_register_interruptible(dev, AB8500_RTC,
+                        ab8500_rtc_time_regs[i], buf[i]);
                if (retval < 0)
                        return retval;
        }
        /* Request a data write */
-        return ab8500_write(ab8500, AB8500_RTC_READ_REQ_REG, RTC_WRITE_REQUEST);
+        return abx500_set_register_interruptible(dev, AB8500_RTC,
+                AB8500_RTC_READ_REQ_REG, RTC_WRITE_REQUEST);
 }
 static int ab8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
        int retval, i;
-        int rtc_ctrl;
+        u8 rtc_ctrl, value;
        unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)];
        unsigned long secs, mins;
        /* Check if the alarm is enabled or not */
-        rtc_ctrl = ab8500_read(ab8500, AB8500_RTC_STAT_REG);
+        retval = abx500_get_register_interruptible(dev, AB8500_RTC,
-        if (rtc_ctrl < 0)
+                AB8500_RTC_STAT_REG, &rtc_ctrl);
-                return rtc_ctrl;
+        if (retval < 0)
+                return retval;
        if (rtc_ctrl & RTC_ALARM_ENA)
                alarm->enabled = 1;
@@ -192,10 +195,11 @@ static int ab8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
        alarm->pending = 0;
        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) {
-                retval = ab8500_read(ab8500, ab8500_rtc_alarm_regs[i]);
+                retval = abx500_get_register_interruptible(dev, AB8500_RTC,
+                        ab8500_rtc_alarm_regs[i], &value);
                if (retval < 0)
                        return retval;
-                buf[i] = retval;
+                buf[i] = value;
        }
        mins = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
@@ -211,15 +215,13 @@ static int ab8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 static int ab8500_rtc_irq_enable(struct device *dev, unsigned int enabled)
 {
-        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
+        return abx500_mask_and_set_register_interruptible(dev, AB8500_RTC,
+                AB8500_RTC_STAT_REG, RTC_ALARM_ENA,
-        return ab8500_set_bits(ab8500, AB8500_RTC_STAT_REG, RTC_ALARM_ENA,
+                enabled ? RTC_ALARM_ENA : 0);
-                               enabled ? RTC_ALARM_ENA : 0);
 }
 static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
        int retval, i;
        unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)];
        unsigned long mins, secs = 0;
@@ -247,7 +249,8 @@ static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
        /* Set the alarm time */
        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) {
-                retval = ab8500_write(ab8500, ab8500_rtc_alarm_regs[i], buf[i]);
+                retval = abx500_set_register_interruptible(dev, AB8500_RTC,
+                        ab8500_rtc_alarm_regs[i], buf[i]);
                if (retval < 0)
                        return retval;
        }
@@ -276,10 +279,9 @@ static const struct rtc_class_ops ab8500_rtc_ops = {
 static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
 {
-        struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
        int err;
        struct rtc_device *rtc;
-        int rtc_ctrl;
+        u8 rtc_ctrl;
        int irq;
        irq = platform_get_irq_byname(pdev, "ALARM");
@@ -287,17 +289,18 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
                return irq;
        /* For RTC supply test */
-        err = ab8500_set_bits(ab8500, AB8500_RTC_STAT_REG, RTC_STATUS_DATA,
+        err = abx500_mask_and_set_register_interruptible(&pdev->dev, AB8500_RTC,
-                        RTC_STATUS_DATA);
+                AB8500_RTC_STAT_REG, RTC_STATUS_DATA, RTC_STATUS_DATA);
        if (err < 0)
                return err;
        /* Wait for reset by the PorRtc */
        msleep(1);
-        rtc_ctrl = ab8500_read(ab8500, AB8500_RTC_STAT_REG);
+        err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC,
-        if (rtc_ctrl < 0)
+                AB8500_RTC_STAT_REG, &rtc_ctrl);
-                return rtc_ctrl;
+        if (err < 0)
+                return err;
        /* Check if the RTC Supply fails */
        if (!(rtc_ctrl & RTC_STATUS_DATA)) {
diff --git a/drivers/rtc/rtc-at32ap700x.c b/drivers/rtc/rtc-at32ap700x.c
index b2752b6e7a2f..e725d51e773d 100644
--- a/drivers/rtc/rtc-at32ap700x.c
+++ b/drivers/rtc/rtc-at32ap700x.c
@@ -134,36 +134,29 @@ static int at32_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
        return ret;
 }
-static int at32_rtc_ioctl(struct device *dev, unsigned int cmd,
+static int at32_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-                        unsigned long arg)
 {
        struct rtc_at32ap700x *rtc = dev_get_drvdata(dev);
        int ret = 0;
        spin_lock_irq(&rtc->lock);
-        switch (cmd) {
+        if(enabled) {
-        case RTC_AIE_ON:
                if (rtc_readl(rtc, VAL) > rtc->alarm_time) {
                        ret = -EINVAL;
-                        break;
+                        goto out;
                }
                rtc_writel(rtc, CTRL, rtc_readl(rtc, CTRL)
                                | RTC_BIT(CTRL_TOPEN));
                rtc_writel(rtc, ICR, RTC_BIT(ICR_TOPI));
                rtc_writel(rtc, IER, RTC_BIT(IER_TOPI));
-                break;
+        } else {
-        case RTC_AIE_OFF:
                rtc_writel(rtc, CTRL, rtc_readl(rtc, CTRL)
                                & ~RTC_BIT(CTRL_TOPEN));
                rtc_writel(rtc, IDR, RTC_BIT(IDR_TOPI));
                rtc_writel(rtc, ICR, RTC_BIT(ICR_TOPI));
-                break;
-        default:
-                ret = -ENOIOCTLCMD;
-                break;
        }
+out:
        spin_unlock_irq(&rtc->lock);
        return ret;
@@ -195,11 +188,11 @@ static irqreturn_t at32_rtc_interrupt(int irq, void *dev_id)
 }
 static struct rtc_class_ops at32_rtc_ops = {
-        .ioctl          = at32_rtc_ioctl,
        .read_time      = at32_rtc_readtime,
        .set_time       = at32_rtc_settime,
        .read_alarm     = at32_rtc_readalarm,
        .set_alarm      = at32_rtc_setalarm,
+        .alarm_irq_enable = at32_rtc_alarm_irq_enable,
 };
 static int __init at32_rtc_probe(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index bc8bbca9a2e2..e39b77a4609a 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -60,7 +60,7 @@ static void at91_rtc_decodetime(unsigned int timereg, unsigned int calreg,
        /*
         * The Calendar Alarm register does not have a field for
         * the year - so these will return an invalid value.  When an
-         * alarm is set, at91_alarm_year wille store the current year.
+         * alarm is set, at91_alarm_year will store the current year.
         */
        tm->tm_year  = bcd2bin(date & AT91_RTC_CENT) * 100;     /* century */
        tm->tm_year += bcd2bin((date & AT91_RTC_YEAR) >> 8);    /* year */
@@ -183,40 +183,18 @@ static int at91_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
        return 0;
 }
-/*
+static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
- * Handle commands from user-space
- */
-static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
-                        unsigned long arg)
 {
-        int ret = 0;
+        pr_debug("%s(): cmd=%08x\n", __func__, enabled);
-        pr_debug("%s(): cmd=%08x, arg=%08lx.\n", __func__, cmd, arg);
+        if (enabled) {
-        /* important:  scrub old status before enabling IRQs */
-        switch (cmd) {
-        case RTC_AIE_OFF:       /* alarm off */
-                at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
-                break;
-        case RTC_AIE_ON:        /* alarm on */
                at91_sys_write(AT91_RTC_SCCR, AT91_RTC_ALARM);
                at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM);
-                break;
+        } else
-        case RTC_UIE_OFF:       /* update off */
+                at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
-                at91_sys_write(AT91_RTC_IDR, AT91_RTC_SECEV);
-                break;
-        case RTC_UIE_ON:        /* update on */
-                at91_sys_write(AT91_RTC_SCCR, AT91_RTC_SECEV);
-                at91_sys_write(AT91_RTC_IER, AT91_RTC_SECEV);
-                break;
-        default:
-                ret = -ENOIOCTLCMD;
-                break;
-        }
-        return ret;
+        return 0;
 }
 /*
 * Provide additional RTC information in /proc/driver/rtc
 */
@@ -264,12 +242,12 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id)
 }
 static const struct rtc_class_ops at91_rtc_ops = {
-        .ioctl          = at91_rtc_ioctl,
        .read_time      = at91_rtc_readtime,
        .set_time       = at91_rtc_settime,
        .read_alarm     = at91_rtc_readalarm,
        .set_alarm      = at91_rtc_setalarm,
        .proc           = at91_rtc_proc,
+        .alarm_irq_enable = at91_rtc_alarm_irq_enable,
 };
 /*
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index f677e0710ca1..a3ad957507dc 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -216,37 +216,17 @@ static int at91_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
        return 0;
 }
-/*
+static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
- * Handle commands from user-space
- */
-static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
-                        unsigned long arg)
 {
        struct sam9_rtc *rtc = dev_get_drvdata(dev);
-        int ret = 0;
        u32 mr = rtt_readl(rtc, MR);
-        dev_dbg(dev, "ioctl: cmd=%08x, arg=%08lx, mr %08x\n", cmd, arg, mr);
+        dev_dbg(dev, "alarm_irq_enable: enabled=%08x, mr %08x\n", enabled, mr);
+        if (enabled)
-        switch (cmd) {
-        case RTC_AIE_OFF:               /* alarm off */
-                rtt_writel(rtc, MR, mr & ~AT91_RTT_ALMIEN);
-                break;
-        case RTC_AIE_ON:                /* alarm on */
                rtt_writel(rtc, MR, mr | AT91_RTT_ALMIEN);
-                break;
+        else
-        case RTC_UIE_OFF:               /* update off */
+                rtt_writel(rtc, MR, mr & ~AT91_RTT_ALMIEN);
-                rtt_writel(rtc, MR, mr & ~AT91_RTT_RTTINCIEN);
+        return 0;
-                break;
-        case RTC_UIE_ON:                /* update on */
-                rtt_writel(rtc, MR, mr | AT91_RTT_RTTINCIEN);
-                break;
-        default:
-                ret = -ENOIOCTLCMD;
-                break;
-        }
-        return ret;
 }
 /*
@@ -296,12 +276,12 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *_rtc)
 }
 static const struct rtc_class_ops at91_rtc_ops = {
-        .ioctl          = at91_rtc_ioctl,
        .read_time      = at91_rtc_readtime,
        .set_time       = at91_rtc_settime,
        .read_alarm     = at91_rtc_readalarm,
        .set_alarm      = at91_rtc_setalarm,
        .proc           = at91_rtc_proc,
+        .alarm_irq_enable = at91_rtc_alarm_irq_enable,
 };
 /*
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index d4fb82d85e9b..90d866272c8e 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -2,7 +2,7 @@
 * Blackfin On-Chip Real Time Clock Driver
 *  Supports BF51x/BF52x/BF53[123]/BF53[467]/BF54x
 *
- * Copyright 2004-2009 Analog Devices Inc.
+ * Copyright 2004-2010 Analog Devices Inc.
 *
 * Enter bugs at http://blackfin.uclinux.org/
 *
@@ -20,9 +20,9 @@
 * write would be discarded and things quickly fall apart.
 *
 * To keep this delay from significantly degrading performance (we, in theory,
- * would have to sleep for up to 1 second everytime we wanted to write a
+ * would have to sleep for up to 1 second every time we wanted to write a
 * register), we only check the write pending status before we start to issue
- * a new write.  We bank on the idea that it doesnt matter when the sync
+ * a new write.  We bank on the idea that it doesn't matter when the sync
 * happens so long as we don't attempt another write before it does.  The only
 * time userspace would take this penalty is when they try and do multiple
 * operations right after another ... but in this case, they need to take the
@@ -183,29 +183,33 @@ static irqreturn_t bfin_rtc_interrupt(int irq, void *dev_id)
        struct bfin_rtc *rtc = dev_get_drvdata(dev);
        unsigned long events = 0;
        bool write_complete = false;
-        u16 rtc_istat, rtc_ictl;
+        u16 rtc_istat, rtc_istat_clear, rtc_ictl, bits;
        dev_dbg_stamp(dev);
        rtc_istat = bfin_read_RTC_ISTAT();
        rtc_ictl = bfin_read_RTC_ICTL();
+        rtc_istat_clear = 0;
-        if (rtc_istat & RTC_ISTAT_WRITE_COMPLETE) {
+        bits = RTC_ISTAT_WRITE_COMPLETE;
-                bfin_write_RTC_ISTAT(RTC_ISTAT_WRITE_COMPLETE);
+        if (rtc_istat & bits) {
+                rtc_istat_clear |= bits;
                write_complete = true;
                complete(&bfin_write_complete);
        }
-        if (rtc_ictl & (RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY)) {
+        bits = (RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY);
-                if (rtc_istat & (RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY)) {
+        if (rtc_ictl & bits) {
-                        bfin_write_RTC_ISTAT(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY);
+                if (rtc_istat & bits) {
+                        rtc_istat_clear |= bits;
                        events |= RTC_AF | RTC_IRQF;
                }
        }
-        if (rtc_ictl & RTC_ISTAT_SEC) {
+        bits = RTC_ISTAT_SEC;
-                if (rtc_istat & RTC_ISTAT_SEC) {
+        if (rtc_ictl & bits) {
-                        bfin_write_RTC_ISTAT(RTC_ISTAT_SEC);
+                if (rtc_istat & bits) {
+                        rtc_istat_clear |= bits;
                        events |= RTC_UF | RTC_IRQF;
                }
        }
@@ -213,9 +217,10 @@ static irqreturn_t bfin_rtc_interrupt(int irq, void *dev_id)
        if (events)
                rtc_update_irq(rtc->rtc_dev, 1, events);
-        if (write_complete || events)
+        if (write_complete || events) {
+                bfin_write_RTC_ISTAT(rtc_istat_clear);
                return IRQ_HANDLED;
-        else
+        } else
                return IRQ_NONE;
 }
@@ -235,40 +240,18 @@ static void bfin_rtc_int_set_alarm(struct bfin_rtc *rtc)
         */
        bfin_rtc_int_set(rtc->rtc_alarm.tm_yday == -1 ? RTC_ISTAT_ALARM : RTC_ISTAT_ALARM_DAY);
 }
-static int bfin_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int bfin_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
        struct bfin_rtc *rtc = dev_get_drvdata(dev);
-        int ret = 0;
        dev_dbg_stamp(dev);
+        if (enabled)
-        bfin_rtc_sync_pending(dev);
-        switch (cmd) {
-        case RTC_UIE_ON:
-                dev_dbg_stamp(dev);
-                bfin_rtc_int_set(RTC_ISTAT_SEC);
-                break;
-        case RTC_UIE_OFF:
-                dev_dbg_stamp(dev);
-                bfin_rtc_int_clear(~RTC_ISTAT_SEC);
-                break;
-        case RTC_AIE_ON:
-                dev_dbg_stamp(dev);
                bfin_rtc_int_set_alarm(rtc);
-                break;
+        else
-        case RTC_AIE_OFF:
-                dev_dbg_stamp(dev);
                bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
-                break;
-        default:
+        return 0;
-                dev_dbg_stamp(dev);
-                ret = -ENOIOCTLCMD;
-        }
-        return ret;
 }
 static int bfin_rtc_read_time(struct device *dev, struct rtc_time *tm)
@@ -351,12 +334,12 @@ static int bfin_rtc_proc(struct device *dev, struct seq_file *seq)
 }
 static struct rtc_class_ops bfin_rtc_ops = {
-        .ioctl         = bfin_rtc_ioctl,
        .read_time     = bfin_rtc_read_time,
        .set_time      = bfin_rtc_set_time,
        .read_alarm    = bfin_rtc_read_alarm,
        .set_alarm     = bfin_rtc_set_alarm,
        .proc          = bfin_rtc_proc,
+        .alarm_irq_enable = bfin_rtc_alarm_irq_enable,
 };
 static int __devinit bfin_rtc_probe(struct platform_device *pdev)
@@ -422,9 +405,13 @@ static int __devexit bfin_rtc_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        if (device_may_wakeup(&pdev->dev)) {
+        struct device *dev = &pdev->dev;
+        dev_dbg_stamp(dev);
+        if (device_may_wakeup(dev)) {
                enable_irq_wake(IRQ_RTC);
-                bfin_rtc_sync_pending(&pdev->dev);
+                bfin_rtc_sync_pending(dev);
        } else
                bfin_rtc_int_clear(0);
@@ -433,7 +420,11 @@ static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 static int bfin_rtc_resume(struct platform_device *pdev)
 {
-        if (device_may_wakeup(&pdev->dev))
+        struct device *dev = &pdev->dev;
+        dev_dbg_stamp(dev);
+        if (device_may_wakeup(dev))
                disable_irq_wake(IRQ_RTC);
        /*
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 5856167a0c90..911e75cdc125 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -36,6 +36,9 @@
 #include <linux/platform_device.h>
 #include <linux/mod_devicetable.h>
 #include <linux/log2.h>
+#include <linux/pm.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
 /* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
 #include <asm-generic/rtc.h>
@@ -374,50 +377,6 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
        return 0;
 }
-static int cmos_irq_set_freq(struct device *dev, int freq)
-{
-        struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        int             f;
-        unsigned long   flags;
-        if (!is_valid_irq(cmos->irq))
-                return -ENXIO;
-        if (!is_power_of_2(freq))
-                return -EINVAL;
-        /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */
-        f = ffs(freq);
-        if (f-- > 16)
-                return -EINVAL;
-        f = 16 - f;
-        spin_lock_irqsave(&rtc_lock, flags);
-        hpet_set_periodic_freq(freq);
-        CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
-        spin_unlock_irqrestore(&rtc_lock, flags);
-        return 0;
-}
-static int cmos_irq_set_state(struct device *dev, int enabled)
-{
-        struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        unsigned long   flags;
-        if (!is_valid_irq(cmos->irq))
-                return -ENXIO;
-        spin_lock_irqsave(&rtc_lock, flags);
-        if (enabled)
-                cmos_irq_enable(cmos, RTC_PIE);
-        else
-                cmos_irq_disable(cmos, RTC_PIE);
-        spin_unlock_irqrestore(&rtc_lock, flags);
-        return 0;
-}
 static int cmos_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
        struct cmos_rtc *cmos = dev_get_drvdata(dev);
@@ -437,25 +396,6 @@ static int cmos_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int cmos_update_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        unsigned long   flags;
-        if (!is_valid_irq(cmos->irq))
-                return -EINVAL;
-        spin_lock_irqsave(&rtc_lock, flags);
-        if (enabled)
-                cmos_irq_enable(cmos, RTC_UIE);
-        else
-                cmos_irq_disable(cmos, RTC_UIE);
-        spin_unlock_irqrestore(&rtc_lock, flags);
-        return 0;
-}
 #if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
 static int cmos_procfs(struct device *dev, struct seq_file *seq)
@@ -500,10 +440,7 @@ static const struct rtc_class_ops cmos_rtc_ops = {
        .read_alarm             = cmos_read_alarm,
        .set_alarm              = cmos_set_alarm,
        .proc                   = cmos_procfs,
-        .irq_set_freq           = cmos_irq_set_freq,
-        .irq_set_state          = cmos_irq_set_state,
        .alarm_irq_enable       = cmos_alarm_irq_enable,
-        .update_irq_enable      = cmos_update_irq_enable,
 };
 /*----------------------------------------------------------------*/
@@ -687,7 +624,8 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 #if     defined(CONFIG_ATARI)
        address_space = 64;
 #elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) \
-                        || defined(__sparc__) || defined(__mips__)
+                        || defined(__sparc__) || defined(__mips__) \
+                        || defined(__powerpc__)
        address_space = 128;
 #else
 #warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
@@ -850,7 +788,7 @@ static void __exit cmos_do_remove(struct device *dev)
 #ifdef  CONFIG_PM
-static int cmos_suspend(struct device *dev, pm_message_t mesg)
+static int cmos_suspend(struct device *dev)
 {
        struct cmos_rtc *cmos = dev_get_drvdata(dev);
        unsigned char   tmp;
@@ -898,7 +836,7 @@ static int cmos_suspend(struct device *dev, pm_message_t mesg)
 */
 static inline int cmos_poweroff(struct device *dev)
 {
-        return cmos_suspend(dev, PMSG_HIBERNATE);
+        return cmos_suspend(dev);
 }
 static int cmos_resume(struct device *dev)
@@ -945,9 +883,9 @@ static int cmos_resume(struct device *dev)
        return 0;
 }
+static SIMPLE_DEV_PM_OPS(cmos_pm_ops, cmos_suspend, cmos_resume);
 #else
-#define cmos_suspend    NULL
-#define cmos_resume     NULL
 static inline int cmos_poweroff(struct device *dev)
 {
@@ -1077,7 +1015,7 @@ static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
 static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
 {
-        return cmos_suspend(&pnp->dev, mesg);
+        return cmos_suspend(&pnp->dev);
 }
 static int cmos_pnp_resume(struct pnp_dev *pnp)
@@ -1121,6 +1059,47 @@ static struct pnp_driver cmos_pnp_driver = {
 #endif  /* CONFIG_PNP */
+#ifdef CONFIG_OF
+static const struct of_device_id of_cmos_match[] = {
+        {
+                .compatible = "motorola,mc146818",
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(of, of_cmos_match);
+static __init void cmos_of_init(struct platform_device *pdev)
+{
+        struct device_node *node = pdev->dev.of_node;
+        struct rtc_time time;
+        int ret;
+        const __be32 *val;
+        if (!node)
+                return;
+        val = of_get_property(node, "ctrl-reg", NULL);
+        if (val)
+                CMOS_WRITE(be32_to_cpup(val), RTC_CONTROL);
+        val = of_get_property(node, "freq-reg", NULL);
+        if (val)
+                CMOS_WRITE(be32_to_cpup(val), RTC_FREQ_SELECT);
+        get_rtc_time(&time);
+        ret = rtc_valid_tm(&time);
+        if (ret) {
+                struct rtc_time def_time = {
+                        .tm_year = 1,
+                        .tm_mday = 1,
+                };
+                set_rtc_time(&def_time);
+        }
+}
+#else
+static inline void cmos_of_init(struct platform_device *pdev) {}
+#define of_cmos_match NULL
+#endif
 /*----------------------------------------------------------------*/
 /* Platform setup should have set up an RTC device, when PNP is
@@ -1129,6 +1108,7 @@ static struct pnp_driver cmos_pnp_driver = {
 static int __init cmos_platform_probe(struct platform_device *pdev)
 {
+        cmos_of_init(pdev);
        cmos_wake_setup(&pdev->dev);
        return cmos_do_probe(&pdev->dev,
                        platform_get_resource(pdev, IORESOURCE_IO, 0),
@@ -1157,8 +1137,10 @@ static struct platform_driver cmos_platform_driver = {
        .shutdown       = cmos_platform_shutdown,
        .driver = {
                .name           = (char *) driver_name,
-                .suspend        = cmos_suspend,
+#ifdef CONFIG_PM
-                .resume         = cmos_resume,
+                .pm             = &cmos_pm_ops,
+#endif
+                .of_match_table = of_cmos_match,
        }
 };
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index 316f484999b5..80f9c88214c5 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -220,6 +220,7 @@ static int __init coh901331_probe(struct platform_device *pdev)
        }
        clk_disable(rtap->clk);
+        platform_set_drvdata(pdev, rtap);
        rtap->rtc = rtc_device_register("coh901331", &pdev->dev, &coh901331_ops,
                                         THIS_MODULE);
        if (IS_ERR(rtap->rtc)) {
@@ -227,11 +228,10 @@ static int __init coh901331_probe(struct platform_device *pdev)
                goto out_no_rtc;
        }
-        platform_set_drvdata(pdev, rtap);
        return 0;
 out_no_rtc:
+        platform_set_drvdata(pdev, NULL);
 out_no_clk_enable:
        clk_put(rtap->clk);
 out_no_clk:
diff --git a/drivers/rtc/rtc-davinci.c b/drivers/rtc/rtc-davinci.c
index 34647fc1ee98..755e1fe914af 100644
--- a/drivers/rtc/rtc-davinci.c
+++ b/drivers/rtc/rtc-davinci.c
@@ -231,10 +231,6 @@ davinci_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
        case RTC_WIE_OFF:
                rtc_ctrl &= ~PRTCSS_RTC_CTRL_WEN;
                break;
-        case RTC_UIE_OFF:
-        case RTC_UIE_ON:
-                ret = -ENOTTY;
-                break;
        default:
                ret = -ENOIOCTLCMD;
        }
@@ -473,55 +469,6 @@ static int davinci_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
        return 0;
 }
-static int davinci_rtc_irq_set_state(struct device *dev, int enabled)
-{
-        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
-        unsigned long flags;
-        u8 rtc_ctrl;
-        spin_lock_irqsave(&davinci_rtc_lock, flags);
-        rtc_ctrl = rtcss_read(davinci_rtc, PRTCSS_RTC_CTRL);
-        if (enabled) {
-                while (rtcss_read(davinci_rtc, PRTCSS_RTC_CTRL)
-                       & PRTCSS_RTC_CTRL_WDTBUS)
-                        cpu_relax();
-                rtc_ctrl |= PRTCSS_RTC_CTRL_TE;
-                rtcss_write(davinci_rtc, rtc_ctrl, PRTCSS_RTC_CTRL);
-                rtcss_write(davinci_rtc, 0x0, PRTCSS_RTC_CLKC_CNT);
-                rtc_ctrl |= PRTCSS_RTC_CTRL_TIEN |
-                            PRTCSS_RTC_CTRL_TMMD |
-                            PRTCSS_RTC_CTRL_TMRFLG;
-        } else
-                rtc_ctrl &= ~PRTCSS_RTC_CTRL_TIEN;
-        rtcss_write(davinci_rtc, rtc_ctrl, PRTCSS_RTC_CTRL);
-        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
-        return 0;
-}
-static int davinci_rtc_irq_set_freq(struct device *dev, int freq)
-{
-        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
-        unsigned long flags;
-        u16 tmr_counter = (0x8000 >> (ffs(freq) - 1));
-        spin_lock_irqsave(&davinci_rtc_lock, flags);
-        rtcss_write(davinci_rtc, tmr_counter & 0xFF, PRTCSS_RTC_TMR0);
-        rtcss_write(davinci_rtc, (tmr_counter & 0xFF00) >> 8, PRTCSS_RTC_TMR1);
-        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
-        return 0;
-}
 static struct rtc_class_ops davinci_rtc_ops = {
        .ioctl                  = davinci_rtc_ioctl,
        .read_time              = davinci_rtc_read_time,
@@ -529,8 +476,6 @@ static struct rtc_class_ops davinci_rtc_ops = {
        .alarm_irq_enable       = davinci_rtc_alarm_irq_enable,
        .read_alarm             = davinci_rtc_read_alarm,
        .set_alarm              = davinci_rtc_set_alarm,
-        .irq_set_state          = davinci_rtc_irq_set_state,
-        .irq_set_freq           = davinci_rtc_irq_set_freq,
 };
 static int __init davinci_rtc_probe(struct platform_device *pdev)
@@ -579,6 +524,8 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
                goto fail2;
        }
+        platform_set_drvdata(pdev, davinci_rtc);
        davinci_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
                                    &davinci_rtc_ops, THIS_MODULE);
        if (IS_ERR(davinci_rtc->rtc)) {
@@ -608,8 +555,6 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
        rtcss_write(davinci_rtc, PRTCSS_RTC_CCTRL_CAEN, PRTCSS_RTC_CCTRL);
-        platform_set_drvdata(pdev, davinci_rtc);
        device_init_wakeup(&pdev->dev, 0);
        return 0;
@@ -617,6 +562,7 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
 fail4:
        rtc_device_unregister(davinci_rtc->rtc);
 fail3:
+        platform_set_drvdata(pdev, NULL);
        iounmap(davinci_rtc->base);
 fail2:
        release_mem_region(davinci_rtc->pbase, davinci_rtc->base_size);
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 62227cd52410..cace6d3aed9a 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -76,7 +76,7 @@ static void rtc_uie_task(struct work_struct *work)
        }
        spin_unlock_irq(&rtc->irq_lock);
        if (num)
-                rtc_update_irq(rtc, num, RTC_UF | RTC_IRQF);
+                rtc_handle_legacy_irq(rtc, num, RTC_UF);
 }
 static void rtc_uie_timer(unsigned long data)
 {
@@ -253,19 +253,7 @@ static long rtc_dev_ioctl(struct file *file,
        if (err)
                goto done;
-        /* try the driver's ioctl interface */
+        /*
-        if (ops->ioctl) {
-                err = ops->ioctl(rtc->dev.parent, cmd, arg);
-                if (err != -ENOIOCTLCMD) {
-                        mutex_unlock(&rtc->ops_lock);
-                        return err;
-                }
-        }
-        /* if the driver does not provide the ioctl interface
-         * or if that particular ioctl was not implemented
-         * (-ENOIOCTLCMD), we will try to emulate here.
-         *
         * Drivers *SHOULD NOT* provide ioctl implementations
         * for these requests.  Instead, provide methods to
         * support the following code, so that the RTC's main
@@ -428,7 +416,13 @@ static long rtc_dev_ioctl(struct file *file,
                return err;
        default:
-                err = -ENOTTY;
+                /* Finally try the driver's ioctl interface */
+                if (ops->ioctl) {
+                        err = ops->ioctl(rtc->dev.parent, cmd, arg);
+                        if (err == -ENOIOCTLCMD)
+                                err = -ENOTTY;
+                } else
+                        err = -ENOTTY;
                break;
        }
diff --git a/drivers/rtc/rtc-ds1286.c b/drivers/rtc/rtc-ds1286.c
index bf430f9091ed..47e681df31e2 100644
--- a/drivers/rtc/rtc-ds1286.c
+++ b/drivers/rtc/rtc-ds1286.c
@@ -40,6 +40,26 @@ static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg)
        __raw_writel(data, &priv->rtcregs[reg]);
 }
+static int ds1286_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct ds1286_priv *priv = dev_get_drvdata(dev);
+        unsigned long flags;
+        unsigned char val;
+        /* Allow or mask alarm interrupts */
+        spin_lock_irqsave(&priv->lock, flags);
+        val = ds1286_rtc_read(priv, RTC_CMD);
+        if (enabled)
+                val &=  ~RTC_TDM;
+        else
+                val |=  RTC_TDM;
+        ds1286_rtc_write(priv, val, RTC_CMD);
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return 0;
+}
 #ifdef CONFIG_RTC_INTF_DEV
 static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
@@ -49,22 +69,6 @@ static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
        unsigned char val;
        switch (cmd) {
-        case RTC_AIE_OFF:
-                /* Mask alarm int. enab. bit    */
-                spin_lock_irqsave(&priv->lock, flags);
-                val = ds1286_rtc_read(priv, RTC_CMD);
-                val |=  RTC_TDM;
-                ds1286_rtc_write(priv, val, RTC_CMD);
-                spin_unlock_irqrestore(&priv->lock, flags);
-                break;
-        case RTC_AIE_ON:
-                /* Allow alarm interrupts.      */
-                spin_lock_irqsave(&priv->lock, flags);
-                val = ds1286_rtc_read(priv, RTC_CMD);
-                val &=  ~RTC_TDM;
-                ds1286_rtc_write(priv, val, RTC_CMD);
-                spin_unlock_irqrestore(&priv->lock, flags);
-                break;
        case RTC_WIE_OFF:
                /* Mask watchdog int. enab. bit */
                spin_lock_irqsave(&priv->lock, flags);
@@ -316,12 +320,13 @@ static int ds1286_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 }
 static const struct rtc_class_ops ds1286_ops = {
-        .ioctl          = ds1286_ioctl,
+        .ioctl          = ds1286_ioctl,
-        .proc           = ds1286_proc,
+        .proc           = ds1286_proc,
        .read_time      = ds1286_read_time,
        .set_time       = ds1286_set_time,
        .read_alarm     = ds1286_read_alarm,
        .set_alarm      = ds1286_set_alarm,
+        .alarm_irq_enable = ds1286_alarm_irq_enable,
 };
 static int __devinit ds1286_probe(struct platform_device *pdev)
@@ -350,6 +355,7 @@ static int __devinit ds1286_probe(struct platform_device *pdev)
                goto out;
        }
        spin_lock_init(&priv->lock);
+        platform_set_drvdata(pdev, priv);
        rtc = rtc_device_register("ds1286", &pdev->dev,
                                  &ds1286_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
@@ -357,7 +363,6 @@ static int __devinit ds1286_probe(struct platform_device *pdev)
                goto out;
        }
        priv->rtc = rtc;
-        platform_set_drvdata(pdev, priv);
        return 0;
 out:
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index 359d1e04626c..f0d638922644 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -35,7 +35,7 @@
 #ifdef CONFIG_SH_SECUREEDGE5410
 #include <asm/rtc.h>
-#include <mach/snapgear.h>
+#include <mach/secureedge5410.h>
 #define RTC_RESET       0x1000
 #define RTC_IODATA      0x0800
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index 48da85e97ca4..57fbcc149ba7 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -139,49 +139,32 @@ static u8 hour2bcd(bool hr12, int hour)
 * Interface to RTC framework
 */
-#ifdef CONFIG_RTC_INTF_DEV
+static int ds1305_alarm_irq_enable(struct device *dev, unsigned int enabled)
-/*
- * Context: caller holds rtc->ops_lock (to protect ds1305->ctrl)
- */
-static int ds1305_ioctl(struct device *dev, unsigned cmd, unsigned long arg)
 {
        struct ds1305   *ds1305 = dev_get_drvdata(dev);
        u8              buf[2];
-        int             status = -ENOIOCTLCMD;
+        long            err = -EINVAL;
        buf[0] = DS1305_WRITE | DS1305_CONTROL;
        buf[1] = ds1305->ctrl[0];
-        switch (cmd) {
+        if (enabled) {
-        case RTC_AIE_OFF:
-                status = 0;
-                if (!(buf[1] & DS1305_AEI0))
-                        goto done;
-                buf[1] &= ~DS1305_AEI0;
-                break;
-        case RTC_AIE_ON:
-                status = 0;
                if (ds1305->ctrl[0] & DS1305_AEI0)
                        goto done;
                buf[1] |= DS1305_AEI0;
-                break;
+        } else {
-        }
+                if (!(buf[1] & DS1305_AEI0))
-        if (status == 0) {
+                        goto done;
-                status = spi_write_then_read(ds1305->spi, buf, sizeof buf,
+                buf[1] &= ~DS1305_AEI0;
-                                NULL, 0);
-                if (status >= 0)
-                        ds1305->ctrl[0] = buf[1];
        }
+        err = spi_write_then_read(ds1305->spi, buf, sizeof buf, NULL, 0);
+        if (err >= 0)
+                ds1305->ctrl[0] = buf[1];
 done:
-        return status;
+        return err;
 }
-#else
-#define ds1305_ioctl    NULL
-#endif
 /*
 * Get/set of date and time is pretty normal.
@@ -460,12 +443,12 @@ done:
 #endif
 static const struct rtc_class_ops ds1305_ops = {
-        .ioctl          = ds1305_ioctl,
        .read_time      = ds1305_get_time,
        .set_time       = ds1305_set_time,
        .read_alarm     = ds1305_get_alarm,
        .set_alarm      = ds1305_set_alarm,
        .proc           = ds1305_proc,
+        .alarm_irq_enable = ds1305_alarm_irq_enable,
 };
 static void ds1305_work(struct work_struct *work)
@@ -813,7 +796,7 @@ static int __devexit ds1305_remove(struct spi_device *spi)
        if (spi->irq) {
                set_bit(FLAG_EXITING, &ds1305->flags);
                free_irq(spi->irq, ds1305);
-                flush_scheduled_work();
+                cancel_work_sync(&ds1305->work);
        }
        rtc_device_unregister(ds1305->rtc);
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index d827ce570a8c..b2005b44e4f7 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -106,9 +106,9 @@ struct ds1307 {
        struct i2c_client       *client;
        struct rtc_device       *rtc;
        struct work_struct      work;
-        s32 (*read_block_data)(struct i2c_client *client, u8 command,
+        s32 (*read_block_data)(const struct i2c_client *client, u8 command,
                               u8 length, u8 *values);
-        s32 (*write_block_data)(struct i2c_client *client, u8 command,
+        s32 (*write_block_data)(const struct i2c_client *client, u8 command,
                                u8 length, const u8 *values);
 };
@@ -149,6 +149,7 @@ static const struct i2c_device_id ds1307_id[] = {
        { "ds1340", ds_1340 },
        { "ds3231", ds_3231 },
        { "m41t00", m41t00 },
+        { "pt7c4338", ds_1307 },
        { "rx8025", rx_8025 },
        { }
 };
@@ -158,8 +159,8 @@ MODULE_DEVICE_TABLE(i2c, ds1307_id);
 #define BLOCK_DATA_MAX_TRIES 10
-static s32 ds1307_read_block_data_once(struct i2c_client *client, u8 command,
+static s32 ds1307_read_block_data_once(const struct i2c_client *client,
-                                  u8 length, u8 *values)
+                                       u8 command, u8 length, u8 *values)
 {
        s32 i, data;
@@ -172,7 +173,7 @@ static s32 ds1307_read_block_data_once(struct i2c_client *client, u8 command,
        return i;
 }
-static s32 ds1307_read_block_data(struct i2c_client *client, u8 command,
+static s32 ds1307_read_block_data(const struct i2c_client *client, u8 command,
                                  u8 length, u8 *values)
 {
        u8 oldvalues[I2C_SMBUS_BLOCK_MAX];
@@ -198,7 +199,7 @@ static s32 ds1307_read_block_data(struct i2c_client *client, u8 command,
        return length;
 }
-static s32 ds1307_write_block_data(struct i2c_client *client, u8 command,
+static s32 ds1307_write_block_data(const struct i2c_client *client, u8 command,
                                   u8 length, const u8 *values)
 {
        u8 currvalues[I2C_SMBUS_BLOCK_MAX];
@@ -495,50 +496,27 @@ static int ds1337_set_alarm(struct device *dev, struct rtc_wkalrm *t)
        return 0;
 }
-static int ds1307_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int ds1307_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                     ret;
-        switch (cmd) {
+        if (!test_bit(HAS_ALARM, &ds1307->flags))
-        case RTC_AIE_OFF:
+                return -ENOTTY;
-                if (!test_bit(HAS_ALARM, &ds1307->flags))
-                        return -ENOTTY;
-                ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
-                if (ret < 0)
-                        return ret;
-                ret &= ~DS1337_BIT_A1IE;
-                ret = i2c_smbus_write_byte_data(client,
-                                                DS1337_REG_CONTROL, ret);
-                if (ret < 0)
-                        return ret;
-                break;
-        case RTC_AIE_ON:
-                if (!test_bit(HAS_ALARM, &ds1307->flags))
-                        return -ENOTTY;
-                ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
+        ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
-                if (ret < 0)
+        if (ret < 0)
-                        return ret;
+                return ret;
+        if (enabled)
                ret |= DS1337_BIT_A1IE;
+        else
+                ret &= ~DS1337_BIT_A1IE;
-                ret = i2c_smbus_write_byte_data(client,
+        ret = i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, ret);
-                                                DS1337_REG_CONTROL, ret);
+        if (ret < 0)
-                if (ret < 0)
+                return ret;
-                        return ret;
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
        return 0;
 }
@@ -548,7 +526,7 @@ static const struct rtc_class_ops ds13xx_rtc_ops = {
        .set_time       = ds1307_set_time,
        .read_alarm     = ds1337_read_alarm,
        .set_alarm      = ds1337_set_alarm,
-        .ioctl          = ds1307_ioctl,
+        .alarm_irq_enable = ds1307_alarm_irq_enable,
 };
 /*----------------------------------------------------------------------*/
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 1f0007fd4431..e6e71deb188f 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -25,6 +25,7 @@
 #include <linux/bcd.h>
 #include <linux/workqueue.h>
 #include <linux/slab.h>
+#include <linux/pm.h>
 #define DS1374_REG_TOD0         0x00 /* Time of Day */
 #define DS1374_REG_TOD1         0x01
@@ -307,42 +308,25 @@ unlock:
        mutex_unlock(&ds1374->mutex);
 }
-static int ds1374_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
        struct i2c_client *client = to_i2c_client(dev);
        struct ds1374 *ds1374 = i2c_get_clientdata(client);
-        int ret = -ENOIOCTLCMD;
+        int ret;
        mutex_lock(&ds1374->mutex);
-        switch (cmd) {
+        ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
-        case RTC_AIE_OFF:
+        if (ret < 0)
-                ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
+                goto out;
-                if (ret < 0)
-                        goto out;
-                ret &= ~DS1374_REG_CR_WACE;
-                ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
-                if (ret < 0)
-                        goto out;
-                break;
-        case RTC_AIE_ON:
-                ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
-                if (ret < 0)
-                        goto out;
+        if (enabled) {
                ret |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE;
                ret &= ~DS1374_REG_CR_WDALM;
+        } else {
-                ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
+                ret &= ~DS1374_REG_CR_WACE;
-                if (ret < 0)
-                        goto out;
-                break;
        }
+        ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
 out:
        mutex_unlock(&ds1374->mutex);
@@ -354,7 +338,7 @@ static const struct rtc_class_ops ds1374_rtc_ops = {
        .set_time = ds1374_set_time,
        .read_alarm = ds1374_read_alarm,
        .set_alarm = ds1374_set_alarm,
-        .ioctl = ds1374_ioctl,
+        .alarm_irq_enable = ds1374_alarm_irq_enable,
 };
 static int ds1374_probe(struct i2c_client *client,
@@ -417,7 +401,7 @@ static int __devexit ds1374_remove(struct i2c_client *client)
                mutex_unlock(&ds1374->mutex);
                free_irq(client->irq, client);
-                flush_scheduled_work();
+                cancel_work_sync(&ds1374->work);
        }
        rtc_device_unregister(ds1374->rtc);
@@ -426,32 +410,38 @@ static int __devexit ds1374_remove(struct i2c_client *client)
 }
 #ifdef CONFIG_PM
-static int ds1374_suspend(struct i2c_client *client, pm_message_t state)
+static int ds1374_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
        if (client->irq >= 0 && device_may_wakeup(&client->dev))
                enable_irq_wake(client->irq);
        return 0;
 }
-static int ds1374_resume(struct i2c_client *client)
+static int ds1374_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
        if (client->irq >= 0 && device_may_wakeup(&client->dev))
                disable_irq_wake(client->irq);
        return 0;
 }
+static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
+#define DS1374_PM (&ds1374_pm)
 #else
-#define ds1374_suspend  NULL
+#define DS1374_PM NULL
-#define ds1374_resume   NULL
 #endif
 static struct i2c_driver ds1374_driver = {
        .driver = {
                .name = "rtc-ds1374",
                .owner = THIS_MODULE,
+                .pm = DS1374_PM,
        },
        .probe = ds1374_probe,
-        .suspend = ds1374_suspend,
-        .resume = ds1374_resume,
        .remove = __devexit_p(ds1374_remove),
        .id_table = ds1374_id,
 };
diff --git a/drivers/rtc/rtc-ds1390.c b/drivers/rtc/rtc-ds1390.c
index 26a86d235051..b038d2cfef26 100644
--- a/drivers/rtc/rtc-ds1390.c
+++ b/drivers/rtc/rtc-ds1390.c
@@ -158,7 +158,7 @@ static int __devinit ds1390_probe(struct spi_device *spi)
 static int __devexit ds1390_remove(struct spi_device *spi)
 {
-        struct ds1390 *chip = platform_get_drvdata(spi);
+        struct ds1390 *chip = spi_get_drvdata(spi);
        rtc_device_unregister(chip->rtc);
        kfree(chip);
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 37268e97de49..fbabc773dded 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -397,29 +397,12 @@ static int ds1511_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int ds1511_rtc_update_irq_enable(struct device *dev,
-        unsigned int enabled)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        if (pdata->irq <= 0)
-                return -EINVAL;
-        if (enabled)
-                pdata->irqen |= RTC_UF;
-        else
-                pdata->irqen &= ~RTC_UF;
-        ds1511_rtc_update_alarm(pdata);
-        return 0;
-}
 static const struct rtc_class_ops ds1511_rtc_ops = {
        .read_time              = ds1511_rtc_read_time,
        .set_time               = ds1511_rtc_set_time,
        .read_alarm             = ds1511_rtc_read_alarm,
        .set_alarm              = ds1511_rtc_set_alarm,
        .alarm_irq_enable       = ds1511_rtc_alarm_irq_enable,
-        .update_irq_enable      = ds1511_rtc_update_irq_enable,
 };
 static ssize_t
@@ -485,7 +468,7 @@ ds1511_nvram_write(struct file *filp, struct kobject *kobj,
 static struct bin_attribute ds1511_nvram_attr = {
        .attr = {
                .name = "nvram",
-                .mode = S_IRUGO | S_IWUGO,
+                .mode = S_IRUGO | S_IWUSR,
        },
        .size = DS1511_RAM_MAX,
        .read = ds1511_nvram_read,
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index ff432e2ca275..fee41b97c9e8 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -227,29 +227,12 @@ static int ds1553_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int ds1553_rtc_update_irq_enable(struct device *dev,
-        unsigned int enabled)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        if (pdata->irq <= 0)
-                return -EINVAL;
-        if (enabled)
-                pdata->irqen |= RTC_UF;
-        else
-                pdata->irqen &= ~RTC_UF;
-        ds1553_rtc_update_alarm(pdata);
-        return 0;
-}
 static const struct rtc_class_ops ds1553_rtc_ops = {
        .read_time              = ds1553_rtc_read_time,
        .set_time               = ds1553_rtc_set_time,
        .read_alarm             = ds1553_rtc_read_alarm,
        .set_alarm              = ds1553_rtc_set_alarm,
        .alarm_irq_enable       = ds1553_rtc_alarm_irq_enable,
-        .update_irq_enable      = ds1553_rtc_update_irq_enable,
 };
 static ssize_t ds1553_nvram_read(struct file *filp, struct kobject *kobj,
diff --git a/drivers/rtc/rtc-ds3232.c b/drivers/rtc/rtc-ds3232.c
index 9de8516e3531..27b7bf672ac6 100644
--- a/drivers/rtc/rtc-ds3232.c
+++ b/drivers/rtc/rtc-ds3232.c
@@ -1,7 +1,8 @@
 /*
 * RTC client/driver for the Maxim/Dallas DS3232 Real-Time Clock over I2C
 *
- * Copyright (C) 2009-2010 Freescale Semiconductor.
+ * Copyright (C) 2009-2011 Freescale Semiconductor.
+ * Author: Jack Lan <jack.lan@freescale.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
@@ -140,9 +141,11 @@ static int ds3232_read_time(struct device *dev, struct rtc_time *time)
                time->tm_hour = bcd2bin(hour);
        }
-        time->tm_wday = bcd2bin(week);
+        /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
+        time->tm_wday = bcd2bin(week) - 1;
        time->tm_mday = bcd2bin(day);
-        time->tm_mon = bcd2bin(month & 0x7F);
+        /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
+        time->tm_mon = bcd2bin(month & 0x7F) - 1;
        if (century)
                add_century = 100;
@@ -161,9 +164,11 @@ static int ds3232_set_time(struct device *dev, struct rtc_time *time)
        buf[0] = bin2bcd(time->tm_sec);
        buf[1] = bin2bcd(time->tm_min);
        buf[2] = bin2bcd(time->tm_hour);
-        buf[3] = bin2bcd(time->tm_wday); /* Day of the week */
+        /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
+        buf[3] = bin2bcd(time->tm_wday + 1);
        buf[4] = bin2bcd(time->tm_mday); /* Date */
-        buf[5] = bin2bcd(time->tm_mon);
+        /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
+        buf[5] = bin2bcd(time->tm_mon + 1);
        if (time->tm_year >= 100) {
                buf[5] |= 0x80;
                buf[6] = bin2bcd(time->tm_year - 100);
@@ -175,6 +180,165 @@ static int ds3232_set_time(struct device *dev, struct rtc_time *time)
                                              DS3232_REG_SECONDS, 7, buf);
 }
+/*
+ * DS3232 has two alarm, we only use alarm1
+ * According to linux specification, only support one-shot alarm
+ * no periodic alarm mode
+ */
+static int ds3232_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ds3232 *ds3232 = i2c_get_clientdata(client);
+        int control, stat;
+        int ret;
+        u8 buf[4];
+        mutex_lock(&ds3232->mutex);
+        ret = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
+        if (ret < 0)
+                goto out;
+        stat = ret;
+        ret = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
+        if (ret < 0)
+                goto out;
+        control = ret;
+        ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
+        if (ret < 0)
+                goto out;
+        alarm->time.tm_sec = bcd2bin(buf[0] & 0x7F);
+        alarm->time.tm_min = bcd2bin(buf[1] & 0x7F);
+        alarm->time.tm_hour = bcd2bin(buf[2] & 0x7F);
+        alarm->time.tm_mday = bcd2bin(buf[3] & 0x7F);
+        alarm->time.tm_mon = -1;
+        alarm->time.tm_year = -1;
+        alarm->time.tm_wday = -1;
+        alarm->time.tm_yday = -1;
+        alarm->time.tm_isdst = -1;
+        alarm->enabled = !!(control & DS3232_REG_CR_A1IE);
+        alarm->pending = !!(stat & DS3232_REG_SR_A1F);
+        ret = 0;
+out:
+        mutex_unlock(&ds3232->mutex);
+        return ret;
+}
+/*
+ * linux rtc-module does not support wday alarm
+ * and only 24h time mode supported indeed
+ */
+static int ds3232_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ds3232 *ds3232 = i2c_get_clientdata(client);
+        int control, stat;
+        int ret;
+        u8 buf[4];
+        if (client->irq <= 0)
+                return -EINVAL;
+        mutex_lock(&ds3232->mutex);
+        buf[0] = bin2bcd(alarm->time.tm_sec);
+        buf[1] = bin2bcd(alarm->time.tm_min);
+        buf[2] = bin2bcd(alarm->time.tm_hour);
+        buf[3] = bin2bcd(alarm->time.tm_mday);
+        /* clear alarm interrupt enable bit */
+        ret = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
+        if (ret < 0)
+                goto out;
+        control = ret;
+        control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
+        ret = i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
+        if (ret < 0)
+                goto out;
+        /* clear any pending alarm flag */
+        ret = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
+        if (ret < 0)
+                goto out;
+        stat = ret;
+        stat &= ~(DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
+        ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
+        if (ret < 0)
+                goto out;
+        ret = i2c_smbus_write_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
+        if (alarm->enabled) {
+                control |= DS3232_REG_CR_A1IE;
+                ret = i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
+        }
+out:
+        mutex_unlock(&ds3232->mutex);
+        return ret;
+}
+static void ds3232_update_alarm(struct i2c_client *client)
+{
+        struct ds3232 *ds3232 = i2c_get_clientdata(client);
+        int control;
+        int ret;
+        u8 buf[4];
+        mutex_lock(&ds3232->mutex);
+        ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
+        if (ret < 0)
+                goto unlock;
+        buf[0] = bcd2bin(buf[0]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
+                                                                0x80 : buf[0];
+        buf[1] = bcd2bin(buf[1]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
+                                                                0x80 : buf[1];
+        buf[2] = bcd2bin(buf[2]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
+                                                                0x80 : buf[2];
+        buf[3] = bcd2bin(buf[3]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
+                                                                0x80 : buf[3];
+        ret = i2c_smbus_write_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
+        if (ret < 0)
+                goto unlock;
+        control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
+        if (control < 0)
+                goto unlock;
+        if (ds3232->rtc->irq_data & (RTC_AF | RTC_UF))
+                /* enable alarm1 interrupt */
+                control |= DS3232_REG_CR_A1IE;
+        else
+                /* disable alarm1 interrupt */
+                control &= ~(DS3232_REG_CR_A1IE);
+        i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
+unlock:
+        mutex_unlock(&ds3232->mutex);
+}
+static int ds3232_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ds3232 *ds3232 = i2c_get_clientdata(client);
+        if (client->irq <= 0)
+                return -EINVAL;
+        if (enabled)
+                ds3232->rtc->irq_data |= RTC_AF;
+        else
+                ds3232->rtc->irq_data &= ~RTC_AF;
+        ds3232_update_alarm(client);
+        return 0;
+}
 static irqreturn_t ds3232_irq(int irq, void *dev_id)
 {
        struct i2c_client *client = dev_id;
@@ -222,6 +386,9 @@ unlock:
 static const struct rtc_class_ops ds3232_rtc_ops = {
        .read_time = ds3232_read_time,
        .set_time = ds3232_set_time,
+        .read_alarm = ds3232_read_alarm,
+        .set_alarm = ds3232_set_alarm,
+        .alarm_irq_enable = ds3232_alarm_irq_enable,
 };
 static int __devinit ds3232_probe(struct i2c_client *client,
@@ -282,7 +449,7 @@ static int __devexit ds3232_remove(struct i2c_client *client)
                mutex_unlock(&ds3232->mutex);
                free_irq(client->irq, client);
-                flush_scheduled_work();
+                cancel_work_sync(&ds3232->work);
        }
        rtc_device_unregister(ds3232->rtc);
diff --git a/drivers/rtc/rtc-ds3234.c b/drivers/rtc/rtc-ds3234.c
index a774ca35b5f7..bbd26228f532 100644
--- a/drivers/rtc/rtc-ds3234.c
+++ b/drivers/rtc/rtc-ds3234.c
@@ -158,7 +158,7 @@ static int __devinit ds3234_probe(struct spi_device *spi)
 static int __devexit ds3234_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = platform_get_drvdata(spi);
+        struct rtc_device *rtc = spi_get_drvdata(spi);
        rtc_device_unregister(rtc);
        return 0;
diff --git a/drivers/rtc/rtc-em3027.c b/drivers/rtc/rtc-em3027.c
new file mode 100644
index 000000000000..d8e1c2578553
--- /dev/null
+++ b/drivers/rtc/rtc-em3027.c
@@ -0,0 +1,161 @@
+/*
+ * An rtc/i2c driver for the EM Microelectronic EM3027
+ * Copyright 2011 CompuLab, Ltd.
+ *
+ * Author: Mike Rapoport <mike@compulab.co.il>
+ *
+ * Based on rtc-ds1672.c by Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/i2c.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+/* Registers */
+#define EM3027_REG_ON_OFF_CTRL  0x00
+#define EM3027_REG_IRQ_CTRL     0x01
+#define EM3027_REG_IRQ_FLAGS    0x02
+#define EM3027_REG_STATUS       0x03
+#define EM3027_REG_RST_CTRL     0x04
+#define EM3027_REG_WATCH_SEC    0x08
+#define EM3027_REG_WATCH_MIN    0x09
+#define EM3027_REG_WATCH_HOUR   0x0a
+#define EM3027_REG_WATCH_DATE   0x0b
+#define EM3027_REG_WATCH_DAY    0x0c
+#define EM3027_REG_WATCH_MON    0x0d
+#define EM3027_REG_WATCH_YEAR   0x0e
+#define EM3027_REG_ALARM_SEC    0x10
+#define EM3027_REG_ALARM_MIN    0x11
+#define EM3027_REG_ALARM_HOUR   0x12
+#define EM3027_REG_ALARM_DATE   0x13
+#define EM3027_REG_ALARM_DAY    0x14
+#define EM3027_REG_ALARM_MON    0x15
+#define EM3027_REG_ALARM_YEAR   0x16
+static struct i2c_driver em3027_driver;
+static int em3027_get_time(struct device *dev, struct rtc_time *tm)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        unsigned char addr = EM3027_REG_WATCH_SEC;
+        unsigned char buf[7];
+        struct i2c_msg msgs[] = {
+                {client->addr, 0, 1, &addr},            /* setup read addr */
+                {client->addr, I2C_M_RD, 7, buf},       /* read time/date */
+        };
+        /* read time/date registers */
+        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __func__);
+                return -EIO;
+        }
+        tm->tm_sec      = bcd2bin(buf[0]);
+        tm->tm_min      = bcd2bin(buf[1]);
+        tm->tm_hour     = bcd2bin(buf[2]);
+        tm->tm_mday     = bcd2bin(buf[3]);
+        tm->tm_wday     = bcd2bin(buf[4]);
+        tm->tm_mon      = bcd2bin(buf[5]);
+        tm->tm_year     = bcd2bin(buf[6]) + 100;
+        return 0;
+}
+static int em3027_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        unsigned char buf[8];
+        struct i2c_msg msg = {
+                client->addr, 0, 8, buf,        /* write time/date */
+        };
+        buf[0] = EM3027_REG_WATCH_SEC;
+        buf[1] = bin2bcd(tm->tm_sec);
+        buf[2] = bin2bcd(tm->tm_min);
+        buf[3] = bin2bcd(tm->tm_hour);
+        buf[4] = bin2bcd(tm->tm_mday);
+        buf[5] = bin2bcd(tm->tm_wday);
+        buf[6] = bin2bcd(tm->tm_mon);
+        buf[7] = bin2bcd(tm->tm_year % 100);
+        /* write time/date registers */
+        if ((i2c_transfer(client->adapter, &msg, 1)) != 1) {
+                dev_err(&client->dev, "%s: write error\n", __func__);
+                return -EIO;
+        }
+        return 0;
+}
+static const struct rtc_class_ops em3027_rtc_ops = {
+        .read_time = em3027_get_time,
+        .set_time = em3027_set_time,
+};
+static int em3027_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct rtc_device *rtc;
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+                return -ENODEV;
+        rtc = rtc_device_register(em3027_driver.driver.name, &client->dev,
+                                  &em3027_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+        i2c_set_clientdata(client, rtc);
+        return 0;
+}
+static int em3027_remove(struct i2c_client *client)
+{
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+        if (rtc)
+                rtc_device_unregister(rtc);
+        return 0;
+}
+static struct i2c_device_id em3027_id[] = {
+        { "em3027", 0 },
+        { }
+};
+static struct i2c_driver em3027_driver = {
+        .driver = {
+                   .name = "rtc-em3027",
+        },
+        .probe = &em3027_probe,
+        .remove = &em3027_remove,
+        .id_table = em3027_id,
+};
+static int __init em3027_init(void)
+{
+        return i2c_add_driver(&em3027_driver);
+}
+static void __exit em3027_exit(void)
+{
+        i2c_del_driver(&em3027_driver);
+}
+MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
+MODULE_DESCRIPTION("EM Microelectronic EM3027 RTC driver");
+MODULE_LICENSE("GPL");
+module_init(em3027_init);
+module_exit(em3027_exit);
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 11ae64dcbf3c..335551d333b2 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -151,6 +151,7 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
                return -ENXIO;
        pdev->dev.platform_data = ep93xx_rtc;
+        platform_set_drvdata(pdev, rtc);
        rtc = rtc_device_register(pdev->name,
                                &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
@@ -159,8 +160,6 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
                goto exit;
        }
-        platform_set_drvdata(pdev, rtc);
        err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
        if (err)
                goto fail;
@@ -168,9 +167,9 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
        return 0;
 fail:
-        platform_set_drvdata(pdev, NULL);
        rtc_device_unregister(rtc);
 exit:
+        platform_set_drvdata(pdev, NULL);
        pdev->dev.platform_data = NULL;
        return err;
 }
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index 468200c38ecb..da8beb8cae51 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -39,6 +39,8 @@
 #define ISL1208_REG_SR_BAT     (1<<1)   /* battery */
 #define ISL1208_REG_SR_RTCF    (1<<0)   /* rtc fail */
 #define ISL1208_REG_INT 0x08
+#define ISL1208_REG_INT_ALME   (1<<6)   /* alarm enable */
+#define ISL1208_REG_INT_IM     (1<<7)   /* interrupt/alarm mode */
 #define ISL1208_REG_09  0x09    /* reserved */
 #define ISL1208_REG_ATR 0x0a
 #define ISL1208_REG_DTR 0x0b
@@ -202,6 +204,30 @@ isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
 }
 static int
+isl1208_rtc_toggle_alarm(struct i2c_client *client, int enable)
+{
+        int icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
+        if (icr < 0) {
+                dev_err(&client->dev, "%s: reading INT failed\n", __func__);
+                return icr;
+        }
+        if (enable)
+                icr |= ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM;
+        else
+                icr &= ~(ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM);
+        icr = i2c_smbus_write_byte_data(client, ISL1208_REG_INT, icr);
+        if (icr < 0) {
+                dev_err(&client->dev, "%s: writing INT failed\n", __func__);
+                return icr;
+        }
+        return 0;
+}
+static int
 isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
 {
        struct i2c_client *const client = to_i2c_client(dev);
@@ -288,9 +314,8 @@ isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 {
        struct rtc_time *const tm = &alarm->time;
        u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
-        int sr;
+        int icr, yr, sr = isl1208_i2c_get_sr(client);
-        sr = isl1208_i2c_get_sr(client);
        if (sr < 0) {
                dev_err(&client->dev, "%s: reading SR failed\n", __func__);
                return sr;
@@ -313,6 +338,73 @@ isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
                bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
        tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
+        /* The alarm doesn't store the year so get it from the rtc section */
+        yr = i2c_smbus_read_byte_data(client, ISL1208_REG_YR);
+        if (yr < 0) {
+                dev_err(&client->dev, "%s: reading RTC YR failed\n", __func__);
+                return yr;
+        }
+        tm->tm_year = bcd2bin(yr) + 100;
+        icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
+        if (icr < 0) {
+                dev_err(&client->dev, "%s: reading INT failed\n", __func__);
+                return icr;
+        }
+        alarm->enabled = !!(icr & ISL1208_REG_INT_ALME);
+        return 0;
+}
+static int
+isl1208_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
+{
+        struct rtc_time *alarm_tm = &alarm->time;
+        u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
+        const int offs = ISL1208_REG_SCA;
+        unsigned long rtc_secs, alarm_secs;
+        struct rtc_time rtc_tm;
+        int err, enable;
+        err = isl1208_i2c_read_time(client, &rtc_tm);
+        if (err)
+                return err;
+        err = rtc_tm_to_time(&rtc_tm, &rtc_secs);
+        if (err)
+                return err;
+        err = rtc_tm_to_time(alarm_tm, &alarm_secs);
+        if (err)
+                return err;
+        /* If the alarm time is before the current time disable the alarm */
+        if (!alarm->enabled || alarm_secs <= rtc_secs)
+                enable = 0x00;
+        else
+                enable = 0x80;
+        /* Program the alarm and enable it for each setting */
+        regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable;
+        regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable;
+        regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) |
+                ISL1208_REG_HR_MIL | enable;
+        regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable;
+        regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable;
+        regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable;
+        /* write ALARM registers */
+        err = isl1208_i2c_set_regs(client, offs, regs,
+                                  ISL1208_ALARM_SECTION_LEN);
+        if (err < 0) {
+                dev_err(&client->dev, "%s: writing ALARM section failed\n",
+                        __func__);
+                return err;
+        }
+        err = isl1208_rtc_toggle_alarm(client, enable);
+        if (err)
+                return err;
        return 0;
 }
@@ -391,12 +483,63 @@ isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
        return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
 }
+static int
+isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm);
+}
+static irqreturn_t
+isl1208_rtc_interrupt(int irq, void *data)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
+        struct i2c_client *client = data;
+        int handled = 0, sr, err;
+        /*
+         * I2C reads get NAK'ed if we read straight away after an interrupt?
+         * Using a mdelay/msleep didn't seem to help either, so we work around
+         * this by continually trying to read the register for a short time.
+         */
+        while (1) {
+                sr = isl1208_i2c_get_sr(client);
+                if (sr >= 0)
+                        break;
+                if (time_after(jiffies, timeout)) {
+                        dev_err(&client->dev, "%s: reading SR failed\n",
+                                __func__);
+                        return sr;
+                }
+        }
+        if (sr & ISL1208_REG_SR_ALM) {
+                dev_dbg(&client->dev, "alarm!\n");
+                /* Clear the alarm */
+                sr &= ~ISL1208_REG_SR_ALM;
+                sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
+                if (sr < 0)
+                        dev_err(&client->dev, "%s: writing SR failed\n",
+                                __func__);
+                else
+                        handled = 1;
+                /* Disable the alarm */
+                err = isl1208_rtc_toggle_alarm(client, 0);
+                if (err)
+                        return err;
+        }
+        return handled ? IRQ_HANDLED : IRQ_NONE;
+}
 static const struct rtc_class_ops isl1208_rtc_ops = {
        .proc = isl1208_rtc_proc,
        .read_time = isl1208_rtc_read_time,
        .set_time = isl1208_rtc_set_time,
        .read_alarm = isl1208_rtc_read_alarm,
-        /*.set_alarm    = isl1208_rtc_set_alarm, */
+        .set_alarm = isl1208_rtc_set_alarm,
 };
 /* sysfs interface */
@@ -488,11 +631,29 @@ isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
        dev_info(&client->dev,
                 "chip found, driver version " DRV_VERSION "\n");
+        if (client->irq > 0) {
+                rc = request_threaded_irq(client->irq, NULL,
+                                          isl1208_rtc_interrupt,
+                                          IRQF_SHARED,
+                                          isl1208_driver.driver.name, client);
+                if (!rc) {
+                        device_init_wakeup(&client->dev, 1);
+                        enable_irq_wake(client->irq);
+                } else {
+                        dev_err(&client->dev,
+                                "Unable to request irq %d, no alarm support\n",
+                                client->irq);
+                        client->irq = 0;
+                }
+        }
        rtc = rtc_device_register(isl1208_driver.driver.name,
                                  &client->dev, &isl1208_rtc_ops,
                                  THIS_MODULE);
-        if (IS_ERR(rtc))
+        if (IS_ERR(rtc)) {
-                return PTR_ERR(rtc);
+                rc = PTR_ERR(rtc);
+                goto exit_free_irq;
+        }
        i2c_set_clientdata(client, rtc);
@@ -514,6 +675,9 @@ isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
 exit_unregister:
        rtc_device_unregister(rtc);
+exit_free_irq:
+        if (client->irq)
+                free_irq(client->irq, client);
        return rc;
 }
@@ -525,6 +689,8 @@ isl1208_remove(struct i2c_client *client)
        sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
        rtc_device_unregister(rtc);
+        if (client->irq)
+                free_irq(client->irq, client);
        return 0;
 }
diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
index 2619d57b91d7..b6473631d182 100644
--- a/drivers/rtc/rtc-jz4740.c
+++ b/drivers/rtc/rtc-jz4740.c
@@ -1,5 +1,6 @@
 /*
 *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
+ *  Copyright (C) 2010, Paul Cercueil <paul@crapouillou.net>
 *       JZ4740 SoC RTC driver
 *
 *  This program is free software; you can redistribute it and/or modify it
@@ -161,17 +162,12 @@ static int jz4740_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
        ret = jz4740_rtc_reg_write(rtc, JZ_REG_RTC_SEC_ALARM, secs);
        if (!ret)
-                ret = jz4740_rtc_ctrl_set_bits(rtc, JZ_RTC_CTRL_AE, alrm->enabled);
+                ret = jz4740_rtc_ctrl_set_bits(rtc,
+                        JZ_RTC_CTRL_AE | JZ_RTC_CTRL_AF_IRQ, alrm->enabled);
        return ret;
 }
-static int jz4740_rtc_update_irq_enable(struct device *dev, unsigned int enable)
-{
-        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
-        return jz4740_rtc_ctrl_set_bits(rtc, JZ_RTC_CTRL_1HZ_IRQ, enable);
-}
 static int jz4740_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
 {
        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
@@ -183,7 +179,6 @@ static struct rtc_class_ops jz4740_rtc_ops = {
        .set_mmss       = jz4740_rtc_set_mmss,
        .read_alarm     = jz4740_rtc_read_alarm,
        .set_alarm      = jz4740_rtc_set_alarm,
-        .update_irq_enable = jz4740_rtc_update_irq_enable,
        .alarm_irq_enable = jz4740_rtc_alarm_irq_enable,
 };
@@ -258,6 +253,8 @@ static int __devinit jz4740_rtc_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, rtc);
+        device_init_wakeup(&pdev->dev, 1);
        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev, &jz4740_rtc_ops,
                                        THIS_MODULE);
        if (IS_ERR(rtc->rtc)) {
@@ -318,12 +315,43 @@ static int __devexit jz4740_rtc_remove(struct platform_device *pdev)
        return 0;
 }
+#ifdef CONFIG_PM
+static int jz4740_rtc_suspend(struct device *dev)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        if (device_may_wakeup(dev))
+                enable_irq_wake(rtc->irq);
+        return 0;
+}
+static int jz4740_rtc_resume(struct device *dev)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        if (device_may_wakeup(dev))
+                disable_irq_wake(rtc->irq);
+        return 0;
+}
+static const struct dev_pm_ops jz4740_pm_ops = {
+        .suspend = jz4740_rtc_suspend,
+        .resume  = jz4740_rtc_resume,
+};
+#define JZ4740_RTC_PM_OPS (&jz4740_pm_ops)
+#else
+#define JZ4740_RTC_PM_OPS NULL
+#endif  /* CONFIG_PM */
 struct platform_driver jz4740_rtc_driver = {
-        .probe = jz4740_rtc_probe,
+        .probe   = jz4740_rtc_probe,
-        .remove = __devexit_p(jz4740_rtc_remove),
+        .remove  = __devexit_p(jz4740_rtc_remove),
-        .driver = {
+        .driver  = {
-                .name = "jz4740-rtc",
+                .name  = "jz4740-rtc",
                .owner = THIS_MODULE,
+                .pm    = JZ4740_RTC_PM_OPS,
        },
 };
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index 773851f338b8..075f1708deae 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -117,4 +117,32 @@ int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
 }
 EXPORT_SYMBOL(rtc_tm_to_time);
+/*
+ * Convert rtc_time to ktime
+ */
+ktime_t rtc_tm_to_ktime(struct rtc_time tm)
+{
+        time_t time;
+        rtc_tm_to_time(&tm, &time);
+        return ktime_set(time, 0);
+}
+EXPORT_SYMBOL_GPL(rtc_tm_to_ktime);
+/*
+ * Convert ktime to rtc_time
+ */
+struct rtc_time rtc_ktime_to_tm(ktime_t kt)
+{
+        struct timespec ts;
+        struct rtc_time ret;
+        ts = ktime_to_timespec(kt);
+        /* Round up any ns */
+        if (ts.tv_nsec)
+                ts.tv_sec++;
+        rtc_time_to_tm(ts.tv_sec, &ret);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(rtc_ktime_to_tm);
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-lpc32xx.c b/drivers/rtc/rtc-lpc32xx.c
new file mode 100644
index 000000000000..ae16250c762f
--- /dev/null
+++ b/drivers/rtc/rtc-lpc32xx.c
@@ -0,0 +1,414 @@
+/*
+ * Copyright (C) 2010 NXP Semiconductors
+ *
+ * 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.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+/*
+ * Clock and Power control register offsets
+ */
+#define LPC32XX_RTC_UCOUNT              0x00
+#define LPC32XX_RTC_DCOUNT              0x04
+#define LPC32XX_RTC_MATCH0              0x08
+#define LPC32XX_RTC_MATCH1              0x0C
+#define LPC32XX_RTC_CTRL                0x10
+#define LPC32XX_RTC_INTSTAT             0x14
+#define LPC32XX_RTC_KEY                 0x18
+#define LPC32XX_RTC_SRAM                0x80
+#define LPC32XX_RTC_CTRL_MATCH0         (1 << 0)
+#define LPC32XX_RTC_CTRL_MATCH1         (1 << 1)
+#define LPC32XX_RTC_CTRL_ONSW_MATCH0    (1 << 2)
+#define LPC32XX_RTC_CTRL_ONSW_MATCH1    (1 << 3)
+#define LPC32XX_RTC_CTRL_SW_RESET       (1 << 4)
+#define LPC32XX_RTC_CTRL_CNTR_DIS       (1 << 6)
+#define LPC32XX_RTC_CTRL_ONSW_FORCE_HI  (1 << 7)
+#define LPC32XX_RTC_INTSTAT_MATCH0      (1 << 0)
+#define LPC32XX_RTC_INTSTAT_MATCH1      (1 << 1)
+#define LPC32XX_RTC_INTSTAT_ONSW        (1 << 2)
+#define LPC32XX_RTC_KEY_ONSW_LOADVAL    0xB5C13F27
+#define RTC_NAME "rtc-lpc32xx"
+#define rtc_readl(dev, reg) \
+        __raw_readl((dev)->rtc_base + (reg))
+#define rtc_writel(dev, reg, val) \
+        __raw_writel((val), (dev)->rtc_base + (reg))
+struct lpc32xx_rtc {
+        void __iomem *rtc_base;
+        int irq;
+        unsigned char alarm_enabled;
+        struct rtc_device *rtc;
+        spinlock_t lock;
+};
+static int lpc32xx_rtc_read_time(struct device *dev, struct rtc_time *time)
+{
+        unsigned long elapsed_sec;
+        struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
+        elapsed_sec = rtc_readl(rtc, LPC32XX_RTC_UCOUNT);
+        rtc_time_to_tm(elapsed_sec, time);
+        return rtc_valid_tm(time);
+}
+static int lpc32xx_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
+        u32 tmp;
+        spin_lock_irq(&rtc->lock);
+        /* RTC must be disabled during count update */
+        tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
+        rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp | LPC32XX_RTC_CTRL_CNTR_DIS);
+        rtc_writel(rtc, LPC32XX_RTC_UCOUNT, secs);
+        rtc_writel(rtc, LPC32XX_RTC_DCOUNT, 0xFFFFFFFF - secs);
+        rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp &= ~LPC32XX_RTC_CTRL_CNTR_DIS);
+        spin_unlock_irq(&rtc->lock);
+        return 0;
+}
+static int lpc32xx_rtc_read_alarm(struct device *dev,
+        struct rtc_wkalrm *wkalrm)
+{
+        struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
+        rtc_time_to_tm(rtc_readl(rtc, LPC32XX_RTC_MATCH0), &wkalrm->time);
+        wkalrm->enabled = rtc->alarm_enabled;
+        wkalrm->pending = !!(rtc_readl(rtc, LPC32XX_RTC_INTSTAT) &
+                LPC32XX_RTC_INTSTAT_MATCH0);
+        return rtc_valid_tm(&wkalrm->time);
+}
+static int lpc32xx_rtc_set_alarm(struct device *dev,
+        struct rtc_wkalrm *wkalrm)
+{
+        struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
+        unsigned long alarmsecs;
+        u32 tmp;
+        int ret;
+        ret = rtc_tm_to_time(&wkalrm->time, &alarmsecs);
+        if (ret < 0) {
+                dev_warn(dev, "Failed to convert time: %d\n", ret);
+                return ret;
+        }
+        spin_lock_irq(&rtc->lock);
+        /* Disable alarm during update */
+        tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
+        rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp & ~LPC32XX_RTC_CTRL_MATCH0);
+        rtc_writel(rtc, LPC32XX_RTC_MATCH0, alarmsecs);
+        rtc->alarm_enabled = wkalrm->enabled;
+        if (wkalrm->enabled) {
+                rtc_writel(rtc, LPC32XX_RTC_INTSTAT,
+                           LPC32XX_RTC_INTSTAT_MATCH0);
+                rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp |
+                           LPC32XX_RTC_CTRL_MATCH0);
+        }
+        spin_unlock_irq(&rtc->lock);
+        return 0;
+}
+static int lpc32xx_rtc_alarm_irq_enable(struct device *dev,
+        unsigned int enabled)
+{
+        struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
+        u32 tmp;
+        spin_lock_irq(&rtc->lock);
+        tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
+        if (enabled) {
+                rtc->alarm_enabled = 1;
+                tmp |= LPC32XX_RTC_CTRL_MATCH0;
+        } else {
+                rtc->alarm_enabled = 0;
+                tmp &= ~LPC32XX_RTC_CTRL_MATCH0;
+        }
+        rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp);
+        spin_unlock_irq(&rtc->lock);
+        return 0;
+}
+static irqreturn_t lpc32xx_rtc_alarm_interrupt(int irq, void *dev)
+{
+        struct lpc32xx_rtc *rtc = dev;
+        spin_lock(&rtc->lock);
+        /* Disable alarm interrupt */
+        rtc_writel(rtc, LPC32XX_RTC_CTRL,
+                rtc_readl(rtc, LPC32XX_RTC_CTRL) &
+                          ~LPC32XX_RTC_CTRL_MATCH0);
+        rtc->alarm_enabled = 0;
+        /*
+         * Write a large value to the match value so the RTC won't
+         * keep firing the match status
+         */
+        rtc_writel(rtc, LPC32XX_RTC_MATCH0, 0xFFFFFFFF);
+        rtc_writel(rtc, LPC32XX_RTC_INTSTAT, LPC32XX_RTC_INTSTAT_MATCH0);
+        spin_unlock(&rtc->lock);
+        rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
+        return IRQ_HANDLED;
+}
+static const struct rtc_class_ops lpc32xx_rtc_ops = {
+        .read_time              = lpc32xx_rtc_read_time,
+        .set_mmss               = lpc32xx_rtc_set_mmss,
+        .read_alarm             = lpc32xx_rtc_read_alarm,
+        .set_alarm              = lpc32xx_rtc_set_alarm,
+        .alarm_irq_enable       = lpc32xx_rtc_alarm_irq_enable,
+};
+static int __devinit lpc32xx_rtc_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct lpc32xx_rtc *rtc;
+        resource_size_t size;
+        int rtcirq;
+        u32 tmp;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Can't get memory resource\n");
+                return -ENOENT;
+        }
+        rtcirq = platform_get_irq(pdev, 0);
+        if (rtcirq < 0 || rtcirq >= NR_IRQS) {
+                dev_warn(&pdev->dev, "Can't get interrupt resource\n");
+                rtcirq = -1;
+        }
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
+        if (unlikely(!rtc)) {
+                dev_err(&pdev->dev, "Can't allocate memory\n");
+                return -ENOMEM;
+        }
+        rtc->irq = rtcirq;
+        size = resource_size(res);
+        if (!devm_request_mem_region(&pdev->dev, res->start, size,
+                                     pdev->name)) {
+                dev_err(&pdev->dev, "RTC registers are not free\n");
+                return -EBUSY;
+        }
+        rtc->rtc_base = devm_ioremap(&pdev->dev, res->start, size);
+        if (!rtc->rtc_base) {
+                dev_err(&pdev->dev, "Can't map memory\n");
+                return -ENOMEM;
+        }
+        spin_lock_init(&rtc->lock);
+        /*
+         * The RTC is on a separate power domain and can keep it's state
+         * across a chip power cycle. If the RTC has never been previously
+         * setup, then set it up now for the first time.
+         */
+        tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
+        if (rtc_readl(rtc, LPC32XX_RTC_KEY) != LPC32XX_RTC_KEY_ONSW_LOADVAL) {
+                tmp &= ~(LPC32XX_RTC_CTRL_SW_RESET |
+                        LPC32XX_RTC_CTRL_CNTR_DIS |
+                        LPC32XX_RTC_CTRL_MATCH0 |
+                        LPC32XX_RTC_CTRL_MATCH1 |
+                        LPC32XX_RTC_CTRL_ONSW_MATCH0 |
+                        LPC32XX_RTC_CTRL_ONSW_MATCH1 |
+                        LPC32XX_RTC_CTRL_ONSW_FORCE_HI);
+                rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp);
+                /* Clear latched interrupt states */
+                rtc_writel(rtc, LPC32XX_RTC_MATCH0, 0xFFFFFFFF);
+                rtc_writel(rtc, LPC32XX_RTC_INTSTAT,
+                           LPC32XX_RTC_INTSTAT_MATCH0 |
+                           LPC32XX_RTC_INTSTAT_MATCH1 |
+                           LPC32XX_RTC_INTSTAT_ONSW);
+                /* Write key value to RTC so it won't reload on reset */
+                rtc_writel(rtc, LPC32XX_RTC_KEY,
+                           LPC32XX_RTC_KEY_ONSW_LOADVAL);
+        } else {
+                rtc_writel(rtc, LPC32XX_RTC_CTRL,
+                           tmp & ~LPC32XX_RTC_CTRL_MATCH0);
+        }
+        platform_set_drvdata(pdev, rtc);
+        rtc->rtc = rtc_device_register(RTC_NAME, &pdev->dev, &lpc32xx_rtc_ops,
+                THIS_MODULE);
+        if (IS_ERR(rtc->rtc)) {
+                dev_err(&pdev->dev, "Can't get RTC\n");
+                platform_set_drvdata(pdev, NULL);
+                return PTR_ERR(rtc->rtc);
+        }
+        /*
+         * IRQ is enabled after device registration in case alarm IRQ
+         * is pending upon suspend exit.
+         */
+        if (rtc->irq >= 0) {
+                if (devm_request_irq(&pdev->dev, rtc->irq,
+                                     lpc32xx_rtc_alarm_interrupt,
+                                     IRQF_DISABLED, pdev->name, rtc) < 0) {
+                        dev_warn(&pdev->dev, "Can't request interrupt.\n");
+                        rtc->irq = -1;
+                } else {
+                        device_init_wakeup(&pdev->dev, 1);
+                }
+        }
+        return 0;
+}
+static int __devexit lpc32xx_rtc_remove(struct platform_device *pdev)
+{
+        struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
+        if (rtc->irq >= 0)
+                device_init_wakeup(&pdev->dev, 0);
+        platform_set_drvdata(pdev, NULL);
+        rtc_device_unregister(rtc->rtc);
+        return 0;
+}
+#ifdef CONFIG_PM
+static int lpc32xx_rtc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
+        if (rtc->irq >= 0) {
+                if (device_may_wakeup(&pdev->dev))
+                        enable_irq_wake(rtc->irq);
+                else
+                        disable_irq_wake(rtc->irq);
+        }
+        return 0;
+}
+static int lpc32xx_rtc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
+        if (rtc->irq >= 0 && device_may_wakeup(&pdev->dev))
+                disable_irq_wake(rtc->irq);
+        return 0;
+}
+/* Unconditionally disable the alarm */
+static int lpc32xx_rtc_freeze(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
+        spin_lock_irq(&rtc->lock);
+        rtc_writel(rtc, LPC32XX_RTC_CTRL,
+                rtc_readl(rtc, LPC32XX_RTC_CTRL) &
+                          ~LPC32XX_RTC_CTRL_MATCH0);
+        spin_unlock_irq(&rtc->lock);
+        return 0;
+}
+static int lpc32xx_rtc_thaw(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
+        if (rtc->alarm_enabled) {
+                spin_lock_irq(&rtc->lock);
+                rtc_writel(rtc, LPC32XX_RTC_CTRL,
+                           rtc_readl(rtc, LPC32XX_RTC_CTRL) |
+                           LPC32XX_RTC_CTRL_MATCH0);
+                spin_unlock_irq(&rtc->lock);
+        }
+        return 0;
+}
+static const struct dev_pm_ops lpc32xx_rtc_pm_ops = {
+        .suspend = lpc32xx_rtc_suspend,
+        .resume = lpc32xx_rtc_resume,
+        .freeze = lpc32xx_rtc_freeze,
+        .thaw = lpc32xx_rtc_thaw,
+        .restore = lpc32xx_rtc_resume
+};
+#define LPC32XX_RTC_PM_OPS (&lpc32xx_rtc_pm_ops)
+#else
+#define LPC32XX_RTC_PM_OPS NULL
+#endif
+static struct platform_driver lpc32xx_rtc_driver = {
+        .probe          = lpc32xx_rtc_probe,
+        .remove         = __devexit_p(lpc32xx_rtc_remove),
+        .driver = {
+                .name   = RTC_NAME,
+                .owner  = THIS_MODULE,
+                .pm     = LPC32XX_RTC_PM_OPS
+        },
+};
+static int __init lpc32xx_rtc_init(void)
+{
+        return platform_driver_register(&lpc32xx_rtc_driver);
+}
+module_init(lpc32xx_rtc_init);
+static void __exit lpc32xx_rtc_exit(void)
+{
+        platform_driver_unregister(&lpc32xx_rtc_driver);
+}
+module_exit(lpc32xx_rtc_exit);
+MODULE_AUTHOR("Kevin Wells <wellsk40@gmail.com");
+MODULE_DESCRIPTION("RTC driver for the LPC32xx SoC");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:rtc-lpc32xx");
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index d60557cae8ef..eda128fc1d38 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -20,7 +20,7 @@
 #include <linux/module.h>
 #include <linux/rtc.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/string.h>
 #ifdef CONFIG_RTC_DRV_M41T80_WDT
 #include <linux/fs.h>
@@ -68,6 +68,7 @@
 #define DRV_VERSION "0.05"
+static DEFINE_MUTEX(m41t80_rtc_mutex);
 static const struct i2c_device_id m41t80_id[] = {
        { "m41t62", M41T80_FEATURE_SQ | M41T80_FEATURE_SQ_ALT },
        { "m41t65", M41T80_FEATURE_HT | M41T80_FEATURE_WD },
@@ -212,41 +213,27 @@ static int m41t80_rtc_set_time(struct device *dev, struct rtc_time *tm)
        return m41t80_set_datetime(to_i2c_client(dev), tm);
 }
-#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
+static int m41t80_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-static int
-m41t80_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
        struct i2c_client *client = to_i2c_client(dev);
        int rc;
-        switch (cmd) {
-        case RTC_AIE_OFF:
-        case RTC_AIE_ON:
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
        rc = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);
        if (rc < 0)
                goto err;
-        switch (cmd) {
-        case RTC_AIE_OFF:
+        if (enabled)
-                rc &= ~M41T80_ALMON_AFE;
-                break;
-        case RTC_AIE_ON:
                rc |= M41T80_ALMON_AFE;
-                break;
+        else
-        }
+                rc &= ~M41T80_ALMON_AFE;
        if (i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON, rc) < 0)
                goto err;
        return 0;
 err:
        return -EIO;
 }
-#else
-#define m41t80_rtc_ioctl NULL
-#endif
 static int m41t80_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
@@ -373,7 +360,7 @@ static struct rtc_class_ops m41t80_rtc_ops = {
        .read_alarm = m41t80_rtc_read_alarm,
        .set_alarm = m41t80_rtc_set_alarm,
        .proc = m41t80_rtc_proc,
-        .ioctl = m41t80_rtc_ioctl,
+        .alarm_irq_enable = m41t80_rtc_alarm_irq_enable,
 };
 #if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
@@ -677,9 +664,9 @@ static long wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
 {
        int ret;
-        lock_kernel();
+        mutex_lock(&m41t80_rtc_mutex);
        ret = wdt_ioctl(file, cmd, arg);
-        unlock_kernel();
+        mutex_unlock(&m41t80_rtc_mutex);
        return ret;
 }
@@ -693,16 +680,16 @@ static long wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
 static int wdt_open(struct inode *inode, struct file *file)
 {
        if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) {
-                lock_kernel();
+                mutex_lock(&m41t80_rtc_mutex);
                if (test_and_set_bit(0, &wdt_is_open)) {
-                        unlock_kernel();
+                        mutex_unlock(&m41t80_rtc_mutex);
                        return -EBUSY;
                }
                /*
                 *      Activate
                 */
                wdt_is_open = 1;
-                unlock_kernel();
+                mutex_unlock(&m41t80_rtc_mutex);
                return nonseekable_open(inode, file);
        }
        return -ENODEV;
@@ -748,6 +735,7 @@ static const struct file_operations wdt_fops = {
        .write  = wdt_write,
        .open   = wdt_open,
        .release = wdt_release,
+        .llseek = no_llseek,
 };
 static struct miscdevice wdt_dev = {
@@ -795,6 +783,9 @@ static int m41t80_probe(struct i2c_client *client,
                goto exit;
        }
+        clientdata->features = id->driver_data;
+        i2c_set_clientdata(client, clientdata);
        rtc = rtc_device_register(client->name, &client->dev,
                                  &m41t80_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
@@ -804,8 +795,6 @@ static int m41t80_probe(struct i2c_client *client,
        }
        clientdata->rtc = rtc;
-        clientdata->features = id->driver_data;
-        i2c_set_clientdata(client, clientdata);
        /* Make sure HT (Halt Update) bit is cleared */
        rc = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_HOUR);
diff --git a/drivers/rtc/rtc-m41t93.c b/drivers/rtc/rtc-m41t93.c
new file mode 100644
index 000000000000..7317d3b9a3d5
--- /dev/null
+++ b/drivers/rtc/rtc-m41t93.c
@@ -0,0 +1,225 @@
+/*
+ *
+ * Driver for ST M41T93 SPI RTC
+ *
+ * (c) 2010 Nikolaus Voss, Weinmann Medical GmbH
+ *
+ * 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/bcd.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/spi/spi.h>
+#define M41T93_REG_SSEC                 0
+#define M41T93_REG_ST_SEC               1
+#define M41T93_REG_MIN                  2
+#define M41T93_REG_CENT_HOUR            3
+#define M41T93_REG_WDAY                 4
+#define M41T93_REG_DAY                  5
+#define M41T93_REG_MON                  6
+#define M41T93_REG_YEAR                 7
+#define M41T93_REG_ALM_HOUR_HT          0xc
+#define M41T93_REG_FLAGS                0xf
+#define M41T93_FLAG_ST                  (1 << 7)
+#define M41T93_FLAG_OF                  (1 << 2)
+#define M41T93_FLAG_BL                  (1 << 4)
+#define M41T93_FLAG_HT                  (1 << 6)
+static inline int m41t93_set_reg(struct spi_device *spi, u8 addr, u8 data)
+{
+        u8 buf[2];
+        /* MSB must be '1' to write */
+        buf[0] = addr | 0x80;
+        buf[1] = data;
+        return spi_write(spi, buf, sizeof(buf));
+}
+static int m41t93_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        u8 buf[9] = {0x80};        /* write cmd + 8 data bytes */
+        u8 * const data = &buf[1]; /* ptr to first data byte */
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "write", tm->tm_sec, tm->tm_min,
+                tm->tm_hour, tm->tm_mday,
+                tm->tm_mon, tm->tm_year, tm->tm_wday);
+        if (tm->tm_year < 100) {
+                dev_warn(&spi->dev, "unsupported date (before 2000-01-01).\n");
+                return -EINVAL;
+        }
+        data[M41T93_REG_SSEC]           = 0;
+        data[M41T93_REG_ST_SEC]         = bin2bcd(tm->tm_sec);
+        data[M41T93_REG_MIN]            = bin2bcd(tm->tm_min);
+        data[M41T93_REG_CENT_HOUR]      = bin2bcd(tm->tm_hour) |
+                                                ((tm->tm_year/100-1) << 6);
+        data[M41T93_REG_DAY]            = bin2bcd(tm->tm_mday);
+        data[M41T93_REG_WDAY]           = bin2bcd(tm->tm_wday + 1);
+        data[M41T93_REG_MON]            = bin2bcd(tm->tm_mon + 1);
+        data[M41T93_REG_YEAR]           = bin2bcd(tm->tm_year % 100);
+        return spi_write(spi, buf, sizeof(buf));
+}
+static int m41t93_get_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        const u8 start_addr = 0;
+        u8 buf[8];
+        int century_after_1900;
+        int tmp;
+        int ret = 0;
+        /* Check status of clock. Two states must be considered:
+           1. halt bit (HT) is set: the clock is running but update of readout
+              registers has been disabled due to power failure. This is normal
+              case after poweron. Time is valid after resetting HT bit.
+           2. oscillator fail bit (OF) is set. Oscillator has be stopped and
+              time is invalid:
+              a) OF can be immeditely reset.
+              b) OF cannot be immediately reset: oscillator has to be restarted.
+        */
+        tmp = spi_w8r8(spi, M41T93_REG_ALM_HOUR_HT);
+        if (tmp < 0)
+                return tmp;
+        if (tmp & M41T93_FLAG_HT) {
+                dev_dbg(&spi->dev, "HT bit is set, reenable clock update.\n");
+                m41t93_set_reg(spi, M41T93_REG_ALM_HOUR_HT,
+                               tmp & ~M41T93_FLAG_HT);
+        }
+        tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
+        if (tmp < 0)
+                return tmp;
+        if (tmp & M41T93_FLAG_OF) {
+                ret = -EINVAL;
+                dev_warn(&spi->dev, "OF bit is set, resetting.\n");
+                m41t93_set_reg(spi, M41T93_REG_FLAGS, tmp & ~M41T93_FLAG_OF);
+                tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
+                if (tmp < 0)
+                        return tmp;
+                else if (tmp & M41T93_FLAG_OF) {
+                        u8 reset_osc = buf[M41T93_REG_ST_SEC] | M41T93_FLAG_ST;
+                        dev_warn(&spi->dev,
+                                 "OF bit is still set, kickstarting clock.\n");
+                        m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
+                        reset_osc &= ~M41T93_FLAG_ST;
+                        m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
+                }
+        }
+        if (tmp & M41T93_FLAG_BL)
+                dev_warn(&spi->dev, "BL bit is set, replace battery.\n");
+        /* read actual time/date */
+        tmp = spi_write_then_read(spi, &start_addr, 1, buf, sizeof(buf));
+        if (tmp < 0)
+                return tmp;
+        tm->tm_sec      = bcd2bin(buf[M41T93_REG_ST_SEC]);
+        tm->tm_min      = bcd2bin(buf[M41T93_REG_MIN]);
+        tm->tm_hour     = bcd2bin(buf[M41T93_REG_CENT_HOUR] & 0x3f);
+        tm->tm_mday     = bcd2bin(buf[M41T93_REG_DAY]);
+        tm->tm_mon      = bcd2bin(buf[M41T93_REG_MON]) - 1;
+        tm->tm_wday     = bcd2bin(buf[M41T93_REG_WDAY] & 0x0f) - 1;
+        century_after_1900 = (buf[M41T93_REG_CENT_HOUR] >> 6) + 1;
+        tm->tm_year = bcd2bin(buf[M41T93_REG_YEAR]) + century_after_1900 * 100;
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "read", tm->tm_sec, tm->tm_min,
+                tm->tm_hour, tm->tm_mday,
+                tm->tm_mon, tm->tm_year, tm->tm_wday);
+        return ret < 0 ? ret : rtc_valid_tm(tm);
+}
+static const struct rtc_class_ops m41t93_rtc_ops = {
+        .read_time      = m41t93_get_time,
+        .set_time       = m41t93_set_time,
+};
+static struct spi_driver m41t93_driver;
+static int __devinit m41t93_probe(struct spi_device *spi)
+{
+        struct rtc_device *rtc;
+        int res;
+        spi->bits_per_word = 8;
+        spi_setup(spi);
+        res = spi_w8r8(spi, M41T93_REG_WDAY);
+        if (res < 0 || (res & 0xf8) != 0) {
+                dev_err(&spi->dev, "not found 0x%x.\n", res);
+                return -ENODEV;
+        }
+        rtc = rtc_device_register(m41t93_driver.driver.name,
+                &spi->dev, &m41t93_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+        dev_set_drvdata(&spi->dev, rtc);
+        return 0;
+}
+static int __devexit m41t93_remove(struct spi_device *spi)
+{
+        struct rtc_device *rtc = spi_get_drvdata(spi);
+        if (rtc)
+                rtc_device_unregister(rtc);
+        return 0;
+}
+static struct spi_driver m41t93_driver = {
+        .driver = {
+                .name   = "rtc-m41t93",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe  = m41t93_probe,
+        .remove = __devexit_p(m41t93_remove),
+};
+static __init int m41t93_init(void)
+{
+        return spi_register_driver(&m41t93_driver);
+}
+module_init(m41t93_init);
+static __exit void m41t93_exit(void)
+{
+        spi_unregister_driver(&m41t93_driver);
+}
+module_exit(m41t93_exit);
+MODULE_AUTHOR("Nikolaus Voss <n.voss@weinmann.de>");
+MODULE_DESCRIPTION("Driver for ST M41T93 SPI RTC");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:rtc-m41t93");
diff --git a/drivers/rtc/rtc-m41t94.c b/drivers/rtc/rtc-m41t94.c
index c8c97a4169d4..e259ed76ae85 100644
--- a/drivers/rtc/rtc-m41t94.c
+++ b/drivers/rtc/rtc-m41t94.c
@@ -136,7 +136,7 @@ static int __devinit m41t94_probe(struct spi_device *spi)
 static int __devexit m41t94_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = platform_get_drvdata(spi);
+        struct rtc_device *rtc = spi_get_drvdata(spi);
        if (rtc)
                rtc_device_unregister(rtc);
diff --git a/drivers/rtc/rtc-m48t59.c b/drivers/rtc/rtc-m48t59.c
index a99a0b554eb8..3978f4caf724 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -263,30 +263,21 @@ static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 /*
 * Handle commands from user-space
 */
-static int m48t59_rtc_ioctl(struct device *dev, unsigned int cmd,
+static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-                        unsigned long arg)
 {
        struct platform_device *pdev = to_platform_device(dev);
        struct m48t59_plat_data *pdata = pdev->dev.platform_data;
        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
        unsigned long flags;
-        int ret = 0;
        spin_lock_irqsave(&m48t59->lock, flags);
-        switch (cmd) {
+        if (enabled)
-        case RTC_AIE_OFF:       /* alarm interrupt off */
-                M48T59_WRITE(0x00, M48T59_INTR);
-                break;
-        case RTC_AIE_ON:        /* alarm interrupt on */
                M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR);
-                break;
+        else
-        default:
+                M48T59_WRITE(0x00, M48T59_INTR);
-                ret = -ENOIOCTLCMD;
-                break;
-        }
        spin_unlock_irqrestore(&m48t59->lock, flags);
-        return ret;
+        return 0;
 }
 static int m48t59_rtc_proc(struct device *dev, struct seq_file *seq)
@@ -330,12 +321,12 @@ static irqreturn_t m48t59_rtc_interrupt(int irq, void *dev_id)
 }
 static const struct rtc_class_ops m48t59_rtc_ops = {
-        .ioctl          = m48t59_rtc_ioctl,
        .read_time      = m48t59_rtc_read_time,
        .set_time       = m48t59_rtc_set_time,
        .read_alarm     = m48t59_rtc_readalarm,
        .set_alarm      = m48t59_rtc_setalarm,
        .proc           = m48t59_rtc_proc,
+        .alarm_irq_enable = m48t59_rtc_alarm_irq_enable,
 };
 static const struct rtc_class_ops m48t02_rtc_ops = {
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index 657403ebd54a..0ec3f588a255 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -139,12 +139,13 @@ static int __devinit max6902_probe(struct spi_device *spi)
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
+        dev_set_drvdata(&spi->dev, rtc);
        return 0;
 }
 static int __devexit max6902_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = platform_get_drvdata(spi);
+        struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
        rtc_device_unregister(rtc);
        return 0;
diff --git a/drivers/rtc/rtc-max8925.c b/drivers/rtc/rtc-max8925.c
index 174036dda786..3bc046f427e0 100644
--- a/drivers/rtc/rtc-max8925.c
+++ b/drivers/rtc/rtc-max8925.c
@@ -257,6 +257,10 @@ static int __devinit max8925_rtc_probe(struct platform_device *pdev)
                goto out_irq;
        }
+        dev_set_drvdata(&pdev->dev, info);
+        /* XXX - isn't this redundant? */
+        platform_set_drvdata(pdev, info);
        info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
                                        &max8925_rtc_ops, THIS_MODULE);
        ret = PTR_ERR(info->rtc_dev);
@@ -265,11 +269,9 @@ static int __devinit max8925_rtc_probe(struct platform_device *pdev)
                goto out_rtc;
        }
-        dev_set_drvdata(&pdev->dev, info);
-        platform_set_drvdata(pdev, info);
        return 0;
 out_rtc:
+        platform_set_drvdata(pdev, NULL);
        free_irq(chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
 out_irq:
        kfree(info);
diff --git a/drivers/rtc/rtc-max8998.c b/drivers/rtc/rtc-max8998.c
new file mode 100644
index 000000000000..2e48aa604273
--- /dev/null
+++ b/drivers/rtc/rtc-max8998.c
@@ -0,0 +1,345 @@
+/*
+ * RTC driver for Maxim MAX8998
+ *
+ * Copyright (C) 2010 Samsung Electronics Co.Ltd
+ * Author: Minkyu Kang <mk7.kang@samsung.com>
+ * Author: Joonyoung Shim <jy0922.shim@samsung.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/i2c.h>
+#include <linux/slab.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/max8998.h>
+#include <linux/mfd/max8998-private.h>
+#include <linux/delay.h>
+#define MAX8998_RTC_SEC                 0x00
+#define MAX8998_RTC_MIN                 0x01
+#define MAX8998_RTC_HOUR                0x02
+#define MAX8998_RTC_WEEKDAY             0x03
+#define MAX8998_RTC_DATE                0x04
+#define MAX8998_RTC_MONTH               0x05
+#define MAX8998_RTC_YEAR1               0x06
+#define MAX8998_RTC_YEAR2               0x07
+#define MAX8998_ALARM0_SEC              0x08
+#define MAX8998_ALARM0_MIN              0x09
+#define MAX8998_ALARM0_HOUR             0x0a
+#define MAX8998_ALARM0_WEEKDAY          0x0b
+#define MAX8998_ALARM0_DATE             0x0c
+#define MAX8998_ALARM0_MONTH            0x0d
+#define MAX8998_ALARM0_YEAR1            0x0e
+#define MAX8998_ALARM0_YEAR2            0x0f
+#define MAX8998_ALARM1_SEC              0x10
+#define MAX8998_ALARM1_MIN              0x11
+#define MAX8998_ALARM1_HOUR             0x12
+#define MAX8998_ALARM1_WEEKDAY          0x13
+#define MAX8998_ALARM1_DATE             0x14
+#define MAX8998_ALARM1_MONTH            0x15
+#define MAX8998_ALARM1_YEAR1            0x16
+#define MAX8998_ALARM1_YEAR2            0x17
+#define MAX8998_ALARM0_CONF             0x18
+#define MAX8998_ALARM1_CONF             0x19
+#define MAX8998_RTC_STATUS              0x1a
+#define MAX8998_WTSR_SMPL_CNTL          0x1b
+#define MAX8998_TEST                    0x1f
+#define HOUR_12                         (1 << 7)
+#define HOUR_PM                         (1 << 5)
+#define ALARM0_STATUS                   (1 << 1)
+#define ALARM1_STATUS                   (1 << 2)
+enum {
+        RTC_SEC = 0,
+        RTC_MIN,
+        RTC_HOUR,
+        RTC_WEEKDAY,
+        RTC_DATE,
+        RTC_MONTH,
+        RTC_YEAR1,
+        RTC_YEAR2,
+};
+struct max8998_rtc_info {
+        struct device           *dev;
+        struct max8998_dev      *max8998;
+        struct i2c_client       *rtc;
+        struct rtc_device       *rtc_dev;
+        int irq;
+        bool lp3974_bug_workaround;
+};
+static void max8998_data_to_tm(u8 *data, struct rtc_time *tm)
+{
+        tm->tm_sec = bcd2bin(data[RTC_SEC]);
+        tm->tm_min = bcd2bin(data[RTC_MIN]);
+        if (data[RTC_HOUR] & HOUR_12) {
+                tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f);
+                if (data[RTC_HOUR] & HOUR_PM)
+                        tm->tm_hour += 12;
+        } else
+                tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f);
+        tm->tm_wday = data[RTC_WEEKDAY] & 0x07;
+        tm->tm_mday = bcd2bin(data[RTC_DATE]);
+        tm->tm_mon = bcd2bin(data[RTC_MONTH]);
+        tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100;
+        tm->tm_year -= 1900;
+}
+static void max8998_tm_to_data(struct rtc_time *tm, u8 *data)
+{
+        data[RTC_SEC] = bin2bcd(tm->tm_sec);
+        data[RTC_MIN] = bin2bcd(tm->tm_min);
+        data[RTC_HOUR] = bin2bcd(tm->tm_hour);
+        data[RTC_WEEKDAY] = tm->tm_wday;
+        data[RTC_DATE] = bin2bcd(tm->tm_mday);
+        data[RTC_MONTH] = bin2bcd(tm->tm_mon);
+        data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100);
+        data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100);
+}
+static int max8998_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct max8998_rtc_info *info = dev_get_drvdata(dev);
+        u8 data[8];
+        int ret;
+        ret = max8998_bulk_read(info->rtc, MAX8998_RTC_SEC, 8, data);
+        if (ret < 0)
+                return ret;
+        max8998_data_to_tm(data, tm);
+        return rtc_valid_tm(tm);
+}
+static int max8998_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct max8998_rtc_info *info = dev_get_drvdata(dev);
+        u8 data[8];
+        int ret;
+        max8998_tm_to_data(tm, data);
+        ret = max8998_bulk_write(info->rtc, MAX8998_RTC_SEC, 8, data);
+        if (info->lp3974_bug_workaround)
+                msleep(2000);
+        return ret;
+}
+static int max8998_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct max8998_rtc_info *info = dev_get_drvdata(dev);
+        u8 data[8];
+        u8 val;
+        int ret;
+        ret = max8998_bulk_read(info->rtc, MAX8998_ALARM0_SEC, 8, data);
+        if (ret < 0)
+                return ret;
+        max8998_data_to_tm(data, &alrm->time);
+        ret = max8998_read_reg(info->rtc, MAX8998_ALARM0_CONF, &val);
+        if (ret < 0)
+                return ret;
+        alrm->enabled = !!val;
+        ret = max8998_read_reg(info->rtc, MAX8998_RTC_STATUS, &val);
+        if (ret < 0)
+                return ret;
+        if (val & ALARM0_STATUS)
+                alrm->pending = 1;
+        else
+                alrm->pending = 0;
+        return 0;
+}
+static int max8998_rtc_stop_alarm(struct max8998_rtc_info *info)
+{
+        int ret = max8998_write_reg(info->rtc, MAX8998_ALARM0_CONF, 0);
+        if (info->lp3974_bug_workaround)
+                msleep(2000);
+        return ret;
+}
+static int max8998_rtc_start_alarm(struct max8998_rtc_info *info)
+{
+        int ret;
+        u8 alarm0_conf = 0x77;
+        /* LP3974 with delay bug chips has rtc alarm bugs with "MONTH" field */
+        if (info->lp3974_bug_workaround)
+                alarm0_conf = 0x57;
+        ret = max8998_write_reg(info->rtc, MAX8998_ALARM0_CONF, alarm0_conf);
+        if (info->lp3974_bug_workaround)
+                msleep(2000);
+        return ret;
+}
+static int max8998_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct max8998_rtc_info *info = dev_get_drvdata(dev);
+        u8 data[8];
+        int ret;
+        max8998_tm_to_data(&alrm->time, data);
+        ret = max8998_rtc_stop_alarm(info);
+        if (ret < 0)
+                return ret;
+        ret = max8998_bulk_write(info->rtc, MAX8998_ALARM0_SEC, 8, data);
+        if (ret < 0)
+                return ret;
+        if (info->lp3974_bug_workaround)
+                msleep(2000);
+        if (alrm->enabled)
+                ret = max8998_rtc_start_alarm(info);
+        return ret;
+}
+static int max8998_rtc_alarm_irq_enable(struct device *dev,
+                                        unsigned int enabled)
+{
+        struct max8998_rtc_info *info = dev_get_drvdata(dev);
+        if (enabled)
+                return max8998_rtc_start_alarm(info);
+        else
+                return max8998_rtc_stop_alarm(info);
+}
+static irqreturn_t max8998_rtc_alarm_irq(int irq, void *data)
+{
+        struct max8998_rtc_info *info = data;
+        rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
+        return IRQ_HANDLED;
+}
+static const struct rtc_class_ops max8998_rtc_ops = {
+        .read_time = max8998_rtc_read_time,
+        .set_time = max8998_rtc_set_time,
+        .read_alarm = max8998_rtc_read_alarm,
+        .set_alarm = max8998_rtc_set_alarm,
+        .alarm_irq_enable = max8998_rtc_alarm_irq_enable,
+};
+static int __devinit max8998_rtc_probe(struct platform_device *pdev)
+{
+        struct max8998_dev *max8998 = dev_get_drvdata(pdev->dev.parent);
+        struct max8998_platform_data *pdata = dev_get_platdata(max8998->dev);
+        struct max8998_rtc_info *info;
+        int ret;
+        info = kzalloc(sizeof(struct max8998_rtc_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+        info->dev = &pdev->dev;
+        info->max8998 = max8998;
+        info->rtc = max8998->rtc;
+        info->irq = max8998->irq_base + MAX8998_IRQ_ALARM0;
+        platform_set_drvdata(pdev, info);
+        info->rtc_dev = rtc_device_register("max8998-rtc", &pdev->dev,
+                        &max8998_rtc_ops, THIS_MODULE);
+        if (IS_ERR(info->rtc_dev)) {
+                ret = PTR_ERR(info->rtc_dev);
+                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
+                goto out_rtc;
+        }
+        ret = request_threaded_irq(info->irq, NULL, max8998_rtc_alarm_irq, 0,
+                        "rtc-alarm0", info);
+        if (ret < 0)
+                dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
+                        info->irq, ret);
+        dev_info(&pdev->dev, "RTC CHIP NAME: %s\n", pdev->id_entry->name);
+        if (pdata->rtc_delay) {
+                info->lp3974_bug_workaround = true;
+                dev_warn(&pdev->dev, "LP3974 with RTC REGERR option."
+                                " RTC updates will be extremely slow.\n");
+        }
+        return 0;
+out_rtc:
+        platform_set_drvdata(pdev, NULL);
+        kfree(info);
+        return ret;
+}
+static int __devexit max8998_rtc_remove(struct platform_device *pdev)
+{
+        struct max8998_rtc_info *info = platform_get_drvdata(pdev);
+        if (info) {
+                free_irq(info->irq, info);
+                rtc_device_unregister(info->rtc_dev);
+                kfree(info);
+        }
+        return 0;
+}
+static const struct platform_device_id max8998_rtc_id[] = {
+        { "max8998-rtc", TYPE_MAX8998 },
+        { "lp3974-rtc", TYPE_LP3974 },
+        { }
+};
+static struct platform_driver max8998_rtc_driver = {
+        .driver         = {
+                .name   = "max8998-rtc",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = max8998_rtc_probe,
+        .remove         = __devexit_p(max8998_rtc_remove),
+        .id_table       = max8998_rtc_id,
+};
+static int __init max8998_rtc_init(void)
+{
+        return platform_driver_register(&max8998_rtc_driver);
+}
+module_init(max8998_rtc_init);
+static void __exit max8998_rtc_exit(void)
+{
+        platform_driver_unregister(&max8998_rtc_driver);
+}
+module_exit(max8998_rtc_exit);
+MODULE_AUTHOR("Minkyu Kang <mk7.kang@samsung.com>");
+MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
+MODULE_DESCRIPTION("Maxim MAX8998 RTC driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-mc13783.c b/drivers/rtc/rtc-mc13783.c
deleted file mode 100644
index 675bfb515367..000000000000
--- a/drivers/rtc/rtc-mc13783.c
+++ /dev/null
@@ -1,428 +0,0 @@
-/*
- * Real Time Clock driver for Freescale MC13783 PMIC
- *
- * (C) 2009 Sascha Hauer, Pengutronix
- * (C) 2009 Uwe Kleine-Koenig, Pengutronix
- *
- * 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/mfd/mc13783.h>
-#include <linux/platform_device.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/rtc.h>
-#define DRIVER_NAME "mc13783-rtc"
-#define MC13783_RTCTOD  20
-#define MC13783_RTCTODA 21
-#define MC13783_RTCDAY  22
-#define MC13783_RTCDAYA 23
-struct mc13783_rtc {
-        struct rtc_device *rtc;
-        struct mc13783 *mc13783;
-        int valid;
-};
-static int mc13783_rtc_irq_enable_unlocked(struct device *dev,
-                unsigned int enabled, int irq)
-{
-        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        int (*func)(struct mc13783 *mc13783, int irq);
-        if (!priv->valid)
-                return -ENODATA;
-        func = enabled ? mc13783_irq_unmask : mc13783_irq_mask;
-        return func(priv->mc13783, irq);
-}
-static int mc13783_rtc_irq_enable(struct device *dev,
-                unsigned int enabled, int irq)
-{
-        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        int ret;
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_rtc_irq_enable_unlocked(dev, enabled, irq);
-        mc13783_unlock(priv->mc13783);
-        return ret;
-}
-static int mc13783_rtc_read_time(struct device *dev, struct rtc_time *tm)
-{
-        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        unsigned int seconds, days1, days2;
-        unsigned long s1970;
-        int ret;
-        mc13783_lock(priv->mc13783);
-        if (!priv->valid) {
-                ret = -ENODATA;
-                goto out;
-        }
-        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days1);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTOD, &seconds);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days2);
-out:
-        mc13783_unlock(priv->mc13783);
-        if (ret)
-                return ret;
-        if (days2 == days1 + 1) {
-                if (seconds >= 86400 / 2)
-                        days2 = days1;
-                else
-                        days1 = days2;
-        }
-        if (days1 != days2)
-                return -EIO;
-        s1970 = days1 * 86400 + seconds;
-        rtc_time_to_tm(s1970, tm);
-        return rtc_valid_tm(tm);
-}
-static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
-{
-        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        unsigned int seconds, days;
-        unsigned int alarmseconds;
-        int ret;
-        seconds = secs % 86400;
-        days = secs / 86400;
-        mc13783_lock(priv->mc13783);
-        /*
-         * temporarily invalidate alarm to prevent triggering it when the day is
-         * already updated while the time isn't yet.
-         */
-        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &alarmseconds);
-        if (unlikely(ret))
-                goto out;
-        if (alarmseconds < 86400) {
-                ret = mc13783_reg_write(priv->mc13783,
-                                MC13783_RTCTODA, 0x1ffff);
-                if (unlikely(ret))
-                        goto out;
-        }
-        /*
-         * write seconds=0 to prevent a day switch between writing days
-         * and seconds below
-         */
-        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, 0);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAY, days);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, seconds);
-        if (unlikely(ret))
-                goto out;
-        /* restore alarm */
-        if (alarmseconds < 86400) {
-                ret = mc13783_reg_write(priv->mc13783,
-                                MC13783_RTCTODA, alarmseconds);
-                if (unlikely(ret))
-                        goto out;
-        }
-        ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_RTCRST);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_irq_unmask(priv->mc13783, MC13783_IRQ_RTCRST);
-out:
-        priv->valid = !ret;
-        mc13783_unlock(priv->mc13783);
-        return ret;
-}
-static int mc13783_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
-{
-        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        unsigned seconds, days;
-        unsigned long s1970;
-        int enabled, pending;
-        int ret;
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &seconds);
-        if (unlikely(ret))
-                goto out;
-        if (seconds >= 86400) {
-                ret = -ENODATA;
-                goto out;
-        }
-        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_irq_status(priv->mc13783, MC13783_IRQ_TODA,
-                        &enabled, &pending);
-out:
-        mc13783_unlock(priv->mc13783);
-        if (ret)
-                return ret;
-        alarm->enabled = enabled;
-        alarm->pending = pending;
-        s1970 = days * 86400 + seconds;
-        rtc_time_to_tm(s1970, &alarm->time);
-        dev_dbg(dev, "%s: %lu\n", __func__, s1970);
-        return 0;
-}
-static int mc13783_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
-{
-        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        unsigned long s1970;
-        unsigned seconds, days;
-        int ret;
-        mc13783_lock(priv->mc13783);
-        /* disable alarm to prevent false triggering */
-        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, 0x1ffff);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_TODA);
-        if (unlikely(ret))
-                goto out;
-        ret = rtc_tm_to_time(&alarm->time, &s1970);
-        if (unlikely(ret))
-                goto out;
-        dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
-                        s1970);
-        ret = mc13783_rtc_irq_enable_unlocked(dev, alarm->enabled,
-                        MC13783_IRQ_TODA);
-        if (unlikely(ret))
-                goto out;
-        seconds = s1970 % 86400;
-        days = s1970 / 86400;
-        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAYA, days);
-        if (unlikely(ret))
-                goto out;
-        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, seconds);
-out:
-        mc13783_unlock(priv->mc13783);
-        return ret;
-}
-static irqreturn_t mc13783_rtc_alarm_handler(int irq, void *dev)
-{
-        struct mc13783_rtc *priv = dev;
-        struct mc13783 *mc13783 = priv->mc13783;
-        dev_dbg(&priv->rtc->dev, "Alarm\n");
-        rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
-        mc13783_irq_ack(mc13783, irq);
-        return IRQ_HANDLED;
-}
-static irqreturn_t mc13783_rtc_update_handler(int irq, void *dev)
-{
-        struct mc13783_rtc *priv = dev;
-        struct mc13783 *mc13783 = priv->mc13783;
-        dev_dbg(&priv->rtc->dev, "1HZ\n");
-        rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF);
-        mc13783_irq_ack(mc13783, irq);
-        return IRQ_HANDLED;
-}
-static int mc13783_rtc_update_irq_enable(struct device *dev,
-                unsigned int enabled)
-{
-        return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_1HZ);
-}
-static int mc13783_rtc_alarm_irq_enable(struct device *dev,
-                unsigned int enabled)
-{
-        return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_TODA);
-}
-static const struct rtc_class_ops mc13783_rtc_ops = {
-        .read_time = mc13783_rtc_read_time,
-        .set_mmss = mc13783_rtc_set_mmss,
-        .read_alarm = mc13783_rtc_read_alarm,
-        .set_alarm = mc13783_rtc_set_alarm,
-        .alarm_irq_enable = mc13783_rtc_alarm_irq_enable,
-        .update_irq_enable = mc13783_rtc_update_irq_enable,
-};
-static irqreturn_t mc13783_rtc_reset_handler(int irq, void *dev)
-{
-        struct mc13783_rtc *priv = dev;
-        struct mc13783 *mc13783 = priv->mc13783;
-        dev_dbg(&priv->rtc->dev, "RTCRST\n");
-        priv->valid = 0;
-        mc13783_irq_mask(mc13783, irq);
-        return IRQ_HANDLED;
-}
-static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
-{
-        int ret;
-        struct mc13783_rtc *priv;
-        struct mc13783 *mc13783;
-        int rtcrst_pending;
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-        mc13783 = dev_get_drvdata(pdev->dev.parent);
-        priv->mc13783 = mc13783;
-        platform_set_drvdata(pdev, priv);
-        mc13783_lock(mc13783);
-        ret = mc13783_irq_request(mc13783, MC13783_IRQ_RTCRST,
-                        mc13783_rtc_reset_handler, DRIVER_NAME, priv);
-        if (ret)
-                goto err_reset_irq_request;
-        ret = mc13783_irq_status(mc13783, MC13783_IRQ_RTCRST,
-                        NULL, &rtcrst_pending);
-        if (ret)
-                goto err_reset_irq_status;
-        priv->valid = !rtcrst_pending;
-        ret = mc13783_irq_request_nounmask(mc13783, MC13783_IRQ_1HZ,
-                        mc13783_rtc_update_handler, DRIVER_NAME, priv);
-        if (ret)
-                goto err_update_irq_request;
-        ret = mc13783_irq_request_nounmask(mc13783, MC13783_IRQ_TODA,
-                        mc13783_rtc_alarm_handler, DRIVER_NAME, priv);
-        if (ret)
-                goto err_alarm_irq_request;
-        priv->rtc = rtc_device_register(pdev->name,
-                        &pdev->dev, &mc13783_rtc_ops, THIS_MODULE);
-        if (IS_ERR(priv->rtc)) {
-                ret = PTR_ERR(priv->rtc);
-                mc13783_irq_free(mc13783, MC13783_IRQ_TODA, priv);
-err_alarm_irq_request:
-                mc13783_irq_free(mc13783, MC13783_IRQ_1HZ, priv);
-err_update_irq_request:
-err_reset_irq_status:
-                mc13783_irq_free(mc13783, MC13783_IRQ_RTCRST, priv);
-err_reset_irq_request:
-                platform_set_drvdata(pdev, NULL);
-                kfree(priv);
-        }
-        mc13783_unlock(mc13783);
-        return ret;
-}
-static int __devexit mc13783_rtc_remove(struct platform_device *pdev)
-{
-        struct mc13783_rtc *priv = platform_get_drvdata(pdev);
-        mc13783_lock(priv->mc13783);
-        rtc_device_unregister(priv->rtc);
-        mc13783_irq_free(priv->mc13783, MC13783_IRQ_TODA, priv);
-        mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv);
-        mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv);
-        mc13783_unlock(priv->mc13783);
-        platform_set_drvdata(pdev, NULL);
-        kfree(priv);
-        return 0;
-}
-static struct platform_driver mc13783_rtc_driver = {
-        .remove = __devexit_p(mc13783_rtc_remove),
-        .driver = {
-                .name = DRIVER_NAME,
-                .owner = THIS_MODULE,
-        },
-};
-static int __init mc13783_rtc_init(void)
-{
-        return platform_driver_probe(&mc13783_rtc_driver, &mc13783_rtc_probe);
-}
-module_init(mc13783_rtc_init);
-static void __exit mc13783_rtc_exit(void)
-{
-        platform_driver_unregister(&mc13783_rtc_driver);
-}
-module_exit(mc13783_rtc_exit);
-MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
-MODULE_DESCRIPTION("RTC driver for Freescale MC13783 PMIC");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/rtc/rtc-mc13xxx.c b/drivers/rtc/rtc-mc13xxx.c
new file mode 100644
index 000000000000..a1a278bc340d
--- /dev/null
+++ b/drivers/rtc/rtc-mc13xxx.c
@@ -0,0 +1,435 @@
+/*
+ * Real Time Clock driver for Freescale MC13XXX PMIC
+ *
+ * (C) 2009 Sascha Hauer, Pengutronix
+ * (C) 2009 Uwe Kleine-Koenig, Pengutronix
+ *
+ * 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/mfd/mc13xxx.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/rtc.h>
+#define DRIVER_NAME "mc13xxx-rtc"
+#define MC13XXX_RTCTOD  20
+#define MC13XXX_RTCTODA 21
+#define MC13XXX_RTCDAY  22
+#define MC13XXX_RTCDAYA 23
+struct mc13xxx_rtc {
+        struct rtc_device *rtc;
+        struct mc13xxx *mc13xxx;
+        int valid;
+};
+static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev,
+                unsigned int enabled, int irq)
+{
+        struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
+        int (*func)(struct mc13xxx *mc13xxx, int irq);
+        if (!priv->valid)
+                return -ENODATA;
+        func = enabled ? mc13xxx_irq_unmask : mc13xxx_irq_mask;
+        return func(priv->mc13xxx, irq);
+}
+static int mc13xxx_rtc_irq_enable(struct device *dev,
+                unsigned int enabled, int irq)
+{
+        struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
+        int ret;
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, irq);
+        mc13xxx_unlock(priv->mc13xxx);
+        return ret;
+}
+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 (ret)
+                return ret;
+        if (days2 == days1 + 1) {
+                if (seconds >= 86400 / 2)
+                        days2 = days1;
+                else
+                        days1 = days2;
+        }
+        if (days1 != days2)
+                return -EIO;
+        s1970 = days1 * 86400 + seconds;
+        rtc_time_to_tm(s1970, tm);
+        return rtc_valid_tm(tm);
+}
+static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
+        unsigned int seconds, days;
+        unsigned int alarmseconds;
+        int ret;
+        seconds = secs % 86400;
+        days = secs / 86400;
+        mc13xxx_lock(priv->mc13xxx);
+        /*
+         * temporarily invalidate alarm to prevent triggering it when the day is
+         * already updated while the time isn't yet.
+         */
+        ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds);
+        if (unlikely(ret))
+                goto out;
+        if (alarmseconds < 86400) {
+                ret = mc13xxx_reg_write(priv->mc13xxx,
+                                MC13XXX_RTCTODA, 0x1ffff);
+                if (unlikely(ret))
+                        goto out;
+        }
+        /*
+         * write seconds=0 to prevent a day switch between writing days
+         * and seconds below
+         */
+        ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0);
+        if (unlikely(ret))
+                goto out;
+        ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days);
+        if (unlikely(ret))
+                goto out;
+        ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds);
+        if (unlikely(ret))
+                goto out;
+        /* restore alarm */
+        if (alarmseconds < 86400) {
+                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;
+        ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
+out:
+        priv->valid = !ret;
+        mc13xxx_unlock(priv->mc13xxx);
+        return ret;
+}
+static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
+        unsigned seconds, days;
+        unsigned long s1970;
+        int enabled, pending;
+        int ret;
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
+        if (unlikely(ret))
+                goto out;
+        if (seconds >= 86400) {
+                ret = -ENODATA;
+                goto out;
+        }
+        ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
+        if (unlikely(ret))
+                goto out;
+        ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
+                        &enabled, &pending);
+out:
+        mc13xxx_unlock(priv->mc13xxx);
+        if (ret)
+                return ret;
+        alarm->enabled = enabled;
+        alarm->pending = pending;
+        s1970 = days * 86400 + seconds;
+        rtc_time_to_tm(s1970, &alarm->time);
+        dev_dbg(dev, "%s: %lu\n", __func__, s1970);
+        return 0;
+}
+static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
+        unsigned long s1970;
+        unsigned seconds, days;
+        int ret;
+        mc13xxx_lock(priv->mc13xxx);
+        /* disable alarm to prevent false triggering */
+        ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
+        if (unlikely(ret))
+                goto out;
+        ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA);
+        if (unlikely(ret))
+                goto out;
+        ret = rtc_tm_to_time(&alarm->time, &s1970);
+        if (unlikely(ret))
+                goto out;
+        dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
+                        s1970);
+        ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
+                        MC13XXX_IRQ_TODA);
+        if (unlikely(ret))
+                goto out;
+        seconds = s1970 % 86400;
+        days = s1970 / 86400;
+        ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
+        if (unlikely(ret))
+                goto out;
+        ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);
+out:
+        mc13xxx_unlock(priv->mc13xxx);
+        return ret;
+}
+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);
+        return IRQ_HANDLED;
+}
+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);
+        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,
+        .read_alarm = mc13xxx_rtc_read_alarm,
+        .set_alarm = mc13xxx_rtc_set_alarm,
+        .alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
+};
+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);
+        return IRQ_HANDLED;
+}
+static int __devinit mc13xxx_rtc_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct mc13xxx_rtc *priv;
+        struct mc13xxx *mc13xxx;
+        int rtcrst_pending;
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+        mc13xxx = dev_get_drvdata(pdev->dev.parent);
+        priv->mc13xxx = mc13xxx;
+        platform_set_drvdata(pdev, priv);
+        mc13xxx_lock(mc13xxx);
+        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;
+        ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_1HZ,
+                        mc13xxx_rtc_update_handler, DRIVER_NAME, priv);
+        if (ret)
+                goto err_update_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;
+        mc13xxx_unlock(mc13xxx);
+        priv->rtc = rtc_device_register(pdev->name,
+                        &pdev->dev, &mc13xxx_rtc_ops, THIS_MODULE);
+        if (IS_ERR(priv->rtc)) {
+                ret = PTR_ERR(priv->rtc);
+                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:
+                mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
+err_reset_irq_request:
+                mc13xxx_unlock(mc13xxx);
+                platform_set_drvdata(pdev, NULL);
+                kfree(priv);
+        }
+        return ret;
+}
+static int __devexit mc13xxx_rtc_remove(struct platform_device *pdev)
+{
+        struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
+        mc13xxx_lock(priv->mc13xxx);
+        rtc_device_unregister(priv->rtc);
+        mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
+        mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_1HZ, priv);
+        mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
+        mc13xxx_unlock(priv->mc13xxx);
+        platform_set_drvdata(pdev, NULL);
+        kfree(priv);
+        return 0;
+}
+const struct platform_device_id mc13xxx_rtc_idtable[] = {
+        {
+                .name = "mc13783-rtc",
+        }, {
+                .name = "mc13892-rtc",
+        },
+        { }
+};
+static struct platform_driver mc13xxx_rtc_driver = {
+        .id_table = mc13xxx_rtc_idtable,
+        .remove = __devexit_p(mc13xxx_rtc_remove),
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+};
+static int __init mc13xxx_rtc_init(void)
+{
+        return platform_driver_probe(&mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
+}
+module_init(mc13xxx_rtc_init);
+static void __exit mc13xxx_rtc_exit(void)
+{
+        platform_driver_unregister(&mc13xxx_rtc_driver);
+}
+module_exit(mc13xxx_rtc_exit);
+MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
+MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/rtc/rtc-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
index dfcdf0901d21..09ccd8d3ba2a 100644
--- a/drivers/rtc/rtc-mpc5121.c
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -240,36 +240,15 @@ static int mpc5121_rtc_alarm_irq_enable(struct device *dev,
        return 0;
 }
-static int mpc5121_rtc_update_irq_enable(struct device *dev,
-                                         unsigned int enabled)
-{
-        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
-        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
-        int val;
-        val = in_8(&regs->int_enable);
-        if (enabled)
-                val = (val & ~0x8) | 0x1;
-        else
-                val &= ~0x1;
-        out_8(&regs->int_enable, val);
-        return 0;
-}
 static const struct rtc_class_ops mpc5121_rtc_ops = {
        .read_time = mpc5121_rtc_read_time,
        .set_time = mpc5121_rtc_set_time,
        .read_alarm = mpc5121_rtc_read_alarm,
        .set_alarm = mpc5121_rtc_set_alarm,
        .alarm_irq_enable = mpc5121_rtc_alarm_irq_enable,
-        .update_irq_enable = mpc5121_rtc_update_irq_enable,
 };
-static int __devinit mpc5121_rtc_probe(struct platform_device *op,
+static int __devinit mpc5121_rtc_probe(struct platform_device *op)
-                                        const struct of_device_id *match)
 {
        struct mpc5121_rtc_data *rtc;
        int err = 0;
@@ -364,7 +343,7 @@ static struct of_device_id mpc5121_rtc_match[] __devinitdata = {
        {},
 };
-static struct of_platform_driver mpc5121_rtc_driver = {
+static struct platform_driver mpc5121_rtc_driver = {
        .driver = {
                .name = "mpc5121-rtc",
                .owner = THIS_MODULE,
@@ -376,13 +355,13 @@ static struct of_platform_driver mpc5121_rtc_driver = {
 static int __init mpc5121_rtc_init(void)
 {
-        return of_register_platform_driver(&mpc5121_rtc_driver);
+        return platform_driver_register(&mpc5121_rtc_driver);
 }
 module_init(mpc5121_rtc_init);
 static void __exit mpc5121_rtc_exit(void)
 {
-        of_unregister_platform_driver(&mpc5121_rtc_driver);
+        platform_driver_unregister(&mpc5121_rtc_driver);
 }
 module_exit(mpc5121_rtc_exit);
diff --git a/drivers/rtc/rtc-mrst.c b/drivers/rtc/rtc-mrst.c
new file mode 100644
index 000000000000..0cec5650d56a
--- /dev/null
+++ b/drivers/rtc/rtc-mrst.c
@@ -0,0 +1,553 @@
+/*
+ * rtc-mrst.c: Driver for Moorestown virtual RTC
+ *
+ * (C) Copyright 2009 Intel Corporation
+ * Author: Jacob Pan (jacob.jun.pan@intel.com)
+ *         Feng Tang (feng.tang@intel.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; version 2
+ * of the License.
+ *
+ * Note:
+ * VRTC is emulated by system controller firmware, the real HW
+ * RTC is located in the PMIC device. SCU FW shadows PMIC RTC
+ * in a memory mapped IO space that is visible to the host IA
+ * processor.
+ *
+ * This driver is based upon drivers/rtc/rtc-cmos.c
+ */
+/*
+ * Note:
+ *  * vRTC only supports binary mode and 24H mode
+ *  * vRTC only support PIE and AIE, no UIE, and its PIE only happens
+ *    at 23:59:59pm everyday, no support for adjustable frequency
+ *  * Alarm function is also limited to hr/min/sec.
+ */
+#include <linux/mod_devicetable.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sfi.h>
+#include <asm-generic/rtc.h>
+#include <asm/intel_scu_ipc.h>
+#include <asm/mrst.h>
+#include <asm/mrst-vrtc.h>
+struct mrst_rtc {
+        struct rtc_device       *rtc;
+        struct device           *dev;
+        int                     irq;
+        struct resource         *iomem;
+        u8                      enabled_wake;
+        u8                      suspend_ctrl;
+};
+static const char driver_name[] = "rtc_mrst";
+#define RTC_IRQMASK     (RTC_PF | RTC_AF)
+static inline int is_intr(u8 rtc_intr)
+{
+        if (!(rtc_intr & RTC_IRQF))
+                return 0;
+        return rtc_intr & RTC_IRQMASK;
+}
+static inline unsigned char vrtc_is_updating(void)
+{
+        unsigned char uip;
+        unsigned long flags;
+        spin_lock_irqsave(&rtc_lock, flags);
+        uip = (vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP);
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        return uip;
+}
+/*
+ * rtc_time's year contains the increment over 1900, but vRTC's YEAR
+ * register can't be programmed to value larger than 0x64, so vRTC
+ * driver chose to use 1960 (1970 is UNIX time start point) as the base,
+ * and does the translation at read/write time.
+ *
+ * Why not just use 1970 as the offset? it's because using 1960 will
+ * make it consistent in leap year setting for both vrtc and low-level
+ * physical rtc devices.
+ */
+static int mrst_read_time(struct device *dev, struct rtc_time *time)
+{
+        unsigned long flags;
+        if (vrtc_is_updating())
+                mdelay(20);
+        spin_lock_irqsave(&rtc_lock, flags);
+        time->tm_sec = vrtc_cmos_read(RTC_SECONDS);
+        time->tm_min = vrtc_cmos_read(RTC_MINUTES);
+        time->tm_hour = vrtc_cmos_read(RTC_HOURS);
+        time->tm_mday = vrtc_cmos_read(RTC_DAY_OF_MONTH);
+        time->tm_mon = vrtc_cmos_read(RTC_MONTH);
+        time->tm_year = vrtc_cmos_read(RTC_YEAR);
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        /* Adjust for the 1960/1900 */
+        time->tm_year += 60;
+        time->tm_mon--;
+        return RTC_24H;
+}
+static int mrst_set_time(struct device *dev, struct rtc_time *time)
+{
+        int ret;
+        unsigned long flags;
+        unsigned char mon, day, hrs, min, sec;
+        unsigned int yrs;
+        yrs = time->tm_year;
+        mon = time->tm_mon + 1;   /* tm_mon starts at zero */
+        day = time->tm_mday;
+        hrs = time->tm_hour;
+        min = time->tm_min;
+        sec = time->tm_sec;
+        if (yrs < 70 || yrs > 138)
+                return -EINVAL;
+        yrs -= 60;
+        spin_lock_irqsave(&rtc_lock, flags);
+        vrtc_cmos_write(yrs, RTC_YEAR);
+        vrtc_cmos_write(mon, RTC_MONTH);
+        vrtc_cmos_write(day, RTC_DAY_OF_MONTH);
+        vrtc_cmos_write(hrs, RTC_HOURS);
+        vrtc_cmos_write(min, RTC_MINUTES);
+        vrtc_cmos_write(sec, RTC_SECONDS);
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETTIME);
+        return ret;
+}
+static int mrst_read_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        unsigned char rtc_control;
+        if (mrst->irq <= 0)
+                return -EIO;
+        /* Basic alarms only support hour, minute, and seconds fields.
+         * Some also support day and month, for alarms up to a year in
+         * the future.
+         */
+        t->time.tm_mday = -1;
+        t->time.tm_mon = -1;
+        t->time.tm_year = -1;
+        /* vRTC only supports binary mode */
+        spin_lock_irq(&rtc_lock);
+        t->time.tm_sec = vrtc_cmos_read(RTC_SECONDS_ALARM);
+        t->time.tm_min = vrtc_cmos_read(RTC_MINUTES_ALARM);
+        t->time.tm_hour = vrtc_cmos_read(RTC_HOURS_ALARM);
+        rtc_control = vrtc_cmos_read(RTC_CONTROL);
+        spin_unlock_irq(&rtc_lock);
+        t->enabled = !!(rtc_control & RTC_AIE);
+        t->pending = 0;
+        return 0;
+}
+static void mrst_checkintr(struct mrst_rtc *mrst, unsigned char rtc_control)
+{
+        unsigned char   rtc_intr;
+        /*
+         * NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
+         * allegedly some older rtcs need that to handle irqs properly
+         */
+        rtc_intr = vrtc_cmos_read(RTC_INTR_FLAGS);
+        rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
+        if (is_intr(rtc_intr))
+                rtc_update_irq(mrst->rtc, 1, rtc_intr);
+}
+static void mrst_irq_enable(struct mrst_rtc *mrst, unsigned char mask)
+{
+        unsigned char   rtc_control;
+        /*
+         * Flush any pending IRQ status, notably for update irqs,
+         * before we enable new IRQs
+         */
+        rtc_control = vrtc_cmos_read(RTC_CONTROL);
+        mrst_checkintr(mrst, rtc_control);
+        rtc_control |= mask;
+        vrtc_cmos_write(rtc_control, RTC_CONTROL);
+        mrst_checkintr(mrst, rtc_control);
+}
+static void mrst_irq_disable(struct mrst_rtc *mrst, unsigned char mask)
+{
+        unsigned char   rtc_control;
+        rtc_control = vrtc_cmos_read(RTC_CONTROL);
+        rtc_control &= ~mask;
+        vrtc_cmos_write(rtc_control, RTC_CONTROL);
+        mrst_checkintr(mrst, rtc_control);
+}
+static int mrst_set_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        unsigned char hrs, min, sec;
+        int ret = 0;
+        if (!mrst->irq)
+                return -EIO;
+        hrs = t->time.tm_hour;
+        min = t->time.tm_min;
+        sec = t->time.tm_sec;
+        spin_lock_irq(&rtc_lock);
+        /* Next rtc irq must not be from previous alarm setting */
+        mrst_irq_disable(mrst, RTC_AIE);
+        /* Update alarm */
+        vrtc_cmos_write(hrs, RTC_HOURS_ALARM);
+        vrtc_cmos_write(min, RTC_MINUTES_ALARM);
+        vrtc_cmos_write(sec, RTC_SECONDS_ALARM);
+        spin_unlock_irq(&rtc_lock);
+        ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETALARM);
+        if (ret)
+                return ret;
+        spin_lock_irq(&rtc_lock);
+        if (t->enabled)
+                mrst_irq_enable(mrst, RTC_AIE);
+        spin_unlock_irq(&rtc_lock);
+        return 0;
+}
+/* Currently, the vRTC doesn't support UIE ON/OFF */
+static int mrst_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        unsigned long   flags;
+        spin_lock_irqsave(&rtc_lock, flags);
+        if (enabled)
+                mrst_irq_enable(mrst, RTC_AIE);
+        else
+                mrst_irq_disable(mrst, RTC_AIE);
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        return 0;
+}
+#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
+static int mrst_procfs(struct device *dev, struct seq_file *seq)
+{
+        unsigned char   rtc_control, valid;
+        spin_lock_irq(&rtc_lock);
+        rtc_control = vrtc_cmos_read(RTC_CONTROL);
+        valid = vrtc_cmos_read(RTC_VALID);
+        spin_unlock_irq(&rtc_lock);
+        return seq_printf(seq,
+                        "periodic_IRQ\t: %s\n"
+                        "alarm\t\t: %s\n"
+                        "BCD\t\t: no\n"
+                        "periodic_freq\t: daily (not adjustable)\n",
+                        (rtc_control & RTC_PIE) ? "on" : "off",
+                        (rtc_control & RTC_AIE) ? "on" : "off");
+}
+#else
+#define mrst_procfs     NULL
+#endif
+static const struct rtc_class_ops mrst_rtc_ops = {
+        .read_time      = mrst_read_time,
+        .set_time       = mrst_set_time,
+        .read_alarm     = mrst_read_alarm,
+        .set_alarm      = mrst_set_alarm,
+        .proc           = mrst_procfs,
+        .alarm_irq_enable = mrst_rtc_alarm_irq_enable,
+};
+static struct mrst_rtc  mrst_rtc;
+/*
+ * When vRTC IRQ is captured by SCU FW, FW will clear the AIE bit in
+ * Reg B, so no need for this driver to clear it
+ */
+static irqreturn_t mrst_rtc_irq(int irq, void *p)
+{
+        u8 irqstat;
+        spin_lock(&rtc_lock);
+        /* This read will clear all IRQ flags inside Reg C */
+        irqstat = vrtc_cmos_read(RTC_INTR_FLAGS);
+        spin_unlock(&rtc_lock);
+        irqstat &= RTC_IRQMASK | RTC_IRQF;
+        if (is_intr(irqstat)) {
+                rtc_update_irq(p, 1, irqstat);
+                return IRQ_HANDLED;
+        }
+        return IRQ_NONE;
+}
+static int __devinit
+vrtc_mrst_do_probe(struct device *dev, struct resource *iomem, int rtc_irq)
+{
+        int retval = 0;
+        unsigned char rtc_control;
+        /* There can be only one ... */
+        if (mrst_rtc.dev)
+                return -EBUSY;
+        if (!iomem)
+                return -ENODEV;
+        iomem = request_mem_region(iomem->start,
+                        iomem->end + 1 - iomem->start,
+                        driver_name);
+        if (!iomem) {
+                dev_dbg(dev, "i/o mem already in use.\n");
+                return -EBUSY;
+        }
+        mrst_rtc.irq = rtc_irq;
+        mrst_rtc.iomem = iomem;
+        mrst_rtc.dev = dev;
+        dev_set_drvdata(dev, &mrst_rtc);
+        mrst_rtc.rtc = rtc_device_register(driver_name, dev,
+                                &mrst_rtc_ops, THIS_MODULE);
+        if (IS_ERR(mrst_rtc.rtc)) {
+                retval = PTR_ERR(mrst_rtc.rtc);
+                goto cleanup0;
+        }
+        rename_region(iomem, dev_name(&mrst_rtc.rtc->dev));
+        spin_lock_irq(&rtc_lock);
+        mrst_irq_disable(&mrst_rtc, RTC_PIE | RTC_AIE);
+        rtc_control = vrtc_cmos_read(RTC_CONTROL);
+        spin_unlock_irq(&rtc_lock);
+        if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY)))
+                dev_dbg(dev, "TODO: support more than 24-hr BCD mode\n");
+        if (rtc_irq) {
+                retval = request_irq(rtc_irq, mrst_rtc_irq,
+                                IRQF_DISABLED, dev_name(&mrst_rtc.rtc->dev),
+                                mrst_rtc.rtc);
+                if (retval < 0) {
+                        dev_dbg(dev, "IRQ %d is already in use, err %d\n",
+                                rtc_irq, retval);
+                        goto cleanup1;
+                }
+        }
+        dev_dbg(dev, "initialised\n");
+        return 0;
+cleanup1:
+        rtc_device_unregister(mrst_rtc.rtc);
+cleanup0:
+        dev_set_drvdata(dev, NULL);
+        mrst_rtc.dev = NULL;
+        release_mem_region(iomem->start, resource_size(iomem));
+        dev_err(dev, "rtc-mrst: unable to initialise\n");
+        return retval;
+}
+static void rtc_mrst_do_shutdown(void)
+{
+        spin_lock_irq(&rtc_lock);
+        mrst_irq_disable(&mrst_rtc, RTC_IRQMASK);
+        spin_unlock_irq(&rtc_lock);
+}
+static void __devexit rtc_mrst_do_remove(struct device *dev)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        struct resource *iomem;
+        rtc_mrst_do_shutdown();
+        if (mrst->irq)
+                free_irq(mrst->irq, mrst->rtc);
+        rtc_device_unregister(mrst->rtc);
+        mrst->rtc = NULL;
+        iomem = mrst->iomem;
+        release_mem_region(iomem->start, resource_size(iomem));
+        mrst->iomem = NULL;
+        mrst->dev = NULL;
+        dev_set_drvdata(dev, NULL);
+}
+#ifdef  CONFIG_PM
+static int mrst_suspend(struct device *dev, pm_message_t mesg)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        unsigned char   tmp;
+        /* Only the alarm might be a wakeup event source */
+        spin_lock_irq(&rtc_lock);
+        mrst->suspend_ctrl = tmp = vrtc_cmos_read(RTC_CONTROL);
+        if (tmp & (RTC_PIE | RTC_AIE)) {
+                unsigned char   mask;
+                if (device_may_wakeup(dev))
+                        mask = RTC_IRQMASK & ~RTC_AIE;
+                else
+                        mask = RTC_IRQMASK;
+                tmp &= ~mask;
+                vrtc_cmos_write(tmp, RTC_CONTROL);
+                mrst_checkintr(mrst, tmp);
+        }
+        spin_unlock_irq(&rtc_lock);
+        if (tmp & RTC_AIE) {
+                mrst->enabled_wake = 1;
+                enable_irq_wake(mrst->irq);
+        }
+        dev_dbg(&mrst_rtc.rtc->dev, "suspend%s, ctrl %02x\n",
+                        (tmp & RTC_AIE) ? ", alarm may wake" : "",
+                        tmp);
+        return 0;
+}
+/*
+ * We want RTC alarms to wake us from the deep power saving state
+ */
+static inline int mrst_poweroff(struct device *dev)
+{
+        return mrst_suspend(dev, PMSG_HIBERNATE);
+}
+static int mrst_resume(struct device *dev)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        unsigned char tmp = mrst->suspend_ctrl;
+        /* Re-enable any irqs previously active */
+        if (tmp & RTC_IRQMASK) {
+                unsigned char   mask;
+                if (mrst->enabled_wake) {
+                        disable_irq_wake(mrst->irq);
+                        mrst->enabled_wake = 0;
+                }
+                spin_lock_irq(&rtc_lock);
+                do {
+                        vrtc_cmos_write(tmp, RTC_CONTROL);
+                        mask = vrtc_cmos_read(RTC_INTR_FLAGS);
+                        mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
+                        if (!is_intr(mask))
+                                break;
+                        rtc_update_irq(mrst->rtc, 1, mask);
+                        tmp &= ~RTC_AIE;
+                } while (mask & RTC_AIE);
+                spin_unlock_irq(&rtc_lock);
+        }
+        dev_dbg(&mrst_rtc.rtc->dev, "resume, ctrl %02x\n", tmp);
+        return 0;
+}
+#else
+#define mrst_suspend    NULL
+#define mrst_resume     NULL
+static inline int mrst_poweroff(struct device *dev)
+{
+        return -ENOSYS;
+}
+#endif
+static int __devinit vrtc_mrst_platform_probe(struct platform_device *pdev)
+{
+        return vrtc_mrst_do_probe(&pdev->dev,
+                        platform_get_resource(pdev, IORESOURCE_MEM, 0),
+                        platform_get_irq(pdev, 0));
+}
+static int __devexit vrtc_mrst_platform_remove(struct platform_device *pdev)
+{
+        rtc_mrst_do_remove(&pdev->dev);
+        return 0;
+}
+static void vrtc_mrst_platform_shutdown(struct platform_device *pdev)
+{
+        if (system_state == SYSTEM_POWER_OFF && !mrst_poweroff(&pdev->dev))
+                return;
+        rtc_mrst_do_shutdown();
+}
+MODULE_ALIAS("platform:vrtc_mrst");
+static struct platform_driver vrtc_mrst_platform_driver = {
+        .probe          = vrtc_mrst_platform_probe,
+        .remove         = __devexit_p(vrtc_mrst_platform_remove),
+        .shutdown       = vrtc_mrst_platform_shutdown,
+        .driver = {
+                .name           = (char *) driver_name,
+                .suspend        = mrst_suspend,
+                .resume         = mrst_resume,
+        }
+};
+static int __init vrtc_mrst_init(void)
+{
+        return platform_driver_register(&vrtc_mrst_platform_driver);
+}
+static void __exit vrtc_mrst_exit(void)
+{
+        platform_driver_unregister(&vrtc_mrst_platform_driver);
+}
+module_init(vrtc_mrst_init);
+module_exit(vrtc_mrst_exit);
+MODULE_AUTHOR("Jacob Pan; Feng Tang");
+MODULE_DESCRIPTION("Driver for Moorestown virtual RTC");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-msm6242.c b/drivers/rtc/rtc-msm6242.c
index b2fff0ca49f8..fcb113c11122 100644
--- a/drivers/rtc/rtc-msm6242.c
+++ b/drivers/rtc/rtc-msm6242.c
@@ -82,7 +82,7 @@ static inline unsigned int msm6242_read(struct msm6242_priv *priv,
 static inline void msm6242_write(struct msm6242_priv *priv, unsigned int val,
                                unsigned int reg)
 {
-        return __raw_writel(val, &priv->regs[reg]);
+        __raw_writel(val, &priv->regs[reg]);
 }
 static inline void msm6242_set(struct msm6242_priv *priv, unsigned int val,
@@ -214,6 +214,7 @@ static int __init msm6242_rtc_probe(struct platform_device *dev)
                error = -ENOMEM;
                goto out_free_priv;
        }
+        platform_set_drvdata(dev, priv);
        rtc = rtc_device_register("rtc-msm6242", &dev->dev, &msm6242_rtc_ops,
                                  THIS_MODULE);
@@ -223,10 +224,10 @@ static int __init msm6242_rtc_probe(struct platform_device *dev)
        }
        priv->rtc = rtc;
-        platform_set_drvdata(dev, priv);
        return 0;
 out_unmap:
+        platform_set_drvdata(dev, NULL);
        iounmap(priv->regs);
 out_free_priv:
        kfree(priv);
diff --git a/drivers/rtc/rtc-mv.c b/drivers/rtc/rtc-mv.c
index bcca47298554..60627a764514 100644
--- a/drivers/rtc/rtc-mv.c
+++ b/drivers/rtc/rtc-mv.c
@@ -169,25 +169,19 @@ static int mv_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
        return 0;
 }
-static int mv_rtc_ioctl(struct device *dev, unsigned int cmd,
+static int mv_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-                        unsigned long arg)
 {
        struct platform_device *pdev = to_platform_device(dev);
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        void __iomem *ioaddr = pdata->ioaddr;
        if (pdata->irq < 0)
-                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
+                return -EINVAL; /* fall back into rtc-dev's emulation */
-        switch (cmd) {
-        case RTC_AIE_OFF:
+        if (enabled)
-                writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
-                break;
-        case RTC_AIE_ON:
                writel(1, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
-                break;
+        else
-        default:
+                writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
-                return -ENOIOCTLCMD;
-        }
        return 0;
 }
@@ -216,7 +210,7 @@ static const struct rtc_class_ops mv_rtc_alarm_ops = {
        .set_time       = mv_rtc_set_time,
        .read_alarm     = mv_rtc_read_alarm,
        .set_alarm      = mv_rtc_set_alarm,
-        .ioctl          = mv_rtc_ioctl,
+        .alarm_irq_enable = mv_rtc_alarm_irq_enable,
 };
 static int __devinit mv_rtc_probe(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 0b06c1e03fd5..39e41fbdf08b 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -55,12 +55,6 @@ static const u32 PIE_BIT_DEF[MAX_PIE_NUM][2] = {
        { MAX_PIE_FREQ, RTC_SAM7_BIT },
 };
-/* Those are the bits from a classic RTC we want to mimic */
-#define RTC_IRQF        0x80    /* any of the following 3 is active */
-#define RTC_PF          0x40    /* Periodic interrupt */
-#define RTC_AF          0x20    /* Alarm interrupt */
-#define RTC_UF          0x10    /* Update interrupt for 1Hz RTC */
 #define MXC_RTC_TIME    0
 #define MXC_RTC_ALARM   1
@@ -274,12 +268,6 @@ static int mxc_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int mxc_rtc_update_irq_enable(struct device *dev, unsigned int enabled)
-{
-        mxc_rtc_irq_enable(dev, RTC_1HZ_BIT, enabled);
-        return 0;
-}
 /*
 * This function reads the current RTC time into tm in Gregorian date.
 */
@@ -368,7 +356,6 @@ static struct rtc_class_ops mxc_rtc_ops = {
        .read_alarm             = mxc_rtc_read_alarm,
        .set_alarm              = mxc_rtc_set_alarm,
        .alarm_irq_enable       = mxc_rtc_alarm_irq_enable,
-        .update_irq_enable      = mxc_rtc_update_irq_enable,
 };
 static int __init mxc_rtc_probe(struct platform_device *pdev)
@@ -425,14 +412,6 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
                goto exit_put_clk;
        }
-        rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
-                                  THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                goto exit_put_clk;
-        }
-        pdata->rtc = rtc;
        platform_set_drvdata(pdev, pdata);
        /* Configure and enable the RTC */
@@ -445,8 +424,19 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
                pdata->irq = -1;
        }
+        rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto exit_clr_drvdata;
+        }
+        pdata->rtc = rtc;
        return 0;
+exit_clr_drvdata:
+        platform_set_drvdata(pdev, NULL);
 exit_put_clk:
        clk_disable(pdata->clk);
        clk_put(pdata->clk);
diff --git a/drivers/rtc/rtc-nuc900.c b/drivers/rtc/rtc-nuc900.c
index 62de66af0a68..781068d62f23 100644
--- a/drivers/rtc/rtc-nuc900.c
+++ b/drivers/rtc/rtc-nuc900.c
@@ -134,20 +134,6 @@ static void nuc900_rtc_bin2bcd(struct device *dev, struct rtc_time *settm,
        gettm->bcd_hour = bin2bcd(settm->tm_hour) << 16;
 }
-static int nuc900_update_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
-        if (enabled)
-                __raw_writel(__raw_readl(rtc->rtc_reg + REG_RTC_RIER)|
-                                (TICKINTENB), rtc->rtc_reg + REG_RTC_RIER);
-        else
-                __raw_writel(__raw_readl(rtc->rtc_reg + REG_RTC_RIER)&
-                                (~TICKINTENB), rtc->rtc_reg + REG_RTC_RIER);
-        return 0;
-}
 static int nuc900_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
@@ -234,7 +220,6 @@ static struct rtc_class_ops nuc900_rtc_ops = {
        .read_alarm = nuc900_rtc_read_alarm,
        .set_alarm = nuc900_rtc_set_alarm,
        .alarm_irq_enable = nuc900_alarm_irq_enable,
-        .update_irq_enable = nuc900_update_irq_enable,
 };
 static int __devinit nuc900_rtc_probe(struct platform_device *pdev)
@@ -274,7 +259,7 @@ static int __devinit nuc900_rtc_probe(struct platform_device *pdev)
        nuc900_rtc->rtcdev = rtc_device_register(pdev->name, &pdev->dev,
                                                &nuc900_rtc_ops, THIS_MODULE);
        if (IS_ERR(nuc900_rtc->rtcdev)) {
-                dev_err(&pdev->dev, "rtc device register faild\n");
+                dev_err(&pdev->dev, "rtc device register failed\n");
                err = PTR_ERR(nuc900_rtc->rtcdev);
                goto fail3;
        }
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 64d9727b7229..bcae8dd41496 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -34,7 +34,8 @@
 * Board-specific wiring options include using split power mode with
 * RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
 * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
- * low power modes).  See the BOARD-SPECIFIC CUSTOMIZATION comment.
+ * low power modes) for OMAP1 boards (OMAP-L138 has this built into
+ * the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.
 */
 #define OMAP_RTC_BASE                   0xfffb4800
@@ -134,42 +135,17 @@ static irqreturn_t rtc_irq(int irq, void *rtc)
        return IRQ_HANDLED;
 }
-#ifdef  CONFIG_RTC_INTF_DEV
+static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-static int
-omap_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
        u8 reg;
-        switch (cmd) {
-        case RTC_AIE_OFF:
-        case RTC_AIE_ON:
-        case RTC_UIE_OFF:
-        case RTC_UIE_ON:
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
        local_irq_disable();
        rtc_wait_not_busy();
        reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
-        switch (cmd) {
+        if (enabled)
-        /* AIE = Alarm Interrupt Enable */
-        case RTC_AIE_OFF:
-                reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
-                break;
-        case RTC_AIE_ON:
                reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
-                break;
+        else
-        /* UIE = Update Interrupt Enable (1/second) */
+                reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
-        case RTC_UIE_OFF:
-                reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER;
-                break;
-        case RTC_UIE_ON:
-                reg |= OMAP_RTC_INTERRUPTS_IT_TIMER;
-                break;
-        }
        rtc_wait_not_busy();
        rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
        local_irq_enable();
@@ -177,10 +153,6 @@ omap_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
        return 0;
 }
-#else
-#define omap_rtc_ioctl  NULL
-#endif
 /* this hardware doesn't support "don't care" alarm fields */
 static int tm2bcd(struct rtc_time *tm)
 {
@@ -303,11 +275,11 @@ static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 }
 static struct rtc_class_ops omap_rtc_ops = {
-        .ioctl          = omap_rtc_ioctl,
        .read_time      = omap_rtc_read_time,
        .set_time       = omap_rtc_set_time,
        .read_alarm     = omap_rtc_read_alarm,
        .set_alarm      = omap_rtc_set_alarm,
+        .alarm_irq_enable = omap_rtc_alarm_irq_enable,
 };
 static int omap_rtc_alarm;
@@ -401,16 +373,17 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
        /* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
         *
-         *  - Boards wired so that RTC_WAKE_INT does something, and muxed
+         *  - Device wake-up capability setting should come through chip
-         *    right (W13_1610_RTC_WAKE_INT is the default after chip reset),
+         *    init logic. OMAP1 boards should initialize the "wakeup capable"
-         *    should initialize the device wakeup flag appropriately.
+         *    flag in the platform device if the board is wired right for
+         *    being woken up by RTC alarm. For OMAP-L138, this capability
+         *    is built into the SoC by the "Deep Sleep" capability.
         *
         *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
         *    rather than nPWRON_RESET, should forcibly enable split
         *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
         *    is write-only, and always reads as zero...)
         */
-        device_init_wakeup(&pdev->dev, 0);
        if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
                pr_info("%s: split power mode\n", pdev->name);
@@ -421,19 +394,20 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
        return 0;
 fail2:
-        free_irq(omap_rtc_timer, NULL);
+        free_irq(omap_rtc_timer, rtc);
 fail1:
        rtc_device_unregister(rtc);
 fail0:
        iounmap(rtc_base);
 fail:
-        release_resource(mem);
+        release_mem_region(mem->start, resource_size(mem));
        return -EIO;
 }
 static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device       *rtc = platform_get_drvdata(pdev);
+        struct resource         *mem = dev_get_drvdata(&rtc->dev);
        device_init_wakeup(&pdev->dev, 0);
@@ -445,8 +419,9 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
        if (omap_rtc_timer != omap_rtc_alarm)
                free_irq(omap_rtc_alarm, rtc);
-        release_resource(dev_get_drvdata(&rtc->dev));
        rtc_device_unregister(rtc);
+        iounmap(rtc_base);
+        release_mem_region(mem->start, resource_size(mem));
        return 0;
 }
diff --git a/drivers/rtc/rtc-pcap.c b/drivers/rtc/rtc-pcap.c
index 25c0b3fd44f1..cd4f198cc2ef 100644
--- a/drivers/rtc/rtc-pcap.c
+++ b/drivers/rtc/rtc-pcap.c
@@ -131,18 +131,12 @@ static int pcap_rtc_alarm_irq_enable(struct device *dev, unsigned int en)
        return pcap_rtc_irq_enable(dev, PCAP_IRQ_TODA, en);
 }
-static int pcap_rtc_update_irq_enable(struct device *dev, unsigned int en)
-{
-        return pcap_rtc_irq_enable(dev, PCAP_IRQ_1HZ, en);
-}
 static const struct rtc_class_ops pcap_rtc_ops = {
        .read_time = pcap_rtc_read_time,
        .read_alarm = pcap_rtc_read_alarm,
        .set_alarm = pcap_rtc_set_alarm,
        .set_mmss = pcap_rtc_set_mmss,
        .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
-        .update_irq_enable = pcap_rtc_update_irq_enable,
 };
 static int __devinit pcap_rtc_probe(struct platform_device *pdev)
@@ -157,6 +151,8 @@ static int __devinit pcap_rtc_probe(struct platform_device *pdev)
        pcap_rtc->pcap = dev_get_drvdata(pdev->dev.parent);
+        platform_set_drvdata(pdev, pcap_rtc);
        pcap_rtc->rtc = rtc_device_register("pcap", &pdev->dev,
                                  &pcap_rtc_ops, THIS_MODULE);
        if (IS_ERR(pcap_rtc->rtc)) {
@@ -164,7 +160,6 @@ static int __devinit pcap_rtc_probe(struct platform_device *pdev)
                goto fail_rtc;
        }
-        platform_set_drvdata(pdev, pcap_rtc);
        timer_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ);
        alarm_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA);
@@ -183,6 +178,7 @@ fail_alarm:
 fail_timer:
        rtc_device_unregister(pcap_rtc->rtc);
 fail_rtc:
+        platform_set_drvdata(pdev, NULL);
        kfree(pcap_rtc);
        return err;
 }
diff --git a/drivers/rtc/rtc-pcf50633.c b/drivers/rtc/rtc-pcf50633.c
index 16edf94ab42f..0c423892923c 100644
--- a/drivers/rtc/rtc-pcf50633.c
+++ b/drivers/rtc/rtc-pcf50633.c
@@ -58,7 +58,6 @@ struct pcf50633_time {
 struct pcf50633_rtc {
        int alarm_enabled;
-        int second_enabled;
        int alarm_pending;
        struct pcf50633 *pcf;
@@ -106,25 +105,6 @@ pcf50633_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int
-pcf50633_rtc_update_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct pcf50633_rtc *rtc = dev_get_drvdata(dev);
-        int err;
-        if (enabled)
-                err = pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_SECOND);
-        else
-                err = pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_SECOND);
-        if (err < 0)
-                return err;
-        rtc->second_enabled = enabled;
-        return 0;
-}
 static int pcf50633_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
        struct pcf50633_rtc *rtc;
@@ -162,7 +142,7 @@ static int pcf50633_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
        struct pcf50633_rtc *rtc;
        struct pcf50633_time pcf_tm;
-        int second_masked, alarm_masked, ret = 0;
+        int alarm_masked, ret = 0;
        rtc = dev_get_drvdata(dev);
@@ -181,11 +161,8 @@ static int pcf50633_rtc_set_time(struct device *dev, struct rtc_time *tm)
                pcf_tm.time[PCF50633_TI_SEC]);
-        second_masked = pcf50633_irq_mask_get(rtc->pcf, PCF50633_IRQ_SECOND);
        alarm_masked = pcf50633_irq_mask_get(rtc->pcf, PCF50633_IRQ_ALARM);
-        if (!second_masked)
-                pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_SECOND);
        if (!alarm_masked)
                pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_ALARM);
@@ -194,8 +171,6 @@ static int pcf50633_rtc_set_time(struct device *dev, struct rtc_time *tm)
                                             PCF50633_TI_EXTENT,
                                             &pcf_tm.time[0]);
-        if (!second_masked)
-                pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_SECOND);
        if (!alarm_masked)
                pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_ALARM);
@@ -262,23 +237,15 @@ static struct rtc_class_ops pcf50633_rtc_ops = {
        .set_time               = pcf50633_rtc_set_time,
        .read_alarm             = pcf50633_rtc_read_alarm,
        .set_alarm              = pcf50633_rtc_set_alarm,
-        .alarm_irq_enable       = pcf50633_rtc_alarm_irq_enable,
+        .alarm_irq_enable       = pcf50633_rtc_alarm_irq_enable,
-        .update_irq_enable      = pcf50633_rtc_update_irq_enable,
 };
 static void pcf50633_rtc_irq(int irq, void *data)
 {
        struct pcf50633_rtc *rtc = data;
-        switch (irq) {
+        rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
-        case PCF50633_IRQ_ALARM:
+        rtc->alarm_pending = 1;
-                rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
-                rtc->alarm_pending = 1;
-                break;
-        case PCF50633_IRQ_SECOND:
-                rtc_update_irq(rtc->rtc_dev, 1, RTC_UF | RTC_IRQF);
-                break;
-        }
 }
 static int __devinit pcf50633_rtc_probe(struct platform_device *pdev)
@@ -302,9 +269,6 @@ static int __devinit pcf50633_rtc_probe(struct platform_device *pdev)
        pcf50633_register_irq(rtc->pcf, PCF50633_IRQ_ALARM,
                                        pcf50633_rtc_irq, rtc);
-        pcf50633_register_irq(rtc->pcf, PCF50633_IRQ_SECOND,
-                                        pcf50633_rtc_irq, rtc);
        return 0;
 }
@@ -315,7 +279,6 @@ static int __devexit pcf50633_rtc_remove(struct platform_device *pdev)
        rtc = platform_get_drvdata(pdev);
        pcf50633_free_irq(rtc->pcf, PCF50633_IRQ_ALARM);
-        pcf50633_free_irq(rtc->pcf, PCF50633_IRQ_SECOND);
        rtc_device_unregister(rtc->rtc_dev);
        kfree(rtc);
diff --git a/drivers/rtc/rtc-pl030.c b/drivers/rtc/rtc-pl030.c
index bbdb2f02798a..1d28d4451dae 100644
--- a/drivers/rtc/rtc-pl030.c
+++ b/drivers/rtc/rtc-pl030.c
@@ -35,11 +35,6 @@ static irqreturn_t pl030_interrupt(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
-static int pl030_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
-{
-        return -ENOIOCTLCMD;
-}
 static int pl030_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
        struct pl030_rtc *rtc = dev_get_drvdata(dev);
@@ -96,14 +91,13 @@ static int pl030_set_time(struct device *dev, struct rtc_time *tm)
 }
 static const struct rtc_class_ops pl030_ops = {
-        .ioctl          = pl030_ioctl,
        .read_time      = pl030_read_time,
        .set_time       = pl030_set_time,
        .read_alarm     = pl030_read_alarm,
        .set_alarm      = pl030_set_alarm,
 };
-static int pl030_probe(struct amba_device *dev, struct amba_id *id)
+static int pl030_probe(struct amba_device *dev, const struct amba_id *id)
 {
        struct pl030_rtc *rtc;
        int ret;
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index b7a6690e5b35..ff1b84bd9bb5 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -293,57 +293,6 @@ static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
        return ret;
 }
-/* Periodic interrupt is only available in ST variants. */
-static int pl031_irq_set_state(struct device *dev, int enabled)
-{
-        struct pl031_local *ldata = dev_get_drvdata(dev);
-        if (enabled == 1) {
-                /* Clear any pending timer interrupt. */
-                writel(RTC_BIT_PI, ldata->base + RTC_ICR);
-                writel(readl(ldata->base + RTC_IMSC) | RTC_BIT_PI,
-                        ldata->base + RTC_IMSC);
-                /* Now start the timer */
-                writel(readl(ldata->base + RTC_TCR) | RTC_TCR_EN,
-                        ldata->base + RTC_TCR);
-        } else {
-                writel(readl(ldata->base + RTC_IMSC) & (~RTC_BIT_PI),
-                        ldata->base + RTC_IMSC);
-                /* Also stop the timer */
-                writel(readl(ldata->base + RTC_TCR) & (~RTC_TCR_EN),
-                        ldata->base + RTC_TCR);
-        }
-        /* Wait at least 1 RTC32 clock cycle to ensure next access
-         * to RTC_TCR will succeed.
-         */
-        udelay(40);
-        return 0;
-}
-static int pl031_irq_set_freq(struct device *dev, int freq)
-{
-        struct pl031_local *ldata = dev_get_drvdata(dev);
-        /* Cant set timer if it is already enabled */
-        if (readl(ldata->base + RTC_TCR) & RTC_TCR_EN) {
-                dev_err(dev, "can't change frequency while timer enabled\n");
-                return -EINVAL;
-        }
-        /* If self start bit in RTC_TCR is set timer will start here,
-         * but we never set that bit. Instead we start the timer when
-         * set_state is called with enabled == 1.
-         */
-        writel(RTC_TIMER_FREQ / freq, ldata->base + RTC_TLR);
-        return 0;
-}
 static int pl031_remove(struct amba_device *adev)
 {
        struct pl031_local *ldata = dev_get_drvdata(&adev->dev);
@@ -358,7 +307,7 @@ static int pl031_remove(struct amba_device *adev)
        return 0;
 }
-static int pl031_probe(struct amba_device *adev, struct amba_id *id)
+static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
 {
        int ret;
        struct pl031_local *ldata;
@@ -440,8 +389,6 @@ static struct rtc_class_ops stv1_pl031_ops = {
        .read_alarm = pl031_read_alarm,
        .set_alarm = pl031_set_alarm,
        .alarm_irq_enable = pl031_alarm_irq_enable,
-        .irq_set_state = pl031_irq_set_state,
-        .irq_set_freq = pl031_irq_set_freq,
 };
 /* And the second ST derivative */
@@ -451,8 +398,6 @@ static struct rtc_class_ops stv2_pl031_ops = {
        .read_alarm = pl031_stv2_read_alarm,
        .set_alarm = pl031_stv2_set_alarm,
        .alarm_irq_enable = pl031_alarm_irq_enable,
-        .irq_set_state = pl031_irq_set_state,
-        .irq_set_freq = pl031_irq_set_freq,
 };
 static struct amba_id pl031_ids[] = {
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
index c086fc30a84c..0a59fda5c09d 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -69,6 +69,14 @@ static int rtc_proc_show(struct seq_file *seq, void *offset)
                                alrm.enabled ? "yes" : "no");
                seq_printf(seq, "alrm_pending\t: %s\n",
                                alrm.pending ? "yes" : "no");
+                seq_printf(seq, "update IRQ enabled\t: %s\n",
+                        (rtc->uie_rtctimer.enabled) ? "yes" : "no");
+                seq_printf(seq, "periodic IRQ enabled\t: %s\n",
+                        (rtc->pie_enabled) ? "yes" : "no");
+                seq_printf(seq, "periodic IRQ frequency\t: %d\n",
+                        rtc->irq_freq);
+                seq_printf(seq, "max user IRQ frequency\t: %d\n",
+                        rtc->max_user_freq);
        }
        seq_printf(seq, "24hr\t\t: yes\n");
@@ -81,12 +89,16 @@ static int rtc_proc_show(struct seq_file *seq, void *offset)
 static int rtc_proc_open(struct inode *inode, struct file *file)
 {
+        int ret;
        struct rtc_device *rtc = PDE(inode)->data;
        if (!try_module_get(THIS_MODULE))
                return -ENODEV;
-        return single_open(file, rtc_proc_show, rtc);
+        ret = single_open(file, rtc_proc_show, rtc);
+        if (ret)
+                module_put(THIS_MODULE);
+        return ret;
 }
 static int rtc_proc_release(struct inode *inode, struct file *file)
diff --git a/drivers/rtc/rtc-puv3.c b/drivers/rtc/rtc-puv3.c
new file mode 100644
index 000000000000..46f14b82f3ab
--- /dev/null
+++ b/drivers/rtc/rtc-puv3.c
@@ -0,0 +1,359 @@
+/*
+ * RTC driver code specific to PKUnity SoC and UniCore ISA
+ *
+ *      Maintained by GUAN Xue-tao <gxt@mprc.pku.edu.cn>
+ *      Copyright (C) 2001-2010 Guan Xuetao
+ *
+ * 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/module.h>
+#include <linux/fs.h>
+#include <linux/string.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/clk.h>
+#include <linux/log2.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <asm/irq.h>
+#include <mach/hardware.h>
+static struct resource *puv3_rtc_mem;
+static int puv3_rtc_alarmno = IRQ_RTCAlarm;
+static int puv3_rtc_tickno  = IRQ_RTC;
+static DEFINE_SPINLOCK(puv3_rtc_pie_lock);
+/* IRQ Handlers */
+static irqreturn_t puv3_rtc_alarmirq(int irq, void *id)
+{
+        struct rtc_device *rdev = id;
+        writel(readl(RTC_RTSR) | RTC_RTSR_AL, RTC_RTSR);
+        rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
+        return IRQ_HANDLED;
+}
+static irqreturn_t puv3_rtc_tickirq(int irq, void *id)
+{
+        struct rtc_device *rdev = id;
+        writel(readl(RTC_RTSR) | RTC_RTSR_HZ, RTC_RTSR);
+        rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
+        return IRQ_HANDLED;
+}
+/* Update control registers */
+static void puv3_rtc_setaie(int to)
+{
+        unsigned int tmp;
+        pr_debug("%s: aie=%d\n", __func__, to);
+        tmp = readl(RTC_RTSR) & ~RTC_RTSR_ALE;
+        if (to)
+                tmp |= RTC_RTSR_ALE;
+        writel(tmp, RTC_RTSR);
+}
+static int puv3_rtc_setpie(struct device *dev, int enabled)
+{
+        unsigned int tmp;
+        pr_debug("%s: pie=%d\n", __func__, enabled);
+        spin_lock_irq(&puv3_rtc_pie_lock);
+        tmp = readl(RTC_RTSR) & ~RTC_RTSR_HZE;
+        if (enabled)
+                tmp |= RTC_RTSR_HZE;
+        writel(tmp, RTC_RTSR);
+        spin_unlock_irq(&puv3_rtc_pie_lock);
+        return 0;
+}
+/* Time read/write */
+static int puv3_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
+{
+        rtc_time_to_tm(readl(RTC_RCNR), rtc_tm);
+        pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n",
+                 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
+                 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
+        return 0;
+}
+static int puv3_rtc_settime(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long rtc_count = 0;
+        pr_debug("set time %02d.%02d.%02d %02d/%02d/%02d\n",
+                 tm->tm_year, tm->tm_mon, tm->tm_mday,
+                 tm->tm_hour, tm->tm_min, tm->tm_sec);
+        rtc_tm_to_time(tm, &rtc_count);
+        writel(rtc_count, RTC_RCNR);
+        return 0;
+}
+static int puv3_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct rtc_time *alm_tm = &alrm->time;
+        rtc_time_to_tm(readl(RTC_RTAR), alm_tm);
+        alrm->enabled = readl(RTC_RTSR) & RTC_RTSR_ALE;
+        pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
+                 alrm->enabled,
+                 alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
+                 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
+        return 0;
+}
+static int puv3_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct rtc_time *tm = &alrm->time;
+        unsigned long rtcalarm_count = 0;
+        pr_debug("puv3_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
+                 alrm->enabled,
+                 tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
+                 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);
+        rtc_tm_to_time(tm, &rtcalarm_count);
+        writel(rtcalarm_count, RTC_RTAR);
+        puv3_rtc_setaie(alrm->enabled);
+        if (alrm->enabled)
+                enable_irq_wake(puv3_rtc_alarmno);
+        else
+                disable_irq_wake(puv3_rtc_alarmno);
+        return 0;
+}
+static int puv3_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        seq_printf(seq, "periodic_IRQ\t: %s\n",
+                     (readl(RTC_RTSR) & RTC_RTSR_HZE) ? "yes" : "no");
+        return 0;
+}
+static int puv3_rtc_open(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
+        int ret;
+        ret = request_irq(puv3_rtc_alarmno, puv3_rtc_alarmirq,
+                          IRQF_DISABLED,  "pkunity-rtc alarm", rtc_dev);
+        if (ret) {
+                dev_err(dev, "IRQ%d error %d\n", puv3_rtc_alarmno, ret);
+                return ret;
+        }
+        ret = request_irq(puv3_rtc_tickno, puv3_rtc_tickirq,
+                          IRQF_DISABLED,  "pkunity-rtc tick", rtc_dev);
+        if (ret) {
+                dev_err(dev, "IRQ%d error %d\n", puv3_rtc_tickno, ret);
+                goto tick_err;
+        }
+        return ret;
+ tick_err:
+        free_irq(puv3_rtc_alarmno, rtc_dev);
+        return ret;
+}
+static void puv3_rtc_release(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
+        /* do not clear AIE here, it may be needed for wake */
+        puv3_rtc_setpie(dev, 0);
+        free_irq(puv3_rtc_alarmno, rtc_dev);
+        free_irq(puv3_rtc_tickno, rtc_dev);
+}
+static const struct rtc_class_ops puv3_rtcops = {
+        .open           = puv3_rtc_open,
+        .release        = puv3_rtc_release,
+        .read_time      = puv3_rtc_gettime,
+        .set_time       = puv3_rtc_settime,
+        .read_alarm     = puv3_rtc_getalarm,
+        .set_alarm      = puv3_rtc_setalarm,
+        .proc           = puv3_rtc_proc,
+};
+static void puv3_rtc_enable(struct platform_device *pdev, int en)
+{
+        if (!en) {
+                writel(readl(RTC_RTSR) & ~RTC_RTSR_HZE, RTC_RTSR);
+        } else {
+                /* re-enable the device, and check it is ok */
+                if ((readl(RTC_RTSR) & RTC_RTSR_HZE) == 0) {
+                        dev_info(&pdev->dev, "rtc disabled, re-enabling\n");
+                        writel(readl(RTC_RTSR) | RTC_RTSR_HZE, RTC_RTSR);
+                }
+        }
+}
+static int puv3_rtc_remove(struct platform_device *dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(dev);
+        platform_set_drvdata(dev, NULL);
+        rtc_device_unregister(rtc);
+        puv3_rtc_setpie(&dev->dev, 0);
+        puv3_rtc_setaie(0);
+        release_resource(puv3_rtc_mem);
+        kfree(puv3_rtc_mem);
+        return 0;
+}
+static int puv3_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        struct resource *res;
+        int ret;
+        pr_debug("%s: probe=%p\n", __func__, pdev);
+        /* find the IRQs */
+        puv3_rtc_tickno = platform_get_irq(pdev, 1);
+        if (puv3_rtc_tickno < 0) {
+                dev_err(&pdev->dev, "no irq for rtc tick\n");
+                return -ENOENT;
+        }
+        puv3_rtc_alarmno = platform_get_irq(pdev, 0);
+        if (puv3_rtc_alarmno < 0) {
+                dev_err(&pdev->dev, "no irq for alarm\n");
+                return -ENOENT;
+        }
+        pr_debug("PKUnity_rtc: tick irq %d, alarm irq %d\n",
+                 puv3_rtc_tickno, puv3_rtc_alarmno);
+        /* get the memory region */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "failed to get memory region resource\n");
+                return -ENOENT;
+        }
+        puv3_rtc_mem = request_mem_region(res->start,
+                                         res->end-res->start+1,
+                                         pdev->name);
+        if (puv3_rtc_mem == NULL) {
+                dev_err(&pdev->dev, "failed to reserve memory region\n");
+                ret = -ENOENT;
+                goto err_nores;
+        }
+        puv3_rtc_enable(pdev, 1);
+        /* register RTC and exit */
+        rtc = rtc_device_register("pkunity", &pdev->dev, &puv3_rtcops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                dev_err(&pdev->dev, "cannot attach rtc\n");
+                ret = PTR_ERR(rtc);
+                goto err_nortc;
+        }
+        /* platform setup code should have handled this; sigh */
+        if (!device_can_wakeup(&pdev->dev))
+                device_init_wakeup(&pdev->dev, 1);
+        platform_set_drvdata(pdev, rtc);
+        return 0;
+ err_nortc:
+        puv3_rtc_enable(pdev, 0);
+        release_resource(puv3_rtc_mem);
+ err_nores:
+        return ret;
+}
+#ifdef CONFIG_PM
+static int ticnt_save;
+static int puv3_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        /* save RTAR for anyone using periodic interrupts */
+        ticnt_save = readl(RTC_RTAR);
+        puv3_rtc_enable(pdev, 0);
+        return 0;
+}
+static int puv3_rtc_resume(struct platform_device *pdev)
+{
+        puv3_rtc_enable(pdev, 1);
+        writel(ticnt_save, RTC_RTAR);
+        return 0;
+}
+#else
+#define puv3_rtc_suspend NULL
+#define puv3_rtc_resume  NULL
+#endif
+static struct platform_driver puv3_rtcdrv = {
+        .probe          = puv3_rtc_probe,
+        .remove         = __devexit_p(puv3_rtc_remove),
+        .suspend        = puv3_rtc_suspend,
+        .resume         = puv3_rtc_resume,
+        .driver         = {
+                .name   = "PKUnity-v3-RTC",
+                .owner  = THIS_MODULE,
+        }
+};
+static char __initdata banner[] = "PKUnity-v3 RTC, (c) 2009 PKUnity Co.\n";
+static int __init puv3_rtc_init(void)
+{
+        printk(banner);
+        return platform_driver_register(&puv3_rtcdrv);
+}
+static void __exit puv3_rtc_exit(void)
+{
+        platform_driver_unregister(&puv3_rtcdrv);
+}
+module_init(puv3_rtc_init);
+module_exit(puv3_rtc_exit);
+MODULE_DESCRIPTION("RTC Driver for the PKUnity v3 chip");
+MODULE_AUTHOR("Hu Dongliang");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-pxa.c b/drivers/rtc/rtc-pxa.c
index 29e867a1aaa8..fc9f4991574b 100644
--- a/drivers/rtc/rtc-pxa.c
+++ b/drivers/rtc/rtc-pxa.c
@@ -209,32 +209,6 @@ static void pxa_rtc_release(struct device *dev)
        free_irq(pxa_rtc->irq_1Hz, dev);
 }
-static int pxa_periodic_irq_set_freq(struct device *dev, int freq)
-{
-        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
-        int period_ms;
-        if (freq < 1 || freq > MAXFREQ_PERIODIC)
-                return -EINVAL;
-        period_ms = 1000 / freq;
-        rtc_writel(pxa_rtc, PIAR, period_ms);
-        return 0;
-}
-static int pxa_periodic_irq_set_state(struct device *dev, int enabled)
-{
-        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
-        if (enabled)
-                rtsr_set_bits(pxa_rtc, RTSR_PIALE | RTSR_PICE);
-        else
-                rtsr_clear_bits(pxa_rtc, RTSR_PIALE | RTSR_PICE);
-        return 0;
-}
 static int pxa_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
@@ -250,21 +224,6 @@ static int pxa_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int pxa_update_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
-        spin_lock_irq(&pxa_rtc->lock);
-        if (enabled)
-                rtsr_set_bits(pxa_rtc, RTSR_HZE);
-        else
-                rtsr_clear_bits(pxa_rtc, RTSR_HZE);
-        spin_unlock_irq(&pxa_rtc->lock);
-        return 0;
-}
 static int pxa_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
@@ -346,10 +305,7 @@ static const struct rtc_class_ops pxa_rtc_ops = {
        .read_alarm = pxa_rtc_read_alarm,
        .set_alarm = pxa_rtc_set_alarm,
        .alarm_irq_enable = pxa_alarm_irq_enable,
-        .update_irq_enable = pxa_update_irq_enable,
        .proc = pxa_rtc_proc,
-        .irq_set_state = pxa_periodic_irq_set_state,
-        .irq_set_freq = pxa_periodic_irq_set_freq,
 };
 static int __init pxa_rtc_probe(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-rp5c01.c b/drivers/rtc/rtc-rp5c01.c
index 36eb66184461..359da6d020b9 100644
--- a/drivers/rtc/rtc-rp5c01.c
+++ b/drivers/rtc/rtc-rp5c01.c
@@ -76,7 +76,7 @@ static inline unsigned int rp5c01_read(struct rp5c01_priv *priv,
 static inline void rp5c01_write(struct rp5c01_priv *priv, unsigned int val,
                                unsigned int reg)
 {
-        return __raw_writel(val, &priv->regs[reg]);
+        __raw_writel(val, &priv->regs[reg]);
 }
 static void rp5c01_lock(struct rp5c01_priv *priv)
@@ -249,15 +249,15 @@ static int __init rp5c01_rtc_probe(struct platform_device *dev)
        spin_lock_init(&priv->lock);
+        platform_set_drvdata(dev, priv);
        rtc = rtc_device_register("rtc-rp5c01", &dev->dev, &rp5c01_rtc_ops,
                                  THIS_MODULE);
        if (IS_ERR(rtc)) {
                error = PTR_ERR(rtc);
                goto out_unmap;
        }
        priv->rtc = rtc;
-        platform_set_drvdata(dev, priv);
        error = sysfs_create_bin_file(&dev->dev.kobj, &priv->nvram_attr);
        if (error)
@@ -268,6 +268,7 @@ static int __init rp5c01_rtc_probe(struct platform_device *dev)
 out_unregister:
        rtc_device_unregister(rtc);
 out_unmap:
+        platform_set_drvdata(dev, NULL);
        iounmap(priv->regs);
 out_free_priv:
        kfree(priv);
diff --git a/drivers/rtc/rtc-rs5c313.c b/drivers/rtc/rtc-rs5c313.c
index e6ea3f5ee1eb..e3ff179b99ca 100644
--- a/drivers/rtc/rtc-rs5c313.c
+++ b/drivers/rtc/rtc-rs5c313.c
@@ -80,21 +80,21 @@
 /* SCSPTR1 data */
 unsigned char scsptr1_data;
-#define RS5C313_CEENABLE    ctrl_outb(RS5C313_CE_RTCCE, RS5C313_CE);
+#define RS5C313_CEENABLE    __raw_writeb(RS5C313_CE_RTCCE, RS5C313_CE);
-#define RS5C313_CEDISABLE   ctrl_outb(0x00, RS5C313_CE)
+#define RS5C313_CEDISABLE   __raw_writeb(0x00, RS5C313_CE)
-#define RS5C313_MISCOP      ctrl_outb(0x02, 0xB0000008)
+#define RS5C313_MISCOP      __raw_writeb(0x02, 0xB0000008)
 static void rs5c313_init_port(void)
 {
        /* Set SCK as I/O port and Initialize SCSPTR1 data & I/O port. */
-        ctrl_outb(ctrl_inb(SCSMR1) & ~SCSMR1_CA, SCSMR1);
+        __raw_writeb(__raw_readb(SCSMR1) & ~SCSMR1_CA, SCSMR1);
-        ctrl_outb(ctrl_inb(SCSCR1) & ~SCSCR1_CKE, SCSCR1);
+        __raw_writeb(__raw_readb(SCSCR1) & ~SCSCR1_CKE, SCSCR1);
        /* And Initialize SCL for RS5C313 clock */
-        scsptr1_data = ctrl_inb(SCSPTR1) | SCL; /* SCL:H */
+        scsptr1_data = __raw_readb(SCSPTR1) | SCL;      /* SCL:H */
-        ctrl_outb(scsptr1_data, SCSPTR1);
+        __raw_writeb(scsptr1_data, SCSPTR1);
-        scsptr1_data = ctrl_inb(SCSPTR1) | SCL_OEN;     /* SCL output enable */
+        scsptr1_data = __raw_readb(SCSPTR1) | SCL_OEN;  /* SCL output enable */
-        ctrl_outb(scsptr1_data, SCSPTR1);
+        __raw_writeb(scsptr1_data, SCSPTR1);
        RS5C313_CEDISABLE;      /* CE:L */
 }
@@ -106,21 +106,21 @@ static void rs5c313_write_data(unsigned char data)
                /* SDA:Write Data */
                scsptr1_data = (scsptr1_data & ~SDA) |
                                ((((0x80 >> i) & data) >> (7 - i)) << 2);
-                ctrl_outb(scsptr1_data, SCSPTR1);
+                __raw_writeb(scsptr1_data, SCSPTR1);
                if (i == 0) {
                        scsptr1_data |= SDA_OEN;        /* SDA:output enable */
-                        ctrl_outb(scsptr1_data, SCSPTR1);
+                        __raw_writeb(scsptr1_data, SCSPTR1);
                }
                ndelay(700);
                scsptr1_data &= ~SCL;   /* SCL:L */
-                ctrl_outb(scsptr1_data, SCSPTR1);
+                __raw_writeb(scsptr1_data, SCSPTR1);
                ndelay(700);
                scsptr1_data |= SCL;    /* SCL:H */
-                ctrl_outb(scsptr1_data, SCSPTR1);
+                __raw_writeb(scsptr1_data, SCSPTR1);
        }
        scsptr1_data &= ~SDA_OEN;       /* SDA:output disable */
-        ctrl_outb(scsptr1_data, SCSPTR1);
+        __raw_writeb(scsptr1_data, SCSPTR1);
 }
 static unsigned char rs5c313_read_data(void)
@@ -131,12 +131,12 @@ static unsigned char rs5c313_read_data(void)
        for (i = 0; i < 8; i++) {
                ndelay(700);
                /* SDA:Read Data */
-                data |= ((ctrl_inb(SCSPTR1) & SDA) >> 2) << (7 - i);
+                data |= ((__raw_readb(SCSPTR1) & SDA) >> 2) << (7 - i);
                scsptr1_data &= ~SCL;   /* SCL:L */
-                ctrl_outb(scsptr1_data, SCSPTR1);
+                __raw_writeb(scsptr1_data, SCSPTR1);
                ndelay(700);
                scsptr1_data |= SCL;    /* SCL:H */
-                ctrl_outb(scsptr1_data, SCSPTR1);
+                __raw_writeb(scsptr1_data, SCSPTR1);
        }
        return data & 0x0F;
 }
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index 90cf0a6ff23e..85c1b848dd72 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -207,7 +207,7 @@ static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
 static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
 {
        struct rs5c372  *rs5c = i2c_get_clientdata(client);
-        unsigned char   buf[8];
+        unsigned char   buf[7];
        int             addr;
        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
@@ -281,10 +281,8 @@ static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
        return rs5c372_set_datetime(to_i2c_client(dev), tm);
 }
-#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
-static int
+static int rs5c_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
        struct i2c_client       *client = to_i2c_client(dev);
        struct rs5c372          *rs5c = i2c_get_clientdata(client);
@@ -292,45 +290,19 @@ rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
        int                     status, addr;
        buf = rs5c->regs[RS5C_REG_CTRL1];
-        switch (cmd) {
-        case RTC_UIE_OFF:
+        if (!rs5c->has_irq)
-        case RTC_UIE_ON:
+                return -EINVAL;
-                /* some 327a modes use a different IRQ pin for 1Hz irqs */
-                if (rs5c->type == rtc_rs5c372a
-                                && (buf & RS5C372A_CTRL1_SL1))
-                        return -ENOIOCTLCMD;
-        case RTC_AIE_OFF:
-        case RTC_AIE_ON:
-                /* these irq management calls only make sense for chips
-                 * which are wired up to an IRQ.
-                 */
-                if (!rs5c->has_irq)
-                        return -ENOIOCTLCMD;
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
        status = rs5c_get_regs(rs5c);
        if (status < 0)
                return status;
        addr = RS5C_ADDR(RS5C_REG_CTRL1);
-        switch (cmd) {
+        if (enabled)
-        case RTC_AIE_OFF:       /* alarm off */
-                buf &= ~RS5C_CTRL1_AALE;
-                break;
-        case RTC_AIE_ON:        /* alarm on */
                buf |= RS5C_CTRL1_AALE;
-                break;
+        else
-        case RTC_UIE_OFF:       /* update off */
+                buf &= ~RS5C_CTRL1_AALE;
-                buf &= ~RS5C_CTRL1_CT_MASK;
-                break;
-        case RTC_UIE_ON:        /* update on */
-                buf &= ~RS5C_CTRL1_CT_MASK;
-                buf |= RS5C_CTRL1_CT4;
-                break;
-        }
        if (i2c_smbus_write_byte_data(client, addr, buf) < 0) {
                printk(KERN_WARNING "%s: can't update alarm\n",
@@ -342,10 +314,6 @@ rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
        return status;
 }
-#else
-#define rs5c_rtc_ioctl  NULL
-#endif
 /* NOTE:  Since RTC_WKALM_{RD,SET} were originally defined for EFI,
 * which only exposes a polled programming interface; and since
@@ -461,11 +429,11 @@ static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
 static const struct rtc_class_ops rs5c372_rtc_ops = {
        .proc           = rs5c372_rtc_proc,
-        .ioctl          = rs5c_rtc_ioctl,
        .read_time      = rs5c372_rtc_read_time,
        .set_time       = rs5c372_rtc_set_time,
        .read_alarm     = rs5c_read_alarm,
        .set_alarm      = rs5c_set_alarm,
+        .alarm_irq_enable = rs5c_rtc_alarm_irq_enable,
 };
 #if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
diff --git a/drivers/rtc/rtc-rv3029c2.c b/drivers/rtc/rtc-rv3029c2.c
new file mode 100644
index 000000000000..ea09ff211dc6
--- /dev/null
+++ b/drivers/rtc/rtc-rv3029c2.c
@@ -0,0 +1,454 @@
+/*
+ * Micro Crystal RV-3029C2 rtc class driver
+ *
+ * Author: Gregory Hermant <gregory.hermant@calao-systems.com>
+ *
+ * based on previously existing rtc class drivers
+ *
+ * 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.
+ *
+ * NOTE: Currently this driver only supports the bare minimum for read
+ * and write the RTC and alarms. The extra features provided by this chip
+ * (trickle charger, eeprom, T° compensation) are unavailable.
+ */
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+/* Register map */
+/* control section */
+#define RV3029C2_ONOFF_CTRL             0x00
+#define RV3029C2_IRQ_CTRL               0x01
+#define RV3029C2_IRQ_CTRL_AIE           (1 << 0)
+#define RV3029C2_IRQ_FLAGS              0x02
+#define RV3029C2_IRQ_FLAGS_AF           (1 << 0)
+#define RV3029C2_STATUS                 0x03
+#define RV3029C2_STATUS_VLOW1           (1 << 2)
+#define RV3029C2_STATUS_VLOW2           (1 << 3)
+#define RV3029C2_STATUS_SR              (1 << 4)
+#define RV3029C2_STATUS_PON             (1 << 5)
+#define RV3029C2_STATUS_EEBUSY          (1 << 7)
+#define RV3029C2_RST_CTRL               0x04
+#define RV3029C2_CONTROL_SECTION_LEN    0x05
+/* watch section */
+#define RV3029C2_W_SEC                  0x08
+#define RV3029C2_W_MINUTES              0x09
+#define RV3029C2_W_HOURS                0x0A
+#define RV3029C2_REG_HR_12_24           (1<<6)  /* 24h/12h mode */
+#define RV3029C2_REG_HR_PM              (1<<5)  /* PM/AM bit in 12h mode */
+#define RV3029C2_W_DATE                 0x0B
+#define RV3029C2_W_DAYS                 0x0C
+#define RV3029C2_W_MONTHS               0x0D
+#define RV3029C2_W_YEARS                0x0E
+#define RV3029C2_WATCH_SECTION_LEN      0x07
+/* alarm section */
+#define RV3029C2_A_SC                   0x10
+#define RV3029C2_A_MN                   0x11
+#define RV3029C2_A_HR                   0x12
+#define RV3029C2_A_DT                   0x13
+#define RV3029C2_A_DW                   0x14
+#define RV3029C2_A_MO                   0x15
+#define RV3029C2_A_YR                   0x16
+#define RV3029C2_ALARM_SECTION_LEN      0x07
+/* timer section */
+#define RV3029C2_TIMER_LOW              0x18
+#define RV3029C2_TIMER_HIGH             0x19
+/* temperature section */
+#define RV3029C2_TEMP_PAGE              0x20
+/* eeprom data section */
+#define RV3029C2_E2P_EEDATA1            0x28
+#define RV3029C2_E2P_EEDATA2            0x29
+/* eeprom control section */
+#define RV3029C2_CONTROL_E2P_EECTRL     0x30
+#define RV3029C2_TRICKLE_1K             (1<<0)  /*  1K resistance */
+#define RV3029C2_TRICKLE_5K             (1<<1)  /*  5K resistance */
+#define RV3029C2_TRICKLE_20K            (1<<2)  /* 20K resistance */
+#define RV3029C2_TRICKLE_80K            (1<<3)  /* 80K resistance */
+#define RV3029C2_CONTROL_E2P_XTALOFFSET 0x31
+#define RV3029C2_CONTROL_E2P_QCOEF      0x32
+#define RV3029C2_CONTROL_E2P_TURNOVER   0x33
+/* user ram section */
+#define RV3029C2_USR1_RAM_PAGE          0x38
+#define RV3029C2_USR1_SECTION_LEN       0x04
+#define RV3029C2_USR2_RAM_PAGE          0x3C
+#define RV3029C2_USR2_SECTION_LEN       0x04
+static int
+rv3029c2_i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf,
+        unsigned len)
+{
+        int ret;
+        if ((reg > RV3029C2_USR1_RAM_PAGE + 7) ||
+                (reg + len > RV3029C2_USR1_RAM_PAGE + 8))
+                return -EINVAL;
+        ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
+        if (ret < 0)
+                return ret;
+        if (ret < len)
+                return -EIO;
+        return 0;
+}
+static int
+rv3029c2_i2c_write_regs(struct i2c_client *client, u8 reg, u8 const buf[],
+                        unsigned len)
+{
+        if ((reg > RV3029C2_USR1_RAM_PAGE + 7) ||
+                (reg + len > RV3029C2_USR1_RAM_PAGE + 8))
+                return -EINVAL;
+        return i2c_smbus_write_i2c_block_data(client, reg, len, buf);
+}
+static int
+rv3029c2_i2c_get_sr(struct i2c_client *client, u8 *buf)
+{
+        int ret = rv3029c2_i2c_read_regs(client, RV3029C2_STATUS, buf, 1);
+        if (ret < 0)
+                return -EIO;
+        dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
+        return 0;
+}
+static int
+rv3029c2_i2c_set_sr(struct i2c_client *client, u8 val)
+{
+        u8 buf[1];
+        int sr;
+        buf[0] = val;
+        sr = rv3029c2_i2c_write_regs(client, RV3029C2_STATUS, buf, 1);
+        dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
+        if (sr < 0)
+                return -EIO;
+        return 0;
+}
+static int
+rv3029c2_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
+{
+        u8 buf[1];
+        int ret;
+        u8 regs[RV3029C2_WATCH_SECTION_LEN] = { 0, };
+        ret = rv3029c2_i2c_get_sr(client, buf);
+        if (ret < 0) {
+                dev_err(&client->dev, "%s: reading SR failed\n", __func__);
+                return -EIO;
+        }
+        ret = rv3029c2_i2c_read_regs(client, RV3029C2_W_SEC , regs,
+                                        RV3029C2_WATCH_SECTION_LEN);
+        if (ret < 0) {
+                dev_err(&client->dev, "%s: reading RTC section failed\n",
+                        __func__);
+                return ret;
+        }
+        tm->tm_sec = bcd2bin(regs[RV3029C2_W_SEC-RV3029C2_W_SEC]);
+        tm->tm_min = bcd2bin(regs[RV3029C2_W_MINUTES-RV3029C2_W_SEC]);
+        /* HR field has a more complex interpretation */
+        {
+                const u8 _hr = regs[RV3029C2_W_HOURS-RV3029C2_W_SEC];
+                if (_hr & RV3029C2_REG_HR_12_24) {
+                        /* 12h format */
+                        tm->tm_hour = bcd2bin(_hr & 0x1f);
+                        if (_hr & RV3029C2_REG_HR_PM)   /* PM flag set */
+                                tm->tm_hour += 12;
+                } else /* 24h format */
+                        tm->tm_hour = bcd2bin(_hr & 0x3f);
+        }
+        tm->tm_mday = bcd2bin(regs[RV3029C2_W_DATE-RV3029C2_W_SEC]);
+        tm->tm_mon = bcd2bin(regs[RV3029C2_W_MONTHS-RV3029C2_W_SEC]) - 1;
+        tm->tm_year = bcd2bin(regs[RV3029C2_W_YEARS-RV3029C2_W_SEC]) + 100;
+        tm->tm_wday = bcd2bin(regs[RV3029C2_W_DAYS-RV3029C2_W_SEC]) - 1;
+        return 0;
+}
+static int rv3029c2_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return rv3029c2_i2c_read_time(to_i2c_client(dev), tm);
+}
+static int
+rv3029c2_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
+{
+        struct rtc_time *const tm = &alarm->time;
+        int ret;
+        u8 regs[8];
+        ret = rv3029c2_i2c_get_sr(client, regs);
+        if (ret < 0) {
+                dev_err(&client->dev, "%s: reading SR failed\n", __func__);
+                return -EIO;
+        }
+        ret = rv3029c2_i2c_read_regs(client, RV3029C2_A_SC, regs,
+                                        RV3029C2_ALARM_SECTION_LEN);
+        if (ret < 0) {
+                dev_err(&client->dev, "%s: reading alarm section failed\n",
+                        __func__);
+                return ret;
+        }
+        tm->tm_sec = bcd2bin(regs[RV3029C2_A_SC-RV3029C2_A_SC] & 0x7f);
+        tm->tm_min = bcd2bin(regs[RV3029C2_A_MN-RV3029C2_A_SC] & 0x7f);
+        tm->tm_hour = bcd2bin(regs[RV3029C2_A_HR-RV3029C2_A_SC] & 0x3f);
+        tm->tm_mday = bcd2bin(regs[RV3029C2_A_DT-RV3029C2_A_SC] & 0x3f);
+        tm->tm_mon = bcd2bin(regs[RV3029C2_A_MO-RV3029C2_A_SC] & 0x1f) - 1;
+        tm->tm_year = bcd2bin(regs[RV3029C2_A_YR-RV3029C2_A_SC] & 0x7f) + 100;
+        tm->tm_wday = bcd2bin(regs[RV3029C2_A_DW-RV3029C2_A_SC] & 0x07) - 1;
+        return 0;
+}
+static int
+rv3029c2_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        return rv3029c2_i2c_read_alarm(to_i2c_client(dev), alarm);
+}
+static int rv3029c2_rtc_i2c_alarm_set_irq(struct i2c_client *client,
+                                        int enable)
+{
+        int ret;
+        u8 buf[1];
+        /* enable AIE irq */
+        ret = rv3029c2_i2c_read_regs(client, RV3029C2_IRQ_CTRL, buf, 1);
+        if (ret < 0) {
+                dev_err(&client->dev, "can't read INT reg\n");
+                return ret;
+        }
+        if (enable)
+                buf[0] |= RV3029C2_IRQ_CTRL_AIE;
+        else
+                buf[0] &= ~RV3029C2_IRQ_CTRL_AIE;
+        ret = rv3029c2_i2c_write_regs(client, RV3029C2_IRQ_CTRL, buf, 1);
+        if (ret < 0) {
+                dev_err(&client->dev, "can't set INT reg\n");
+                return ret;
+        }
+        return 0;
+}
+static int rv3029c2_rtc_i2c_set_alarm(struct i2c_client *client,
+                                        struct rtc_wkalrm *alarm)
+{
+        struct rtc_time *const tm = &alarm->time;
+        int ret;
+        u8 regs[8];
+        /*
+         * The clock has an 8 bit wide bcd-coded register (they never learn)
+         * for the year. tm_year is an offset from 1900 and we are interested
+         * in the 2000-2099 range, so any value less than 100 is invalid.
+        */
+        if (tm->tm_year < 100)
+                return -EINVAL;
+        ret = rv3029c2_i2c_get_sr(client, regs);
+        if (ret < 0) {
+                dev_err(&client->dev, "%s: reading SR failed\n", __func__);
+                return -EIO;
+        }
+        regs[RV3029C2_A_SC-RV3029C2_A_SC] = bin2bcd(tm->tm_sec & 0x7f);
+        regs[RV3029C2_A_MN-RV3029C2_A_SC] = bin2bcd(tm->tm_min & 0x7f);
+        regs[RV3029C2_A_HR-RV3029C2_A_SC] = bin2bcd(tm->tm_hour & 0x3f);
+        regs[RV3029C2_A_DT-RV3029C2_A_SC] = bin2bcd(tm->tm_mday & 0x3f);
+        regs[RV3029C2_A_MO-RV3029C2_A_SC] = bin2bcd((tm->tm_mon & 0x1f) - 1);
+        regs[RV3029C2_A_DW-RV3029C2_A_SC] = bin2bcd((tm->tm_wday & 7) - 1);
+        regs[RV3029C2_A_YR-RV3029C2_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100);
+        ret = rv3029c2_i2c_write_regs(client, RV3029C2_A_SC, regs,
+                                        RV3029C2_ALARM_SECTION_LEN);
+        if (ret < 0)
+                return ret;
+        if (alarm->enabled) {
+                u8 buf[1];
+                /* clear AF flag */
+                ret = rv3029c2_i2c_read_regs(client, RV3029C2_IRQ_FLAGS,
+                                                buf, 1);
+                if (ret < 0) {
+                        dev_err(&client->dev, "can't read alarm flag\n");
+                        return ret;
+                }
+                buf[0] &= ~RV3029C2_IRQ_FLAGS_AF;
+                ret = rv3029c2_i2c_write_regs(client, RV3029C2_IRQ_FLAGS,
+                                                buf, 1);
+                if (ret < 0) {
+                        dev_err(&client->dev, "can't set alarm flag\n");
+                        return ret;
+                }
+                /* enable AIE irq */
+                ret = rv3029c2_rtc_i2c_alarm_set_irq(client, 1);
+                if (ret)
+                        return ret;
+                dev_dbg(&client->dev, "alarm IRQ armed\n");
+        } else {
+                /* disable AIE irq */
+                ret = rv3029c2_rtc_i2c_alarm_set_irq(client, 1);
+                if (ret)
+                        return ret;
+                dev_dbg(&client->dev, "alarm IRQ disabled\n");
+        }
+        return 0;
+}
+static int rv3029c2_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        return rv3029c2_rtc_i2c_set_alarm(to_i2c_client(dev), alarm);
+}
+static int
+rv3029c2_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
+{
+        u8 regs[8];
+        int ret;
+        /*
+         * The clock has an 8 bit wide bcd-coded register (they never learn)
+         * for the year. tm_year is an offset from 1900 and we are interested
+         * in the 2000-2099 range, so any value less than 100 is invalid.
+        */
+        if (tm->tm_year < 100)
+                return -EINVAL;
+        regs[RV3029C2_W_SEC-RV3029C2_W_SEC] = bin2bcd(tm->tm_sec);
+        regs[RV3029C2_W_MINUTES-RV3029C2_W_SEC] = bin2bcd(tm->tm_min);
+        regs[RV3029C2_W_HOURS-RV3029C2_W_SEC] = bin2bcd(tm->tm_hour);
+        regs[RV3029C2_W_DATE-RV3029C2_W_SEC] = bin2bcd(tm->tm_mday);
+        regs[RV3029C2_W_MONTHS-RV3029C2_W_SEC] = bin2bcd(tm->tm_mon+1);
+        regs[RV3029C2_W_DAYS-RV3029C2_W_SEC] = bin2bcd((tm->tm_wday & 7)+1);
+        regs[RV3029C2_W_YEARS-RV3029C2_W_SEC] = bin2bcd(tm->tm_year - 100);
+        ret = rv3029c2_i2c_write_regs(client, RV3029C2_W_SEC, regs,
+                                        RV3029C2_WATCH_SECTION_LEN);
+        if (ret < 0)
+                return ret;
+        ret = rv3029c2_i2c_get_sr(client, regs);
+        if (ret < 0) {
+                dev_err(&client->dev, "%s: reading SR failed\n", __func__);
+                return ret;
+        }
+        /* clear PON bit */
+        ret = rv3029c2_i2c_set_sr(client, (regs[0] & ~RV3029C2_STATUS_PON));
+        if (ret < 0) {
+                dev_err(&client->dev, "%s: reading SR failed\n", __func__);
+                return ret;
+        }
+        return 0;
+}
+static int rv3029c2_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return rv3029c2_i2c_set_time(to_i2c_client(dev), tm);
+}
+static const struct rtc_class_ops rv3029c2_rtc_ops = {
+        .read_time      = rv3029c2_rtc_read_time,
+        .set_time       = rv3029c2_rtc_set_time,
+        .read_alarm     = rv3029c2_rtc_read_alarm,
+        .set_alarm      = rv3029c2_rtc_set_alarm,
+};
+static struct i2c_device_id rv3029c2_id[] = {
+        { "rv3029c2", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, rv3029c2_id);
+static int __devinit
+rv3029c2_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        struct rtc_device *rtc;
+        int rc = 0;
+        u8 buf[1];
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_EMUL))
+                return -ENODEV;
+        rtc = rtc_device_register(client->name,
+                                &client->dev, &rv3029c2_rtc_ops,
+                                THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+        i2c_set_clientdata(client, rtc);
+        rc = rv3029c2_i2c_get_sr(client, buf);
+        if (rc < 0) {
+                dev_err(&client->dev, "reading status failed\n");
+                goto exit_unregister;
+        }
+        return 0;
+exit_unregister:
+        rtc_device_unregister(rtc);
+        return rc;
+}
+static int __devexit rv3029c2_remove(struct i2c_client *client)
+{
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+        rtc_device_unregister(rtc);
+        return 0;
+}
+static struct i2c_driver rv3029c2_driver = {
+        .driver = {
+                .name = "rtc-rv3029c2",
+        },
+        .probe = rv3029c2_probe,
+        .remove = __devexit_p(rv3029c2_remove),
+        .id_table = rv3029c2_id,
+};
+static int __init rv3029c2_init(void)
+{
+        return i2c_add_driver(&rv3029c2_driver);
+}
+static void __exit rv3029c2_exit(void)
+{
+        i2c_del_driver(&rv3029c2_driver);
+}
+module_init(rv3029c2_init);
+module_exit(rv3029c2_exit);
+MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
+MODULE_DESCRIPTION("Micro Crystal RV3029C2 RTC driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-rx8025.c b/drivers/rtc/rtc-rx8025.c
index 1146e3522d3c..fde172fb2abe 100644
--- a/drivers/rtc/rtc-rx8025.c
+++ b/drivers/rtc/rtc-rx8025.c
@@ -424,37 +424,12 @@ static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int rx8025_irq_set_state(struct device *dev, int enabled)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct rx8025_data *rx8025 = i2c_get_clientdata(client);
-        int ctrl1;
-        int err;
-        if (client->irq <= 0)
-                return -ENXIO;
-        ctrl1 = rx8025->ctrl1 & ~RX8025_BIT_CTRL1_CT;
-        if (enabled)
-                ctrl1 |= RX8025_BIT_CTRL1_CT_1HZ;
-        if (ctrl1 != rx8025->ctrl1) {
-                rx8025->ctrl1 = ctrl1;
-                err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
-                                       rx8025->ctrl1);
-                if (err)
-                        return err;
-        }
-        return 0;
-}
 static struct rtc_class_ops rx8025_rtc_ops = {
        .read_time = rx8025_get_time,
        .set_time = rx8025_set_time,
        .read_alarm = rx8025_read_alarm,
        .set_alarm = rx8025_set_alarm,
        .alarm_irq_enable = rx8025_alarm_irq_enable,
-        .irq_set_state  = rx8025_irq_set_state,
 };
 /*
@@ -650,7 +625,7 @@ static int __devexit rx8025_remove(struct i2c_client *client)
                mutex_unlock(lock);
                free_irq(client->irq, client);
-                flush_scheduled_work();
+                cancel_work_sync(&rx8025->work);
        }
        rx8025_sysfs_unregister(&client->dev);
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index f57a87f4ae96..16512ecae31a 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -46,6 +46,7 @@ static struct clk *rtc_clk;
 static void __iomem *s3c_rtc_base;
 static int s3c_rtc_alarmno = NO_IRQ;
 static int s3c_rtc_tickno  = NO_IRQ;
+static bool wake_en;
 static enum s3c_cpu_type s3c_rtc_cpu_type;
 static DEFINE_SPINLOCK(s3c_rtc_pie_lock);
@@ -77,47 +78,18 @@ static irqreturn_t s3c_rtc_tickirq(int irq, void *id)
 }
 /* Update control registers */
-static void s3c_rtc_setaie(int to)
+static int s3c_rtc_setaie(struct device *dev, unsigned int enabled)
 {
        unsigned int tmp;
-        pr_debug("%s: aie=%d\n", __func__, to);
+        pr_debug("%s: aie=%d\n", __func__, enabled);
        tmp = readb(s3c_rtc_base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;
-        if (to)
+        if (enabled)
                tmp |= S3C2410_RTCALM_ALMEN;
        writeb(tmp, s3c_rtc_base + S3C2410_RTCALM);
-}
-static int s3c_rtc_setpie(struct device *dev, int enabled)
-{
-        unsigned int tmp;
-        pr_debug("%s: pie=%d\n", __func__, enabled);
-        spin_lock_irq(&s3c_rtc_pie_lock);
-        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
-                tmp = readb(s3c_rtc_base + S3C2410_RTCCON);
-                tmp &= ~S3C64XX_RTCCON_TICEN;
-                if (enabled)
-                        tmp |= S3C64XX_RTCCON_TICEN;
-                writew(tmp, s3c_rtc_base + S3C2410_RTCCON);
-        } else {
-                tmp = readb(s3c_rtc_base + S3C2410_TICNT);
-                tmp &= ~S3C2410_TICNT_ENABLE;
-                if (enabled)
-                        tmp |= S3C2410_TICNT_ENABLE;
-                writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
-        }
-        spin_unlock_irq(&s3c_rtc_pie_lock);
        return 0;
 }
@@ -171,8 +143,8 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
                goto retry_get_time;
        }
-        pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n",
+        pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n",
-                 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
+                 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
                 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
@@ -185,7 +157,7 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
        rtc_tm->tm_year += 100;
        rtc_tm->tm_mon -= 1;
-        return 0;
+        return rtc_valid_tm(rtc_tm);
 }
 static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
@@ -193,8 +165,8 @@ static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
        void __iomem *base = s3c_rtc_base;
        int year = tm->tm_year - 100;
-        pr_debug("set time %02d.%02d.%02d %02d/%02d/%02d\n",
+        pr_debug("set time %04d.%02d.%02d %02d:%02d:%02d\n",
-                 tm->tm_year, tm->tm_mon, tm->tm_mday,
+                 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
                 tm->tm_hour, tm->tm_min, tm->tm_sec);
        /* we get around y2k by simply not supporting it */
@@ -231,9 +203,9 @@ static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
        alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;
-        pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
+        pr_debug("read alarm %d, %04d.%02d.%02d %02d:%02d:%02d\n",
                 alm_en,
-                 alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
+                 1900 + alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
                 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
@@ -242,34 +214,34 @@ static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
        if (alm_en & S3C2410_RTCALM_SECEN)
                alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
        else
-                alm_tm->tm_sec = 0xff;
+                alm_tm->tm_sec = -1;
        if (alm_en & S3C2410_RTCALM_MINEN)
                alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
        else
-                alm_tm->tm_min = 0xff;
+                alm_tm->tm_min = -1;
        if (alm_en & S3C2410_RTCALM_HOUREN)
                alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
        else
-                alm_tm->tm_hour = 0xff;
+                alm_tm->tm_hour = -1;
        if (alm_en & S3C2410_RTCALM_DAYEN)
                alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
        else
-                alm_tm->tm_mday = 0xff;
+                alm_tm->tm_mday = -1;
        if (alm_en & S3C2410_RTCALM_MONEN) {
                alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
                alm_tm->tm_mon -= 1;
        } else {
-                alm_tm->tm_mon = 0xff;
+                alm_tm->tm_mon = -1;
        }
        if (alm_en & S3C2410_RTCALM_YEAREN)
                alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
        else
-                alm_tm->tm_year = 0xffff;
+                alm_tm->tm_year = -1;
        return 0;
 }
@@ -280,10 +252,10 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
        void __iomem *base = s3c_rtc_base;
        unsigned int alrm_en;
-        pr_debug("s3c_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
+        pr_debug("s3c_rtc_setalarm: %d, %04d.%02d.%02d %02d:%02d:%02d\n",
                 alrm->enabled,
-                 tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
+                 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
-                 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);
+                 tm->tm_hour, tm->tm_min, tm->tm_sec);
        alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
@@ -308,7 +280,7 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
        writeb(alrm_en, base + S3C2410_RTCALM);
-        s3c_rtc_setaie(alrm->enabled);
+        s3c_rtc_setaie(dev, alrm->enabled);
        return 0;
 }
@@ -318,7 +290,7 @@ static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
        unsigned int ticnt;
        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
-                ticnt = readb(s3c_rtc_base + S3C2410_RTCCON);
+                ticnt = readw(s3c_rtc_base + S3C2410_RTCCON);
                ticnt &= S3C64XX_RTCCON_TICEN;
        } else {
                ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
@@ -365,7 +337,6 @@ static void s3c_rtc_release(struct device *dev)
        /* do not clear AIE here, it may be needed for wake */
-        s3c_rtc_setpie(dev, 0);
        free_irq(s3c_rtc_alarmno, rtc_dev);
        free_irq(s3c_rtc_tickno, rtc_dev);
 }
@@ -377,9 +348,8 @@ static const struct rtc_class_ops s3c_rtcops = {
        .set_time       = s3c_rtc_settime,
        .read_alarm     = s3c_rtc_getalarm,
        .set_alarm      = s3c_rtc_setalarm,
-        .irq_set_freq   = s3c_rtc_setfreq,
+        .proc           = s3c_rtc_proc,
-        .irq_set_state  = s3c_rtc_setpie,
+        .alarm_irq_enable = s3c_rtc_setaie,
-        .proc           = s3c_rtc_proc,
 };
 static void s3c_rtc_enable(struct platform_device *pdev, int en)
@@ -391,11 +361,11 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
                return;
        if (!en) {
-                tmp = readb(base + S3C2410_RTCCON);
+                tmp = readw(base + S3C2410_RTCCON);
                if (s3c_rtc_cpu_type == TYPE_S3C64XX)
                        tmp &= ~S3C64XX_RTCCON_TICEN;
                tmp &= ~S3C2410_RTCCON_RTCEN;
-                writeb(tmp, base + S3C2410_RTCCON);
+                writew(tmp, base + S3C2410_RTCCON);
                if (s3c_rtc_cpu_type == TYPE_S3C2410) {
                        tmp = readb(base + S3C2410_TICNT);
@@ -405,25 +375,28 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
        } else {
                /* re-enable the device, and check it is ok */
-                if ((readb(base+S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0){
+                if ((readw(base+S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0) {
                        dev_info(&pdev->dev, "rtc disabled, re-enabling\n");
-                        tmp = readb(base + S3C2410_RTCCON);
+                        tmp = readw(base + S3C2410_RTCCON);
-                        writeb(tmp|S3C2410_RTCCON_RTCEN, base+S3C2410_RTCCON);
+                        writew(tmp | S3C2410_RTCCON_RTCEN,
+                                base + S3C2410_RTCCON);
                }
-                if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)){
+                if ((readw(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)) {
                        dev_info(&pdev->dev, "removing RTCCON_CNTSEL\n");
-                        tmp = readb(base + S3C2410_RTCCON);
+                        tmp = readw(base + S3C2410_RTCCON);
-                        writeb(tmp& ~S3C2410_RTCCON_CNTSEL, base+S3C2410_RTCCON);
+                        writew(tmp & ~S3C2410_RTCCON_CNTSEL,
+                                base + S3C2410_RTCCON);
                }
-                if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)){
+                if ((readw(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)) {
                        dev_info(&pdev->dev, "removing RTCCON_CLKRST\n");
-                        tmp = readb(base + S3C2410_RTCCON);
+                        tmp = readw(base + S3C2410_RTCCON);
-                        writeb(tmp & ~S3C2410_RTCCON_CLKRST, base+S3C2410_RTCCON);
+                        writew(tmp & ~S3C2410_RTCCON_CLKRST,
+                                base + S3C2410_RTCCON);
                }
        }
 }
@@ -435,8 +408,7 @@ static int __devexit s3c_rtc_remove(struct platform_device *dev)
        platform_set_drvdata(dev, NULL);
        rtc_device_unregister(rtc);
-        s3c_rtc_setpie(&dev->dev, 0);
+        s3c_rtc_setaie(&dev->dev, 0);
-        s3c_rtc_setaie(0);
        clk_disable(rtc_clk);
        clk_put(rtc_clk);
@@ -452,8 +424,8 @@ static int __devexit s3c_rtc_remove(struct platform_device *dev)
 static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
+        struct rtc_time rtc_tm;
        struct resource *res;
-        unsigned int tmp, i;
        int ret;
        pr_debug("%s: probe=%p\n", __func__, pdev);
@@ -514,8 +486,8 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
        s3c_rtc_enable(pdev, 1);
-        pr_debug("s3c2410_rtc: RTCCON=%02x\n",
+        pr_debug("s3c2410_rtc: RTCCON=%02x\n",
-                 readb(s3c_rtc_base + S3C2410_RTCCON));
+                 readw(s3c_rtc_base + S3C2410_RTCCON));
        device_init_wakeup(&pdev->dev, 1);
@@ -534,11 +506,19 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
        /* Check RTC Time */
-        for (i = S3C2410_RTCSEC; i <= S3C2410_RTCYEAR; i += 0x4) {
+        s3c_rtc_gettime(NULL, &rtc_tm);
-                tmp = readb(s3c_rtc_base + i);
+        if (rtc_valid_tm(&rtc_tm)) {
+                rtc_tm.tm_year  = 100;
+                rtc_tm.tm_mon   = 0;
+                rtc_tm.tm_mday  = 1;
+                rtc_tm.tm_hour  = 0;
+                rtc_tm.tm_min   = 0;
+                rtc_tm.tm_sec   = 0;
-                if ((tmp & 0xf) > 0x9 || ((tmp >> 4) & 0xf) > 0x9)
+                s3c_rtc_settime(NULL, &rtc_tm);
-                        writeb(0, s3c_rtc_base + i);
+                dev_warn(&pdev->dev, "warning: invalid RTC value so initializing it\n");
        }
        if (s3c_rtc_cpu_type == TYPE_S3C64XX)
@@ -578,13 +558,17 @@ static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state)
        /* 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 = readb(s3c_rtc_base + S3C2410_RTCCON);
+                ticnt_en_save = readw(s3c_rtc_base + S3C2410_RTCCON);
                ticnt_en_save &= S3C64XX_RTCCON_TICEN;
        }
        s3c_rtc_enable(pdev, 0);
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(&pdev->dev) && !wake_en) {
-                enable_irq_wake(s3c_rtc_alarmno);
+                if (enable_irq_wake(s3c_rtc_alarmno) == 0)
+                        wake_en = true;
+                else
+                        dev_err(&pdev->dev, "enable_irq_wake failed\n");
+        }
        return 0;
 }
@@ -596,12 +580,14 @@ static int s3c_rtc_resume(struct platform_device *pdev)
        s3c_rtc_enable(pdev, 1);
        writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
        if (s3c_rtc_cpu_type == TYPE_S3C64XX && ticnt_en_save) {
-                tmp = readb(s3c_rtc_base + S3C2410_RTCCON);
+                tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
-                writeb(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
+                writew(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
        }
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(&pdev->dev) && wake_en) {
                disable_irq_wake(s3c_rtc_alarmno);
+                wake_en = false;
+        }
        return 0;
 }
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index e4a44b641702..0b40bb88a884 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -39,11 +39,10 @@
 #include <mach/regs-ost.h>
 #endif
-#define RTC_DEF_DIVIDER         32768 - 1
+#define RTC_DEF_DIVIDER         (32768 - 1)
 #define RTC_DEF_TRIM            0
-static unsigned long rtc_freq = 1024;
+static const unsigned long RTC_FREQ = 1024;
-static unsigned long timer_freq;
 static struct rtc_time rtc_alarm;
 static DEFINE_SPINLOCK(sa1100_rtc_lock);
@@ -61,7 +60,8 @@ static inline int rtc_periodic_alarm(struct rtc_time *tm)
 * Calculate the next alarm time given the requested alarm time mask
 * and the current time.
 */
-static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now, struct rtc_time *alrm)
+static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now,
+        struct rtc_time *alrm)
 {
        unsigned long next_time;
        unsigned long now_time;
@@ -116,7 +116,23 @@ static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id)
        rtsr = RTSR;
        /* clear interrupt sources */
        RTSR = 0;
-        RTSR = (RTSR_AL | RTSR_HZ) & (rtsr >> 2);
+        /* Fix for a nasty initialization problem the in SA11xx RTSR register.
+         * See also the comments in sa1100_rtc_probe(). */
+        if (rtsr & (RTSR_ALE | RTSR_HZE)) {
+                /* This is the original code, before there was the if test
+                 * above. This code does not clear interrupts that were not
+                 * enabled. */
+                RTSR = (RTSR_AL | RTSR_HZ) & (rtsr >> 2);
+        } else {
+                /* For some reason, it is possible to enter this routine
+                 * without interruptions enabled, it has been tested with
+                 * several units (Bug in SA11xx chip?).
+                 *
+                 * This situation leads to an infinite "loop" of interrupt
+                 * routine calling and as a result the processor seems to
+                 * lock on its first call to open(). */
+                RTSR = RTSR_AL | RTSR_HZ;
+        }
        /* clear alarm interrupt if it has occurred */
        if (rtsr & RTSR_AL)
@@ -139,80 +155,29 @@ static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
-static int rtc_timer1_count;
-static irqreturn_t timer1_interrupt(int irq, void *dev_id)
-{
-        struct platform_device *pdev = to_platform_device(dev_id);
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        /*
-         * If we match for the first time, rtc_timer1_count will be 1.
-         * Otherwise, we wrapped around (very unlikely but
-         * still possible) so compute the amount of missed periods.
-         * The match reg is updated only when the data is actually retrieved
-         * to avoid unnecessary interrupts.
-         */
-        OSSR = OSSR_M1; /* clear match on timer1 */
-        rtc_update_irq(rtc, rtc_timer1_count, RTC_PF | RTC_IRQF);
-        if (rtc_timer1_count == 1)
-                rtc_timer1_count = (rtc_freq * ((1 << 30) / (timer_freq >> 2)));
-        return IRQ_HANDLED;
-}
-static int sa1100_rtc_read_callback(struct device *dev, int data)
-{
-        if (data & RTC_PF) {
-                /* interpolate missed periods and set match for the next */
-                unsigned long period = timer_freq / rtc_freq;
-                unsigned long oscr = OSCR;
-                unsigned long osmr1 = OSMR1;
-                unsigned long missed = (oscr - osmr1)/period;
-                data += missed << 8;
-                OSSR = OSSR_M1; /* clear match on timer 1 */
-                OSMR1 = osmr1 + (missed + 1)*period;
-                /* Ensure we didn't miss another match in the mean time.
-                 * Here we compare (match - OSCR) 8 instead of 0 --
-                 * see comment in pxa_timer_interrupt() for explanation.
-                 */
-                while( (signed long)((osmr1 = OSMR1) - OSCR) <= 8 ) {
-                        data += 0x100;
-                        OSSR = OSSR_M1; /* clear match on timer 1 */
-                        OSMR1 = osmr1 + period;
-                }
-        }
-        return data;
-}
 static int sa1100_rtc_open(struct device *dev)
 {
        int ret;
+        struct platform_device *plat_dev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
        ret = request_irq(IRQ_RTC1Hz, sa1100_rtc_interrupt, IRQF_DISABLED,
-                                "rtc 1Hz", dev);
+                "rtc 1Hz", dev);
        if (ret) {
                dev_err(dev, "IRQ %d already in use.\n", IRQ_RTC1Hz);
                goto fail_ui;
        }
        ret = request_irq(IRQ_RTCAlrm, sa1100_rtc_interrupt, IRQF_DISABLED,
-                                "rtc Alrm", dev);
+                "rtc Alrm", dev);
        if (ret) {
                dev_err(dev, "IRQ %d already in use.\n", IRQ_RTCAlrm);
                goto fail_ai;
        }
-        ret = request_irq(IRQ_OST1, timer1_interrupt, IRQF_DISABLED,
+        rtc->max_user_freq = RTC_FREQ;
-                                "rtc timer", dev);
+        rtc_irq_set_freq(rtc, NULL, RTC_FREQ);
-        if (ret) {
-                dev_err(dev, "IRQ %d already in use.\n", IRQ_OST1);
-                goto fail_pi;
-        }
        return 0;
- fail_pi:
-        free_irq(IRQ_RTCAlrm, dev);
 fail_ai:
        free_irq(IRQ_RTC1Hz, dev);
 fail_ui:
@@ -227,57 +192,19 @@ static void sa1100_rtc_release(struct device *dev)
        OSSR = OSSR_M1;
        spin_unlock_irq(&sa1100_rtc_lock);
-        free_irq(IRQ_OST1, dev);
        free_irq(IRQ_RTCAlrm, dev);
        free_irq(IRQ_RTC1Hz, dev);
 }
+static int sa1100_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-static int sa1100_rtc_ioctl(struct device *dev, unsigned int cmd,
-                unsigned long arg)
 {
-        switch(cmd) {
+        spin_lock_irq(&sa1100_rtc_lock);
-        case RTC_AIE_OFF:
+        if (enabled)
-                spin_lock_irq(&sa1100_rtc_lock);
-                RTSR &= ~RTSR_ALE;
-                spin_unlock_irq(&sa1100_rtc_lock);
-                return 0;
-        case RTC_AIE_ON:
-                spin_lock_irq(&sa1100_rtc_lock);
                RTSR |= RTSR_ALE;
-                spin_unlock_irq(&sa1100_rtc_lock);
+        else
-                return 0;
+                RTSR &= ~RTSR_ALE;
-        case RTC_UIE_OFF:
+        spin_unlock_irq(&sa1100_rtc_lock);
-                spin_lock_irq(&sa1100_rtc_lock);
+        return 0;
-                RTSR &= ~RTSR_HZE;
-                spin_unlock_irq(&sa1100_rtc_lock);
-                return 0;
-        case RTC_UIE_ON:
-                spin_lock_irq(&sa1100_rtc_lock);
-                RTSR |= RTSR_HZE;
-                spin_unlock_irq(&sa1100_rtc_lock);
-                return 0;
-        case RTC_PIE_OFF:
-                spin_lock_irq(&sa1100_rtc_lock);
-                OIER &= ~OIER_E1;
-                spin_unlock_irq(&sa1100_rtc_lock);
-                return 0;
-        case RTC_PIE_ON:
-                spin_lock_irq(&sa1100_rtc_lock);
-                OSMR1 = timer_freq / rtc_freq + OSCR;
-                OIER |= OIER_E1;
-                rtc_timer1_count = 1;
-                spin_unlock_irq(&sa1100_rtc_lock);
-                return 0;
-        case RTC_IRQP_READ:
-                return put_user(rtc_freq, (unsigned long *)arg);
-        case RTC_IRQP_SET:
-                if (arg < 1 || arg > timer_freq)
-                        return -EINVAL;
-                rtc_freq = arg;
-                return 0;
-        }
-        return -ENOIOCTLCMD;
 }
 static int sa1100_rtc_read_time(struct device *dev, struct rtc_time *tm)
@@ -327,34 +254,27 @@ static int sa1100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 static int sa1100_rtc_proc(struct device *dev, struct seq_file *seq)
 {
-        seq_printf(seq, "trim/divider\t: 0x%08x\n", (u32) RTTR);
+        seq_printf(seq, "trim/divider\t\t: 0x%08x\n", (u32) RTTR);
-        seq_printf(seq, "update_IRQ\t: %s\n",
+        seq_printf(seq, "RTSR\t\t\t: 0x%08x\n", (u32)RTSR);
-                        (RTSR & RTSR_HZE) ? "yes" : "no");
-        seq_printf(seq, "periodic_IRQ\t: %s\n",
-                        (OIER & OIER_E1) ? "yes" : "no");
-        seq_printf(seq, "periodic_freq\t: %ld\n", rtc_freq);
        return 0;
 }
 static const struct rtc_class_ops sa1100_rtc_ops = {
        .open = sa1100_rtc_open,
-        .read_callback = sa1100_rtc_read_callback,
        .release = sa1100_rtc_release,
-        .ioctl = sa1100_rtc_ioctl,
        .read_time = sa1100_rtc_read_time,
        .set_time = sa1100_rtc_set_time,
        .read_alarm = sa1100_rtc_read_alarm,
        .set_alarm = sa1100_rtc_set_alarm,
        .proc = sa1100_rtc_proc,
+        .alarm_irq_enable = sa1100_rtc_alarm_irq_enable,
 };
 static int sa1100_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
-        timer_freq = get_clock_tick_rate();
        /*
         * According to the manual we should be able to let RTTR be zero
         * and then a default diviser for a 32.768KHz clock is used.
@@ -364,7 +284,8 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
         */
        if (RTTR == 0) {
                RTTR = RTC_DEF_DIVIDER + (RTC_DEF_TRIM << 16);
-                dev_warn(&pdev->dev, "warning: initializing default clock divider/trim value\n");
+                dev_warn(&pdev->dev, "warning: "
+                        "initializing default clock divider/trim value\n");
                /* The current RTC value probably doesn't make sense either */
                RCNR = 0;
        }
@@ -372,13 +293,37 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
        device_init_wakeup(&pdev->dev, 1);
        rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops,
-                                THIS_MODULE);
+                THIS_MODULE);
        if (IS_ERR(rtc))
                return PTR_ERR(rtc);
        platform_set_drvdata(pdev, rtc);
+        /* Fix for a nasty initialization problem the in SA11xx RTSR register.
+         * See also the comments in sa1100_rtc_interrupt().
+         *
+         * Sometimes bit 1 of the RTSR (RTSR_HZ) will wake up 1, which means an
+         * interrupt pending, even though interrupts were never enabled.
+         * In this case, this bit it must be reset before enabling
+         * interruptions to avoid a nonexistent interrupt to occur.
+         *
+         * In principle, the same problem would apply to bit 0, although it has
+         * never been observed to happen.
+         *
+         * This issue is addressed both here and in sa1100_rtc_interrupt().
+         * If the issue is not addressed here, in the times when the processor
+         * wakes up with the bit set there will be one spurious interrupt.
+         *
+         * The issue is also dealt with in sa1100_rtc_interrupt() to be on the
+         * safe side, once the condition that lead to this strange
+         * initialization is unknown and could in principle happen during
+         * normal processing.
+         *
+         * Notice that clearing bit 1 and 0 is accomplished by writting ONES to
+         * the corresponding bits in RTSR. */
+        RTSR = RTSR_AL | RTSR_HZ;
        return 0;
 }
@@ -386,7 +331,7 @@ static int sa1100_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        if (rtc)
+        if (rtc)
                rtc_device_unregister(rtc);
        return 0;
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 5efbd5990ff8..6ac55fd48413 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -344,29 +344,10 @@ static inline void sh_rtc_setcie(struct device *dev, unsigned int enable)
        spin_unlock_irq(&rtc->lock);
 }
-static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int sh_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
-        struct sh_rtc *rtc = dev_get_drvdata(dev);
+        sh_rtc_setaie(dev, enabled);
-        unsigned int ret = 0;
+        return 0;
-        switch (cmd) {
-        case RTC_AIE_OFF:
-        case RTC_AIE_ON:
-                sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
-                break;
-        case RTC_UIE_OFF:
-                rtc->periodic_freq &= ~PF_OXS;
-                sh_rtc_setcie(dev, 0);
-                break;
-        case RTC_UIE_ON:
-                rtc->periodic_freq |= PF_OXS;
-                sh_rtc_setcie(dev, 1);
-                break;
-        default:
-                ret = -ENOIOCTLCMD;
-        }
-        return ret;
 }
 static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
@@ -596,14 +577,12 @@ static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
 }
 static struct rtc_class_ops sh_rtc_ops = {
-        .ioctl          = sh_rtc_ioctl,
        .read_time      = sh_rtc_read_time,
        .set_time       = sh_rtc_set_time,
        .read_alarm     = sh_rtc_read_alarm,
        .set_alarm      = sh_rtc_set_alarm,
-        .irq_set_state  = sh_rtc_irq_set_state,
-        .irq_set_freq   = sh_rtc_irq_set_freq,
        .proc           = sh_rtc_proc,
+        .alarm_irq_enable = sh_rtc_alarm_irq_enable,
 };
 static int __init sh_rtc_probe(struct platform_device *pdev)
@@ -761,7 +740,7 @@ err_unmap:
        clk_put(rtc->clk);
        iounmap(rtc->regbase);
 err_badmap:
-        release_resource(rtc->res);
+        release_mem_region(rtc->res->start, rtc->regsize);
 err_badres:
        kfree(rtc);
@@ -786,7 +765,7 @@ static int __exit sh_rtc_remove(struct platform_device *pdev)
        }
        iounmap(rtc->regbase);
-        release_resource(rtc->res);
+        release_mem_region(rtc->res->start, rtc->regsize);
        clk_disable(rtc->clk);
        clk_put(rtc->clk);
@@ -803,11 +782,11 @@ static void sh_rtc_set_irq_wake(struct device *dev, int enabled)
        struct platform_device *pdev = to_platform_device(dev);
        struct sh_rtc *rtc = platform_get_drvdata(pdev);
-        set_irq_wake(rtc->periodic_irq, enabled);
+        irq_set_irq_wake(rtc->periodic_irq, enabled);
        if (rtc->carry_irq > 0) {
-                set_irq_wake(rtc->carry_irq, enabled);
+                irq_set_irq_wake(rtc->carry_irq, enabled);
-                set_irq_wake(rtc->alarm_irq, enabled);
+                irq_set_irq_wake(rtc->alarm_irq, enabled);
        }
 }
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
new file mode 100644
index 000000000000..893bac2bb21b
--- /dev/null
+++ b/drivers/rtc/rtc-spear.c
@@ -0,0 +1,534 @@
+/*
+ * drivers/rtc/rtc-spear.c
+ *
+ * Copyright (C) 2010 ST Microelectronics
+ * Rajeev Kumar<rajeev-dlh.kumar@st.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+#include <linux/bcd.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+/* RTC registers */
+#define TIME_REG                0x00
+#define DATE_REG                0x04
+#define ALARM_TIME_REG          0x08
+#define ALARM_DATE_REG          0x0C
+#define CTRL_REG                0x10
+#define STATUS_REG              0x14
+/* TIME_REG & ALARM_TIME_REG */
+#define SECONDS_UNITS           (0xf<<0)        /* seconds units position */
+#define SECONDS_TENS            (0x7<<4)        /* seconds tens position */
+#define MINUTES_UNITS           (0xf<<8)        /* minutes units position */
+#define MINUTES_TENS            (0x7<<12)       /* minutes tens position */
+#define HOURS_UNITS             (0xf<<16)       /* hours units position */
+#define HOURS_TENS              (0x3<<20)       /* hours tens position */
+/* DATE_REG & ALARM_DATE_REG */
+#define DAYS_UNITS              (0xf<<0)        /* days units position */
+#define DAYS_TENS               (0x3<<4)        /* days tens position */
+#define MONTHS_UNITS            (0xf<<8)        /* months units position */
+#define MONTHS_TENS             (0x1<<12)       /* months tens position */
+#define YEARS_UNITS             (0xf<<16)       /* years units position */
+#define YEARS_TENS              (0xf<<20)       /* years tens position */
+#define YEARS_HUNDREDS          (0xf<<24)       /* years hundereds position */
+#define YEARS_MILLENIUMS        (0xf<<28)       /* years millenium position */
+/* MASK SHIFT TIME_REG & ALARM_TIME_REG*/
+#define SECOND_SHIFT            0x00            /* seconds units */
+#define MINUTE_SHIFT            0x08            /* minutes units position */
+#define HOUR_SHIFT              0x10            /* hours units position */
+#define MDAY_SHIFT              0x00            /* Month day shift */
+#define MONTH_SHIFT             0x08            /* Month shift */
+#define YEAR_SHIFT              0x10            /* Year shift */
+#define SECOND_MASK             0x7F
+#define MIN_MASK                0x7F
+#define HOUR_MASK               0x3F
+#define DAY_MASK                0x3F
+#define MONTH_MASK              0x7F
+#define YEAR_MASK               0xFFFF
+/* date reg equal to time reg, for debug only */
+#define TIME_BYP                (1<<9)
+#define INT_ENABLE              (1<<31)         /* interrupt enable */
+/* STATUS_REG */
+#define CLK_UNCONNECTED         (1<<0)
+#define PEND_WR_TIME            (1<<2)
+#define PEND_WR_DATE            (1<<3)
+#define LOST_WR_TIME            (1<<4)
+#define LOST_WR_DATE            (1<<5)
+#define RTC_INT_MASK            (1<<31)
+#define STATUS_BUSY             (PEND_WR_TIME | PEND_WR_DATE)
+#define STATUS_FAIL             (LOST_WR_TIME | LOST_WR_DATE)
+struct spear_rtc_config {
+        struct clk *clk;
+        spinlock_t lock;
+        void __iomem *ioaddr;
+};
+static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config)
+{
+        unsigned int val;
+        unsigned long flags;
+        spin_lock_irqsave(&config->lock, flags);
+        val = readl(config->ioaddr + STATUS_REG);
+        val |= RTC_INT_MASK;
+        writel(val, config->ioaddr + STATUS_REG);
+        spin_unlock_irqrestore(&config->lock, flags);
+}
+static inline void spear_rtc_enable_interrupt(struct spear_rtc_config *config)
+{
+        unsigned int val;
+        val = readl(config->ioaddr + CTRL_REG);
+        if (!(val & INT_ENABLE)) {
+                spear_rtc_clear_interrupt(config);
+                val |= INT_ENABLE;
+                writel(val, config->ioaddr + CTRL_REG);
+        }
+}
+static inline void spear_rtc_disable_interrupt(struct spear_rtc_config *config)
+{
+        unsigned int val;
+        val = readl(config->ioaddr + CTRL_REG);
+        if (val & INT_ENABLE) {
+                val &= ~INT_ENABLE;
+                writel(val, config->ioaddr + CTRL_REG);
+        }
+}
+static inline int is_write_complete(struct spear_rtc_config *config)
+{
+        int ret = 0;
+        unsigned long flags;
+        spin_lock_irqsave(&config->lock, flags);
+        if ((readl(config->ioaddr + STATUS_REG)) & STATUS_FAIL)
+                ret = -EIO;
+        spin_unlock_irqrestore(&config->lock, flags);
+        return ret;
+}
+static void rtc_wait_not_busy(struct spear_rtc_config *config)
+{
+        int status, count = 0;
+        unsigned long flags;
+        /* Assuming BUSY may stay active for 80 msec) */
+        for (count = 0; count < 80; count++) {
+                spin_lock_irqsave(&config->lock, flags);
+                status = readl(config->ioaddr + STATUS_REG);
+                spin_unlock_irqrestore(&config->lock, flags);
+                if ((status & STATUS_BUSY) == 0)
+                        break;
+                /* check status busy, after each msec */
+                msleep(1);
+        }
+}
+static irqreturn_t spear_rtc_irq(int irq, void *dev_id)
+{
+        struct rtc_device *rtc = (struct rtc_device *)dev_id;
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        unsigned long flags, events = 0;
+        unsigned int irq_data;
+        spin_lock_irqsave(&config->lock, flags);
+        irq_data = readl(config->ioaddr + STATUS_REG);
+        spin_unlock_irqrestore(&config->lock, flags);
+        if ((irq_data & RTC_INT_MASK)) {
+                spear_rtc_clear_interrupt(config);
+                events = RTC_IRQF | RTC_AF;
+                rtc_update_irq(rtc, 1, events);
+                return IRQ_HANDLED;
+        } else
+                return IRQ_NONE;
+}
+static int tm2bcd(struct rtc_time *tm)
+{
+        if (rtc_valid_tm(tm) != 0)
+                return -EINVAL;
+        tm->tm_sec = bin2bcd(tm->tm_sec);
+        tm->tm_min = bin2bcd(tm->tm_min);
+        tm->tm_hour = bin2bcd(tm->tm_hour);
+        tm->tm_mday = bin2bcd(tm->tm_mday);
+        tm->tm_mon = bin2bcd(tm->tm_mon + 1);
+        tm->tm_year = bin2bcd(tm->tm_year);
+        return 0;
+}
+static void bcd2tm(struct rtc_time *tm)
+{
+        tm->tm_sec = bcd2bin(tm->tm_sec);
+        tm->tm_min = bcd2bin(tm->tm_min);
+        tm->tm_hour = bcd2bin(tm->tm_hour);
+        tm->tm_mday = bcd2bin(tm->tm_mday);
+        tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
+        /* epoch == 1900 */
+        tm->tm_year = bcd2bin(tm->tm_year);
+}
+/*
+ * spear_rtc_read_time - set the time
+ * @dev: rtc device in use
+ * @tm: holds date and time
+ *
+ * This function read time and date. On success it will return 0
+ * otherwise -ve error is returned.
+ */
+static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        unsigned int time, date;
+        /* we don't report wday/yday/isdst ... */
+        rtc_wait_not_busy(config);
+        time = readl(config->ioaddr + TIME_REG);
+        date = readl(config->ioaddr + DATE_REG);
+        tm->tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
+        tm->tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
+        tm->tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
+        tm->tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
+        tm->tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
+        tm->tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
+        bcd2tm(tm);
+        return 0;
+}
+/*
+ * spear_rtc_set_time - set the time
+ * @dev: rtc device in use
+ * @tm: holds date and time
+ *
+ * This function set time and date. On success it will return 0
+ * otherwise -ve error is returned.
+ */
+static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        unsigned int time, date, err = 0;
+        if (tm2bcd(tm) < 0)
+                return -EINVAL;
+        rtc_wait_not_busy(config);
+        time = (tm->tm_sec << SECOND_SHIFT) | (tm->tm_min << MINUTE_SHIFT) |
+                (tm->tm_hour << HOUR_SHIFT);
+        date = (tm->tm_mday << MDAY_SHIFT) | (tm->tm_mon << MONTH_SHIFT) |
+                (tm->tm_year << YEAR_SHIFT);
+        writel(time, config->ioaddr + TIME_REG);
+        writel(date, config->ioaddr + DATE_REG);
+        err = is_write_complete(config);
+        if (err < 0)
+                return err;
+        return 0;
+}
+/*
+ * spear_rtc_read_alarm - read the alarm time
+ * @dev: rtc device in use
+ * @alm: holds alarm date and time
+ *
+ * This function read alarm time and date. On success it will return 0
+ * otherwise -ve error is returned.
+ */
+static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        unsigned int time, date;
+        rtc_wait_not_busy(config);
+        time = readl(config->ioaddr + ALARM_TIME_REG);
+        date = readl(config->ioaddr + ALARM_DATE_REG);
+        alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK;
+        alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK;
+        alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK;
+        alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK;
+        alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK;
+        alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK;
+        bcd2tm(&alm->time);
+        alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE;
+        return 0;
+}
+/*
+ * spear_rtc_set_alarm - set the alarm time
+ * @dev: rtc device in use
+ * @alm: holds alarm date and time
+ *
+ * This function set alarm time and date. On success it will return 0
+ * otherwise -ve error is returned.
+ */
+static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        unsigned int time, date, err = 0;
+        if (tm2bcd(&alm->time) < 0)
+                return -EINVAL;
+        rtc_wait_not_busy(config);
+        time = (alm->time.tm_sec << SECOND_SHIFT) | (alm->time.tm_min <<
+                        MINUTE_SHIFT) | (alm->time.tm_hour << HOUR_SHIFT);
+        date = (alm->time.tm_mday << MDAY_SHIFT) | (alm->time.tm_mon <<
+                        MONTH_SHIFT) | (alm->time.tm_year << YEAR_SHIFT);
+        writel(time, config->ioaddr + ALARM_TIME_REG);
+        writel(date, config->ioaddr + ALARM_DATE_REG);
+        err = is_write_complete(config);
+        if (err < 0)
+                return err;
+        if (alm->enabled)
+                spear_rtc_enable_interrupt(config);
+        else
+                spear_rtc_disable_interrupt(config);
+        return 0;
+}
+static struct rtc_class_ops spear_rtc_ops = {
+        .read_time = spear_rtc_read_time,
+        .set_time = spear_rtc_set_time,
+        .read_alarm = spear_rtc_read_alarm,
+        .set_alarm = spear_rtc_set_alarm,
+};
+static int __devinit spear_rtc_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct rtc_device *rtc;
+        struct spear_rtc_config *config;
+        unsigned int status = 0;
+        int irq;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "no resource defined\n");
+                return -EBUSY;
+        }
+        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
+                dev_err(&pdev->dev, "rtc region already claimed\n");
+                return -EBUSY;
+        }
+        config = kzalloc(sizeof(*config), GFP_KERNEL);
+        if (!config) {
+                dev_err(&pdev->dev, "out of memory\n");
+                status = -ENOMEM;
+                goto err_release_region;
+        }
+        config->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(config->clk)) {
+                status = PTR_ERR(config->clk);
+                goto err_kfree;
+        }
+        status = clk_enable(config->clk);
+        if (status < 0)
+                goto err_clk_put;
+        config->ioaddr = ioremap(res->start, resource_size(res));
+        if (!config->ioaddr) {
+                dev_err(&pdev->dev, "ioremap fail\n");
+                status = -ENOMEM;
+                goto err_disable_clock;
+        }
+        spin_lock_init(&config->lock);
+        rtc = rtc_device_register(pdev->name, &pdev->dev, &spear_rtc_ops,
+                        THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
+                                PTR_ERR(rtc));
+                status = PTR_ERR(rtc);
+                goto err_iounmap;
+        }
+        platform_set_drvdata(pdev, rtc);
+        dev_set_drvdata(&rtc->dev, config);
+        /* alarm irqs */
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "no update irq?\n");
+                status = irq;
+                goto err_clear_platdata;
+        }
+        status = request_irq(irq, spear_rtc_irq, 0, pdev->name, rtc);
+        if (status) {
+                dev_err(&pdev->dev, "Alarm interrupt IRQ%d already \
+                                claimed\n", irq);
+                goto err_clear_platdata;
+        }
+        if (!device_can_wakeup(&pdev->dev))
+                device_init_wakeup(&pdev->dev, 1);
+        return 0;
+err_clear_platdata:
+        platform_set_drvdata(pdev, NULL);
+        dev_set_drvdata(&rtc->dev, NULL);
+        rtc_device_unregister(rtc);
+err_iounmap:
+        iounmap(config->ioaddr);
+err_disable_clock:
+        clk_disable(config->clk);
+err_clk_put:
+        clk_put(config->clk);
+err_kfree:
+        kfree(config);
+err_release_region:
+        release_mem_region(res->start, resource_size(res));
+        return status;
+}
+static int __devexit spear_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        int irq;
+        struct resource *res;
+        /* leave rtc running, but disable irqs */
+        spear_rtc_disable_interrupt(config);
+        device_init_wakeup(&pdev->dev, 0);
+        irq = platform_get_irq(pdev, 0);
+        if (irq)
+                free_irq(irq, pdev);
+        clk_disable(config->clk);
+        clk_put(config->clk);
+        iounmap(config->ioaddr);
+        kfree(config);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res)
+                release_mem_region(res->start, resource_size(res));
+        platform_set_drvdata(pdev, NULL);
+        dev_set_drvdata(&rtc->dev, NULL);
+        rtc_device_unregister(rtc);
+        return 0;
+}
+#ifdef CONFIG_PM
+static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        int irq;
+        irq = platform_get_irq(pdev, 0);
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(irq);
+        else {
+                spear_rtc_disable_interrupt(config);
+                clk_disable(config->clk);
+        }
+        return 0;
+}
+static int spear_rtc_resume(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        int irq;
+        irq = platform_get_irq(pdev, 0);
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(irq);
+        else {
+                clk_enable(config->clk);
+                spear_rtc_enable_interrupt(config);
+        }
+        return 0;
+}
+#else
+#define spear_rtc_suspend       NULL
+#define spear_rtc_resume        NULL
+#endif
+static void spear_rtc_shutdown(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        spear_rtc_disable_interrupt(config);
+        clk_disable(config->clk);
+}
+static struct platform_driver spear_rtc_driver = {
+        .probe = spear_rtc_probe,
+        .remove = __devexit_p(spear_rtc_remove),
+        .suspend = spear_rtc_suspend,
+        .resume = spear_rtc_resume,
+        .shutdown = spear_rtc_shutdown,
+        .driver = {
+                .name = "rtc-spear",
+        },
+};
+static int __init rtc_init(void)
+{
+        return platform_driver_register(&spear_rtc_driver);
+}
+module_init(rtc_init);
+static void __exit rtc_exit(void)
+{
+        platform_driver_unregister(&spear_rtc_driver);
+}
+module_exit(rtc_exit);
+MODULE_ALIAS("platform:rtc-spear");
+MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
+MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-stmp3xxx.c b/drivers/rtc/rtc-stmp3xxx.c
index 7e7d0c806f2d..572e9534b591 100644
--- a/drivers/rtc/rtc-stmp3xxx.c
+++ b/drivers/rtc/rtc-stmp3xxx.c
@@ -115,19 +115,6 @@ static int stmp3xxx_alarm_irq_enable(struct device *dev, unsigned int enabled)
        return 0;
 }
-static int stmp3xxx_update_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
-        if (enabled)
-                stmp3xxx_setl(BM_RTC_CTRL_ONEMSEC_IRQ_EN,
-                                rtc_data->io + HW_RTC_CTRL);
-        else
-                stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN,
-                                rtc_data->io + HW_RTC_CTRL);
-        return 0;
-}
 static int stmp3xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
@@ -149,8 +136,6 @@ static int stmp3xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 static struct rtc_class_ops stmp3xxx_rtc_ops = {
        .alarm_irq_enable =
                          stmp3xxx_alarm_irq_enable,
-        .update_irq_enable =
-                          stmp3xxx_update_irq_enable,
        .read_time      = stmp3xxx_rtc_gettime,
        .set_mmss       = stmp3xxx_rtc_set_mmss,
        .read_alarm     = stmp3xxx_rtc_read_alarm,
diff --git a/drivers/rtc/rtc-tegra.c b/drivers/rtc/rtc-tegra.c
new file mode 100644
index 000000000000..2fc31aac3f4e
--- /dev/null
+++ b/drivers/rtc/rtc-tegra.c
@@ -0,0 +1,488 @@
+/*
+ * An RTC driver for the NVIDIA Tegra 200 series internal RTC.
+ *
+ * Copyright (c) 2010, NVIDIA Corporation.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+/* set to 1 = busy every eight 32kHz clocks during copy of sec+msec to AHB */
+#define TEGRA_RTC_REG_BUSY                      0x004
+#define TEGRA_RTC_REG_SECONDS                   0x008
+/* when msec is read, the seconds are buffered into shadow seconds. */
+#define TEGRA_RTC_REG_SHADOW_SECONDS            0x00c
+#define TEGRA_RTC_REG_MILLI_SECONDS             0x010
+#define TEGRA_RTC_REG_SECONDS_ALARM0            0x014
+#define TEGRA_RTC_REG_SECONDS_ALARM1            0x018
+#define TEGRA_RTC_REG_MILLI_SECONDS_ALARM0      0x01c
+#define TEGRA_RTC_REG_INTR_MASK                 0x028
+/* write 1 bits to clear status bits */
+#define TEGRA_RTC_REG_INTR_STATUS               0x02c
+/* bits in INTR_MASK */
+#define TEGRA_RTC_INTR_MASK_MSEC_CDN_ALARM      (1<<4)
+#define TEGRA_RTC_INTR_MASK_SEC_CDN_ALARM       (1<<3)
+#define TEGRA_RTC_INTR_MASK_MSEC_ALARM          (1<<2)
+#define TEGRA_RTC_INTR_MASK_SEC_ALARM1          (1<<1)
+#define TEGRA_RTC_INTR_MASK_SEC_ALARM0          (1<<0)
+/* bits in INTR_STATUS */
+#define TEGRA_RTC_INTR_STATUS_MSEC_CDN_ALARM    (1<<4)
+#define TEGRA_RTC_INTR_STATUS_SEC_CDN_ALARM     (1<<3)
+#define TEGRA_RTC_INTR_STATUS_MSEC_ALARM        (1<<2)
+#define TEGRA_RTC_INTR_STATUS_SEC_ALARM1        (1<<1)
+#define TEGRA_RTC_INTR_STATUS_SEC_ALARM0        (1<<0)
+struct tegra_rtc_info {
+        struct platform_device  *pdev;
+        struct rtc_device       *rtc_dev;
+        void __iomem            *rtc_base; /* NULL if not initialized. */
+        int                     tegra_rtc_irq; /* alarm and periodic irq */
+        spinlock_t              tegra_rtc_lock;
+};
+/* RTC hardware is busy when it is updating its values over AHB once
+ * every eight 32kHz clocks (~250uS).
+ * outside of these updates the CPU is free to write.
+ * CPU is always free to read.
+ */
+static inline u32 tegra_rtc_check_busy(struct tegra_rtc_info *info)
+{
+        return readl(info->rtc_base + TEGRA_RTC_REG_BUSY) & 1;
+}
+/* Wait for hardware to be ready for writing.
+ * This function tries to maximize the amount of time before the next update.
+ * It does this by waiting for the RTC to become busy with its periodic update,
+ * then returning once the RTC first becomes not busy.
+ * This periodic update (where the seconds and milliseconds are copied to the
+ * AHB side) occurs every eight 32kHz clocks (~250uS).
+ * The behavior of this function allows us to make some assumptions without
+ * introducing a race, because 250uS is plenty of time to read/write a value.
+ */
+static int tegra_rtc_wait_while_busy(struct device *dev)
+{
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
+        int retries = 500; /* ~490 us is the worst case, ~250 us is best. */
+        /* first wait for the RTC to become busy. this is when it
+         * posts its updated seconds+msec registers to AHB side. */
+        while (tegra_rtc_check_busy(info)) {
+                if (!retries--)
+                        goto retry_failed;
+                udelay(1);
+        }
+        /* now we have about 250 us to manipulate registers */
+        return 0;
+retry_failed:
+        dev_err(dev, "write failed:retry count exceeded.\n");
+        return -ETIMEDOUT;
+}
+static int tegra_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
+        unsigned long sec, msec;
+        unsigned long sl_irq_flags;
+        /* RTC hardware copies seconds to shadow seconds when a read
+         * of milliseconds occurs. use a lock to keep other threads out. */
+        spin_lock_irqsave(&info->tegra_rtc_lock, sl_irq_flags);
+        msec = readl(info->rtc_base + TEGRA_RTC_REG_MILLI_SECONDS);
+        sec = readl(info->rtc_base + TEGRA_RTC_REG_SHADOW_SECONDS);
+        spin_unlock_irqrestore(&info->tegra_rtc_lock, sl_irq_flags);
+        rtc_time_to_tm(sec, tm);
+        dev_vdbg(dev, "time read as %lu. %d/%d/%d %d:%02u:%02u\n",
+                sec,
+                tm->tm_mon + 1,
+                tm->tm_mday,
+                tm->tm_year + 1900,
+                tm->tm_hour,
+                tm->tm_min,
+                tm->tm_sec
+        );
+        return 0;
+}
+static int tegra_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
+        unsigned long sec;
+        int ret;
+        /* convert tm to seconds. */
+        ret = rtc_valid_tm(tm);
+        if (ret)
+                return ret;
+        rtc_tm_to_time(tm, &sec);
+        dev_vdbg(dev, "time set to %lu. %d/%d/%d %d:%02u:%02u\n",
+                sec,
+                tm->tm_mon+1,
+                tm->tm_mday,
+                tm->tm_year+1900,
+                tm->tm_hour,
+                tm->tm_min,
+                tm->tm_sec
+        );
+        /* seconds only written if wait succeeded. */
+        ret = tegra_rtc_wait_while_busy(dev);
+        if (!ret)
+                writel(sec, info->rtc_base + TEGRA_RTC_REG_SECONDS);
+        dev_vdbg(dev, "time read back as %d\n",
+                readl(info->rtc_base + TEGRA_RTC_REG_SECONDS));
+        return ret;
+}
+static int tegra_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
+        unsigned long sec;
+        unsigned tmp;
+        sec = readl(info->rtc_base + TEGRA_RTC_REG_SECONDS_ALARM0);
+        if (sec == 0) {
+                /* alarm is disabled. */
+                alarm->enabled = 0;
+                alarm->time.tm_mon = -1;
+                alarm->time.tm_mday = -1;
+                alarm->time.tm_year = -1;
+                alarm->time.tm_hour = -1;
+                alarm->time.tm_min = -1;
+                alarm->time.tm_sec = -1;
+        } else {
+                /* alarm is enabled. */
+                alarm->enabled = 1;
+                rtc_time_to_tm(sec, &alarm->time);
+        }
+        tmp = readl(info->rtc_base + TEGRA_RTC_REG_INTR_STATUS);
+        alarm->pending = (tmp & TEGRA_RTC_INTR_STATUS_SEC_ALARM0) != 0;
+        return 0;
+}
+static int tegra_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
+        unsigned status;
+        unsigned long sl_irq_flags;
+        tegra_rtc_wait_while_busy(dev);
+        spin_lock_irqsave(&info->tegra_rtc_lock, sl_irq_flags);
+        /* read the original value, and OR in the flag. */
+        status = readl(info->rtc_base + TEGRA_RTC_REG_INTR_MASK);
+        if (enabled)
+                status |= TEGRA_RTC_INTR_MASK_SEC_ALARM0; /* set it */
+        else
+                status &= ~TEGRA_RTC_INTR_MASK_SEC_ALARM0; /* clear it */
+        writel(status, info->rtc_base + TEGRA_RTC_REG_INTR_MASK);
+        spin_unlock_irqrestore(&info->tegra_rtc_lock, sl_irq_flags);
+        return 0;
+}
+static int tegra_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
+        unsigned long sec;
+        if (alarm->enabled)
+                rtc_tm_to_time(&alarm->time, &sec);
+        else
+                sec = 0;
+        tegra_rtc_wait_while_busy(dev);
+        writel(sec, info->rtc_base + TEGRA_RTC_REG_SECONDS_ALARM0);
+        dev_vdbg(dev, "alarm read back as %d\n",
+                readl(info->rtc_base + TEGRA_RTC_REG_SECONDS_ALARM0));
+        /* if successfully written and alarm is enabled ... */
+        if (sec) {
+                tegra_rtc_alarm_irq_enable(dev, 1);
+                dev_vdbg(dev, "alarm set as %lu. %d/%d/%d %d:%02u:%02u\n",
+                        sec,
+                        alarm->time.tm_mon+1,
+                        alarm->time.tm_mday,
+                        alarm->time.tm_year+1900,
+                        alarm->time.tm_hour,
+                        alarm->time.tm_min,
+                        alarm->time.tm_sec);
+        } else {
+                /* disable alarm if 0 or write error. */
+                dev_vdbg(dev, "alarm disabled\n");
+                tegra_rtc_alarm_irq_enable(dev, 0);
+        }
+        return 0;
+}
+static int tegra_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        if (!dev || !dev->driver)
+                return 0;
+        return seq_printf(seq, "name\t\t: %s\n", dev_name(dev));
+}
+static irqreturn_t tegra_rtc_irq_handler(int irq, void *data)
+{
+        struct device *dev = data;
+        struct tegra_rtc_info *info = dev_get_drvdata(dev);
+        unsigned long events = 0;
+        unsigned status;
+        unsigned long sl_irq_flags;
+        status = readl(info->rtc_base + TEGRA_RTC_REG_INTR_STATUS);
+        if (status) {
+                /* clear the interrupt masks and status on any irq. */
+                tegra_rtc_wait_while_busy(dev);
+                spin_lock_irqsave(&info->tegra_rtc_lock, sl_irq_flags);
+                writel(0, info->rtc_base + TEGRA_RTC_REG_INTR_MASK);
+                writel(status, info->rtc_base + TEGRA_RTC_REG_INTR_STATUS);
+                spin_unlock_irqrestore(&info->tegra_rtc_lock, sl_irq_flags);
+        }
+        /* check if Alarm */
+        if ((status & TEGRA_RTC_INTR_STATUS_SEC_ALARM0))
+                events |= RTC_IRQF | RTC_AF;
+        /* check if Periodic */
+        if ((status & TEGRA_RTC_INTR_STATUS_SEC_CDN_ALARM))
+                events |= RTC_IRQF | RTC_PF;
+        rtc_update_irq(info->rtc_dev, 1, events);
+        return IRQ_HANDLED;
+}
+static struct rtc_class_ops tegra_rtc_ops = {
+        .read_time      = tegra_rtc_read_time,
+        .set_time       = tegra_rtc_set_time,
+        .read_alarm     = tegra_rtc_read_alarm,
+        .set_alarm      = tegra_rtc_set_alarm,
+        .proc           = tegra_rtc_proc,
+        .alarm_irq_enable = tegra_rtc_alarm_irq_enable,
+};
+static int __devinit tegra_rtc_probe(struct platform_device *pdev)
+{
+        struct tegra_rtc_info *info;
+        struct resource *res;
+        int ret;
+        info = kzalloc(sizeof(struct tegra_rtc_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev,
+                        "Unable to allocate resources for device.\n");
+                ret = -EBUSY;
+                goto err_free_info;
+        }
+        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
+                dev_err(&pdev->dev,
+                        "Unable to request mem region for device.\n");
+                ret = -EBUSY;
+                goto err_free_info;
+        }
+        info->tegra_rtc_irq = platform_get_irq(pdev, 0);
+        if (info->tegra_rtc_irq <= 0) {
+                ret = -EBUSY;
+                goto err_release_mem_region;
+        }
+        info->rtc_base = ioremap_nocache(res->start, resource_size(res));
+        if (!info->rtc_base) {
+                dev_err(&pdev->dev, "Unable to grab IOs for device.\n");
+                ret = -EBUSY;
+                goto err_release_mem_region;
+        }
+        /* set context info. */
+        info->pdev = pdev;
+        info->tegra_rtc_lock = __SPIN_LOCK_UNLOCKED(info->tegra_rtc_lock);
+        platform_set_drvdata(pdev, info);
+        /* clear out the hardware. */
+        writel(0, info->rtc_base + TEGRA_RTC_REG_SECONDS_ALARM0);
+        writel(0xffffffff, info->rtc_base + TEGRA_RTC_REG_INTR_STATUS);
+        writel(0, info->rtc_base + TEGRA_RTC_REG_INTR_MASK);
+        device_init_wakeup(&pdev->dev, 1);
+        info->rtc_dev = rtc_device_register(
+                pdev->name, &pdev->dev, &tegra_rtc_ops, THIS_MODULE);
+        if (IS_ERR(info->rtc_dev)) {
+                ret = PTR_ERR(info->rtc_dev);
+                info->rtc_dev = NULL;
+                dev_err(&pdev->dev,
+                        "Unable to register device (err=%d).\n",
+                        ret);
+                goto err_iounmap;
+        }
+        ret = request_irq(info->tegra_rtc_irq, tegra_rtc_irq_handler,
+                IRQF_TRIGGER_HIGH, "rtc alarm", &pdev->dev);
+        if (ret) {
+                dev_err(&pdev->dev,
+                        "Unable to request interrupt for device (err=%d).\n",
+                        ret);
+                goto err_dev_unreg;
+        }
+        dev_notice(&pdev->dev, "Tegra internal Real Time Clock\n");
+        return 0;
+err_dev_unreg:
+        rtc_device_unregister(info->rtc_dev);
+err_iounmap:
+        iounmap(info->rtc_base);
+err_release_mem_region:
+        release_mem_region(res->start, resource_size(res));
+err_free_info:
+        kfree(info);
+        return ret;
+}
+static int __devexit tegra_rtc_remove(struct platform_device *pdev)
+{
+        struct tegra_rtc_info *info = platform_get_drvdata(pdev);
+        struct resource *res;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -EBUSY;
+        free_irq(info->tegra_rtc_irq, &pdev->dev);
+        rtc_device_unregister(info->rtc_dev);
+        iounmap(info->rtc_base);
+        release_mem_region(res->start, resource_size(res));
+        kfree(info);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+#ifdef CONFIG_PM
+static int tegra_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct device *dev = &pdev->dev;
+        struct tegra_rtc_info *info = platform_get_drvdata(pdev);
+        tegra_rtc_wait_while_busy(dev);
+        /* only use ALARM0 as a wake source. */
+        writel(0xffffffff, info->rtc_base + TEGRA_RTC_REG_INTR_STATUS);
+        writel(TEGRA_RTC_INTR_STATUS_SEC_ALARM0,
+                info->rtc_base + TEGRA_RTC_REG_INTR_MASK);
+        dev_vdbg(dev, "alarm sec = %d\n",
+                readl(info->rtc_base + TEGRA_RTC_REG_SECONDS_ALARM0));
+        dev_vdbg(dev, "Suspend (device_may_wakeup=%d) irq:%d\n",
+                device_may_wakeup(dev), info->tegra_rtc_irq);
+        /* leave the alarms on as a wake source. */
+        if (device_may_wakeup(dev))
+                enable_irq_wake(info->tegra_rtc_irq);
+        return 0;
+}
+static int tegra_rtc_resume(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct tegra_rtc_info *info = platform_get_drvdata(pdev);
+        dev_vdbg(dev, "Resume (device_may_wakeup=%d)\n",
+                device_may_wakeup(dev));
+        /* alarms were left on as a wake source, turn them off. */
+        if (device_may_wakeup(dev))
+                disable_irq_wake(info->tegra_rtc_irq);
+        return 0;
+}
+#endif
+static void tegra_rtc_shutdown(struct platform_device *pdev)
+{
+        dev_vdbg(&pdev->dev, "disabling interrupts.\n");
+        tegra_rtc_alarm_irq_enable(&pdev->dev, 0);
+}
+MODULE_ALIAS("platform:tegra_rtc");
+static struct platform_driver tegra_rtc_driver = {
+        .remove         = __devexit_p(tegra_rtc_remove),
+        .shutdown       = tegra_rtc_shutdown,
+        .driver         = {
+                .name   = "tegra_rtc",
+                .owner  = THIS_MODULE,
+        },
+#ifdef CONFIG_PM
+        .suspend        = tegra_rtc_suspend,
+        .resume         = tegra_rtc_resume,
+#endif
+};
+static int __init tegra_rtc_init(void)
+{
+        return platform_driver_probe(&tegra_rtc_driver, tegra_rtc_probe);
+}
+module_init(tegra_rtc_init);
+static void __exit tegra_rtc_exit(void)
+{
+        platform_driver_unregister(&tegra_rtc_driver);
+}
+module_exit(tegra_rtc_exit);
+MODULE_AUTHOR("Jon Mayo <jmayo@nvidia.com>");
+MODULE_DESCRIPTION("driver for Tegra internal RTC");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index 51725f7755b0..7e96254bd365 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -50,24 +50,9 @@ static int test_rtc_proc(struct device *dev, struct seq_file *seq)
        return 0;
 }
-static int test_rtc_ioctl(struct device *dev, unsigned int cmd,
+static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
-        unsigned long arg)
 {
-        /* We do support interrupts, they're generated
+        return 0;
-         * using the sysfs interface.
-         */
-        switch (cmd) {
-        case RTC_PIE_ON:
-        case RTC_PIE_OFF:
-        case RTC_UIE_ON:
-        case RTC_UIE_OFF:
-        case RTC_AIE_ON:
-        case RTC_AIE_OFF:
-                return 0;
-        default:
-                return -ENOIOCTLCMD;
-        }
 }
 static const struct rtc_class_ops test_rtc_ops = {
@@ -76,7 +61,7 @@ static const struct rtc_class_ops test_rtc_ops = {
        .read_alarm = test_rtc_read_alarm,
        .set_alarm = test_rtc_set_alarm,
        .set_mmss = test_rtc_set_mmss,
-        .ioctl = test_rtc_ioctl,
+        .alarm_irq_enable = test_rtc_alarm_irq_enable,
 };
 static ssize_t test_irq_show(struct device *dev,
@@ -93,11 +78,16 @@ static ssize_t test_irq_store(struct device *dev,
        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
        retval = count;
-        if (strncmp(buf, "tick", 4) == 0)
+        if (strncmp(buf, "tick", 4) == 0 && rtc->pie_enabled)
                rtc_update_irq(rtc, 1, RTC_PF | RTC_IRQF);
-        else if (strncmp(buf, "alarm", 5) == 0)
+        else if (strncmp(buf, "alarm", 5) == 0) {
-                rtc_update_irq(rtc, 1, RTC_AF | RTC_IRQF);
+                struct rtc_wkalrm alrm;
-        else if (strncmp(buf, "update", 6) == 0)
+                int err = rtc_read_alarm(rtc, &alrm);
+                if (!err && alrm.enabled)
+                        rtc_update_irq(rtc, 1, RTC_AF | RTC_IRQF);
+        } else if (strncmp(buf, "update", 6) == 0 && rtc->uie_rtctimer.enabled)
                rtc_update_irq(rtc, 1, RTC_UF | RTC_IRQF);
        else
                retval = -EINVAL;
diff --git a/drivers/rtc/rtc-tile.c b/drivers/rtc/rtc-tile.c
new file mode 100644
index 000000000000..eb65dafee66e
--- /dev/null
+++ b/drivers/rtc/rtc-tile.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2011 Tilera Corporation. All Rights Reserved.
+ *
+ *   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, version 2.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ *
+ * Tilera-specific RTC driver.
+ */
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+/* Platform device pointer. */
+static struct platform_device *tile_rtc_platform_device;
+/*
+ * RTC read routine.  Gets time info from RTC chip via hypervisor syscall.
+ */
+static int read_rtc_time(struct device *dev, struct rtc_time *tm)
+{
+        HV_RTCTime hvtm = hv_get_rtc();
+        tm->tm_sec = hvtm.tm_sec;
+        tm->tm_min = hvtm.tm_min;
+        tm->tm_hour = hvtm.tm_hour;
+        tm->tm_mday = hvtm.tm_mday;
+        tm->tm_mon = hvtm.tm_mon;
+        tm->tm_year = hvtm.tm_year;
+        tm->tm_wday = 0;
+        tm->tm_yday = 0;
+        tm->tm_isdst = 0;
+        if (rtc_valid_tm(tm) < 0)
+                dev_warn(dev, "Read invalid date/time from RTC\n");
+        return 0;
+}
+/*
+ * RTC write routine.  Sends time info to hypervisor via syscall, to be
+ * written to RTC chip.
+ */
+static int set_rtc_time(struct device *dev, struct rtc_time *tm)
+{
+        HV_RTCTime hvtm;
+        hvtm.tm_sec = tm->tm_sec;
+        hvtm.tm_min = tm->tm_min;
+        hvtm.tm_hour = tm->tm_hour;
+        hvtm.tm_mday = tm->tm_mday;
+        hvtm.tm_mon = tm->tm_mon;
+        hvtm.tm_year = tm->tm_year;
+        hv_set_rtc(hvtm);
+        return 0;
+}
+/*
+ * RTC read/write ops.
+ */
+static const struct rtc_class_ops tile_rtc_ops = {
+        .read_time      = read_rtc_time,
+        .set_time       = set_rtc_time,
+};
+/*
+ * Device probe routine.
+ */
+static int __devinit tile_rtc_probe(struct platform_device *dev)
+{
+        struct rtc_device *rtc;
+        rtc = rtc_device_register("tile",
+                                  &dev->dev, &tile_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+        platform_set_drvdata(dev, rtc);
+        return 0;
+}
+/*
+ * Device cleanup routine.
+ */
+static int __devexit tile_rtc_remove(struct platform_device *dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(dev);
+        if (rtc)
+                rtc_device_unregister(rtc);
+        platform_set_drvdata(dev, NULL);
+        return 0;
+}
+static struct platform_driver tile_rtc_platform_driver = {
+        .driver         = {
+                .name   = "rtc-tile",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = tile_rtc_probe,
+        .remove         = __devexit_p(tile_rtc_remove),
+};
+/*
+ * Driver init routine.
+ */
+static int __init tile_rtc_driver_init(void)
+{
+        int err;
+        err = platform_driver_register(&tile_rtc_platform_driver);
+        if (err)
+                return err;
+        tile_rtc_platform_device = platform_device_alloc("rtc-tile", 0);
+        if (tile_rtc_platform_device == NULL) {
+                err = -ENOMEM;
+                goto exit_driver_unregister;
+        }
+        err = platform_device_add(tile_rtc_platform_device);
+        if (err)
+                goto exit_device_put;
+        return 0;
+exit_device_put:
+        platform_device_put(tile_rtc_platform_device);
+exit_driver_unregister:
+        platform_driver_unregister(&tile_rtc_platform_driver);
+        return err;
+}
+/*
+ * Driver cleanup routine.
+ */
+static void __exit tile_rtc_driver_exit(void)
+{
+        platform_driver_unregister(&tile_rtc_platform_driver);
+}
+module_init(tile_rtc_driver_init);
+module_exit(tile_rtc_driver_exit);
+MODULE_DESCRIPTION("Tilera-specific Real Time Clock Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:rtc-tile");
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index ed1b86828124..f9a2799c44d6 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -213,18 +213,6 @@ static int twl_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
        return ret;
 }
-static int twl_rtc_update_irq_enable(struct device *dev, unsigned enabled)
-{
-        int ret;
-        if (enabled)
-                ret = set_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
-        else
-                ret = mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
-        return ret;
-}
 /*
 * Gets current TWL RTC time and date parameters.
 *
@@ -433,7 +421,6 @@ static struct rtc_class_ops twl_rtc_ops = {
        .read_alarm     = twl_rtc_read_alarm,
        .set_alarm      = twl_rtc_set_alarm,
        .alarm_irq_enable = twl_rtc_alarm_irq_enable,
-        .update_irq_enable = twl_rtc_update_irq_enable,
 };
 /*----------------------------------------------------------------------*/
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index c3244244e8cf..c5698cda366a 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -207,59 +207,9 @@ static int vr41xx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
        return 0;
 }
-static int vr41xx_rtc_irq_set_freq(struct device *dev, int freq)
-{
-        u64 count;
-        if (!is_power_of_2(freq))
-                return -EINVAL;
-        count = RTC_FREQUENCY;
-        do_div(count, freq);
-        spin_lock_irq(&rtc_lock);
-        periodic_count = count;
-        rtc1_write(RTCL1LREG, periodic_count);
-        rtc1_write(RTCL1HREG, periodic_count >> 16);
-        spin_unlock_irq(&rtc_lock);
-        return 0;
-}
-static int vr41xx_rtc_irq_set_state(struct device *dev, int enabled)
-{
-        if (enabled)
-                enable_irq(pie_irq);
-        else
-                disable_irq(pie_irq);
-        return 0;
-}
 static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
        switch (cmd) {
-        case RTC_AIE_ON:
-                spin_lock_irq(&rtc_lock);
-                if (!alarm_enabled) {
-                        enable_irq(aie_irq);
-                        alarm_enabled = 1;
-                }
-                spin_unlock_irq(&rtc_lock);
-                break;
-        case RTC_AIE_OFF:
-                spin_lock_irq(&rtc_lock);
-                if (alarm_enabled) {
-                        disable_irq(aie_irq);
-                        alarm_enabled = 0;
-                }
-                spin_unlock_irq(&rtc_lock);
-                break;
        case RTC_EPOCH_READ:
                return put_user(epoch, (unsigned long __user *)arg);
        case RTC_EPOCH_SET:
@@ -275,6 +225,24 @@ static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long
        return 0;
 }
+static int vr41xx_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        spin_lock_irq(&rtc_lock);
+        if (enabled) {
+                if (!alarm_enabled) {
+                        enable_irq(aie_irq);
+                        alarm_enabled = 1;
+                }
+        } else {
+                if (alarm_enabled) {
+                        disable_irq(aie_irq);
+                        alarm_enabled = 0;
+                }
+        }
+        spin_unlock_irq(&rtc_lock);
+        return 0;
+}
 static irqreturn_t elapsedtime_interrupt(int irq, void *dev_id)
 {
        struct platform_device *pdev = (struct platform_device *)dev_id;
@@ -310,8 +278,6 @@ static const struct rtc_class_ops vr41xx_rtc_ops = {
        .set_time       = vr41xx_rtc_set_time,
        .read_alarm     = vr41xx_rtc_read_alarm,
        .set_alarm      = vr41xx_rtc_set_alarm,
-        .irq_set_freq   = vr41xx_rtc_irq_set_freq,
-        .irq_set_state  = vr41xx_rtc_irq_set_state,
 };
 static int __devinit rtc_probe(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-vt8500.c b/drivers/rtc/rtc-vt8500.c
new file mode 100644
index 000000000000..efd6066b5cd2
--- /dev/null
+++ b/drivers/rtc/rtc-vt8500.c
@@ -0,0 +1,327 @@
+/*
+ * drivers/rtc/rtc-vt8500.c
+ *
+ *  Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
+ *
+ * Based on rtc-pxa.c
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/bcd.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+/*
+ * Register definitions
+ */
+#define VT8500_RTC_TS           0x00    /* Time set */
+#define VT8500_RTC_DS           0x04    /* Date set */
+#define VT8500_RTC_AS           0x08    /* Alarm set */
+#define VT8500_RTC_CR           0x0c    /* Control */
+#define VT8500_RTC_TR           0x10    /* Time read */
+#define VT8500_RTC_DR           0x14    /* Date read */
+#define VT8500_RTC_WS           0x18    /* Write status */
+#define VT8500_RTC_CL           0x20    /* Calibration */
+#define VT8500_RTC_IS           0x24    /* Interrupt status */
+#define VT8500_RTC_ST           0x28    /* Status */
+#define INVALID_TIME_BIT        (1 << 31)
+#define DATE_CENTURY_S          19
+#define DATE_YEAR_S             11
+#define DATE_YEAR_MASK          (0xff << DATE_YEAR_S)
+#define DATE_MONTH_S            6
+#define DATE_MONTH_MASK         (0x1f << DATE_MONTH_S)
+#define DATE_DAY_MASK           0x3f
+#define TIME_DOW_S              20
+#define TIME_DOW_MASK           (0x07 << TIME_DOW_S)
+#define TIME_HOUR_S             14
+#define TIME_HOUR_MASK          (0x3f << TIME_HOUR_S)
+#define TIME_MIN_S              7
+#define TIME_MIN_MASK           (0x7f << TIME_MIN_S)
+#define TIME_SEC_MASK           0x7f
+#define ALARM_DAY_S             20
+#define ALARM_DAY_MASK          (0x3f << ALARM_DAY_S)
+#define ALARM_DAY_BIT           (1 << 29)
+#define ALARM_HOUR_BIT          (1 << 28)
+#define ALARM_MIN_BIT           (1 << 27)
+#define ALARM_SEC_BIT           (1 << 26)
+#define ALARM_ENABLE_MASK       (ALARM_DAY_BIT \
+                                | ALARM_HOUR_BIT \
+                                | ALARM_MIN_BIT \
+                                | ALARM_SEC_BIT)
+#define VT8500_RTC_CR_ENABLE    (1 << 0)        /* Enable RTC */
+#define VT8500_RTC_CR_24H       (1 << 1)        /* 24h time format */
+#define VT8500_RTC_CR_SM_ENABLE (1 << 2)        /* Enable periodic irqs */
+#define VT8500_RTC_CR_SM_SEC    (1 << 3)        /* 0: 1Hz/60, 1: 1Hz */
+#define VT8500_RTC_CR_CALIB     (1 << 4)        /* Enable calibration */
+struct vt8500_rtc {
+        void __iomem            *regbase;
+        struct resource         *res;
+        int                     irq_alarm;
+        struct rtc_device       *rtc;
+        spinlock_t              lock;           /* Protects this structure */
+};
+static irqreturn_t vt8500_rtc_irq(int irq, void *dev_id)
+{
+        struct vt8500_rtc *vt8500_rtc = dev_id;
+        u32 isr;
+        unsigned long events = 0;
+        spin_lock(&vt8500_rtc->lock);
+        /* clear interrupt sources */
+        isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
+        writel(isr, vt8500_rtc->regbase + VT8500_RTC_IS);
+        spin_unlock(&vt8500_rtc->lock);
+        if (isr & 1)
+                events |= RTC_AF | RTC_IRQF;
+        rtc_update_irq(vt8500_rtc->rtc, 1, events);
+        return IRQ_HANDLED;
+}
+static int vt8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
+        u32 date, time;
+        date = readl(vt8500_rtc->regbase + VT8500_RTC_DR);
+        time = readl(vt8500_rtc->regbase + VT8500_RTC_TR);
+        tm->tm_sec = bcd2bin(time & TIME_SEC_MASK);
+        tm->tm_min = bcd2bin((time & TIME_MIN_MASK) >> TIME_MIN_S);
+        tm->tm_hour = bcd2bin((time & TIME_HOUR_MASK) >> TIME_HOUR_S);
+        tm->tm_mday = bcd2bin(date & DATE_DAY_MASK);
+        tm->tm_mon = bcd2bin((date & DATE_MONTH_MASK) >> DATE_MONTH_S);
+        tm->tm_year = bcd2bin((date & DATE_YEAR_MASK) >> DATE_YEAR_S)
+                        + ((date >> DATE_CENTURY_S) & 1 ? 200 : 100);
+        tm->tm_wday = (time & TIME_DOW_MASK) >> TIME_DOW_S;
+        return 0;
+}
+static int vt8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
+        if (tm->tm_year < 100) {
+                dev_warn(dev, "Only years 2000-2199 are supported by the "
+                              "hardware!\n");
+                return -EINVAL;
+        }
+        writel((bin2bcd(tm->tm_year - 100) << DATE_YEAR_S)
+                | (bin2bcd(tm->tm_mon) << DATE_MONTH_S)
+                | (bin2bcd(tm->tm_mday)),
+                vt8500_rtc->regbase + VT8500_RTC_DS);
+        writel((bin2bcd(tm->tm_wday) << TIME_DOW_S)
+                | (bin2bcd(tm->tm_hour) << TIME_HOUR_S)
+                | (bin2bcd(tm->tm_min) << TIME_MIN_S)
+                | (bin2bcd(tm->tm_sec)),
+                vt8500_rtc->regbase + VT8500_RTC_TS);
+        return 0;
+}
+static int vt8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
+        u32 isr, alarm;
+        alarm = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
+        isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
+        alrm->time.tm_mday = bcd2bin((alarm & ALARM_DAY_MASK) >> ALARM_DAY_S);
+        alrm->time.tm_hour = bcd2bin((alarm & TIME_HOUR_MASK) >> TIME_HOUR_S);
+        alrm->time.tm_min = bcd2bin((alarm & TIME_MIN_MASK) >> TIME_MIN_S);
+        alrm->time.tm_sec = bcd2bin((alarm & TIME_SEC_MASK));
+        alrm->enabled = (alarm & ALARM_ENABLE_MASK) ? 1 : 0;
+        alrm->pending = (isr & 1) ? 1 : 0;
+        return rtc_valid_tm(&alrm->time);
+}
+static int vt8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
+        writel((alrm->enabled ? ALARM_ENABLE_MASK : 0)
+                | (bin2bcd(alrm->time.tm_mday) << ALARM_DAY_S)
+                | (bin2bcd(alrm->time.tm_hour) << TIME_HOUR_S)
+                | (bin2bcd(alrm->time.tm_min) << TIME_MIN_S)
+                | (bin2bcd(alrm->time.tm_sec)),
+                vt8500_rtc->regbase + VT8500_RTC_AS);
+        return 0;
+}
+static int vt8500_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
+        unsigned long tmp = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
+        if (enabled)
+                tmp |= ALARM_ENABLE_MASK;
+        else
+                tmp &= ~ALARM_ENABLE_MASK;
+        writel(tmp, vt8500_rtc->regbase + VT8500_RTC_AS);
+        return 0;
+}
+static const struct rtc_class_ops vt8500_rtc_ops = {
+        .read_time = vt8500_rtc_read_time,
+        .set_time = vt8500_rtc_set_time,
+        .read_alarm = vt8500_rtc_read_alarm,
+        .set_alarm = vt8500_rtc_set_alarm,
+        .alarm_irq_enable = vt8500_alarm_irq_enable,
+};
+static int __devinit vt8500_rtc_probe(struct platform_device *pdev)
+{
+        struct vt8500_rtc *vt8500_rtc;
+        int ret;
+        vt8500_rtc = kzalloc(sizeof(struct vt8500_rtc), GFP_KERNEL);
+        if (!vt8500_rtc)
+                return -ENOMEM;
+        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");
+                ret = -ENXIO;
+                goto err_free;
+        }
+        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");
+                ret = -ENXIO;
+                goto err_free;
+        }
+        vt8500_rtc->res = request_mem_region(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");
+                ret = -EBUSY;
+                goto err_free;
+        }
+        vt8500_rtc->regbase = ioremap(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_release;
+        }
+        /* Enable RTC and set it to 24-hour mode */
+        writel(VT8500_RTC_CR_ENABLE | VT8500_RTC_CR_24H,
+               vt8500_rtc->regbase + VT8500_RTC_CR);
+        vt8500_rtc->rtc = rtc_device_register("vt8500-rtc", &pdev->dev,
+                                              &vt8500_rtc_ops, THIS_MODULE);
+        if (IS_ERR(vt8500_rtc->rtc)) {
+                ret = PTR_ERR(vt8500_rtc->rtc);
+                dev_err(&pdev->dev,
+                        "Failed to register RTC device -> %d\n", ret);
+                goto err_unmap;
+        }
+        ret = request_irq(vt8500_rtc->irq_alarm, vt8500_rtc_irq, 0,
+                          "rtc alarm", vt8500_rtc);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "can't get irq %i, err %d\n",
+                        vt8500_rtc->irq_alarm, ret);
+                goto err_unreg;
+        }
+        return 0;
+err_unreg:
+        rtc_device_unregister(vt8500_rtc->rtc);
+err_unmap:
+        iounmap(vt8500_rtc->regbase);
+err_release:
+        release_mem_region(vt8500_rtc->res->start,
+                           resource_size(vt8500_rtc->res));
+err_free:
+        kfree(vt8500_rtc);
+        return ret;
+}
+static int __devexit vt8500_rtc_remove(struct platform_device *pdev)
+{
+        struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
+        free_irq(vt8500_rtc->irq_alarm, vt8500_rtc);
+        rtc_device_unregister(vt8500_rtc->rtc);
+        /* Disable alarm matching */
+        writel(0, vt8500_rtc->regbase + VT8500_RTC_IS);
+        iounmap(vt8500_rtc->regbase);
+        release_mem_region(vt8500_rtc->res->start,
+                           resource_size(vt8500_rtc->res));
+        kfree(vt8500_rtc);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+static struct platform_driver vt8500_rtc_driver = {
+        .probe          = vt8500_rtc_probe,
+        .remove         = __devexit_p(vt8500_rtc_remove),
+        .driver         = {
+                .name   = "vt8500-rtc",
+                .owner  = THIS_MODULE,
+        },
+};
+static int __init vt8500_rtc_init(void)
+{
+        return platform_driver_register(&vt8500_rtc_driver);
+}
+module_init(vt8500_rtc_init);
+static void __exit vt8500_rtc_exit(void)
+{
+        platform_driver_unregister(&vt8500_rtc_driver);
+}
+module_exit(vt8500_rtc_exit);
+MODULE_AUTHOR("Alexey Charkov <alchark@gmail.com>");
+MODULE_DESCRIPTION("VIA VT8500 SoC Realtime Clock Driver (RTC)");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:vt8500-rtc");
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
index 82931dc65c0b..bdc909bd56da 100644
--- a/drivers/rtc/rtc-wm831x.c
+++ b/drivers/rtc/rtc-wm831x.c
@@ -315,21 +315,6 @@ static int wm831x_rtc_alarm_irq_enable(struct device *dev,
                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;
@@ -354,7 +339,6 @@ static const struct rtc_class_ops wm831x_rtc_ops = {
        .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
diff --git a/drivers/rtc/rtc-wm8350.c b/drivers/rtc/rtc-wm8350.c
index 3d0dc76b38af..66421426e404 100644
--- a/drivers/rtc/rtc-wm8350.c
+++ b/drivers/rtc/rtc-wm8350.c
@@ -302,26 +302,6 @@ static int wm8350_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
        return ret;
 }
-static int wm8350_rtc_update_irq_enable(struct device *dev,
-                                        unsigned int enabled)
-{
-        struct wm8350 *wm8350 = dev_get_drvdata(dev);
-        /* Suppress duplicate changes since genirq nests enable and
-         * disable calls. */
-        if (enabled == wm8350->rtc.update_enabled)
-                return 0;
-        if (enabled)
-                wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_SEC);
-        else
-                wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
-        wm8350->rtc.update_enabled = enabled;
-        return 0;
-}
 static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data)
 {
        struct wm8350 *wm8350 = data;
@@ -357,7 +337,6 @@ static const struct rtc_class_ops wm8350_rtc_ops = {
        .read_alarm = wm8350_rtc_readalarm,
        .set_alarm = wm8350_rtc_setalarm,
        .alarm_irq_enable = wm8350_rtc_alarm_irq_enable,
-        .update_irq_enable = wm8350_rtc_update_irq_enable,
 };
 #ifdef CONFIG_PM
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index 9aae49139a0a..b00aad2620d4 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -573,7 +573,7 @@ static int x1205_probe(struct i2c_client *client,
        i2c_set_clientdata(client, rtc);
-        /* Check for power failures and eventualy enable the osc */
+        /* Check for power failures and eventually enable the osc */
        if ((err = x1205_get_status(client, &sr)) == 0) {
                if (sr & X1205_SR_RTCF) {
                        dev_err(&client->dev,