41 files changed, 2983 insertions, 1129 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 48ca7132cc05..4941cade319f 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -171,7 +171,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 +196,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
@@ -452,6 +463,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
@@ -765,15 +788,15 @@ config RTC_DRV_AT32AP700X
           AT32AP700x family processors.
 
 config RTC_DRV_AT91RM9200
-        tristate "AT91RM9200 or AT91SAM9RL"
-        depends on ARCH_AT91RM9200 || ARCH_AT91SAM9RL
+        tristate "AT91RM9200 or some AT91SAM9 RTC"
+        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 +804,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
-          module and leave the RTT available for other uses.)
+          (On AT91SAM9rl and AT91SAM9G45 chips you probably want to use the
+          dedicated RTC module and leave the RTT available for other uses.)
 
 config RTC_DRV_AT91SAM9_RTT
         int
@@ -925,11 +948,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
-        depends on MFD_MC13783
-        tristate "Freescale MC13783 RTC"
+config RTC_DRV_MC13XXX
+        depends on MFD_MC13XXX
+        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 +976,13 @@ 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.
+
 endif # RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 0f207b3b5833..2afdaf3ff986 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -30,6 +30,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
@@ -51,6 +52,7 @@ 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_M41T94)    += rtc-m41t94.o
 obj-$(CONFIG_RTC_DRV_M48T35)    += rtc-m48t35.o
@@ -59,8 +61,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
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 565562ba6ac9..c404b61386bf 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"
 
@@ -142,6 +143,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 +154,28 @@ 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;
+
         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..cb2f0728fd70 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;
 }
@@ -106,188 +116,60 @@ int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
 }
 EXPORT_SYMBOL_GPL(rtc_set_mmss);
 
-static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
         int err;
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         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));
-                err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
+                alarm->enabled = rtc->aie_timer.enabled;
+                alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
         }
-
         mutex_unlock(&rtc->ops_lock);
+
         return err;
 }
+EXPORT_SYMBOL_GPL(rtc_read_alarm);
 
-int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
+        struct rtc_time tm;
+        long now, scheduled;
         int err;
-        struct rtc_time before, now;
-        int first_time = 1;
-        unsigned long t_now, t_alm;
-        enum { none, day, month, year } missing = none;
-        unsigned days;
-
-        /* The lower level RTC driver may return -1 in some fields,
-         * creating invalid alarm->time values, for reasons like:
-         *
-         *   - The hardware may not be capable of filling them in;
-         *     many alarms match only on time-of-day fields, not
-         *     day/month/year calendar data.
-         *
-         *   - Some hardware uses illegal values as "wildcard" match
-         *     values, which non-Linux firmware (like a BIOS) may try
-         *     to set up as e.g. "alarm 15 minutes after each hour".
-         *     Linux uses only oneshot alarms.
-         *
-         * When we see that here, we deal with it by using values from
-         * a current RTC timestamp for any missing (-1) values.  The
-         * RTC driver prevents "periodic alarm" modes.
-         *
-         * But this can be racey, because some fields of the RTC timestamp
-         * may have wrapped in the interval since we read the RTC alarm,
-         * which would lead to us inserting inconsistent values in place
-         * of the -1 fields.
-         *
-         * Reading the alarm and timestamp in the reverse sequence
-         * would have the same race condition, and not solve the issue.
-         *
-         * So, we must first read the RTC timestamp,
-         * then read the RTC alarm value,
-         * and then read a second RTC timestamp.
-         *
-         * If any fields of the second timestamp have changed
-         * when compared with the first timestamp, then we know
-         * our timestamp may be inconsistent with that used by
-         * the low-level rtc_read_alarm_internal() function.
-         *
-         * So, when the two timestamps disagree, we just loop and do
-         * the process again to get a fully consistent set of values.
-         *
-         * This could all instead be done in the lower level driver,
-         * but since more than one lower level RTC implementation needs it,
-         * then it's probably best best to do it here instead of there..
-         */
 
-        /* Get the "before" timestamp */
-        err = rtc_read_time(rtc, &before);
-        if (err < 0)
+        err = rtc_valid_tm(&alarm->time);
+        if (err)
                 return err;
-        do {
-                if (!first_time)
-                        memcpy(&before, &now, sizeof(struct rtc_time));
-                first_time = 0;
-
-                /* get the RTC alarm values, which may be incomplete */
-                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)
-                        return 0;
-
-                /* get the "after" timestamp, to detect wrapped fields */
-                err = rtc_read_time(rtc, &now);
-                if (err < 0)
-                        return err;
-
-                /* note that tm_sec is a "don't care" value here: */
-        } while (   before.tm_min   != now.tm_min
-                 || before.tm_hour  != now.tm_hour
-                 || before.tm_mon   != now.tm_mon
-                 || before.tm_year  != now.tm_year);
+        rtc_tm_to_time(&alarm->time, &scheduled);
 
