9 files changed, 737 insertions, 67 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 2785a0f16c9f..6a77437d4f5a 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.
@@ -952,4 +953,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..7a7cb3228a1d 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -51,6 +51,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
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 565562ba6ac9..e6539cbabb35 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -158,8 +158,10 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
         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/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index d4fb82d85e9b..b4b6087f2234 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;
 }
 
@@ -422,9 +427,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 +442,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-ds3232.c b/drivers/rtc/rtc-ds3232.c
index 9de8516e3531..57063552d3b7 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,
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-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-omap.c b/drivers/rtc/rtc-omap.c
index 64d9727b7229..73377b0d65da 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
@@ -401,16 +402,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);
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))