9 files changed, 727 insertions, 39 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 2883428d5ac8..4941cade319f 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -463,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
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 4c2832df4697..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
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 62227cd52410..0cc0984d155b 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -104,7 +104,7 @@ static int clear_uie(struct rtc_device *rtc)
                 }
                 if (rtc->uie_task_active) {
                         spin_unlock_irq(&rtc->irq_lock);
-                        flush_scheduled_work();
+                        flush_work_sync(&rtc->uie_task);
                         spin_lock_irq(&rtc->irq_lock);
                 }
                 rtc->uie_irq_active = 0;
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index 48da85e97ca4..077af1d7b9e4 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -813,7 +813,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-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 1f0007fd4431..47fb6357c346 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -417,7 +417,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 57063552d3b7..23a9ee19764c 100644
--- a/drivers/rtc/rtc-ds3232.c
+++ b/drivers/rtc/rtc-ds3232.c
@@ -463,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-mrst.c b/drivers/rtc/rtc-mrst.c
new file mode 100644
index 000000000000..bcd0cf63eb16
--- /dev/null
+++ b/drivers/rtc/rtc-mrst.c
@@ -0,0 +1,582 @@
+/*
+ * 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;
+}
+
+#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
+
+/* Currently, the vRTC doesn't support UIE ON/OFF */
+static int
+mrst_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        struct mrst_rtc *mrst = dev_get_drvdata(dev);
+        unsigned long   flags;
+
+        switch (cmd) {
+        case RTC_AIE_OFF:
+        case RTC_AIE_ON:
+                if (!mrst->irq)
+                        return -EINVAL;
+                break;
+        default:
+                /* PIE ON/OFF is handled by mrst_irq_set_state() */
+                return -ENOIOCTLCMD;
+        }
+
+        spin_lock_irqsave(&rtc_lock, flags);
+        switch (cmd) {
+        case RTC_AIE_OFF:       /* alarm off */
+                mrst_irq_disable(mrst, RTC_AIE);
+                break;
+        case RTC_AIE_ON:        /* alarm on */
+                mrst_irq_enable(mrst, RTC_AIE);
+                break;
+        }
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        return 0;
+}
+
+#else
+#define mrst_rtc_ioctl  NULL
+#endif
+
+#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 = {
+        .ioctl          = mrst_rtc_ioctl,
+        .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,
+};
+
+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-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-sa1100.c b/drivers/rtc/rtc-sa1100.c
index e4a44b641702..88ea52b8647a 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,7 +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) {
+        switch (cmd) {
         case RTC_AIE_OFF:
                 spin_lock_irq(&sa1100_rtc_lock);
                 RTSR &= ~RTSR_ALE;
@@ -257,25 +334,6 @@ 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;
 }
@@ -327,12 +385,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 +408,8 @@ 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,
 };
 
 static int sa1100_rtc_probe(struct platform_device *pdev)
@@ -364,7 +427,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 +436,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 +479,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;