-        /* Fill in the missing alarm fields using the timestamp; we
-         * know there's at least one since alarm->time is invalid.
+        /* 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 (alarm->time.tm_sec == -1)
-                alarm->time.tm_sec = now.tm_sec;
-        if (alarm->time.tm_min == -1)
-                alarm->time.tm_min = now.tm_min;
-        if (alarm->time.tm_hour == -1)
-                alarm->time.tm_hour = now.tm_hour;
-
-        /* For simplicity, only support date rollover for now */
-        if (alarm->time.tm_mday == -1) {
-                alarm->time.tm_mday = now.tm_mday;
-                missing = day;
-        }
-        if (alarm->time.tm_mon == -1) {
-                alarm->time.tm_mon = now.tm_mon;
-                if (missing == none)
-                        missing = month;
-        }
-        if (alarm->time.tm_year == -1) {
-                alarm->time.tm_year = now.tm_year;
-                if (missing == none)
-                        missing = year;
-        }
 
-        /* with luck, no rollover is needed */
-        rtc_tm_to_time(&now, &t_now);
-        rtc_tm_to_time(&alarm->time, &t_alm);
-        if (t_now < t_alm)
-                goto done;
-
-        switch (missing) {
-
-        /* 24 hour rollover ... if it's now 10am Monday, an alarm that
-         * that will trigger at 5am will do so at 5am Tuesday, which
-         * could also be in the next month or year.  This is a common
-         * case, especially for PCs.
-         */
-        case day:
-                dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day");
-                t_alm += 24 * 60 * 60;
-                rtc_time_to_tm(t_alm, &alarm->time);
-                break;
-
-        /* Month rollover ... if it's the 31th, an alarm on the 3rd will
-         * be next month.  An alarm matching on the 30th, 29th, or 28th
-         * may end up in the month after that!  Many newer PCs support
-         * this type of alarm.
-         */
-        case month:
-                dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
-                do {
-                        if (alarm->time.tm_mon < 11)
-                                alarm->time.tm_mon++;
-                        else {
-                                alarm->time.tm_mon = 0;
-                                alarm->time.tm_year++;
-                        }
-                        days = rtc_month_days(alarm->time.tm_mon,
-                                        alarm->time.tm_year);
-                } while (days < alarm->time.tm_mday);
-                break;
-
-        /* Year rollover ... easy except for leap years! */
-        case year:
-                dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
-                do {
-                        alarm->time.tm_year++;
-                } while (rtc_valid_tm(&alarm->time) != 0);
-                break;
-
-        default:
-                dev_warn(&rtc->dev, "alarm rollover not handled\n");
-        }
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->set_alarm)
+                err = -EINVAL;
+        else
+                err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
 
-done:
-        return 0;
+        return err;
 }
-EXPORT_SYMBOL_GPL(rtc_read_alarm);
 
 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
@@ -300,14 +182,14 @@ int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
                 return err;
-
-        if (!rtc->ops)
-                err = -ENODEV;
-        else if (!rtc->ops->set_alarm)
-                err = -EINVAL;
-        else
-                err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
-
+        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;
 }
@@ -319,7 +201,16 @@ int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
         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 +231,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)
-                err = -ENODEV;
-        else if (!rtc->ops->update_irq_enable)
-                err = -EINVAL;
-        else
-                err = rtc->ops->update_irq_enable(rtc->dev.parent, enabled);
-
+out:
         mutex_unlock(&rtc->ops_lock);
-
 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
         /*
          * Enable emulation if the driver did not provide
@@ -364,25 +264,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: 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
+ * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
+ * @rtc: pointer to the rtc device
+ *
+ * This function is called when an AIE, UIE or PIE mode interrupt
+ * has occured (or been emulated).
+ *
+ * Triggers the registered irq_task function callback.
  */
-void rtc_update_irq(struct rtc_device *rtc,
-                unsigned long num, unsigned long events)
+void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
 {
         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 +296,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 +445,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)
-                err = rtc->ops->irq_set_state(rtc->dev.parent, enabled);
+        if (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 +479,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)
-                return -ENXIO;
+        if (freq <= 0)
+                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);
-                if (err == 0)
-                        rtc->irq_freq = freq;
+                rtc->irq_freq = freq;
+                if (rtc->pie_enabled) {
+                        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-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_CC_CONF_REG          0x0F01
-#define AB8500_RTC_READ_REQ_REG         0x0F02
-#define AB8500_RTC_WATCH_TSECMID_REG    0x0F03
-#define AB8500_RTC_WATCH_TSECHI_REG     0x0F04
-#define AB8500_RTC_WATCH_TMIN_LOW_REG   0x0F05
-#define AB8500_RTC_WATCH_TMIN_MID_REG   0x0F06
-#define AB8500_RTC_WATCH_TMIN_HI_REG    0x0F07
-#define AB8500_RTC_ALRM_MIN_LOW_REG     0x0F08
-#define AB8500_RTC_ALRM_MIN_MID_REG     0x0F09
-#define AB8500_RTC_ALRM_MIN_HI_REG      0x0F0A
-#define AB8500_RTC_STAT_REG             0x0F0B
-#define AB8500_RTC_BKUP_CHG_REG         0x0F0C
-#define AB8500_RTC_FORCE_BKUP_REG       0x0F0D
-#define AB8500_RTC_CALIB_REG            0x0F0E
-#define AB8500_RTC_SWITCH_STAT_REG      0x0F0F
-#define AB8500_REV_REG                  0x1080
+#define AB8500_RTC_SOFF_STAT_REG        0x00
+#define AB8500_RTC_CC_CONF_REG          0x01
+#define AB8500_RTC_READ_REQ_REG         0x02
+#define AB8500_RTC_WATCH_TSECMID_REG    0x03
+#define AB8500_RTC_WATCH_TSECHI_REG     0x04
+#define AB8500_RTC_WATCH_TMIN_LOW_REG   0x05
+#define AB8500_RTC_WATCH_TMIN_MID_REG   0x06
+#define AB8500_RTC_WATCH_TMIN_HI_REG    0x07
+#define AB8500_RTC_ALRM_MIN_LOW_REG     0x08
+#define AB8500_RTC_ALRM_MIN_MID_REG     0x09
+#define AB8500_RTC_ALRM_MIN_HI_REG      0x0A
+#define AB8500_RTC_STAT_REG             0x0B
+#define AB8500_RTC_BKUP_CHG_REG         0x0C
+#define AB8500_RTC_FORCE_BKUP_REG       0x0D
+#define AB8500_RTC_CALIB_REG            0x0E
+#define AB8500_RTC_SWITCH_STAT_REG      0x0F
 
 /* 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,
-                              RTC_READ_REQUEST);
+        retval = abx500_set_register_interruptible(dev,
+                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);
-        if (rtc_ctrl < 0)
-                return rtc_ctrl;
+        retval = abx500_get_register_interruptible(dev, AB8500_RTC,
+                AB8500_RTC_STAT_REG, &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 ab8500_set_bits(ab8500, AB8500_RTC_STAT_REG, RTC_ALARM_ENA,
-                               enabled ? RTC_ALARM_ENA : 0);
+        return abx500_mask_and_set_register_interruptible(dev, AB8500_RTC,
+                AB8500_RTC_STAT_REG, RTC_ALARM_ENA,
+                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,
-                        RTC_STATUS_DATA);
+        err = abx500_mask_and_set_register_interruptible(&pdev->dev, AB8500_RTC,
+                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);
-        if (rtc_ctrl < 0)
-                return rtc_ctrl;
+        err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC,
+                AB8500_RTC_STAT_REG, &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,
-                        unsigned long arg)
+static int at32_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         struct rtc_at32ap700x *rtc = dev_get_drvdata(dev);
         int ret = 0;
 
         spin_lock_irq(&rtc->lock);
 
-        switch (cmd) {
-        case RTC_AIE_ON:
+        if(enabled) {
                 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;
-        case RTC_AIE_OFF:
+        } else {
                 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..26d1cf5d19ae 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -195,13 +195,6 @@ static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
 
         /* 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;
         case RTC_UIE_OFF:       /* update off */
                 at91_sys_write(AT91_RTC_IDR, AT91_RTC_SECEV);
                 break;
@@ -217,6 +210,18 @@ static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
         return ret;
 }
 
+static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        pr_debug("%s(): cmd=%08x\n", __func__, enabled);
+
+        if (enabled) {
+                at91_sys_write(AT91_RTC_SCCR, AT91_RTC_ALARM);
+                at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM);
+        } else
+                at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
+
+        return 0;
+}
 /*
  * Provide additional RTC information in /proc/driver/rtc
  */
@@ -270,6 +275,7 @@ static const struct rtc_class_ops at91_rtc_ops = {
         .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..5469c52cba3d 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -229,12 +229,6 @@ static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
         dev_dbg(dev, "ioctl: cmd=%08x, arg=%08lx, mr %08x\n", cmd, arg, mr);
 
         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;
         case RTC_UIE_OFF:               /* update off */
                 rtt_writel(rtc, MR, mr & ~AT91_RTT_RTTINCIEN);
                 break;
@@ -249,6 +243,19 @@ static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
         return ret;
 }
 
+static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct sam9_rtc *rtc = dev_get_drvdata(dev);
+        u32 mr = rtt_readl(rtc, MR);
+
+        dev_dbg(dev, "alarm_irq_enable: enabled=%08x, mr %08x\n", enabled, mr);
+        if (enabled)
+                rtt_writel(rtc, MR, mr | AT91_RTT_ALMIEN);
+        else
+                rtt_writel(rtc, MR, mr & ~AT91_RTT_ALMIEN);
+        return 0;
+}
+
 /*
  * Provide additional RTC information in /proc/driver/rtc
  */
@@ -302,6 +309,7 @@ static const struct rtc_class_ops at91_rtc_ops = {
         .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..17971d93354d 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/
  *
@@ -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) {
-                bfin_write_RTC_ISTAT(RTC_ISTAT_WRITE_COMPLETE);
+        bits = 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)) {
-                if (rtc_istat & (RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY)) {
-                        bfin_write_RTC_ISTAT(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY);
+        bits = (RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY);
+        if (rtc_ictl & bits) {
+                if (rtc_istat & bits) {
+                        rtc_istat_clear |= bits;
                         events |= RTC_AF | RTC_IRQF;
                 }
         }
 
-        if (rtc_ictl & RTC_ISTAT_SEC) {
-                if (rtc_istat & RTC_ISTAT_SEC) {
-                        bfin_write_RTC_ISTAT(RTC_ISTAT_SEC);
+        bits = RTC_ISTAT_SEC;
+        if (rtc_ictl & bits) {
+                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;
 }
 
@@ -254,15 +259,6 @@ static int bfin_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long ar
                 bfin_rtc_int_clear(~RTC_ISTAT_SEC);
                 break;
 
-        case RTC_AIE_ON:
-                dev_dbg_stamp(dev);
-                bfin_rtc_int_set_alarm(rtc);
-                break;
-        case RTC_AIE_OFF:
-                dev_dbg_stamp(dev);
-                bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
-                break;
-
         default:
                 dev_dbg_stamp(dev);
                 ret = -ENOIOCTLCMD;
@@ -271,6 +267,17 @@ static int bfin_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long ar
         return ret;
 }
 
+static int bfin_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct bfin_rtc *rtc = dev_get_drvdata(dev);
+
+        dev_dbg_stamp(dev);
+        if (enabled)
+                bfin_rtc_int_set_alarm(rtc);
+        else
+                bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
+}
+
 static int bfin_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         struct bfin_rtc *rtc = dev_get_drvdata(dev);
@@ -357,6 +364,7 @@ static struct rtc_class_ops bfin_rtc_ops = {
         .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 +430,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 +445,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..c7ff8df347e7 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -36,6 +36,7 @@
 #include <linux/platform_device.h>
 #include <linux/mod_devicetable.h>
 #include <linux/log2.h>
+#include <linux/pm.h>
 
 /* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
 #include <asm-generic/rtc.h>
@@ -687,7 +688,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 +852,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 +900,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 +947,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 +1079,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)
@@ -1157,8 +1159,9 @@ static struct platform_driver cmos_platform_driver = {
         .shutdown       = cmos_platform_shutdown,
         .driver = {
                 .name           = (char *) driver_name,
-                .suspend        = cmos_suspend,
-                .resume         = cmos_resume,
+#ifdef CONFIG_PM
+                .pm             = &cmos_pm_ops,
+#endif
         }
 };
 
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 62227cd52410..d0e06edb14c5 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,12 @@ 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;
+                }
                 break;
         }
 
diff --git a/drivers/rtc/rtc-ds1286.c b/drivers/rtc/rtc-ds1286.c
index bf430f9091ed..60ce69600828 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,
-        .proc           = ds1286_proc,
+        .ioctl          = ds1286_ioctl,
+        .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)
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
-
-/*
- * Context: caller holds rtc->ops_lock (to protect ds1305->ctrl)
- */
-static int ds1305_ioctl(struct device *dev, unsigned cmd, unsigned long arg)
+static int ds1305_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         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) {
-        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 (enabled) {
                 if (ds1305->ctrl[0] & DS1305_AEI0)
                         goto done;
                 buf[1] |= DS1305_AEI0;
-                break;
-        }
-        if (status == 0) {
-                status = spi_write_then_read(ds1305->spi, buf, sizeof buf,
-                                NULL, 0);
-                if (status >= 0)
-                        ds1305->ctrl[0] = buf[1];
+        } else {
+                if (!(buf[1] & DS1305_AEI0))
+                        goto done;
+                buf[1] &= ~DS1305_AEI0;
         }
-
+        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..4724ba3acf1a 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);
 };
 
@@ -158,8 +158,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,
-                                  u8 length, u8 *values)
+static s32 ds1307_read_block_data_once(const struct i2c_client *client,
+                                       u8 command, u8 length, u8 *values)
 {
         s32 i, data;
 
@@ -172,7 +172,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 +198,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 +495,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) {
-        case RTC_AIE_OFF:
-                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;
+        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 = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
+        if (ret < 0)
+                return ret;
 
+        if (enabled)
                 ret |= DS1337_BIT_A1IE;
+        else
+                ret &= ~DS1337_BIT_A1IE;
 
-                ret = i2c_smbus_write_byte_data(client,
-                                                DS1337_REG_CONTROL, ret);
-                if (ret < 0)
-                        return ret;
-
-                break;
-
-        default:
-                return -ENOIOCTLCMD;
-        }
+        ret = i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, ret);
+        if (ret < 0)
+                return ret;
 
         return 0;
 }
@@ -548,7 +525,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..d834a63ec4b0 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -307,42 +307,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) {
-        case RTC_AIE_OFF:
-                ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
-                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;
+        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;
-
-                ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
-                if (ret < 0)
-                        goto out;
-
-                break;
+        } else {
+                ret &= ~DS1374_REG_CR_WACE;
         }
+        ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
 
 out:
         mutex_unlock(&ds1374->mutex);
@@ -354,7 +337,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 +400,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);
diff --git a/drivers/rtc/rtc-ds3232.c b/drivers/rtc/rtc-ds3232.c
index 9de8516e3531..23a9ee19764c 100644
--- a/drivers/rtc/rtc-ds3232.c
+++ b/drivers/rtc/rtc-ds3232.c
@@ -2,6 +2,7 @@
  * RTC client/driver for the Maxim/Dallas DS3232 Real-Time Clock over I2C
  *
  * Copyright (C) 2009-2010 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
@@ -175,6 +176,182 @@ 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 int ds3232_update_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_UF;
+        else
+                ds3232->rtc->irq_data &= ~RTC_UF;
+
+        ds3232_update_alarm(client);
+        return 0;
+}
+
 static irqreturn_t ds3232_irq(int irq, void *dev_id)
 {
         struct i2c_client *client = dev_id;
@@ -222,6 +399,10 @@ 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,
+        .update_irq_enable = ds3232_update_irq_enable,
 };
 
 static int __devinit ds3232_probe(struct i2c_client *client,
@@ -282,7 +463,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-jz4740.c b/drivers/rtc/rtc-jz4740.c
index 2619d57b91d7..2e16f72c9056 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,7 +162,8 @@ 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;
 }
@@ -258,6 +260,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 +322,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,
-        .remove = __devexit_p(jz4740_rtc_remove),
-        .driver = {
-                .name = "jz4740-rtc",
+        .probe   = jz4740_rtc_probe,
+        .remove  = __devexit_p(jz4740_rtc_remove),
+        .driver  = {
+                .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..ec8701ce99f9
--- /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 seperate 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..69fe664a2228 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_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int m41t80_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         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:
-                rc &= ~M41T80_ALMON_AFE;
-                break;
-        case RTC_AIE_ON:
+
+        if (enabled)
                 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 = {
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,
-                        unsigned long arg)
+static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         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) {
-        case RTC_AIE_OFF:       /* alarm interrupt off */
-                M48T59_WRITE(0x00, M48T59_INTR);
-                break;
-        case RTC_AIE_ON:        /* alarm interrupt on */
+        if (enabled)
                 M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR);
-                break;
-        default:
-                ret = -ENOIOCTLCMD;
-                break;
-        }
+        else
+                M48T59_WRITE(0x00, M48T59_INTR);
         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-max8998.c b/drivers/rtc/rtc-max8998.c
new file mode 100644
index 000000000000..3f7bc6b9fefa
--- /dev/null
+++ b/drivers/rtc/rtc-max8998.c
@@ -0,0 +1,344 @@
+/*
+ * 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;
+
+        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;
+        }
+
+        platform_set_drvdata(pdev, info);
+
+        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:
+        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..5314b153bfba
--- /dev/null
+++ b/drivers/rtc/rtc-mc13xxx.c
@@ -0,0 +1,437 @@
+/*
+ * 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_update_irq_enable(struct device *dev,
+                unsigned int enabled)
+{
+        return mc13xxx_rtc_irq_enable(dev, enabled, MC13XXX_IRQ_1HZ);
+}
+
+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,
+        .update_irq_enable = mc13xxx_rtc_update_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;
+
+        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_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:
+
+                platform_set_drvdata(pdev, NULL);
+                kfree(priv);
+        }
+
+        mc13xxx_unlock(mc13xxx);
+
+        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-mrst.c b/drivers/rtc/rtc-mrst.c
new file mode 100644
index 000000000000..1db62db8469d
--- /dev/null
+++ b/drivers/rtc/rtc-mrst.c
@@ -0,0 +1,561 @@
+/*
+ * 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;
+}
+
+/*
+ * 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 (rtc_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;
+}
+
+static int mrst_irq_set_state(struct device *dev, int enabled)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        unsigned long   flags;
+
+        if (!mrst->irq)
+                return -ENXIO;
+
+        spin_lock_irqsave(&rtc_lock, flags);
+
+        if (enabled)
+                mrst_irq_enable(mrst, RTC_PIE);
+        else
+                mrst_irq_disable(mrst, RTC_PIE);
+
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        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,
+        .irq_set_state  = mrst_irq_set_state,
+        .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 __init
+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.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;
+        }
+
+        mrst_rtc.dev = dev;
+        dev_set_drvdata(dev, &mrst_rtc);
+        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:
+        mrst_rtc.dev = NULL;
+        rtc_device_unregister(mrst_rtc.rtc);
+cleanup0:
+        release_region(iomem->start, iomem->end + 1 - iomem->start);
+        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 __exit 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_region(iomem->start, iomem->end + 1 - iomem->start);
+        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 __init 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 __exit 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         = __exit_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..67820626e18f 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,
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,
-                        unsigned long arg)
+static int mv_rtc_alarm_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);
         void __iomem *ioaddr = pdata->ioaddr;
 
         if (pdata->irq < 0)
-                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
-        switch (cmd) {
-        case RTC_AIE_OFF:
-                writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
-                break;
-        case RTC_AIE_ON:
+                return -EINVAL; /* fall back into rtc-dev's emulation */
+
+        if (enabled)
                 writel(1, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
+        else
+                writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
         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-nuc900.c b/drivers/rtc/rtc-nuc900.c
index 62de66af0a68..ddb0857e15a4 100644
--- a/drivers/rtc/rtc-nuc900.c
+++ b/drivers/rtc/rtc-nuc900.c
@@ -274,7 +274,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..b4dbf3a319b3 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
@@ -142,8 +143,6 @@ 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;
@@ -155,13 +154,6 @@ omap_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         rtc_wait_not_busy();
         reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
         switch (cmd) {
-        /* 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;
         /* UIE = Update Interrupt Enable (1/second) */
         case RTC_UIE_OFF:
                 reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER;
@@ -181,6 +173,24 @@ omap_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 #define omap_rtc_ioctl  NULL
 #endif
 
+static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        u8 reg;
+
+        local_irq_disable();
+        rtc_wait_not_busy();
+        reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+        if (enabled)
+                reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
+        else
+                reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
+        rtc_wait_not_busy();
+        rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
+        local_irq_enable();
+
+        return 0;
+}
+
 /* this hardware doesn't support "don't care" alarm fields */
 static int tm2bcd(struct rtc_time *tm)
 {
@@ -308,6 +318,7 @@ static struct rtc_class_ops omap_rtc_ops = {
         .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 +412,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
-         *    right (W13_1610_RTC_WAKE_INT is the default after chip reset),
-         *    should initialize the device wakeup flag appropriately.
+         *  - Device wake-up capability setting should come through chip
+         *    init logic. OMAP1 boards should initialize the "wakeup capable"
+         *    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);
@@ -427,13 +439,14 @@ fail1:
 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 +458,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-proc.c b/drivers/rtc/rtc-proc.c
index c086fc30a84c..242bbf86c74a 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -81,12 +81,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-rp5c01.c b/drivers/rtc/rtc-rp5c01.c
index 36eb66184461..694da39b6dd2 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)
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_CEDISABLE   ctrl_outb(0x00, RS5C313_CE)
-#define RS5C313_MISCOP      ctrl_outb(0x02, 0xB0000008)
+#define RS5C313_CEENABLE    __raw_writeb(RS5C313_CE_RTCCE, RS5C313_CE);
+#define RS5C313_CEDISABLE   __raw_writeb(0x00, RS5C313_CE)
+#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);
-        ctrl_outb(ctrl_inb(SCSCR1) & ~SCSCR1_CKE, SCSCR1);
+        __raw_writeb(__raw_readb(SCSMR1) & ~SCSMR1_CA, SCSMR1);
+        __raw_writeb(__raw_readb(SCSCR1) & ~SCSCR1_CKE, SCSCR1);
 
         /* And Initialize SCL for RS5C313 clock */
-        scsptr1_data = ctrl_inb(SCSPTR1) | SCL; /* SCL:H */
-        ctrl_outb(scsptr1_data, SCSPTR1);
-        scsptr1_data = ctrl_inb(SCSPTR1) | SCL_OEN;     /* SCL output enable */
-        ctrl_outb(scsptr1_data, SCSPTR1);
+        scsptr1_data = __raw_readb(SCSPTR1) | SCL;      /* SCL:H */
+        __raw_writeb(scsptr1_data, SCSPTR1);
+        scsptr1_data = __raw_readb(SCSPTR1) | SCL_OEN;  /* SCL output enable */
+        __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..6aaa1550e3b1 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 "
@@ -299,14 +299,6 @@ rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
                 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;
         }
@@ -317,12 +309,6 @@ rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 
         addr = RS5C_ADDR(RS5C_REG_CTRL1);
         switch (cmd) {
-        case RTC_AIE_OFF:       /* alarm off */
-                buf &= ~RS5C_CTRL1_AALE;
-                break;
-        case RTC_AIE_ON:        /* alarm on */
-                buf |= RS5C_CTRL1_AALE;
-                break;
         case RTC_UIE_OFF:       /* update off */
                 buf &= ~RS5C_CTRL1_CT_MASK;
                 break;
@@ -347,6 +333,39 @@ rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 #endif
 
 
+static int rs5c_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct i2c_client       *client = to_i2c_client(dev);
+        struct rs5c372          *rs5c = i2c_get_clientdata(client);
+        unsigned char           buf;
+        int                     status, addr;
+
+        buf = rs5c->regs[RS5C_REG_CTRL1];
+
+        if (!rs5c->has_irq)
+                return -EINVAL;
+
+        status = rs5c_get_regs(rs5c);
+        if (status < 0)
+                return status;
+
+        addr = RS5C_ADDR(RS5C_REG_CTRL1);
+        if (enabled)
+                buf |= RS5C_CTRL1_AALE;
+        else
+                buf &= ~RS5C_CTRL1_AALE;
+
+        if (i2c_smbus_write_byte_data(client, addr, buf) < 0) {
+                printk(KERN_WARNING "%s: can't update alarm\n",
+                        rs5c->rtc->name);
+                status = -EIO;
+        } else
+                rs5c->regs[RS5C_REG_CTRL1] = buf;
+
+        return status;
+}
+
+
 /* NOTE:  Since RTC_WKALM_{RD,SET} were originally defined for EFI,
  * which only exposes a polled programming interface; and since
  * these calls map directly to those EFI requests; we don't demand
@@ -466,6 +485,7 @@ static const struct rtc_class_ops rs5c372_rtc_ops = {
         .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-rx8025.c b/drivers/rtc/rtc-rx8025.c
index 1146e3522d3c..af32a62e12a8 100644
--- a/drivers/rtc/rtc-rx8025.c
+++ b/drivers/rtc/rtc-rx8025.c
@@ -650,7 +650,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..cf953ecbfca9 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -100,7 +100,7 @@ static int s3c_rtc_setpie(struct device *dev, int enabled)
         spin_lock_irq(&s3c_rtc_pie_lock);
 
         if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
-                tmp = readb(s3c_rtc_base + S3C2410_RTCCON);
+                tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
                 tmp &= ~S3C64XX_RTCCON_TICEN;
 
                 if (enabled)
@@ -171,8 +171,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",
-                 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
+        pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n",
+                 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 +185,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 +193,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",
-                 tm->tm_year, tm->tm_mon, tm->tm_mday,
+        pr_debug("set time %04d.%02d.%02d %02d:%02d:%02d\n",
+                 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 +231,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 +242,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 +280,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,
-                 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);
+                 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
+                 tm->tm_hour, tm->tm_min, tm->tm_sec);
 
 
         alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
@@ -318,7 +318,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);
@@ -379,7 +379,8 @@ static const struct rtc_class_ops s3c_rtcops = {
         .set_alarm      = s3c_rtc_setalarm,
         .irq_set_freq   = s3c_rtc_setfreq,
         .irq_set_state  = s3c_rtc_setpie,
-        .proc           = s3c_rtc_proc,
+        .proc           = s3c_rtc_proc,
+        .alarm_irq_enable = s3c_rtc_setaie,
 };
 
 static void s3c_rtc_enable(struct platform_device *pdev, int en)
@@ -391,11 +392,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 +406,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);
-                        writeb(tmp|S3C2410_RTCCON_RTCEN, base+S3C2410_RTCCON);
+                        tmp = readw(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);
-                        writeb(tmp& ~S3C2410_RTCCON_CNTSEL, base+S3C2410_RTCCON);
+                        tmp = readw(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);
-                        writeb(tmp & ~S3C2410_RTCCON_CLKRST, base+S3C2410_RTCCON);
+                        tmp = readw(base + S3C2410_RTCCON);
+                        writew(tmp & ~S3C2410_RTCCON_CLKRST,
+                                base + S3C2410_RTCCON);
                 }
         }
 }
@@ -452,8 +456,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 +518,8 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 
         s3c_rtc_enable(pdev, 1);
 
-        pr_debug("s3c2410_rtc: RTCCON=%02x\n",
-                 readb(s3c_rtc_base + S3C2410_RTCCON));
+        pr_debug("s3c2410_rtc: RTCCON=%02x\n",
+                 readw(s3c_rtc_base + S3C2410_RTCCON));
 
         device_init_wakeup(&pdev->dev, 1);
 
@@ -534,11 +538,19 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 
         /* Check RTC Time */
 
-        for (i = S3C2410_RTCSEC; i <= S3C2410_RTCYEAR; i += 0x4) {
-                tmp = readb(s3c_rtc_base + i);
+        s3c_rtc_gettime(NULL, &rtc_tm);
+
+        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;
+
+                s3c_rtc_settime(NULL, &rtc_tm);
 
-                if ((tmp & 0xf) > 0x9 || ((tmp >> 4) & 0xf) > 0x9)
-                        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,7 +590,7 @@ 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);
@@ -596,8 +608,8 @@ 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);
-                writeb(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
+                tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
+                writew(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
         }
 
         if (device_may_wakeup(&pdev->dev))
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index e4a44b641702..5dfe5ffcb0d3 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -39,10 +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 +61,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 +117,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,8 +156,58 @@ static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+static int sa1100_irq_set_freq(struct device *dev, int freq)
+{
+        if (freq < 1 || freq > timer_freq) {
+                return -EINVAL;
+        } else {
+                struct rtc_device *rtc = (struct rtc_device *)dev;
+
+                rtc->irq_freq = freq;
+
+                return 0;
+        }
+}
+
 static int rtc_timer1_count;
 
+static int sa1100_irq_set_state(struct device *dev, int enabled)
+{
+        spin_lock_irq(&sa1100_rtc_lock);
+        if (enabled) {
+                struct rtc_device *rtc = (struct rtc_device *)dev;
+
+                OSMR1 = timer_freq / rtc->irq_freq + OSCR;
+                OIER |= OIER_E1;
+                rtc_timer1_count = 1;
+        } else {
+                OIER &= ~OIER_E1;
+        }
+        spin_unlock_irq(&sa1100_rtc_lock);
+
+        return 0;
+}
+
+static inline int sa1100_timer1_retrigger(struct rtc_device *rtc)
+{
+        unsigned long diff;
+        unsigned long period = timer_freq / rtc->irq_freq;
+
+        spin_lock_irq(&sa1100_rtc_lock);
+
+        do {
+                OSMR1 += period;
+                diff = OSMR1 - OSCR;
+                /* If OSCR > OSMR1, diff is a very large number (unsigned
+                 * math). This means we have a lost interrupt. */
+        } while (diff > period);
+        OIER |= OIER_E1;
+
+        spin_unlock_irq(&sa1100_rtc_lock);
+
+        return 0;
+}
+
 static irqreturn_t timer1_interrupt(int irq, void *dev_id)
 {
         struct platform_device *pdev = to_platform_device(dev_id);
@@ -158,7 +225,11 @@ static irqreturn_t timer1_interrupt(int irq, void *dev_id)
         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)));
+                rtc_timer1_count =
+                        (rtc->irq_freq * ((1 << 30) / (timer_freq >> 2)));
+
+        /* retrigger. */
+        sa1100_timer1_retrigger(rtc);
 
         return IRQ_HANDLED;
 }
@@ -166,8 +237,10 @@ static irqreturn_t timer1_interrupt(int irq, void *dev_id)
 static int sa1100_rtc_read_callback(struct device *dev, int data)
 {
         if (data & RTC_PF) {
+                struct rtc_device *rtc = (struct rtc_device *)dev;
+
                 /* interpolate missed periods and set match for the next */
-                unsigned long period = timer_freq / rtc_freq;
+                unsigned long period = timer_freq / rtc->irq_freq;
                 unsigned long oscr = OSCR;
                 unsigned long osmr1 = OSMR1;
                 unsigned long missed = (oscr - osmr1)/period;
@@ -178,7 +251,7 @@ static int sa1100_rtc_read_callback(struct device *dev, int data)
                  * Here we compare (match - OSCR) 8 instead of 0 --
                  * see comment in pxa_timer_interrupt() for explanation.
                  */
-                while( (signed long)((osmr1 = OSMR1) - OSCR) <= 8 ) {
+                while ((signed long)((osmr1 = OSMR1) - OSCR) <= 8) {
                         data += 0x100;
                         OSSR = OSSR_M1; /* clear match on timer 1 */
                         OSMR1 = osmr1 + period;
@@ -190,25 +263,29 @@ static int sa1100_rtc_read_callback(struct device *dev, int data)
 static int sa1100_rtc_open(struct device *dev)
 {
         int ret;
+        struct rtc_device *rtc = (struct rtc_device *)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 timer", dev);
+                "rtc timer", dev);
         if (ret) {
                 dev_err(dev, "IRQ %d already in use.\n", IRQ_OST1);
                 goto fail_pi;
         }
+        rtc->max_user_freq = RTC_FREQ;
+        sa1100_irq_set_freq(dev, RTC_FREQ);
+
         return 0;
 
  fail_pi:
@@ -236,17 +313,7 @@ static void sa1100_rtc_release(struct device *dev)
 static int sa1100_rtc_ioctl(struct device *dev, unsigned int cmd,
                 unsigned long arg)
 {
-        switch(cmd) {
-        case RTC_AIE_OFF:
-                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);
-                return 0;
+        switch (cmd) {
         case RTC_UIE_OFF:
                 spin_lock_irq(&sa1100_rtc_lock);
                 RTSR &= ~RTSR_HZE;
@@ -257,29 +324,21 @@ static int sa1100_rtc_ioctl(struct device *dev, unsigned int cmd,
                 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_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        spin_lock_irq(&sa1100_rtc_lock);
+        if (enabled)
+                RTSR |= RTSR_ALE;
+        else
+                RTSR &= ~RTSR_ALE;
+        spin_unlock_irq(&sa1100_rtc_lock);
+        return 0;
+}
+
 static int sa1100_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         rtc_time_to_tm(RCNR, tm);
@@ -327,12 +386,15 @@ 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)
 {
+        struct rtc_device *rtc = (struct rtc_device *)dev;
+
         seq_printf(seq, "trim/divider\t: 0x%08x\n", (u32) RTTR);
         seq_printf(seq, "update_IRQ\t: %s\n",
                         (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);
+        seq_printf(seq, "periodic_freq\t: %d\n", rtc->irq_freq);
+        seq_printf(seq, "RTSR\t\t: 0x%08x\n", (u32)RTSR);
 
         return 0;
 }
@@ -347,6 +409,9 @@ static const struct rtc_class_ops sa1100_rtc_ops = {
         .read_alarm = sa1100_rtc_read_alarm,
         .set_alarm = sa1100_rtc_set_alarm,
         .proc = sa1100_rtc_proc,
+        .irq_set_freq = sa1100_irq_set_freq,
+        .irq_set_state = sa1100_irq_set_state,
+        .alarm_irq_enable = sa1100_rtc_alarm_irq_enable,
 };
 
 static int sa1100_rtc_probe(struct platform_device *pdev)
@@ -364,7 +429,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 +438,42 @@ 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);
 
+        /* Set the irq_freq */
+        /*TODO: Find out who is messing with this value after we initialize
+         * it here.*/
+        rtc->irq_freq = RTC_FREQ;
+
+        /* 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 +481,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..93314a9e7fa9 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -350,10 +350,6 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         unsigned int ret = 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);
@@ -369,6 +365,12 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         return ret;
 }
 
+static int sh_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        sh_rtc_setaie(dev, enabled);
+        return 0;
+}
+
 static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -604,6 +606,7 @@ static struct rtc_class_ops sh_rtc_ops = {
         .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 +764,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 +789,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);
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index 51725f7755b0..a82d6fe97076 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,
-        unsigned long arg)
+static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
 {
-        /* We do support interrupts, they're generated
-         * 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;
-        }
+        return 0;
 }
 
 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,
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index c3244244e8cf..769190ac6d11 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -240,26 +240,6 @@ static int vr41xx_rtc_irq_set_state(struct device *dev, int enabled)
 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 +255,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;