83 files changed, 11576 insertions, 1607 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 81adbdbd5042..4941cade319f 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -166,6 +166,17 @@ config RTC_DRV_DS1672
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1672.
 
+config RTC_DRV_DS3232
+        tristate "Dallas/Maxim DS3232"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for Dallas Semiconductor
+          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.
+
 config RTC_DRV_MAX6900
         tristate "Maxim MAX6900"
         help
@@ -175,6 +186,26 @@ config RTC_DRV_MAX6900
           This driver can also be built as a module. If so, the module
           will be called rtc-max6900.
 
+config RTC_DRV_MAX8925
+        tristate "Maxim MAX8925"
+        depends on MFD_MAX8925
+        help
+          If you say yes here you will get support for the
+          RTC of Maxim MAX8925 PMIC.
+
+          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
@@ -193,6 +224,15 @@ config RTC_DRV_ISL1208
           This driver can also be built as a module. If so, the module
           will be called rtc-isl1208.
 
+config RTC_DRV_ISL12022
+        tristate "Intersil ISL12022"
+        help
+          If you say yes here you get support for the
+          Intersil ISL12022 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-isl12022.
+
 config RTC_DRV_X1205
         tristate "Xicor/Intersil X1205"
         help
@@ -242,6 +282,15 @@ config RTC_DRV_M41T80_WDT
           If you say Y here you will get support for the
           watchdog timer in the ST M41T60 and M41T80 RTC chips series.
 
+config RTC_DRV_BQ32K
+        tristate "TI BQ32000"
+        help
+          If you say Y here you will get support for the TI
+          BQ32000 I2C RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-bq32k.
+
 config RTC_DRV_DM355EVM
         tristate "TI DaVinci DM355 EVM RTC"
         depends on MFD_DM355EVM_MSP
@@ -258,14 +307,14 @@ config RTC_DRV_TWL92330
           the Menelaus driver; it's not separate module.
 
 config RTC_DRV_TWL4030
-        tristate "TI TWL4030/TWL5030/TPS659x0"
+        tristate "TI TWL4030/TWL5030/TWL6030/TPS659x0"
         depends on RTC_CLASS && TWL4030_CORE
         help
           If you say yes here you get support for the RTC on the
-          TWL4030 family chips, used mostly with OMAP3 platforms.
+          TWL4030/TWL5030/TWL6030 family chips, used mostly with OMAP3 platforms.
 
           This driver can also be built as a module. If so, the module
-          will be called rtc-twl4030.
+          will be called rtc-twl.
 
 config RTC_DRV_S35390A
         tristate "Seiko Instruments S-35390A"
@@ -378,6 +427,15 @@ config RTC_DRV_DS3234
           This driver can also be built as a module. If so, the module
           will be called rtc-ds3234.
 
+config RTC_DRV_PCF2123
+        tristate "NXP PCF2123"
+        help
+          If you say yes here you get support for the NXP PCF2123
+          RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-pcf2123.
+
 endif # SPI_MASTER
 
 comment "Platform RTC drivers"
@@ -405,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
@@ -500,6 +570,36 @@ config RTC_DRV_M48T59
           This driver can also be built as a module, if so, the module
           will be called "rtc-m48t59".
 
+config RTC_DRV_MSM6242
+        tristate "Oki MSM6242"
+        help
+          If you say yes here you get support for the Oki MSM6242
+          timekeeping chip. It is used in some Amiga models (e.g. A2000).
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-msm6242.
+
+config RTC_DRV_IMXDI
+        tristate "Freescale IMX DryIce Real Time Clock"
+        depends on ARCH_MX25
+        depends on RTC_CLASS
+        help
+           Support for Freescale IMX DryIce RTC
+
+           This driver can also be built as a module, if so, the module
+           will be called "rtc-imxdi".
+
+config RTC_MXC
+        tristate "Freescale MXC Real Time Clock"
+        depends on ARCH_MXC
+        depends on RTC_CLASS
+        help
+           If you say yes here you get support for the Freescale MXC
+           RTC module.
+
+           This driver can also be built as a module, if so, the module
+           will be called "rtc-mxc".
+
 config RTC_DRV_BQ4802
         tristate "TI BQ4802"
         help
@@ -509,6 +609,16 @@ config RTC_DRV_BQ4802
           This driver can also be built as a module. If so, the module
           will be called rtc-bq4802.
 
+config RTC_DRV_RP5C01
+        tristate "Ricoh RP5C01"
+        help
+          If you say yes here you get support for the Ricoh RP5C01
+          timekeeping chip. It is used in some Amiga models (e.g. A3000
+          and A4000).
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rp5c01.
+
 config RTC_DRV_V3020
         tristate "EM Microelectronic V3020"
         help
@@ -518,6 +628,16 @@ config RTC_DRV_V3020
           This driver can also be built as a module. If so, the module
           will be called rtc-v3020.
 
+config RTC_DRV_WM831X
+        tristate "Wolfson Microelectronics WM831x RTC"
+        depends on MFD_WM831X
+        help
+          If you say yes here you will get support for the RTC subsystem
+          of the Wolfson Microelectronics WM831X series PMICs.
+
+          This driver can also be built as a module. If so, the module
+          will be called "rtc-wm831x".
+
 config RTC_DRV_WM8350
         tristate "Wolfson Microelectronics WM8350 RTC"
         depends on MFD_WM8350
@@ -535,18 +655,58 @@ config RTC_DRV_PCF50633
           If you say yes here you get support for the RTC subsystem of the
           NXP PCF50633 used in embedded systems.
 
+config RTC_DRV_AB3100
+        tristate "ST-Ericsson AB3100 RTC"
+        depends on AB3100_CORE
+        default y if AB3100_CORE
+        help
+          Select this to enable the ST-Ericsson AB3100 Mixed Signal IC RTC
+          support. This chip contains a battery- and capacitor-backed RTC.
+
+config RTC_DRV_AB8500
+        tristate "ST-Ericsson AB8500 RTC"
+        depends on AB8500_CORE
+        help
+          Select this to enable the ST-Ericsson AB8500 power management IC RTC
+          support. This chip contains a battery- and capacitor-backed RTC.
+
+config RTC_DRV_NUC900
+        tristate "NUC910/NUC920 RTC driver"
+        depends on RTC_CLASS && ARCH_W90X900
+        help
+          If you say yes here you get support for the RTC subsystem of the
+          NUC910/NUC920 used in embedded systems.
+
 comment "on-CPU RTC drivers"
 
+config RTC_DRV_DAVINCI
+        tristate "TI DaVinci RTC"
+        depends on ARCH_DAVINCI_DM365
+        help
+          If you say yes here you get support for the RTC on the
+          DaVinci platforms (DM365).
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-davinci.
+
 config RTC_DRV_OMAP
         tristate "TI OMAP1"
-        depends on ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730
+        depends on ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 || ARCH_DAVINCI_DA8XX
+        help
+          Say "yes" here to support the real time clock on TI OMAP1 and
+          DA8xx/OMAP-L13x chips.  This driver can also be built as a
+          module called rtc-omap.
+
+config HAVE_S3C_RTC
+        bool
         help
-          Say "yes" here to support the real time clock on TI OMAP1 chips.
-          This driver can also be built as a module called rtc-omap.
+          This will include RTC support for Samsung SoCs. If
+          you want to include RTC support for any machine, kindly
+          select this in the respective mach-XXXX/Kconfig file.
 
 config RTC_DRV_S3C
         tristate "Samsung S3C series SoC RTC"
-        depends on ARCH_S3C2410
+        depends on ARCH_S3C2410 || ARCH_S3C64XX || HAVE_S3C_RTC
         help
           RTC (Realtime Clock) driver for the clock inbuilt into the
           Samsung S3C24XX series of SoCs. This can provide periodic
@@ -628,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
@@ -644,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
@@ -673,7 +833,7 @@ config RTC_DRV_AT91SAM9_GPBR
 
 config RTC_DRV_AU1XXX
         tristate "Au1xxx Counter0 RTC support"
-        depends on SOC_AU1X00
+        depends on MIPS_ALCHEMY
         help
           This is a driver for the Au1xxx on-chip Counter0 (Time-Of-Year
           counter) to be used as a RTC.
@@ -741,7 +901,7 @@ config RTC_DRV_TX4939
 
 config RTC_DRV_MV
         tristate "Marvell SoC RTC"
-        depends on ARCH_KIRKWOOD
+        depends on ARCH_KIRKWOOD || ARCH_DOVE
         help
           If you say yes here you will get support for the in-chip RTC
           that can be found in some of Marvell's SoC devices, such as
@@ -759,4 +919,70 @@ config RTC_DRV_PS3
           This driver can also be built as a module. If so, the module
           will be called rtc-ps3.
 
+config RTC_DRV_COH901331
+        tristate "ST-Ericsson COH 901 331 RTC"
+        depends on ARCH_U300
+        help
+          If you say Y here you will get access to ST-Ericsson
+          COH 901 331 RTC clock found in some ST-Ericsson Mobile
+          Platforms.
+
+          This driver can also be built as a module. If so, the module
+          will be called "rtc-coh901331".
+
+
+config RTC_DRV_STMP
+        tristate "Freescale STMP3xxx RTC"
+        depends on ARCH_STMP3XXX
+        help
+          If you say yes here you will get support for the onboard
+          STMP3xxx RTC.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-stmp3xxx.
+
+config RTC_DRV_PCAP
+        tristate "PCAP RTC"
+        depends on EZX_PCAP
+        help
+          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_MC13XXX
+        depends on MFD_MC13XXX
+        tristate "Freescale MC13xxx RTC"
+        help
+          This enables support for the RTCs found on Freescale's PMICs
+          MC13783 and MC13892.
+
+config RTC_DRV_MPC5121
+        tristate "Freescale MPC5121 built-in RTC"
+        depends on PPC_MPC512x && RTC_CLASS
+        help
+          If you say yes here you will get support for the
+          built-in RTC MPC5121.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-mpc5121.
+
+config RTC_DRV_JZ4740
+        tristate "Ingenic JZ4740 SoC"
+        depends on RTC_CLASS
+        depends on MACH_JZ4740
+        help
+          If you say yes here you get support for the Ingenic JZ4740 SoC RTC
+          controller.
+
+          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 3c0f2b2ac927..2afdaf3ff986 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -17,13 +17,20 @@ rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
 
 # Keep the list ordered.
 
+obj-$(CONFIG_RTC_DRV_AB3100)    += rtc-ab3100.o
+obj-$(CONFIG_RTC_DRV_AB8500)    += rtc-ab8500.o
 obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
 obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
 obj-$(CONFIG_RTC_DRV_AT91SAM9)  += rtc-at91sam9.o
 obj-$(CONFIG_RTC_DRV_AU1XXX)    += rtc-au1xxx.o
 obj-$(CONFIG_RTC_DRV_BFIN)      += rtc-bfin.o
+obj-$(CONFIG_RTC_DRV_BQ32K)     += rtc-bq32k.o
+obj-$(CONFIG_RTC_DRV_BQ4802)    += rtc-bq4802.o
 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
@@ -35,30 +42,44 @@ obj-$(CONFIG_RTC_DRV_DS1511)	+= rtc-ds1511.o
 obj-$(CONFIG_RTC_DRV_DS1553)    += rtc-ds1553.o
 obj-$(CONFIG_RTC_DRV_DS1672)    += rtc-ds1672.o
 obj-$(CONFIG_RTC_DRV_DS1742)    += rtc-ds1742.o
+obj-$(CONFIG_RTC_DRV_DS3232)    += rtc-ds3232.o
 obj-$(CONFIG_RTC_DRV_DS3234)    += rtc-ds3234.o
 obj-$(CONFIG_RTC_DRV_EFI)       += rtc-efi.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
 obj-$(CONFIG_RTC_DRV_FM3130)    += rtc-fm3130.o
+obj-$(CONFIG_RTC_DRV_GENERIC)   += rtc-generic.o
+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
 obj-$(CONFIG_RTC_DRV_M48T59)    += rtc-m48t59.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
-obj-$(CONFIG_RTC_DRV_BQ4802)    += rtc-bq4802.o
-obj-$(CONFIG_RTC_DRV_SUN4V)     += rtc-sun4v.o
-obj-$(CONFIG_RTC_DRV_STARFIRE)  += rtc-starfire.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_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
+obj-$(CONFIG_RTC_DRV_NUC900)    += rtc-nuc900.o
 obj-$(CONFIG_RTC_DRV_OMAP)      += rtc-omap.o
+obj-$(CONFIG_RTC_DRV_PCAP)      += rtc-pcap.o
 obj-$(CONFIG_RTC_DRV_PCF8563)   += rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)   += rtc-pcf8583.o
+obj-$(CONFIG_RTC_DRV_PCF2123)   += rtc-pcf2123.o
+obj-$(CONFIG_RTC_DRV_PCF50633)  += rtc-pcf50633.o
 obj-$(CONFIG_RTC_DRV_PL030)     += rtc-pl030.o
 obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
-obj-$(CONFIG_RTC_DRV_GENERIC)   += rtc-generic.o
+obj-$(CONFIG_RTC_DRV_PS3)       += rtc-ps3.o
 obj-$(CONFIG_RTC_DRV_PXA)       += rtc-pxa.o
 obj-$(CONFIG_RTC_DRV_R9701)     += rtc-r9701.o
+obj-$(CONFIG_RTC_DRV_RP5C01)    += rtc-rp5c01.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_RS5C348)   += rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_RS5C372)   += rtc-rs5c372.o
@@ -68,13 +89,15 @@ obj-$(CONFIG_RTC_DRV_S35390A)	+= rtc-s35390a.o
 obj-$(CONFIG_RTC_DRV_S3C)       += rtc-s3c.o
 obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
 obj-$(CONFIG_RTC_DRV_SH)        += rtc-sh.o
+obj-$(CONFIG_RTC_DRV_STARFIRE)  += rtc-starfire.o
 obj-$(CONFIG_RTC_DRV_STK17TA8)  += rtc-stk17ta8.o
+obj-$(CONFIG_RTC_DRV_STMP)      += rtc-stmp3xxx.o
+obj-$(CONFIG_RTC_DRV_SUN4V)     += rtc-sun4v.o
 obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
-obj-$(CONFIG_RTC_DRV_TWL4030)   += rtc-twl4030.o
+obj-$(CONFIG_RTC_DRV_TWL4030)   += rtc-twl.o
 obj-$(CONFIG_RTC_DRV_TX4939)    += rtc-tx4939.o
 obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.o
+obj-$(CONFIG_RTC_DRV_WM831X)    += rtc-wm831x.o
 obj-$(CONFIG_RTC_DRV_WM8350)    += rtc-wm8350.o
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
-obj-$(CONFIG_RTC_DRV_PCF50633)  += rtc-pcf50633.o
-obj-$(CONFIG_RTC_DRV_PS3)       += rtc-ps3.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index be5a6b73e601..9583cbcc6b79 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -15,6 +15,8 @@
 #include <linux/rtc.h>
 #include <linux/kdev_t.h>
 #include <linux/idr.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
 
 #include "rtc-core.h"
 
@@ -151,14 +153,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);
@@ -226,6 +242,7 @@ static void __exit rtc_exit(void)
 {
         rtc_dev_exit();
         class_destroy(rtc_class);
+        idr_destroy(&rtc_idr);
 }
 
 subsys_initcall(rtc_init);
diff --git a/drivers/rtc/hctosys.c b/drivers/rtc/hctosys.c
index 33c0e98243ee..bc90b091f195 100644
--- a/drivers/rtc/hctosys.c
+++ b/drivers/rtc/hctosys.c
@@ -22,48 +22,57 @@
  * the best guess is to add 0.5s.
  */
 
+int rtc_hctosys_ret = -ENODEV;
+
 static int __init rtc_hctosys(void)
 {
-        int err;
+        int err = -ENODEV;
         struct rtc_time tm;
+        struct timespec tv = {
+                .tv_nsec = NSEC_PER_SEC >> 1,
+        };
         struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
 
         if (rtc == NULL) {
-                printk("%s: unable to open rtc device (%s)\n",
+                pr_err("%s: unable to open rtc device (%s)\n",
                         __FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
-                return -ENODEV;
+                goto err_open;
         }
 
         err = rtc_read_time(rtc, &tm);
-        if (err == 0) {
-                err = rtc_valid_tm(&tm);
-                if (err == 0) {
-                        struct timespec tv;
+        if (err) {
+                dev_err(rtc->dev.parent,
+                        "hctosys: unable to read the hardware clock\n");
+                goto err_read;
 
-                        tv.tv_nsec = NSEC_PER_SEC >> 1;
+        }
 
-                        rtc_tm_to_time(&tm, &tv.tv_sec);
+        err = rtc_valid_tm(&tm);
+        if (err) {
+                dev_err(rtc->dev.parent,
+                        "hctosys: invalid date/time\n");
+                goto err_invalid;
+        }
 
-                        do_settimeofday(&tv);
+        rtc_tm_to_time(&tm, &tv.tv_sec);
 
-                        dev_info(rtc->dev.parent,
-                                "setting system clock to "
-                                "%d-%02d-%02d %02d:%02d:%02d UTC (%u)\n",
-                                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
-                                tm.tm_hour, tm.tm_min, tm.tm_sec,
-                                (unsigned int) tv.tv_sec);
-                }
-                else
-                        dev_err(rtc->dev.parent,
-                                "hctosys: invalid date/time\n");
-        }
-        else
-                dev_err(rtc->dev.parent,
-                        "hctosys: unable to read the hardware clock\n");
+        do_settimeofday(&tv);
 
+        dev_info(rtc->dev.parent,
+                "setting system clock to "
+                "%d-%02d-%02d %02d:%02d:%02d UTC (%u)\n",
+                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                tm.tm_hour, tm.tm_min, tm.tm_sec,
+                (unsigned int) tv.tv_sec);
+
+err_invalid:
+err_read:
         rtc_class_close(rtc);
 
-        return 0;
+err_open:
+        rtc_hctosys_ret = err;
+
+        return err;
 }
 
 late_initcall(rtc_hctosys);
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 4cdb31a362ca..90384b9f6b2c 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -12,16 +12,13 @@
 */
 
 #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_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)
@@ -30,7 +27,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;
 }
@@ -105,188 +113,54 @@ 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;
+        if (alarm->enabled)
+                alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
         mutex_unlock(&rtc->ops_lock);
-        return err;
+
+        return 0;
 }
+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);
-
-        /* Fill in the missing alarm fields using the timestamp; we
-         * know there's at least one since alarm->time is invalid.
-         */
-        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) {
+        rtc_tm_to_time(&alarm->time, &scheduled);
 
-        /* 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.
+        /* 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.
          */
-        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");
-        }
 
-done:
-        return 0;
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->set_alarm)
+                err = -EINVAL;
+        else
+                err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
+
+        return err;
 }
-EXPORT_SYMBOL_GPL(rtc_read_alarm);
 
 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
@@ -299,16 +173,18 @@ 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.enabled = 0;
+        }
+        rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
+        rtc->aie_timer.period = ktime_set(0, 0);
+        if (alarm->enabled) {
+                rtc->aie_timer.enabled = 1;
+                rtc_timer_enqueue(rtc, &rtc->aie_timer);
+        }
         mutex_unlock(&rtc->ops_lock);
-        return err;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(rtc_set_alarm);
 
@@ -318,6 +194,16 @@ int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
         if (err)
                 return err;
 
+        if (rtc->aie_timer.enabled != enabled) {
+                if (enabled) {
+                        rtc->aie_timer.enabled = 1;
+                        rtc_timer_enqueue(rtc, &rtc->aie_timer);
+                } else {
+                        rtc_timer_remove(rtc, &rtc->aie_timer);
+                        rtc->aie_timer.enabled = 0;
+                }
+        }
+
         if (!rtc->ops)
                 err = -ENODEV;
         else if (!rtc->ops->alarm_irq_enable)
@@ -336,52 +222,53 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
         if (err)
                 return err;
 
-#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);
+        /* 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);
+                rtc->uie_rtctimer.enabled = 1;
+                rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
+        } else {
+                rtc_timer_remove(rtc, &rtc->uie_rtctimer);
+                rtc->uie_rtctimer.enabled = 0;
         }
-#endif
-
-        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
-         * the update_irq_enable function pointer or if returned
-         * -EINVAL to signal that it has been configured without
-         * interrupts or that are not available at the moment.
-         */
-        if (err == -EINVAL)
-                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)
+static 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);
@@ -390,6 +277,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)
@@ -476,18 +426,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;
 }
@@ -508,21 +460,194 @@ 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;
-
         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.
+ *
+ * Must hold ops_lock for proper serialization of timerqueue
+ */
+void rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
+{
+        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);
+        }
+}
+
+/**
+ * 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.
+ *
+ * Must hold ops_lock for proper serialization of timerqueue
+ */
+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);
+
+        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;
+
+        timer->enabled = 1;
+        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);
+        timer->enabled = 0;
+        mutex_unlock(&rtc->ops_lock);
+        return ret;
+}
+
+
diff --git a/drivers/rtc/rtc-ab3100.c b/drivers/rtc/rtc-ab3100.c
new file mode 100644
index 000000000000..261a07e0fb24
--- /dev/null
+++ b/drivers/rtc/rtc-ab3100.c
@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2007-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * RTC clock driver for the AB3100 Analog Baseband Chip
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/mfd/abx500.h>
+
+/* Clock rate in Hz */
+#define AB3100_RTC_CLOCK_RATE   32768
+
+/*
+ * The AB3100 RTC registers. These are the same for
+ * AB3000 and AB3100.
+ * Control register:
+ * Bit 0: RTC Monitor cleared=0, active=1, if you set it
+ *        to 1 it remains active until RTC power is lost.
+ * Bit 1: 32 kHz Oscillator, 0 = on, 1 = bypass
+ * Bit 2: Alarm on, 0 = off, 1 = on
+ * Bit 3: 32 kHz buffer disabling, 0 = enabled, 1 = disabled
+ */
+#define AB3100_RTC              0x53
+/* default setting, buffer disabled, alarm on */
+#define RTC_SETTING             0x30
+/* Alarm when AL0-AL3 == TI0-TI3  */
+#define AB3100_AL0              0x56
+#define AB3100_AL1              0x57
+#define AB3100_AL2              0x58
+#define AB3100_AL3              0x59
+/* This 48-bit register that counts up at 32768 Hz */
+#define AB3100_TI0              0x5a
+#define AB3100_TI1              0x5b
+#define AB3100_TI2              0x5c
+#define AB3100_TI3              0x5d
+#define AB3100_TI4              0x5e
+#define AB3100_TI5              0x5f
+
+/*
+ * RTC clock functions and device struct declaration
+ */
+static int ab3100_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        u8 regs[] = {AB3100_TI0, AB3100_TI1, AB3100_TI2,
+                     AB3100_TI3, AB3100_TI4, AB3100_TI5};
+        unsigned char buf[6];
+        u64 fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
+        int err = 0;
+        int i;
+
+        buf[0] = (fat_time) & 0xFF;
+        buf[1] = (fat_time >> 8) & 0xFF;
+        buf[2] = (fat_time >> 16) & 0xFF;
+        buf[3] = (fat_time >> 24) & 0xFF;
+        buf[4] = (fat_time >> 32) & 0xFF;
+        buf[5] = (fat_time >> 40) & 0xFF;
+
+        for (i = 0; i < 6; i++) {
+                err = abx500_set_register_interruptible(dev, 0,
+                                                        regs[i], buf[i]);
+                if (err)
+                        return err;
+        }
+
+        /* Set the flag to mark that the clock is now set */
+        return abx500_mask_and_set_register_interruptible(dev, 0,
+                                                          AB3100_RTC,
+                                                          0x01, 0x01);
+
+}
+
+static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long time;
+        u8 rtcval;
+        int err;
+
+        err = abx500_get_register_interruptible(dev, 0,
+                                                AB3100_RTC, &rtcval);
+        if (err)
+                return err;
+
+        if (!(rtcval & 0x01)) {
+                dev_info(dev, "clock not set (lost power)");
+                return -EINVAL;
+        } else {
+                u64 fat_time;
+                u8 buf[6];
+
+                /* Read out time registers */
+                err = abx500_get_register_page_interruptible(dev, 0,
+                                                             AB3100_TI0,
+                                                             buf, 6);
+                if (err != 0)
+                        return err;
+
+                fat_time = ((u64) buf[5] << 40) | ((u64) buf[4] << 32) |
+                        ((u64) buf[3] << 24) | ((u64) buf[2] << 16) |
+                        ((u64) buf[1] << 8) | (u64) buf[0];
+                time = (unsigned long) (fat_time /
+                                        (u64) (AB3100_RTC_CLOCK_RATE * 2));
+        }
+
+        rtc_time_to_tm(time, tm);
+
+        return rtc_valid_tm(tm);
+}
+
+static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        unsigned long time;
+        u64 fat_time;
+        u8 buf[6];
+        u8 rtcval;
+        int err;
+
+        /* Figure out if alarm is enabled or not */
+        err = abx500_get_register_interruptible(dev, 0,
+                                                AB3100_RTC, &rtcval);
+        if (err)
+                return err;
+        if (rtcval & 0x04)
+                alarm->enabled = 1;
+        else
+                alarm->enabled = 0;
+        /* No idea how this could be represented */
+        alarm->pending = 0;
+        /* Read out alarm registers, only 4 bytes */
+        err = abx500_get_register_page_interruptible(dev, 0,
+                                                     AB3100_AL0, buf, 4);
+        if (err)
+                return err;
+        fat_time = ((u64) buf[3] << 40) | ((u64) buf[2] << 32) |
+                ((u64) buf[1] << 24) | ((u64) buf[0] << 16);
+        time = (unsigned long) (fat_time / (u64) (AB3100_RTC_CLOCK_RATE * 2));
+
+        rtc_time_to_tm(time, &alarm->time);
+
+        return rtc_valid_tm(&alarm->time);
+}
+
+static int ab3100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        u8 regs[] = {AB3100_AL0, AB3100_AL1, AB3100_AL2, AB3100_AL3};
+        unsigned char buf[4];
+        unsigned long secs;
+        u64 fat_time;
+        int err;
+        int i;
+
+        rtc_tm_to_time(&alarm->time, &secs);
+        fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
+        buf[0] = (fat_time >> 16) & 0xFF;
+        buf[1] = (fat_time >> 24) & 0xFF;
+        buf[2] = (fat_time >> 32) & 0xFF;
+        buf[3] = (fat_time >> 40) & 0xFF;
+
+        /* Set the alarm */
+        for (i = 0; i < 4; i++) {
+                err = abx500_set_register_interruptible(dev, 0,
+                                                        regs[i], buf[i]);
+                if (err)
+                        return err;
+        }
+        /* Then enable the alarm */
+        return abx500_mask_and_set_register_interruptible(dev, 0,
+                                                          AB3100_RTC, (1 << 2),
+                                                          alarm->enabled << 2);
+}
+
+static int ab3100_rtc_irq_enable(struct device *dev, unsigned int enabled)
+{
+        /*
+         * It's not possible to enable/disable the alarm IRQ for this RTC.
+         * It does not actually trigger any IRQ: instead its only function is
+         * to power up the system, if it wasn't on. This will manifest as
+         * a "power up cause" in the AB3100 power driver (battery charging etc)
+         * and need to be handled there instead.
+         */
+        if (enabled)
+                return abx500_mask_and_set_register_interruptible(dev, 0,
+                                                    AB3100_RTC, (1 << 2),
+                                                    1 << 2);
+        else
+                return abx500_mask_and_set_register_interruptible(dev, 0,
+                                                    AB3100_RTC, (1 << 2),
+                                                    0);
+}
+
+static const struct rtc_class_ops ab3100_rtc_ops = {
+        .read_time      = ab3100_rtc_read_time,
+        .set_mmss       = ab3100_rtc_set_mmss,
+        .read_alarm     = ab3100_rtc_read_alarm,
+        .set_alarm      = ab3100_rtc_set_alarm,
+        .alarm_irq_enable = ab3100_rtc_irq_enable,
+};
+
+static int __init ab3100_rtc_probe(struct platform_device *pdev)
+{
+        int err;
+        u8 regval;
+        struct rtc_device *rtc;
+
+        /* The first RTC register needs special treatment */
+        err = abx500_get_register_interruptible(&pdev->dev, 0,
+                                                AB3100_RTC, &regval);
+        if (err) {
+                dev_err(&pdev->dev, "unable to read RTC register\n");
+                return -ENODEV;
+        }
+
+        if ((regval & 0xFE) != RTC_SETTING) {
+                dev_warn(&pdev->dev, "not default value in RTC reg 0x%x\n",
+                         regval);
+        }
+
+        if ((regval & 1) == 0) {
+                /*
+                 * Set bit to detect power loss.
+                 * This bit remains until RTC power is lost.
+                 */
+                regval = 1 | RTC_SETTING;
+                err = abx500_set_register_interruptible(&pdev->dev, 0,
+                                                        AB3100_RTC, regval);
+                /* Ignore any error on this write */
+        }
+
+        rtc = rtc_device_register("ab3100-rtc", &pdev->dev, &ab3100_rtc_ops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                return err;
+        }
+        platform_set_drvdata(pdev, rtc);
+
+        return 0;
+}
+
+static int __exit ab3100_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(rtc);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static struct platform_driver ab3100_rtc_driver = {
+        .driver = {
+                .name = "ab3100-rtc",
+                .owner = THIS_MODULE,
+        },
+        .remove  = __exit_p(ab3100_rtc_remove),
+};
+
+static int __init ab3100_rtc_init(void)
+{
+        return platform_driver_probe(&ab3100_rtc_driver,
+                                     ab3100_rtc_probe);
+}
+
+static void __exit ab3100_rtc_exit(void)
+{
+        platform_driver_unregister(&ab3100_rtc_driver);
+}
+
+module_init(ab3100_rtc_init);
+module_exit(ab3100_rtc_exit);
+
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+MODULE_DESCRIPTION("AB3100 RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
new file mode 100644
index 000000000000..e346705aae92
--- /dev/null
+++ b/drivers/rtc/rtc-ab8500.c
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License terms: GNU General Public License (GPL) version 2
+ * Author: Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>
+ *
+ * RTC clock driver for the RTC part of the AB8500 Power management chip.
+ * Based on RTC clock driver for the AB3100 Analog Baseband Chip by
+ * Linus Walleij <linus.walleij@stericsson.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/mfd/abx500.h>
+#include <linux/mfd/ab8500.h>
+#include <linux/delay.h>
+
+#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
+#define RTC_WRITE_REQUEST               0x02
+
+/* RtcCtrl bits */
+#define RTC_ALARM_ENA                   0x04
+#define RTC_STATUS_DATA                 0x01
+
+#define COUNTS_PER_SEC                  (0xF000 / 60)
+#define AB8500_RTC_EPOCH                2000
+
+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 u8 ab8500_rtc_alarm_regs[] = {
+        AB8500_RTC_ALRM_MIN_HI_REG, AB8500_RTC_ALRM_MIN_MID_REG,
+        AB8500_RTC_ALRM_MIN_LOW_REG
+};
+
+/* Calculate the seconds from 1970 to 01-01-2000 00:00:00 */
+static unsigned long get_elapsed_seconds(int year)
+{
+        unsigned long secs;
+        struct rtc_time tm = {
+                .tm_year = year - 1900,
+                .tm_mday = 1,
+        };
+
+        /*
+         * This function calculates secs from 1970 and not from
+         * 1900, even if we supply the offset from year 1900.
+         */
+        rtc_tm_to_time(&tm, &secs);
+        return secs;
+}
+
+static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        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 = 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 (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 = abx500_get_register_interruptible(dev,
+                                AB8500_RTC, AB8500_RTC_READ_REQ_REG, &value);
+                        if (retval < 0)
+                                return retval;
+
+                        if (!(value & RTC_READ_REQUEST))
+                                break;
+
+                        msleep(1);
+                }
+        }
+
+        /* Read the Watchtime registers */
+        for (i = 0; i < ARRAY_SIZE(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] = value;
+        }
+
+        mins = (buf[0] << 16) | (buf[1] << 8) | buf[2];
+
+        secs =  (buf[3] << 8) | buf[4];
+        secs =  secs / COUNTS_PER_SEC;
+        secs =  secs + (mins * 60);
+
+        /* Add back the initially subtracted number of seconds */
+        secs += get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        rtc_time_to_tm(secs, tm);
+        return rtc_valid_tm(tm);
+}
+
+static int ab8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        int retval, i;
+        unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)];
+        unsigned long no_secs, no_mins, secs = 0;
+
+        if (tm->tm_year < (AB8500_RTC_EPOCH - 1900)) {
+                dev_dbg(dev, "year should be equal to or greater than %d\n",
+                                AB8500_RTC_EPOCH);
+                return -EINVAL;
+        }
+
+        /* Get the number of seconds since 1970 */
+        rtc_tm_to_time(tm, &secs);
+
+        /*
+         * Convert it to the number of seconds since 01-01-2000 00:00:00, since
+         * we only have a small counter in the RTC.
+         */
+        secs -= get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        no_mins = secs / 60;
+
+        no_secs = secs % 60;
+        /* Make the seconds count as per the RTC resolution */
+        no_secs = no_secs * COUNTS_PER_SEC;
+
+        buf[4] = no_secs & 0xFF;
+        buf[3] = (no_secs >> 8) & 0xFF;
+
+        buf[2] = no_mins & 0xFF;
+        buf[1] = (no_mins >> 8) & 0xFF;
+        buf[0] = (no_mins >> 16) & 0xFF;
+
+        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); 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 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)
+{
+        int retval, i;
+        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 */
+        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;
+        else
+                alarm->enabled = 0;
+
+        alarm->pending = 0;
+
+        for (i = 0; i < ARRAY_SIZE(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] = value;
+        }
+
+        mins = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
+        secs = mins * 60;
+
+        /* Add back the initially subtracted number of seconds */
+        secs += get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        rtc_time_to_tm(secs, &alarm->time);
+
+        return rtc_valid_tm(&alarm->time);
+}
+
+static int ab8500_rtc_irq_enable(struct device *dev, unsigned int enabled)
+{
+        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)
+{
+        int retval, i;
+        unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)];
+        unsigned long mins, secs = 0;
+
+        if (alarm->time.tm_year < (AB8500_RTC_EPOCH - 1900)) {
+                dev_dbg(dev, "year should be equal to or greater than %d\n",
+                                AB8500_RTC_EPOCH);
+                return -EINVAL;
+        }
+
+        /* Get the number of seconds since 1970 */
+        rtc_tm_to_time(&alarm->time, &secs);
+
+        /*
+         * Convert it to the number of seconds since 01-01-2000 00:00:00, since
+         * we only have a small counter in the RTC.
+         */
+        secs -= get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        mins = secs / 60;
+
+        buf[2] = mins & 0xFF;
+        buf[1] = (mins >> 8) & 0xFF;
+        buf[0] = (mins >> 16) & 0xFF;
+
+        /* Set the alarm time */
+        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) {
+                retval = abx500_set_register_interruptible(dev, AB8500_RTC,
+                        ab8500_rtc_alarm_regs[i], buf[i]);
+                if (retval < 0)
+                        return retval;
+        }
+
+        return ab8500_rtc_irq_enable(dev, alarm->enabled);
+}
+
+static irqreturn_t rtc_alarm_handler(int irq, void *data)
+{
+        struct rtc_device *rtc = data;
+        unsigned long events = RTC_IRQF | RTC_AF;
+
+        dev_dbg(&rtc->dev, "%s\n", __func__);
+        rtc_update_irq(rtc, 1, events);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops ab8500_rtc_ops = {
+        .read_time              = ab8500_rtc_read_time,
+        .set_time               = ab8500_rtc_set_time,
+        .read_alarm             = ab8500_rtc_read_alarm,
+        .set_alarm              = ab8500_rtc_set_alarm,
+        .alarm_irq_enable       = ab8500_rtc_irq_enable,
+};
+
+static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
+{
+        int err;
+        struct rtc_device *rtc;
+        u8 rtc_ctrl;
+        int irq;
+
+        irq = platform_get_irq_byname(pdev, "ALARM");
+        if (irq < 0)
+                return irq;
+
+        /* For RTC supply test */
+        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);
+
+        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)) {
+                dev_err(&pdev->dev, "RTC supply failure\n");
+                return -ENODEV;
+        }
+
+        rtc = rtc_device_register("ab8500-rtc", &pdev->dev, &ab8500_rtc_ops,
+                        THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                dev_err(&pdev->dev, "Registration failed\n");
+                err = PTR_ERR(rtc);
+                return err;
+        }
+
+        err = request_threaded_irq(irq, NULL, rtc_alarm_handler, 0,
+                                   "ab8500-rtc", rtc);
+        if (err < 0) {
+                rtc_device_unregister(rtc);
+                return err;
+        }
+
+        platform_set_drvdata(pdev, rtc);
+
+        return 0;
+}
+
+static int __devexit ab8500_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        int irq = platform_get_irq_byname(pdev, "ALARM");
+
+        free_irq(irq, rtc);
+        rtc_device_unregister(rtc);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver ab8500_rtc_driver = {
+        .driver = {
+                .name = "ab8500-rtc",
+                .owner = THIS_MODULE,
+        },
+        .probe  = ab8500_rtc_probe,
+        .remove = __devexit_p(ab8500_rtc_remove),
+};
+
+static int __init ab8500_rtc_init(void)
+{
+        return platform_driver_register(&ab8500_rtc_driver);
+}
+
+static void __exit ab8500_rtc_exit(void)
+{
+        platform_driver_unregister(&ab8500_rtc_driver);
+}
+
+module_init(ab8500_rtc_init);
+module_exit(ab8500_rtc_exit);
+MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>");
+MODULE_DESCRIPTION("AB8500 RTC Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-at32ap700x.c b/drivers/rtc/rtc-at32ap700x.c
index e1ec33e40e38..b2752b6e7a2f 100644
--- a/drivers/rtc/rtc-at32ap700x.c
+++ b/drivers/rtc/rtc-at32ap700x.c
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <linux/rtc.h>
 #include <linux/io.h>
 
@@ -256,6 +257,8 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
                 goto out_iounmap;
         }
 
+        platform_set_drvdata(pdev, rtc);
+
         rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
                                 &at32_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc->rtc)) {
@@ -264,7 +267,6 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
                 goto out_free_irq;
         }
 
-        platform_set_drvdata(pdev, rtc);
         device_init_wakeup(&pdev->dev, 1);
 
         dev_info(&pdev->dev, "Atmel RTC for AT32AP700x at %08lx irq %ld\n",
@@ -273,6 +275,7 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
         return 0;
 
 out_free_irq:
+        platform_set_drvdata(pdev, NULL);
         free_irq(irq, rtc);
 out_iounmap:
         iounmap(rtc->regs);
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index b5bf93706913..bc8bbca9a2e2 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -289,7 +289,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
                                         AT91_RTC_CALEV);
 
         ret = request_irq(AT91_ID_SYS, at91_rtc_interrupt,
-                                IRQF_DISABLED | IRQF_SHARED,
+                                IRQF_SHARED,
                                 "at91_rtc", pdev);
         if (ret) {
                 printk(KERN_ERR "at91_rtc: IRQ %d already in use.\n",
@@ -340,7 +340,7 @@ static int __exit at91_rtc_remove(struct platform_device *pdev)
 
 static u32 at91_rtc_imr;
 
-static int at91_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int at91_rtc_suspend(struct device *dev)
 {
         /* this IRQ is shared with DBGU and other hardware which isn't
          * necessarily doing PM like we are...
@@ -348,7 +348,7 @@ static int at91_rtc_suspend(struct platform_device *pdev, pm_message_t state)
         at91_rtc_imr = at91_sys_read(AT91_RTC_IMR)
                         & (AT91_RTC_ALARM|AT91_RTC_SECEV);
         if (at91_rtc_imr) {
-                if (device_may_wakeup(&pdev->dev))
+                if (device_may_wakeup(dev))
                         enable_irq_wake(AT91_ID_SYS);
                 else
                         at91_sys_write(AT91_RTC_IDR, at91_rtc_imr);
@@ -356,28 +356,34 @@ static int at91_rtc_suspend(struct platform_device *pdev, pm_message_t state)
         return 0;
 }
 
-static int at91_rtc_resume(struct platform_device *pdev)
+static int at91_rtc_resume(struct device *dev)
 {
         if (at91_rtc_imr) {
-                if (device_may_wakeup(&pdev->dev))
+                if (device_may_wakeup(dev))
                         disable_irq_wake(AT91_ID_SYS);
                 else
                         at91_sys_write(AT91_RTC_IER, at91_rtc_imr);
         }
         return 0;
 }
+
+static const struct dev_pm_ops at91_rtc_pm = {
+        .suspend =      at91_rtc_suspend,
+        .resume =       at91_rtc_resume,
+};
+
+#define at91_rtc_pm_ptr &at91_rtc_pm
+
 #else
-#define at91_rtc_suspend NULL
-#define at91_rtc_resume  NULL
+#define at91_rtc_pm_ptr NULL
 #endif
 
 static struct platform_driver at91_rtc_driver = {
         .remove         = __exit_p(at91_rtc_remove),
-        .suspend        = at91_rtc_suspend,
-        .resume         = at91_rtc_resume,
         .driver         = {
                 .name   = "at91_rtc",
                 .owner  = THIS_MODULE,
+                .pm     = at91_rtc_pm_ptr,
         },
 };
 
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 86c61f143515..f677e0710ca1 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -18,6 +18,7 @@
 #include <linux/rtc.h>
 #include <linux/interrupt.h>
 #include <linux/ioctl.h>
+#include <linux/slab.h>
 
 #include <mach/board.h>
 #include <mach/at91_rtt.h>
@@ -161,7 +162,7 @@ static int at91_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
         if (offset == 0)
                 return -EILSEQ;
 
-        memset(alrm, 0, sizeof(alrm));
+        memset(alrm, 0, sizeof(*alrm));
         if (alarm != ALARM_DISABLED && offset != 0) {
                 rtc_time_to_tm(offset + alarm, tm);
 
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index aafd3e6ebb0d..b4b6087f2234 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -1,8 +1,8 @@
 /*
  * Blackfin On-Chip Real Time Clock Driver
- *  Supports BF52[257]/BF53[123]/BF53[467]/BF54[24789]
+ *  Supports BF51x/BF52x/BF53[123]/BF53[467]/BF54x
  *
- * Copyright 2004-2008 Analog Devices Inc.
+ * Copyright 2004-2010 Analog Devices Inc.
  *
  * Enter bugs at http://blackfin.uclinux.org/
  *
@@ -51,6 +51,7 @@
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <asm/blackfin.h>
 
@@ -182,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;
                 }
         }
@@ -212,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;
 }
 
@@ -363,7 +369,7 @@ static int __devinit bfin_rtc_probe(struct platform_device *pdev)
         struct bfin_rtc *rtc;
         struct device *dev = &pdev->dev;
         int ret = 0;
-        unsigned long timeout;
+        unsigned long timeout = jiffies + HZ;
 
         dev_dbg_stamp(dev);
 
@@ -374,32 +380,32 @@ static int __devinit bfin_rtc_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, rtc);
         device_init_wakeup(dev, 1);
 
+        /* Register our RTC with the RTC framework */
+        rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops,
+                                                THIS_MODULE);
+        if (unlikely(IS_ERR(rtc->rtc_dev))) {
+                ret = PTR_ERR(rtc->rtc_dev);
+                goto err;
+        }
+
         /* Grab the IRQ and init the hardware */
-        ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, IRQF_SHARED, pdev->name, dev);
+        ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, 0, pdev->name, dev);
         if (unlikely(ret))
-                goto err;
+                goto err_reg;
         /* sometimes the bootloader touched things, but the write complete was not
          * enabled, so let's just do a quick timeout here since the IRQ will not fire ...
          */
-        timeout = jiffies + HZ;
         while (bfin_read_RTC_ISTAT() & RTC_ISTAT_WRITE_PENDING)
                 if (time_after(jiffies, timeout))
                         break;
         bfin_rtc_reset(dev, RTC_ISTAT_WRITE_COMPLETE);
         bfin_write_RTC_SWCNT(0);
 
-        /* Register our RTC with the RTC framework */
-        rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops, THIS_MODULE);
-        if (unlikely(IS_ERR(rtc->rtc_dev))) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto err_irq;
-        }
-
         return 0;
 
- err_irq:
-        free_irq(IRQ_RTC, dev);
- err:
+err_reg:
+        rtc_device_unregister(rtc->rtc_dev);
+err:
         kfree(rtc);
         return ret;
 }
@@ -421,21 +427,38 @@ 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(-1);
+                bfin_rtc_int_clear(0);
 
         return 0;
 }
 
 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);
-        else
-                bfin_write_RTC_ISTAT(-1);
+
+        /*
+         * Since only some of the RTC bits are maintained externally in the
+         * Vbat domain, we need to wait for the RTC MMRs to be synced into
+         * the core after waking up.  This happens every RTC 1HZ.  Once that
+         * has happened, we can go ahead and re-enable the important write
+         * complete interrupt event.
+         */
+        while (!(bfin_read_RTC_ISTAT() & RTC_ISTAT_SEC))
+                continue;
+        bfin_rtc_int_set(RTC_ISTAT_WRITE_COMPLETE);
 
         return 0;
 }
diff --git a/drivers/rtc/rtc-bq32k.c b/drivers/rtc/rtc-bq32k.c
new file mode 100644
index 000000000000..408cc8f735be
--- /dev/null
+++ b/drivers/rtc/rtc-bq32k.c
@@ -0,0 +1,204 @@
+/*
+ * Driver for TI BQ32000 RTC.
+ *
+ * Copyright (C) 2009 Semihalf.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/rtc.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/bcd.h>
+
+#define BQ32K_SECONDS           0x00    /* Seconds register address */
+#define BQ32K_SECONDS_MASK      0x7F    /* Mask over seconds value */
+#define BQ32K_STOP              0x80    /* Oscillator Stop flat */
+
+#define BQ32K_MINUTES           0x01    /* Minutes register address */
+#define BQ32K_MINUTES_MASK      0x7F    /* Mask over minutes value */
+#define BQ32K_OF                0x80    /* Oscillator Failure flag */
+
+#define BQ32K_HOURS_MASK        0x3F    /* Mask over hours value */
+#define BQ32K_CENT              0x40    /* Century flag */
+#define BQ32K_CENT_EN           0x80    /* Century flag enable bit */
+
+struct bq32k_regs {
+        uint8_t         seconds;
+        uint8_t         minutes;
+        uint8_t         cent_hours;
+        uint8_t         day;
+        uint8_t         date;
+        uint8_t         month;
+        uint8_t         years;
+};
+
+static struct i2c_driver bq32k_driver;
+
+static int bq32k_read(struct device *dev, void *data, uint8_t off, uint8_t len)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct i2c_msg msgs[] = {
+                {
+                        .addr = client->addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = &off,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = len,
+                        .buf = data,
+                }
+        };
+
+        if (i2c_transfer(client->adapter, msgs, 2) == 2)
+                return 0;
+
+        return -EIO;
+}
+
+static int bq32k_write(struct device *dev, void *data, uint8_t off, uint8_t len)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        uint8_t buffer[len + 1];
+
+        buffer[0] = off;
+        memcpy(&buffer[1], data, len);
+
+        if (i2c_master_send(client, buffer, len + 1) == len + 1)
+                return 0;
+
+        return -EIO;
+}
+
+static int bq32k_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct bq32k_regs regs;
+        int error;
+
+        error = bq32k_read(dev, &regs, 0, sizeof(regs));
+        if (error)
+                return error;
+
+        tm->tm_sec = bcd2bin(regs.seconds & BQ32K_SECONDS_MASK);
+        tm->tm_min = bcd2bin(regs.minutes & BQ32K_SECONDS_MASK);
+        tm->tm_hour = bcd2bin(regs.cent_hours & BQ32K_HOURS_MASK);
+        tm->tm_mday = bcd2bin(regs.date);
+        tm->tm_wday = bcd2bin(regs.day) - 1;
+        tm->tm_mon = bcd2bin(regs.month) - 1;
+        tm->tm_year = bcd2bin(regs.years) +
+                                ((regs.cent_hours & BQ32K_CENT) ? 100 : 0);
+
+        return rtc_valid_tm(tm);
+}
+
+static int bq32k_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct bq32k_regs regs;
+
+        regs.seconds = bin2bcd(tm->tm_sec);
+        regs.minutes = bin2bcd(tm->tm_min);
+        regs.cent_hours = bin2bcd(tm->tm_hour) | BQ32K_CENT_EN;
+        regs.day = bin2bcd(tm->tm_wday + 1);
+        regs.date = bin2bcd(tm->tm_mday);
+        regs.month = bin2bcd(tm->tm_mon + 1);
+
+        if (tm->tm_year >= 100) {
+                regs.cent_hours |= BQ32K_CENT;
+                regs.years = bin2bcd(tm->tm_year - 100);
+        } else
+                regs.years = bin2bcd(tm->tm_year);
+
+        return bq32k_write(dev, &regs, 0, sizeof(regs));
+}
+
+static const struct rtc_class_ops bq32k_rtc_ops = {
+        .read_time      = bq32k_rtc_read_time,
+        .set_time       = bq32k_rtc_set_time,
+};
+
+static int bq32k_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct rtc_device *rtc;
+        uint8_t reg;
+        int error;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+                return -ENODEV;
+
+        /* Check Oscillator Stop flag */
+        error = bq32k_read(dev, &reg, BQ32K_SECONDS, 1);
+        if (!error && (reg & BQ32K_STOP)) {
+                dev_warn(dev, "Oscillator was halted. Restarting...\n");
+                reg &= ~BQ32K_STOP;
+                error = bq32k_write(dev, &reg, BQ32K_SECONDS, 1);
+        }
+        if (error)
+                return error;
+
+        /* Check Oscillator Failure flag */
+        error = bq32k_read(dev, &reg, BQ32K_MINUTES, 1);
+        if (!error && (reg & BQ32K_OF)) {
+                dev_warn(dev, "Oscillator Failure. Check RTC battery.\n");
+                reg &= ~BQ32K_OF;
+                error = bq32k_write(dev, &reg, BQ32K_MINUTES, 1);
+        }
+        if (error)
+                return error;
+
+        rtc = rtc_device_register(bq32k_driver.driver.name, &client->dev,
+                                                &bq32k_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        i2c_set_clientdata(client, rtc);
+
+        return 0;
+}
+
+static int __devexit bq32k_remove(struct i2c_client *client)
+{
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+
+        rtc_device_unregister(rtc);
+        return 0;
+}
+
+static const struct i2c_device_id bq32k_id[] = {
+        { "bq32000", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, bq32k_id);
+
+static struct i2c_driver bq32k_driver = {
+        .driver = {
+                .name   = "bq32k",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = bq32k_probe,
+        .remove         = __devexit_p(bq32k_remove),
+        .id_table       = bq32k_id,
+};
+
+static __init int bq32k_init(void)
+{
+        return i2c_add_driver(&bq32k_driver);
+}
+module_init(bq32k_init);
+
+static __exit void bq32k_exit(void)
+{
+        i2c_del_driver(&bq32k_driver);
+}
+module_exit(bq32k_exit);
+
+MODULE_AUTHOR("Semihalf, Piotr Ziecik <kosmo@semihalf.com>");
+MODULE_DESCRIPTION("TI BQ32000 I2C RTC driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-bq4802.c b/drivers/rtc/rtc-bq4802.c
index d00a274df8fc..128270ce355d 100644
--- a/drivers/rtc/rtc-bq4802.c
+++ b/drivers/rtc/rtc-bq4802.c
@@ -10,6 +10,7 @@
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
+#include <linux/slab.h>
 
 MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
 MODULE_DESCRIPTION("TI BQ4802 RTC driver");
@@ -169,6 +170,8 @@ static int __devinit bq4802_probe(struct platform_device *pdev)
                 goto out_free;
         }
 
+        platform_set_drvdata(pdev, p);
+
         p->rtc = rtc_device_register("bq4802", &pdev->dev,
                                      &bq4802_ops, THIS_MODULE);
         if (IS_ERR(p->rtc)) {
@@ -176,7 +179,6 @@ static int __devinit bq4802_probe(struct platform_device *pdev)
                 goto out_iounmap;
         }
 
-        platform_set_drvdata(pdev, p);
         err = 0;
 out:
         return err;
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 23e10b6263d6..7e6ce626b7f1 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -238,31 +238,32 @@ static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
         rtc_control = CMOS_READ(RTC_CONTROL);
         spin_unlock_irq(&rtc_lock);
 
-        /* REVISIT this assumes PC style usage:  always BCD */
-
-        if (((unsigned)t->time.tm_sec) < 0x60)
-                t->time.tm_sec = bcd2bin(t->time.tm_sec);
-        else
-                t->time.tm_sec = -1;
-        if (((unsigned)t->time.tm_min) < 0x60)
-                t->time.tm_min = bcd2bin(t->time.tm_min);
-        else
-                t->time.tm_min = -1;
-        if (((unsigned)t->time.tm_hour) < 0x24)
-                t->time.tm_hour = bcd2bin(t->time.tm_hour);
-        else
-                t->time.tm_hour = -1;
-
-        if (cmos->day_alrm) {
-                if (((unsigned)t->time.tm_mday) <= 0x31)
-                        t->time.tm_mday = bcd2bin(t->time.tm_mday);
+        if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
+                if (((unsigned)t->time.tm_sec) < 0x60)
+                        t->time.tm_sec = bcd2bin(t->time.tm_sec);
                 else
-                        t->time.tm_mday = -1;
-                if (cmos->mon_alrm) {
-                        if (((unsigned)t->time.tm_mon) <= 0x12)
-                                t->time.tm_mon = bcd2bin(t->time.tm_mon) - 1;
+                        t->time.tm_sec = -1;
+                if (((unsigned)t->time.tm_min) < 0x60)
+                        t->time.tm_min = bcd2bin(t->time.tm_min);
+                else
+                        t->time.tm_min = -1;
+                if (((unsigned)t->time.tm_hour) < 0x24)
+                        t->time.tm_hour = bcd2bin(t->time.tm_hour);
+                else
+                        t->time.tm_hour = -1;
+
+                if (cmos->day_alrm) {
+                        if (((unsigned)t->time.tm_mday) <= 0x31)
+                                t->time.tm_mday = bcd2bin(t->time.tm_mday);
                         else
-                                t->time.tm_mon = -1;
+                                t->time.tm_mday = -1;
+
+                        if (cmos->mon_alrm) {
+                                if (((unsigned)t->time.tm_mon) <= 0x12)
+                                        t->time.tm_mon = bcd2bin(t->time.tm_mon)-1;
+                                else
+                                        t->time.tm_mon = -1;
+                        }
                 }
         }
         t->time.tm_year = -1;
@@ -322,29 +323,26 @@ static void cmos_irq_disable(struct cmos_rtc *cmos, unsigned char mask)
 static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        unsigned char   mon, mday, hrs, min, sec;
+       unsigned char   mon, mday, hrs, min, sec, rtc_control;
 
         if (!is_valid_irq(cmos->irq))
                 return -EIO;
 
-        /* REVISIT this assumes PC style usage:  always BCD */
-
-        /* Writing 0xff means "don't care" or "match all".  */
-
         mon = t->time.tm_mon + 1;
-        mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
-
         mday = t->time.tm_mday;
-        mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
-
         hrs = t->time.tm_hour;
-        hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
-
         min = t->time.tm_min;
-        min = (min < 60) ? bin2bcd(min) : 0xff;
-
         sec = t->time.tm_sec;
-        sec = (sec < 60) ? bin2bcd(sec) : 0xff;
+
+        rtc_control = CMOS_READ(RTC_CONTROL);
+        if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
+                /* Writing 0xff means "don't care" or "match all".  */
+                mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
+                mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
+                hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
+                min = (min < 60) ? bin2bcd(min) : 0xff;
+                sec = (sec < 60) ? bin2bcd(sec) : 0xff;
+        }
 
         spin_lock_irq(&rtc_lock);
 
@@ -420,49 +418,43 @@ static int cmos_irq_set_state(struct device *dev, int enabled)
         return 0;
 }
 
-#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
-
-static int
-cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int cmos_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
         unsigned long   flags;
 
-        switch (cmd) {
-        case RTC_AIE_OFF:
-        case RTC_AIE_ON:
-        case RTC_UIE_OFF:
-        case RTC_UIE_ON:
-                if (!is_valid_irq(cmos->irq))
-                        return -EINVAL;
-                break;
-        /* PIE ON/OFF is handled by cmos_irq_set_state() */
-        default:
-                return -ENOIOCTLCMD;
-        }
+        if (!is_valid_irq(cmos->irq))
+                return -EINVAL;
 
         spin_lock_irqsave(&rtc_lock, flags);
-        switch (cmd) {
-        case RTC_AIE_OFF:       /* alarm off */
-                cmos_irq_disable(cmos, RTC_AIE);
-                break;
-        case RTC_AIE_ON:        /* alarm on */
+
+        if (enabled)
                 cmos_irq_enable(cmos, RTC_AIE);
-                break;
-        case RTC_UIE_OFF:       /* update off */
-                cmos_irq_disable(cmos, RTC_UIE);
-                break;
-        case RTC_UIE_ON:        /* update on */
-                cmos_irq_enable(cmos, RTC_UIE);
-                break;
-        }
+        else
+                cmos_irq_disable(cmos, RTC_AIE);
+
         spin_unlock_irqrestore(&rtc_lock, flags);
         return 0;
 }
 
-#else
-#define cmos_rtc_ioctl  NULL
-#endif
+static int cmos_update_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct cmos_rtc *cmos = dev_get_drvdata(dev);
+        unsigned long   flags;
+
+        if (!is_valid_irq(cmos->irq))
+                return -EINVAL;
+
+        spin_lock_irqsave(&rtc_lock, flags);
+
+        if (enabled)
+                cmos_irq_enable(cmos, RTC_UIE);
+        else
+                cmos_irq_disable(cmos, RTC_UIE);
+
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        return 0;
+}
 
 #if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
 
@@ -484,7 +476,7 @@ static int cmos_procfs(struct device *dev, struct seq_file *seq)
                         "update_IRQ\t: %s\n"
                         "HPET_emulated\t: %s\n"
                         // "square_wave\t: %s\n"
-                        // "BCD\t\t: %s\n"
+                        "BCD\t\t: %s\n"
                         "DST_enable\t: %s\n"
                         "periodic_freq\t: %d\n"
                         "batt_status\t: %s\n",
@@ -492,7 +484,7 @@ static int cmos_procfs(struct device *dev, struct seq_file *seq)
                         (rtc_control & RTC_UIE) ? "yes" : "no",
                         is_hpet_enabled() ? "yes" : "no",
                         // (rtc_control & RTC_SQWE) ? "yes" : "no",
-                        // (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
+                        (rtc_control & RTC_DM_BINARY) ? "no" : "yes",
                         (rtc_control & RTC_DST_EN) ? "yes" : "no",
                         cmos->rtc->irq_freq,
                         (valid & RTC_VRT) ? "okay" : "dead");
@@ -503,14 +495,15 @@ static int cmos_procfs(struct device *dev, struct seq_file *seq)
 #endif
 
 static const struct rtc_class_ops cmos_rtc_ops = {
-        .ioctl          = cmos_rtc_ioctl,
-        .read_time      = cmos_read_time,
-        .set_time       = cmos_set_time,
-        .read_alarm     = cmos_read_alarm,
-        .set_alarm      = cmos_set_alarm,
-        .proc           = cmos_procfs,
-        .irq_set_freq   = cmos_irq_set_freq,
-        .irq_set_state  = cmos_irq_set_state,
+        .read_time              = cmos_read_time,
+        .set_time               = cmos_set_time,
+        .read_alarm             = cmos_read_alarm,
+        .set_alarm              = cmos_set_alarm,
+        .proc                   = cmos_procfs,
+        .irq_set_freq           = cmos_irq_set_freq,
+        .irq_set_state          = cmos_irq_set_state,
+        .alarm_irq_enable       = cmos_alarm_irq_enable,
+        .update_irq_enable      = cmos_update_irq_enable,
 };
 
 /*----------------------------------------------------------------*/
@@ -524,7 +517,8 @@ static const struct rtc_class_ops cmos_rtc_ops = {
 #define NVRAM_OFFSET    (RTC_REG_D + 1)
 
 static ssize_t
-cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
+cmos_nvram_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t off, size_t count)
 {
         int     retval;
@@ -552,7 +546,8 @@ cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 }
 
 static ssize_t
-cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
+cmos_nvram_write(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t off, size_t count)
 {
         struct cmos_rtc *cmos;
@@ -691,7 +686,9 @@ 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__)
+#elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) \
+                        || defined(__sparc__) || defined(__mips__) \
+                        || defined(__powerpc__)
         address_space = 128;
 #else
 #warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
@@ -723,6 +720,9 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                 }
         }
 
+        cmos_rtc.dev = dev;
+        dev_set_drvdata(dev, &cmos_rtc);
+
         cmos_rtc.rtc = rtc_device_register(driver_name, dev,
                                 &cmos_rtc_ops, THIS_MODULE);
         if (IS_ERR(cmos_rtc.rtc)) {
@@ -730,8 +730,6 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                 goto cleanup0;
         }
 
-        cmos_rtc.dev = dev;
-        dev_set_drvdata(dev, &cmos_rtc);
         rename_region(ports, dev_name(&cmos_rtc.rtc->dev));
 
         spin_lock_irq(&rtc_lock);
@@ -753,12 +751,11 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 
         spin_unlock_irq(&rtc_lock);
 
-        /* FIXME teach the alarm code how to handle binary mode;
+        /* FIXME:
          * <asm-generic/rtc.h> doesn't know 12-hour mode either.
          */
-        if (is_valid_irq(rtc_irq) &&
-            (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY)))) {
-                dev_dbg(dev, "only 24-hr BCD mode supported\n");
+       if (is_valid_irq(rtc_irq) && !(rtc_control & RTC_24H)) {
+                dev_warn(dev, "only 24-hr supported\n");
                 retval = -ENXIO;
                 goto cleanup1;
         }
@@ -871,8 +868,9 @@ static int cmos_suspend(struct device *dev, pm_message_t mesg)
                         mask = RTC_IRQMASK;
                 tmp &= ~mask;
                 CMOS_WRITE(tmp, RTC_CONTROL);
-                hpet_mask_rtc_irq_bit(mask);
 
+                /* shut down hpet emulation - we don't need it for alarm */
+                hpet_mask_rtc_irq_bit(RTC_PIE|RTC_AIE|RTC_UIE);
                 cmos_checkintr(cmos, tmp);
         }
         spin_unlock_irq(&rtc_lock);
@@ -973,7 +971,6 @@ static inline int cmos_poweroff(struct device *dev)
 
 #include <linux/acpi.h>
 
-#ifdef  CONFIG_PM
 static u32 rtc_handler(void *context)
 {
         acpi_clear_event(ACPI_EVENT_RTC);
@@ -1002,11 +999,6 @@ static void rtc_wake_off(struct device *dev)
 {
         acpi_disable_event(ACPI_EVENT_RTC, 0);
 }
-#else
-#define rtc_wake_setup()        do{}while(0)
-#define rtc_wake_on             NULL
-#define rtc_wake_off            NULL
-#endif
 
 /* Every ACPI platform has a mc146818 compatible "cmos rtc".  Here we find
  * its device node and pass extra config data.  This helps its driver use
@@ -1099,9 +1091,9 @@ static int cmos_pnp_resume(struct pnp_dev *pnp)
 #define cmos_pnp_resume         NULL
 #endif
 
-static void cmos_pnp_shutdown(struct device *pdev)
+static void cmos_pnp_shutdown(struct pnp_dev *pnp)
 {
-        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(pdev))
+        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pnp->dev))
                 return;
 
         cmos_do_shutdown();
@@ -1120,15 +1112,12 @@ static struct pnp_driver cmos_pnp_driver = {
         .id_table       = rtc_ids,
         .probe          = cmos_pnp_probe,
         .remove         = __exit_p(cmos_pnp_remove),
+        .shutdown       = cmos_pnp_shutdown,
 
         /* flag ensures resume() gets called, and stops syslog spam */
         .flags          = PNP_DRIVER_RES_DO_NOT_CHANGE,
         .suspend        = cmos_pnp_suspend,
         .resume         = cmos_pnp_resume,
-        .driver         = {
-                .name     = (char *)driver_name,
-                .shutdown = cmos_pnp_shutdown,
-        }
 };
 
 #endif  /* CONFIG_PNP */
@@ -1174,23 +1163,34 @@ static struct platform_driver cmos_platform_driver = {
         }
 };
 
+#ifdef CONFIG_PNP
+static bool pnp_driver_registered;
+#endif
+static bool platform_driver_registered;
+
 static int __init cmos_init(void)
 {
         int retval = 0;
 
 #ifdef  CONFIG_PNP
-        pnp_register_driver(&cmos_pnp_driver);
+        retval = pnp_register_driver(&cmos_pnp_driver);
+        if (retval == 0)
+                pnp_driver_registered = true;
 #endif
 
-        if (!cmos_rtc.dev)
+        if (!cmos_rtc.dev) {
                 retval = platform_driver_probe(&cmos_platform_driver,
                                                cmos_platform_probe);
+                if (retval == 0)
+                        platform_driver_registered = true;
+        }
 
         if (retval == 0)
                 return 0;
 
 #ifdef  CONFIG_PNP
-        pnp_unregister_driver(&cmos_pnp_driver);
+        if (pnp_driver_registered)
+                pnp_unregister_driver(&cmos_pnp_driver);
 #endif
         return retval;
 }
@@ -1199,9 +1199,11 @@ module_init(cmos_init);
 static void __exit cmos_exit(void)
 {
 #ifdef  CONFIG_PNP
-        pnp_unregister_driver(&cmos_pnp_driver);
+        if (pnp_driver_registered)
+                pnp_unregister_driver(&cmos_pnp_driver);
 #endif
-        platform_driver_unregister(&cmos_platform_driver);
+        if (platform_driver_registered)
+                platform_driver_unregister(&cmos_platform_driver);
 }
 module_exit(cmos_exit);
 
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
new file mode 100644
index 000000000000..316f484999b5
--- /dev/null
+++ b/drivers/rtc/rtc-coh901331.c
@@ -0,0 +1,324 @@
+/*
+ * Copyright (C) 2007-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * Real Time Clock interface for ST-Ericsson AB COH 901 331 RTC.
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ * Based on rtc-pl031.c by Deepak Saxena <dsaxena@plexity.net>
+ * Copyright 2006 (c) MontaVista Software, Inc.
+ */
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/clk.h>
+#include <linux/interrupt.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+
+/*
+ * Registers in the COH 901 331
+ */
+/* Alarm value 32bit (R/W) */
+#define COH901331_ALARM         0x00U
+/* Used to set current time 32bit (R/W) */
+#define COH901331_SET_TIME      0x04U
+/* Indication if current time is valid 32bit (R/-) */
+#define COH901331_VALID         0x08U
+/* Read the current time 32bit (R/-) */
+#define COH901331_CUR_TIME      0x0cU
+/* Event register for the "alarm" interrupt */
+#define COH901331_IRQ_EVENT     0x10U
+/* Mask register for the "alarm" interrupt */
+#define COH901331_IRQ_MASK      0x14U
+/* Force register for the "alarm" interrupt */
+#define COH901331_IRQ_FORCE     0x18U
+
+/*
+ * Reference to RTC block clock
+ * Notice that the frequent clk_enable()/clk_disable() on this
+ * clock is mainly to be able to turn on/off other clocks in the
+ * hierarchy as needed, the RTC clock is always on anyway.
+ */
+struct coh901331_port {
+        struct rtc_device *rtc;
+        struct clk *clk;
+        u32 phybase;
+        u32 physize;
+        void __iomem *virtbase;
+        int irq;
+#ifdef CONFIG_PM
+        u32 irqmaskstore;
+#endif
+};
+
+static irqreturn_t coh901331_interrupt(int irq, void *data)
+{
+        struct coh901331_port *rtap = data;
+
+        clk_enable(rtap->clk);
+        /* Ack IRQ */
+        writel(1, rtap->virtbase + COH901331_IRQ_EVENT);
+        /*
+         * Disable the interrupt. This is necessary because
+         * the RTC lives on a lower-clocked line and will
+         * not release the IRQ line until after a few (slower)
+         * clock cycles. The interrupt will be re-enabled when
+         * a new alarm is set anyway.
+         */
+        writel(0, rtap->virtbase + COH901331_IRQ_MASK);
+        clk_disable(rtap->clk);
+
+        /* Set alarm flag */
+        rtc_update_irq(rtap->rtc, 1, RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static int coh901331_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(dev);
+
+        clk_enable(rtap->clk);
+        /* Check if the time is valid */
+        if (readl(rtap->virtbase + COH901331_VALID)) {
+                rtc_time_to_tm(readl(rtap->virtbase + COH901331_CUR_TIME), tm);
+                clk_disable(rtap->clk);
+                return rtc_valid_tm(tm);
+        }
+        clk_disable(rtap->clk);
+        return -EINVAL;
+}
+
+static int coh901331_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(dev);
+
+        clk_enable(rtap->clk);
+        writel(secs, rtap->virtbase + COH901331_SET_TIME);
+        clk_disable(rtap->clk);
+
+        return 0;
+}
+
+static int coh901331_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(dev);
+
+        clk_enable(rtap->clk);
+        rtc_time_to_tm(readl(rtap->virtbase + COH901331_ALARM), &alarm->time);
+        alarm->pending = readl(rtap->virtbase + COH901331_IRQ_EVENT) & 1U;
+        alarm->enabled = readl(rtap->virtbase + COH901331_IRQ_MASK) & 1U;
+        clk_disable(rtap->clk);
+
+        return 0;
+}
+
+static int coh901331_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(dev);
+        unsigned long time;
+
+        rtc_tm_to_time(&alarm->time, &time);
+        clk_enable(rtap->clk);
+        writel(time, rtap->virtbase + COH901331_ALARM);
+        writel(alarm->enabled, rtap->virtbase + COH901331_IRQ_MASK);
+        clk_disable(rtap->clk);
+
+        return 0;
+}
+
+static int coh901331_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(dev);
+
+        clk_enable(rtap->clk);
+        if (enabled)
+                writel(1, rtap->virtbase + COH901331_IRQ_MASK);
+        else
+                writel(0, rtap->virtbase + COH901331_IRQ_MASK);
+        clk_disable(rtap->clk);
+
+        return 0;
+}
+
+static struct rtc_class_ops coh901331_ops = {
+        .read_time = coh901331_read_time,
+        .set_mmss = coh901331_set_mmss,
+        .read_alarm = coh901331_read_alarm,
+        .set_alarm = coh901331_set_alarm,
+        .alarm_irq_enable = coh901331_alarm_irq_enable,
+};
+
+static int __exit coh901331_remove(struct platform_device *pdev)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
+
+        if (rtap) {
+                free_irq(rtap->irq, rtap);
+                rtc_device_unregister(rtap->rtc);
+                clk_put(rtap->clk);
+                iounmap(rtap->virtbase);
+                release_mem_region(rtap->phybase, rtap->physize);
+                platform_set_drvdata(pdev, NULL);
+                kfree(rtap);
+        }
+
+        return 0;
+}
+
+
+static int __init coh901331_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct coh901331_port *rtap;
+        struct resource *res;
+
+        rtap = kzalloc(sizeof(struct coh901331_port), GFP_KERNEL);
+        if (!rtap)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENOENT;
+                goto out_no_resource;
+        }
+        rtap->phybase = res->start;
+        rtap->physize = resource_size(res);
+
+        if (request_mem_region(rtap->phybase, rtap->physize,
+                               "rtc-coh901331") == NULL) {
+                ret = -EBUSY;
+                goto out_no_memregion;
+        }
+
+        rtap->virtbase = ioremap(rtap->phybase, rtap->physize);
+        if (!rtap->virtbase) {
+                ret = -ENOMEM;
+                goto out_no_remap;
+        }
+
+        rtap->irq = platform_get_irq(pdev, 0);
+        if (request_irq(rtap->irq, coh901331_interrupt, IRQF_DISABLED,
+                        "RTC COH 901 331 Alarm", rtap)) {
+                ret = -EIO;
+                goto out_no_irq;
+        }
+
+        rtap->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(rtap->clk)) {
+                ret = PTR_ERR(rtap->clk);
+                dev_err(&pdev->dev, "could not get clock\n");
+                goto out_no_clk;
+        }
+
+        /* We enable/disable the clock only to assure it works */
+        ret = clk_enable(rtap->clk);
+        if (ret) {
+                dev_err(&pdev->dev, "could not enable clock\n");
+                goto out_no_clk_enable;
+        }
+        clk_disable(rtap->clk);
+
+        rtap->rtc = rtc_device_register("coh901331", &pdev->dev, &coh901331_ops,
+                                         THIS_MODULE);
+        if (IS_ERR(rtap->rtc)) {
+                ret = PTR_ERR(rtap->rtc);
+                goto out_no_rtc;
+        }
+
+        platform_set_drvdata(pdev, rtap);
+
+        return 0;
+
+ out_no_rtc:
+ out_no_clk_enable:
+        clk_put(rtap->clk);
+ out_no_clk:
+        free_irq(rtap->irq, rtap);
+ out_no_irq:
+        iounmap(rtap->virtbase);
+ out_no_remap:
+        platform_set_drvdata(pdev, NULL);
+ out_no_memregion:
+        release_mem_region(rtap->phybase, SZ_4K);
+ out_no_resource:
+        kfree(rtap);
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int coh901331_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
+
+        /*
+         * If this RTC alarm will be used for waking the system up,
+         * don't disable it of course. Else we just disable the alarm
+         * and await suspension.
+         */
+        if (device_may_wakeup(&pdev->dev)) {
+                enable_irq_wake(rtap->irq);
+        } else {
+                clk_enable(rtap->clk);
+                rtap->irqmaskstore = readl(rtap->virtbase + COH901331_IRQ_MASK);
+                writel(0, rtap->virtbase + COH901331_IRQ_MASK);
+                clk_disable(rtap->clk);
+        }
+        return 0;
+}
+
+static int coh901331_resume(struct platform_device *pdev)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
+
+        if (device_may_wakeup(&pdev->dev)) {
+                disable_irq_wake(rtap->irq);
+        } else {
+                clk_enable(rtap->clk);
+                writel(rtap->irqmaskstore, rtap->virtbase + COH901331_IRQ_MASK);
+                clk_disable(rtap->clk);
+        }
+        return 0;
+}
+#else
+#define coh901331_suspend NULL
+#define coh901331_resume NULL
+#endif
+
+static void coh901331_shutdown(struct platform_device *pdev)
+{
+        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
+
+        clk_enable(rtap->clk);
+        writel(0, rtap->virtbase + COH901331_IRQ_MASK);
+        clk_disable(rtap->clk);
+}
+
+static struct platform_driver coh901331_driver = {
+        .driver = {
+                .name = "rtc-coh901331",
+                .owner = THIS_MODULE,
+        },
+        .remove = __exit_p(coh901331_remove),
+        .suspend = coh901331_suspend,
+        .resume = coh901331_resume,
+        .shutdown = coh901331_shutdown,
+};
+
+static int __init coh901331_init(void)
+{
+        return platform_driver_probe(&coh901331_driver, coh901331_probe);
+}
+
+static void __exit coh901331_exit(void)
+{
+        platform_driver_unregister(&coh901331_driver);
+}
+
+module_init(coh901331_init);
+module_exit(coh901331_exit);
+
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+MODULE_DESCRIPTION("ST-Ericsson AB COH 901 331 RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-davinci.c b/drivers/rtc/rtc-davinci.c
new file mode 100644
index 000000000000..34647fc1ee98
--- /dev/null
+++ b/drivers/rtc/rtc-davinci.c
@@ -0,0 +1,674 @@
+/*
+ * DaVinci Power Management and Real Time Clock Driver for TI platforms
+ *
+ * Copyright (C) 2009 Texas Instruments, Inc
+ *
+ * Author: Miguel Aguilar <miguel.aguilar@ridgerun.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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/spinlock.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+
+/*
+ * The DaVinci RTC is a simple RTC with the following
+ * Sec: 0 - 59 : BCD count
+ * Min: 0 - 59 : BCD count
+ * Hour: 0 - 23 : BCD count
+ * Day: 0 - 0x7FFF(32767) : Binary count ( Over 89 years )
+ */
+
+/* PRTC interface registers */
+#define DAVINCI_PRTCIF_PID              0x00
+#define PRTCIF_CTLR                     0x04
+#define PRTCIF_LDATA                    0x08
+#define PRTCIF_UDATA                    0x0C
+#define PRTCIF_INTEN                    0x10
+#define PRTCIF_INTFLG                   0x14
+
+/* PRTCIF_CTLR bit fields */
+#define PRTCIF_CTLR_BUSY                BIT(31)
+#define PRTCIF_CTLR_SIZE                BIT(25)
+#define PRTCIF_CTLR_DIR                 BIT(24)
+#define PRTCIF_CTLR_BENU_MSB            BIT(23)
+#define PRTCIF_CTLR_BENU_3RD_BYTE       BIT(22)
+#define PRTCIF_CTLR_BENU_2ND_BYTE       BIT(21)
+#define PRTCIF_CTLR_BENU_LSB            BIT(20)
+#define PRTCIF_CTLR_BENU_MASK           (0x00F00000)
+#define PRTCIF_CTLR_BENL_MSB            BIT(19)
+#define PRTCIF_CTLR_BENL_3RD_BYTE       BIT(18)
+#define PRTCIF_CTLR_BENL_2ND_BYTE       BIT(17)
+#define PRTCIF_CTLR_BENL_LSB            BIT(16)
+#define PRTCIF_CTLR_BENL_MASK           (0x000F0000)
+
+/* PRTCIF_INTEN bit fields */
+#define PRTCIF_INTEN_RTCSS              BIT(1)
+#define PRTCIF_INTEN_RTCIF              BIT(0)
+#define PRTCIF_INTEN_MASK               (PRTCIF_INTEN_RTCSS \
+                                        | PRTCIF_INTEN_RTCIF)
+
+/* PRTCIF_INTFLG bit fields */
+#define PRTCIF_INTFLG_RTCSS             BIT(1)
+#define PRTCIF_INTFLG_RTCIF             BIT(0)
+#define PRTCIF_INTFLG_MASK              (PRTCIF_INTFLG_RTCSS \
+                                        | PRTCIF_INTFLG_RTCIF)
+
+/* PRTC subsystem registers */
+#define PRTCSS_RTC_INTC_EXTENA1         (0x0C)
+#define PRTCSS_RTC_CTRL                 (0x10)
+#define PRTCSS_RTC_WDT                  (0x11)
+#define PRTCSS_RTC_TMR0                 (0x12)
+#define PRTCSS_RTC_TMR1                 (0x13)
+#define PRTCSS_RTC_CCTRL                (0x14)
+#define PRTCSS_RTC_SEC                  (0x15)
+#define PRTCSS_RTC_MIN                  (0x16)
+#define PRTCSS_RTC_HOUR                 (0x17)
+#define PRTCSS_RTC_DAY0                 (0x18)
+#define PRTCSS_RTC_DAY1                 (0x19)
+#define PRTCSS_RTC_AMIN                 (0x1A)
+#define PRTCSS_RTC_AHOUR                (0x1B)
+#define PRTCSS_RTC_ADAY0                (0x1C)
+#define PRTCSS_RTC_ADAY1                (0x1D)
+#define PRTCSS_RTC_CLKC_CNT             (0x20)
+
+/* PRTCSS_RTC_INTC_EXTENA1 */
+#define PRTCSS_RTC_INTC_EXTENA1_MASK    (0x07)
+
+/* PRTCSS_RTC_CTRL bit fields */
+#define PRTCSS_RTC_CTRL_WDTBUS          BIT(7)
+#define PRTCSS_RTC_CTRL_WEN             BIT(6)
+#define PRTCSS_RTC_CTRL_WDRT            BIT(5)
+#define PRTCSS_RTC_CTRL_WDTFLG          BIT(4)
+#define PRTCSS_RTC_CTRL_TE              BIT(3)
+#define PRTCSS_RTC_CTRL_TIEN            BIT(2)
+#define PRTCSS_RTC_CTRL_TMRFLG          BIT(1)
+#define PRTCSS_RTC_CTRL_TMMD            BIT(0)
+
+/* PRTCSS_RTC_CCTRL bit fields */
+#define PRTCSS_RTC_CCTRL_CALBUSY        BIT(7)
+#define PRTCSS_RTC_CCTRL_DAEN           BIT(5)
+#define PRTCSS_RTC_CCTRL_HAEN           BIT(4)
+#define PRTCSS_RTC_CCTRL_MAEN           BIT(3)
+#define PRTCSS_RTC_CCTRL_ALMFLG         BIT(2)
+#define PRTCSS_RTC_CCTRL_AIEN           BIT(1)
+#define PRTCSS_RTC_CCTRL_CAEN           BIT(0)
+
+static DEFINE_SPINLOCK(davinci_rtc_lock);
+
+struct davinci_rtc {
+        struct rtc_device               *rtc;
+        void __iomem                    *base;
+        resource_size_t                 pbase;
+        size_t                          base_size;
+        int                             irq;
+};
+
+static inline void rtcif_write(struct davinci_rtc *davinci_rtc,
+                               u32 val, u32 addr)
+{
+        writel(val, davinci_rtc->base + addr);
+}
+
+static inline u32 rtcif_read(struct davinci_rtc *davinci_rtc, u32 addr)
+{
+        return readl(davinci_rtc->base + addr);
+}
+
+static inline void rtcif_wait(struct davinci_rtc *davinci_rtc)
+{
+        while (rtcif_read(davinci_rtc, PRTCIF_CTLR) & PRTCIF_CTLR_BUSY)
+                cpu_relax();
+}
+
+static inline void rtcss_write(struct davinci_rtc *davinci_rtc,
+                               unsigned long val, u8 addr)
+{
+        rtcif_wait(davinci_rtc);
+
+        rtcif_write(davinci_rtc, PRTCIF_CTLR_BENL_LSB | addr, PRTCIF_CTLR);
+        rtcif_write(davinci_rtc, val, PRTCIF_LDATA);
+
+        rtcif_wait(davinci_rtc);
+}
+
+static inline u8 rtcss_read(struct davinci_rtc *davinci_rtc, u8 addr)
+{
+        rtcif_wait(davinci_rtc);
+
+        rtcif_write(davinci_rtc, PRTCIF_CTLR_DIR | PRTCIF_CTLR_BENL_LSB | addr,
+                    PRTCIF_CTLR);
+
+        rtcif_wait(davinci_rtc);
+
+        return rtcif_read(davinci_rtc, PRTCIF_LDATA);
+}
+
+static inline void davinci_rtcss_calendar_wait(struct davinci_rtc *davinci_rtc)
+{
+        while (rtcss_read(davinci_rtc, PRTCSS_RTC_CCTRL) &
+               PRTCSS_RTC_CCTRL_CALBUSY)
+                cpu_relax();
+}
+
+static irqreturn_t davinci_rtc_interrupt(int irq, void *class_dev)
+{
+        struct davinci_rtc *davinci_rtc = class_dev;
+        unsigned long events = 0;
+        u32 irq_flg;
+        u8 alm_irq, tmr_irq;
+        u8 rtc_ctrl, rtc_cctrl;
+        int ret = IRQ_NONE;
+
+        irq_flg = rtcif_read(davinci_rtc, PRTCIF_INTFLG) &
+                  PRTCIF_INTFLG_RTCSS;
+
+        alm_irq = rtcss_read(davinci_rtc, PRTCSS_RTC_CCTRL) &
+                  PRTCSS_RTC_CCTRL_ALMFLG;
+
+        tmr_irq = rtcss_read(davinci_rtc, PRTCSS_RTC_CTRL) &
+                  PRTCSS_RTC_CTRL_TMRFLG;
+
+        if (irq_flg) {
+                if (alm_irq) {
+                        events |= RTC_IRQF | RTC_AF;
+                        rtc_cctrl = rtcss_read(davinci_rtc, PRTCSS_RTC_CCTRL);
+                        rtc_cctrl |=  PRTCSS_RTC_CCTRL_ALMFLG;
+                        rtcss_write(davinci_rtc, rtc_cctrl, PRTCSS_RTC_CCTRL);
+                } else if (tmr_irq) {
+                        events |= RTC_IRQF | RTC_PF;
+                        rtc_ctrl = rtcss_read(davinci_rtc, PRTCSS_RTC_CTRL);
+                        rtc_ctrl |=  PRTCSS_RTC_CTRL_TMRFLG;
+                        rtcss_write(davinci_rtc, rtc_ctrl, PRTCSS_RTC_CTRL);
+                }
+
+                rtcif_write(davinci_rtc, PRTCIF_INTFLG_RTCSS,
+                                    PRTCIF_INTFLG);
+                rtc_update_irq(davinci_rtc->rtc, 1, events);
+
+                ret = IRQ_HANDLED;
+        }
+
+        return ret;
+}
+
+static int
+davinci_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        u8 rtc_ctrl;
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        rtc_ctrl = rtcss_read(davinci_rtc, PRTCSS_RTC_CTRL);
+
+        switch (cmd) {
+        case RTC_WIE_ON:
+                rtc_ctrl |= PRTCSS_RTC_CTRL_WEN | PRTCSS_RTC_CTRL_WDTFLG;
+                break;
+        case RTC_WIE_OFF:
+                rtc_ctrl &= ~PRTCSS_RTC_CTRL_WEN;
+                break;
+        case RTC_UIE_OFF:
+        case RTC_UIE_ON:
+                ret = -ENOTTY;
+                break;
+        default:
+                ret = -ENOIOCTLCMD;
+        }
+
+        rtcss_write(davinci_rtc, rtc_ctrl, PRTCSS_RTC_CTRL);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+
+        return ret;
+}
+
+static int convertfromdays(u16 days, struct rtc_time *tm)
+{
+        int tmp_days, year, mon;
+
+        for (year = 2000;; year++) {
+                tmp_days = rtc_year_days(1, 12, year);
+                if (days >= tmp_days)
+                        days -= tmp_days;
+                else {
+                        for (mon = 0;; mon++) {
+                                tmp_days = rtc_month_days(mon, year);
+                                if (days >= tmp_days) {
+                                        days -= tmp_days;
+                                } else {
+                                        tm->tm_year = year - 1900;
+                                        tm->tm_mon = mon;
+                                        tm->tm_mday = days + 1;
+                                        break;
+                                }
+                        }
+                        break;
+                }
+        }
+        return 0;
+}
+
+static int convert2days(u16 *days, struct rtc_time *tm)
+{
+        int i;
+        *days = 0;
+
+        /* epoch == 1900 */
+        if (tm->tm_year < 100 || tm->tm_year > 199)
+                return -EINVAL;
+
+        for (i = 2000; i < 1900 + tm->tm_year; i++)
+                *days += rtc_year_days(1, 12, i);
+
+        *days += rtc_year_days(tm->tm_mday, tm->tm_mon, 1900 + tm->tm_year);
+
+        return 0;
+}
+
+static int davinci_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        u16 days = 0;
+        u8 day0, day1;
+        unsigned long flags;
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        tm->tm_sec = bcd2bin(rtcss_read(davinci_rtc, PRTCSS_RTC_SEC));
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        tm->tm_min = bcd2bin(rtcss_read(davinci_rtc, PRTCSS_RTC_MIN));
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        tm->tm_hour = bcd2bin(rtcss_read(davinci_rtc, PRTCSS_RTC_HOUR));
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        day0 = rtcss_read(davinci_rtc, PRTCSS_RTC_DAY0);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        day1 = rtcss_read(davinci_rtc, PRTCSS_RTC_DAY1);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+
+        days |= day1;
+        days <<= 8;
+        days |= day0;
+
+        if (convertfromdays(days, tm) < 0)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int davinci_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        u16 days;
+        u8 rtc_cctrl;
+        unsigned long flags;
+
+        if (convert2days(&days, tm) < 0)
+                return -EINVAL;
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, bin2bcd(tm->tm_sec), PRTCSS_RTC_SEC);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, bin2bcd(tm->tm_min), PRTCSS_RTC_MIN);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, bin2bcd(tm->tm_hour), PRTCSS_RTC_HOUR);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, days & 0xFF, PRTCSS_RTC_DAY0);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, (days & 0xFF00) >> 8, PRTCSS_RTC_DAY1);
+
+        rtc_cctrl = rtcss_read(davinci_rtc, PRTCSS_RTC_CCTRL);
+        rtc_cctrl |= PRTCSS_RTC_CCTRL_CAEN;
+        rtcss_write(davinci_rtc, rtc_cctrl, PRTCSS_RTC_CCTRL);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+
+        return 0;
+}
+
+static int davinci_rtc_alarm_irq_enable(struct device *dev,
+                                        unsigned int enabled)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        unsigned long flags;
+        u8 rtc_cctrl = rtcss_read(davinci_rtc, PRTCSS_RTC_CCTRL);
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        if (enabled)
+                rtc_cctrl |= PRTCSS_RTC_CCTRL_DAEN |
+                             PRTCSS_RTC_CCTRL_HAEN |
+                             PRTCSS_RTC_CCTRL_MAEN |
+                             PRTCSS_RTC_CCTRL_ALMFLG |
+                             PRTCSS_RTC_CCTRL_AIEN;
+        else
+                rtc_cctrl &= ~PRTCSS_RTC_CCTRL_AIEN;
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, rtc_cctrl, PRTCSS_RTC_CCTRL);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+
+        return 0;
+}
+
+static int davinci_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        u16 days = 0;
+        u8 day0, day1;
+        unsigned long flags;
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        alm->time.tm_min = bcd2bin(rtcss_read(davinci_rtc, PRTCSS_RTC_AMIN));
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        alm->time.tm_hour = bcd2bin(rtcss_read(davinci_rtc, PRTCSS_RTC_AHOUR));
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        day0 = rtcss_read(davinci_rtc, PRTCSS_RTC_ADAY0);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        day1 = rtcss_read(davinci_rtc, PRTCSS_RTC_ADAY1);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+        days |= day1;
+        days <<= 8;
+        days |= day0;
+
+        if (convertfromdays(days, &alm->time) < 0)
+                return -EINVAL;
+
+        alm->pending = !!(rtcss_read(davinci_rtc,
+                          PRTCSS_RTC_CCTRL) &
+                        PRTCSS_RTC_CCTRL_AIEN);
+        alm->enabled = alm->pending && device_may_wakeup(dev);
+
+        return 0;
+}
+
+static int davinci_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        unsigned long flags;
+        u16 days;
+
+        if (alm->time.tm_mday <= 0 && alm->time.tm_mon < 0
+            && alm->time.tm_year < 0) {
+                struct rtc_time tm;
+                unsigned long now, then;
+
+                davinci_rtc_read_time(dev, &tm);
+                rtc_tm_to_time(&tm, &now);
+
+                alm->time.tm_mday = tm.tm_mday;
+                alm->time.tm_mon = tm.tm_mon;
+                alm->time.tm_year = tm.tm_year;
+                rtc_tm_to_time(&alm->time, &then);
+
+                if (then < now) {
+                        rtc_time_to_tm(now + 24 * 60 * 60, &tm);
+                        alm->time.tm_mday = tm.tm_mday;
+                        alm->time.tm_mon = tm.tm_mon;
+                        alm->time.tm_year = tm.tm_year;
+                }
+        }
+
+        if (convert2days(&days, &alm->time) < 0)
+                return -EINVAL;
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, bin2bcd(alm->time.tm_min), PRTCSS_RTC_AMIN);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, bin2bcd(alm->time.tm_hour), PRTCSS_RTC_AHOUR);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, days & 0xFF, PRTCSS_RTC_ADAY0);
+
+        davinci_rtcss_calendar_wait(davinci_rtc);
+        rtcss_write(davinci_rtc, (days & 0xFF00) >> 8, PRTCSS_RTC_ADAY1);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+
+        return 0;
+}
+
+static int davinci_rtc_irq_set_state(struct device *dev, int enabled)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        unsigned long flags;
+        u8 rtc_ctrl;
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        rtc_ctrl = rtcss_read(davinci_rtc, PRTCSS_RTC_CTRL);
+
+        if (enabled) {
+                while (rtcss_read(davinci_rtc, PRTCSS_RTC_CTRL)
+                       & PRTCSS_RTC_CTRL_WDTBUS)
+                        cpu_relax();
+
+                rtc_ctrl |= PRTCSS_RTC_CTRL_TE;
+                rtcss_write(davinci_rtc, rtc_ctrl, PRTCSS_RTC_CTRL);
+
+                rtcss_write(davinci_rtc, 0x0, PRTCSS_RTC_CLKC_CNT);
+
+                rtc_ctrl |= PRTCSS_RTC_CTRL_TIEN |
+                            PRTCSS_RTC_CTRL_TMMD |
+                            PRTCSS_RTC_CTRL_TMRFLG;
+        } else
+                rtc_ctrl &= ~PRTCSS_RTC_CTRL_TIEN;
+
+        rtcss_write(davinci_rtc, rtc_ctrl, PRTCSS_RTC_CTRL);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+
+        return 0;
+}
+
+static int davinci_rtc_irq_set_freq(struct device *dev, int freq)
+{
+        struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
+        unsigned long flags;
+        u16 tmr_counter = (0x8000 >> (ffs(freq) - 1));
+
+        spin_lock_irqsave(&davinci_rtc_lock, flags);
+
+        rtcss_write(davinci_rtc, tmr_counter & 0xFF, PRTCSS_RTC_TMR0);
+        rtcss_write(davinci_rtc, (tmr_counter & 0xFF00) >> 8, PRTCSS_RTC_TMR1);
+
+        spin_unlock_irqrestore(&davinci_rtc_lock, flags);
+
+        return 0;
+}
+
+static struct rtc_class_ops davinci_rtc_ops = {
+        .ioctl                  = davinci_rtc_ioctl,
+        .read_time              = davinci_rtc_read_time,
+        .set_time               = davinci_rtc_set_time,
+        .alarm_irq_enable       = davinci_rtc_alarm_irq_enable,
+        .read_alarm             = davinci_rtc_read_alarm,
+        .set_alarm              = davinci_rtc_set_alarm,
+        .irq_set_state          = davinci_rtc_irq_set_state,
+        .irq_set_freq           = davinci_rtc_irq_set_freq,
+};
+
+static int __init davinci_rtc_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct davinci_rtc *davinci_rtc;
+        struct resource *res, *mem;
+        int ret = 0;
+
+        davinci_rtc = kzalloc(sizeof(struct davinci_rtc), GFP_KERNEL);
+        if (!davinci_rtc) {
+                dev_dbg(dev, "could not allocate memory for private data\n");
+                return -ENOMEM;
+        }
+
+        davinci_rtc->irq = platform_get_irq(pdev, 0);
+        if (davinci_rtc->irq < 0) {
+                dev_err(dev, "no RTC irq\n");
+                ret = davinci_rtc->irq;
+                goto fail1;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "no mem resource\n");
+                ret = -EINVAL;
+                goto fail1;
+        }
+
+        davinci_rtc->pbase = res->start;
+        davinci_rtc->base_size = resource_size(res);
+
+        mem = request_mem_region(davinci_rtc->pbase, davinci_rtc->base_size,
+                                 pdev->name);
+        if (!mem) {
+                dev_err(dev, "RTC registers at %08x are not free\n",
+                        davinci_rtc->pbase);
+                ret = -EBUSY;
+                goto fail1;
+        }
+
+        davinci_rtc->base = ioremap(davinci_rtc->pbase, davinci_rtc->base_size);
+        if (!davinci_rtc->base) {
+                dev_err(dev, "unable to ioremap MEM resource\n");
+                ret = -ENOMEM;
+                goto fail2;
+        }
+
+        davinci_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                    &davinci_rtc_ops, THIS_MODULE);
+        if (IS_ERR(davinci_rtc->rtc)) {
+                dev_err(dev, "unable to register RTC device, err %ld\n",
+                                PTR_ERR(davinci_rtc->rtc));
+                goto fail3;
+        }
+
+        rtcif_write(davinci_rtc, PRTCIF_INTFLG_RTCSS, PRTCIF_INTFLG);
+        rtcif_write(davinci_rtc, 0, PRTCIF_INTEN);
+        rtcss_write(davinci_rtc, 0, PRTCSS_RTC_INTC_EXTENA1);
+
+        rtcss_write(davinci_rtc, 0, PRTCSS_RTC_CTRL);
+        rtcss_write(davinci_rtc, 0, PRTCSS_RTC_CCTRL);
+
+        ret = request_irq(davinci_rtc->irq, davinci_rtc_interrupt,
+                          IRQF_DISABLED, "davinci_rtc", davinci_rtc);
+        if (ret < 0) {
+                dev_err(dev, "unable to register davinci RTC interrupt\n");
+                goto fail4;
+        }
+
+        /* Enable interrupts */
+        rtcif_write(davinci_rtc, PRTCIF_INTEN_RTCSS, PRTCIF_INTEN);
+        rtcss_write(davinci_rtc, PRTCSS_RTC_INTC_EXTENA1_MASK,
+                            PRTCSS_RTC_INTC_EXTENA1);
+
+        rtcss_write(davinci_rtc, PRTCSS_RTC_CCTRL_CAEN, PRTCSS_RTC_CCTRL);
+
+        platform_set_drvdata(pdev, davinci_rtc);
+
+        device_init_wakeup(&pdev->dev, 0);
+
+        return 0;
+
+fail4:
+        rtc_device_unregister(davinci_rtc->rtc);
+fail3:
+        iounmap(davinci_rtc->base);
+fail2:
+        release_mem_region(davinci_rtc->pbase, davinci_rtc->base_size);
+fail1:
+        kfree(davinci_rtc);
+
+        return ret;
+}
+
+static int __devexit davinci_rtc_remove(struct platform_device *pdev)
+{
+        struct davinci_rtc *davinci_rtc = platform_get_drvdata(pdev);
+
+        device_init_wakeup(&pdev->dev, 0);
+
+        rtcif_write(davinci_rtc, 0, PRTCIF_INTEN);
+
+        free_irq(davinci_rtc->irq, davinci_rtc);
+
+        rtc_device_unregister(davinci_rtc->rtc);
+
+        iounmap(davinci_rtc->base);
+        release_mem_region(davinci_rtc->pbase, davinci_rtc->base_size);
+
+        platform_set_drvdata(pdev, NULL);
+
+        kfree(davinci_rtc);
+
+        return 0;
+}
+
+static struct platform_driver davinci_rtc_driver = {
+        .probe          = davinci_rtc_probe,
+        .remove         = __devexit_p(davinci_rtc_remove),
+        .driver         = {
+                .name = "rtc_davinci",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init rtc_init(void)
+{
+        return platform_driver_probe(&davinci_rtc_driver, davinci_rtc_probe);
+}
+module_init(rtc_init);
+
+static void __exit rtc_exit(void)
+{
+        platform_driver_unregister(&davinci_rtc_driver);
+}
+module_exit(rtc_exit);
+
+MODULE_AUTHOR("Miguel Aguilar <miguel.aguilar@ridgerun.com>");
+MODULE_DESCRIPTION("Texas Instruments DaVinci PRTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 8a11de9552cd..212b16edafc0 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -13,6 +13,7 @@
 
 #include <linux/module.h>
 #include <linux/rtc.h>
+#include <linux/sched.h>
 #include "rtc-core.h"
 
 static dev_t rtc_devt;
@@ -45,105 +46,6 @@ static int rtc_dev_open(struct inode *inode, struct file *file)
         return err;
 }
 
-#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
-/*
- * Routine to poll RTC seconds field for change as often as possible,
- * after first RTC_UIE use timer to reduce polling
- */
-static void rtc_uie_task(struct work_struct *work)
-{
-        struct rtc_device *rtc =
-                container_of(work, struct rtc_device, uie_task);
-        struct rtc_time tm;
-        int num = 0;
-        int err;
-
-        err = rtc_read_time(rtc, &tm);
-
-        spin_lock_irq(&rtc->irq_lock);
-        if (rtc->stop_uie_polling || err) {
-                rtc->uie_task_active = 0;
-        } else if (rtc->oldsecs != tm.tm_sec) {
-                num = (tm.tm_sec + 60 - rtc->oldsecs) % 60;
-                rtc->oldsecs = tm.tm_sec;
-                rtc->uie_timer.expires = jiffies + HZ - (HZ/10);
-                rtc->uie_timer_active = 1;
-                rtc->uie_task_active = 0;
-                add_timer(&rtc->uie_timer);
-        } else if (schedule_work(&rtc->uie_task) == 0) {
-                rtc->uie_task_active = 0;
-        }
-        spin_unlock_irq(&rtc->irq_lock);
-        if (num)
-                rtc_update_irq(rtc, num, RTC_UF | RTC_IRQF);
-}
-static void rtc_uie_timer(unsigned long data)
-{
-        struct rtc_device *rtc = (struct rtc_device *)data;
-        unsigned long flags;
-
-        spin_lock_irqsave(&rtc->irq_lock, flags);
-        rtc->uie_timer_active = 0;
-        rtc->uie_task_active = 1;
-        if ((schedule_work(&rtc->uie_task) == 0))
-                rtc->uie_task_active = 0;
-        spin_unlock_irqrestore(&rtc->irq_lock, flags);
-}
-
-static int clear_uie(struct rtc_device *rtc)
-{
-        spin_lock_irq(&rtc->irq_lock);
-        if (rtc->uie_irq_active) {
-                rtc->stop_uie_polling = 1;
-                if (rtc->uie_timer_active) {
-                        spin_unlock_irq(&rtc->irq_lock);
-                        del_timer_sync(&rtc->uie_timer);
-                        spin_lock_irq(&rtc->irq_lock);
-                        rtc->uie_timer_active = 0;
-                }
-                if (rtc->uie_task_active) {
-                        spin_unlock_irq(&rtc->irq_lock);
-                        flush_scheduled_work();
-                        spin_lock_irq(&rtc->irq_lock);
-                }
-                rtc->uie_irq_active = 0;
-        }
-        spin_unlock_irq(&rtc->irq_lock);
-        return 0;
-}
-
-static int set_uie(struct rtc_device *rtc)
-{
-        struct rtc_time tm;
-        int err;
-
-        err = rtc_read_time(rtc, &tm);
-        if (err)
-                return err;
-        spin_lock_irq(&rtc->irq_lock);
-        if (!rtc->uie_irq_active) {
-                rtc->uie_irq_active = 1;
-                rtc->stop_uie_polling = 0;
-                rtc->oldsecs = tm.tm_sec;
-                rtc->uie_task_active = 1;
-                if (schedule_work(&rtc->uie_task) == 0)
-                        rtc->uie_task_active = 0;
-        }
-        rtc->irq_data = 0;
-        spin_unlock_irq(&rtc->irq_lock);
-        return 0;
-}
-
-int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, unsigned int enabled)
-{
-        if (enabled)
-                return set_uie(rtc);
-        else
-                return clear_uie(rtc);
-}
-EXPORT_SYMBOL(rtc_dev_update_irq_enable_emul);
-
-#endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */
 
 static ssize_t
 rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
@@ -492,11 +394,6 @@ void rtc_dev_prepare(struct rtc_device *rtc)
 
         rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);
 
-#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
-        INIT_WORK(&rtc->uie_task, rtc_uie_task);
-        setup_timer(&rtc->uie_timer, rtc_uie_timer, (unsigned long)rtc);
-#endif
-
         cdev_init(&rtc->char_dev, &rtc_dev_fops);
         rtc->char_dev.owner = rtc->owner;
 }
diff --git a/drivers/rtc/rtc-ds1216.c b/drivers/rtc/rtc-ds1216.c
index 4aedc705518c..45cd8c9f5a39 100644
--- a/drivers/rtc/rtc-ds1216.c
+++ b/drivers/rtc/rtc-ds1216.c
@@ -9,6 +9,7 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/bcd.h>
+#include <linux/slab.h>
 
 #define DRV_VERSION "0.2"
 
diff --git a/drivers/rtc/rtc-ds1286.c b/drivers/rtc/rtc-ds1286.c
index 4fcb16bbff4a..bf430f9091ed 100644
--- a/drivers/rtc/rtc-ds1286.c
+++ b/drivers/rtc/rtc-ds1286.c
@@ -18,6 +18,7 @@
 #include <linux/bcd.h>
 #include <linux/ds1286.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #define DRV_VERSION             "1.0"
 
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index 184556620778..f0d638922644 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -1,26 +1,24 @@
 /*
  * Dallas DS1302 RTC Support
  *
- *  Copyright (C) 2002  David McCullough
- *  Copyright (C) 2003 - 2007  Paul Mundt
+ *  Copyright (C) 2002 David McCullough
+ *  Copyright (C) 2003 - 2007 Paul Mundt
  *
  * This file is subject to the terms and conditions of the GNU General Public
- * License version 2.  See the file "COPYING" in the main directory of
+ * License version 2. See the file "COPYING" in the main directory of
  * this archive for more details.
  */
+
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
-#include <linux/time.h>
 #include <linux/rtc.h>
-#include <linux/spinlock.h>
 #include <linux/io.h>
 #include <linux/bcd.h>
-#include <asm/rtc.h>
 
 #define DRV_NAME        "rtc-ds1302"
-#define DRV_VERSION     "0.1.0"
+#define DRV_VERSION     "0.1.1"
 
 #define RTC_CMD_READ    0x81            /* Read command */
 #define RTC_CMD_WRITE   0x80            /* Write command */
@@ -35,32 +33,68 @@
 #define RTC_ADDR_MIN    0x01            /* Address of minute register */
 #define RTC_ADDR_SEC    0x00            /* Address of second register */
 
+#ifdef CONFIG_SH_SECUREEDGE5410
+#include <asm/rtc.h>
+#include <mach/secureedge5410.h>
+
 #define RTC_RESET       0x1000
 #define RTC_IODATA      0x0800
 #define RTC_SCLK        0x0400
 
-#ifdef CONFIG_SH_SECUREEDGE5410
-#include <mach/snapgear.h>
 #define set_dp(x)       SECUREEDGE_WRITE_IOPORT(x, 0x1c00)
 #define get_dp()        SECUREEDGE_READ_IOPORT()
+#define ds1302_set_tx()
+#define ds1302_set_rx()
+
+static inline int ds1302_hw_init(void)
+{
+        return 0;
+}
+
+static inline void ds1302_reset(void)
+{
+        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
+}
+
+static inline void ds1302_clock(void)
+{
+        set_dp(get_dp() | RTC_SCLK);    /* clock high */
+        set_dp(get_dp() & ~RTC_SCLK);   /* clock low */
+}
+
+static inline void ds1302_start(void)
+{
+        set_dp(get_dp() | RTC_RESET);
+}
+
+static inline void ds1302_stop(void)
+{
+        set_dp(get_dp() & ~RTC_RESET);
+}
+
+static inline void ds1302_txbit(int bit)
+{
+        set_dp((get_dp() & ~RTC_IODATA) | (bit ? RTC_IODATA : 0));
+}
+
+static inline int ds1302_rxbit(void)
+{
+        return !!(get_dp() & RTC_IODATA);
+}
+
 #else
 #error "Add support for your platform"
 #endif
 
-struct ds1302_rtc {
-        struct rtc_device *rtc_dev;
-        spinlock_t lock;
-};
-
 static void ds1302_sendbits(unsigned int val)
 {
         int i;
 
+        ds1302_set_tx();
+
         for (i = 8; (i); i--, val >>= 1) {
-                set_dp((get_dp() & ~RTC_IODATA) | ((val & 0x1) ?
-                        RTC_IODATA : 0));
-                set_dp(get_dp() | RTC_SCLK);    /* clock high */
-                set_dp(get_dp() & ~RTC_SCLK);   /* clock low */
+                ds1302_txbit(val & 0x1);
+                ds1302_clock();
         }
 }
 
@@ -69,10 +103,11 @@ static unsigned int ds1302_recvbits(void)
         unsigned int val;
         int i;
 
+        ds1302_set_rx();
+
         for (i = 0, val = 0; (i < 8); i++) {
-                val |= (((get_dp() & RTC_IODATA) ? 1 : 0) << i);
-                set_dp(get_dp() | RTC_SCLK);    /* clock high */
-                set_dp(get_dp() & ~RTC_SCLK);   /* clock low */
+                val |= (ds1302_rxbit() << i);
+                ds1302_clock();
         }
 
         return val;
@@ -82,31 +117,28 @@ static unsigned int ds1302_readbyte(unsigned int addr)
 {
         unsigned int val;
 
-        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
+        ds1302_reset();
 
-        set_dp(get_dp() | RTC_RESET);
+        ds1302_start();
         ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_READ);
         val = ds1302_recvbits();
-        set_dp(get_dp() & ~RTC_RESET);
+        ds1302_stop();
 
         return val;
 }
 
 static void ds1302_writebyte(unsigned int addr, unsigned int val)
 {
-        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
-        set_dp(get_dp() | RTC_RESET);
+        ds1302_reset();
+
+        ds1302_start();
         ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_WRITE);
         ds1302_sendbits(val);
-        set_dp(get_dp() & ~RTC_RESET);
+        ds1302_stop();
 }
 
 static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ds1302_rtc *rtc = dev_get_drvdata(dev);
-
-        spin_lock_irq(&rtc->lock);
-
         tm->tm_sec      = bcd2bin(ds1302_readbyte(RTC_ADDR_SEC));
         tm->tm_min      = bcd2bin(ds1302_readbyte(RTC_ADDR_MIN));
         tm->tm_hour     = bcd2bin(ds1302_readbyte(RTC_ADDR_HOUR));
@@ -118,26 +150,17 @@ static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
 
-        spin_unlock_irq(&rtc->lock);
-
         dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                 "mday=%d, mon=%d, year=%d, wday=%d\n",
                 __func__,
                 tm->tm_sec, tm->tm_min, tm->tm_hour,
                 tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
 
-        if (rtc_valid_tm(tm) < 0)
-                dev_err(dev, "invalid date\n");
-
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ds1302_rtc *rtc = dev_get_drvdata(dev);
-
-        spin_lock_irq(&rtc->lock);
-
         /* Stop RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) | 0x80);
 
@@ -152,8 +175,6 @@ static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
         /* Start RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) & ~0x80);
 
-        spin_unlock_irq(&rtc->lock);
-
         return 0;
 }
 
@@ -164,15 +185,12 @@ static int ds1302_rtc_ioctl(struct device *dev, unsigned int cmd,
 #ifdef RTC_SET_CHARGE
         case RTC_SET_CHARGE:
         {
-                struct ds1302_rtc *rtc = dev_get_drvdata(dev);
                 int tcs_val;
 
                 if (copy_from_user(&tcs_val, (int __user *)arg, sizeof(int)))
                         return -EFAULT;
 
-                spin_lock_irq(&rtc->lock);
                 ds1302_writebyte(RTC_ADDR_TCR, (0xa0 | tcs_val * 0xf));
-                spin_unlock_irq(&rtc->lock);
                 return 0;
         }
 #endif
@@ -187,50 +205,42 @@ static struct rtc_class_ops ds1302_rtc_ops = {
         .ioctl          = ds1302_rtc_ioctl,
 };
 
-static int __devinit ds1302_rtc_probe(struct platform_device *pdev)
+static int __init ds1302_rtc_probe(struct platform_device *pdev)
 {
-        struct ds1302_rtc *rtc;
-        int ret;
+        struct rtc_device *rtc;
+
+        if (ds1302_hw_init()) {
+                dev_err(&pdev->dev, "Failed to init communication channel");
+                return -EINVAL;
+        }
 
         /* Reset */
-        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
+        ds1302_reset();
 
         /* Write a magic value to the DS1302 RAM, and see if it sticks. */
         ds1302_writebyte(RTC_ADDR_RAM0, 0x42);
-        if (ds1302_readbyte(RTC_ADDR_RAM0) != 0x42)
+        if (ds1302_readbyte(RTC_ADDR_RAM0) != 0x42) {
+                dev_err(&pdev->dev, "Failed to probe");
                 return -ENODEV;
+        }
 
-        rtc = kzalloc(sizeof(struct ds1302_rtc), GFP_KERNEL);
-        if (unlikely(!rtc))
-                return -ENOMEM;
-
-        spin_lock_init(&rtc->lock);
-        rtc->rtc_dev = rtc_device_register("ds1302", &pdev->dev,
+        rtc = rtc_device_register("ds1302", &pdev->dev,
                                            &ds1302_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto out;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
 
         platform_set_drvdata(pdev, rtc);
 
         return 0;
-out:
-        kfree(rtc);
-        return ret;
 }
 
 static int __devexit ds1302_rtc_remove(struct platform_device *pdev)
 {
-        struct ds1302_rtc *rtc = platform_get_drvdata(pdev);
-
-        if (likely(rtc->rtc_dev))
-                rtc_device_unregister(rtc->rtc_dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
 
+        rtc_device_unregister(rtc);
         platform_set_drvdata(pdev, NULL);
 
-        kfree(rtc);
-
         return 0;
 }
 
@@ -239,13 +249,12 @@ static struct platform_driver ds1302_platform_driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
         },
-        .probe          = ds1302_rtc_probe,
         .remove         = __devexit_p(ds1302_rtc_remove),
 };
 
 static int __init ds1302_rtc_init(void)
 {
-        return platform_driver_register(&ds1302_platform_driver);
+        return platform_driver_probe(&ds1302_platform_driver, ds1302_rtc_probe);
 }
 
 static void __exit ds1302_rtc_exit(void)
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index 8f410e59d9f5..077af1d7b9e4 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/bcd.h>
+#include <linux/slab.h>
 #include <linux/rtc.h>
 #include <linux/workqueue.h>
 
@@ -541,7 +542,8 @@ static void msg_init(struct spi_message *m, struct spi_transfer *x,
 }
 
 static ssize_t
-ds1305_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
+ds1305_nvram_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t off, size_t count)
 {
         struct spi_device       *spi;
@@ -571,7 +573,8 @@ ds1305_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 }
 
 static ssize_t
-ds1305_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
+ds1305_nvram_write(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t off, size_t count)
 {
         struct spi_device       *spi;
@@ -617,7 +620,6 @@ static struct bin_attribute nvram = {
 static int __devinit ds1305_probe(struct spi_device *spi)
 {
         struct ds1305                   *ds1305;
-        struct rtc_device               *rtc;
         int                             status;
         u8                              addr, value;
         struct ds1305_platform_data     *pdata = spi->dev.platform_data;
@@ -756,14 +758,13 @@ static int __devinit ds1305_probe(struct spi_device *spi)
                 dev_dbg(&spi->dev, "AM/PM\n");
 
         /* register RTC ... from here on, ds1305->ctrl needs locking */
-        rtc = rtc_device_register("ds1305", &spi->dev,
+        ds1305->rtc = rtc_device_register("ds1305", &spi->dev,
                         &ds1305_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                status = PTR_ERR(rtc);
+        if (IS_ERR(ds1305->rtc)) {
+                status = PTR_ERR(ds1305->rtc);
                 dev_dbg(&spi->dev, "register rtc --> %d\n", status);
                 goto fail0;
         }
-        ds1305->rtc = rtc;
 
         /* Maybe set up alarm IRQ; be ready to handle it triggering right
          * away.  NOTE that we don't share this.  The signal is active low,
@@ -774,12 +775,14 @@ static int __devinit ds1305_probe(struct spi_device *spi)
         if (spi->irq) {
                 INIT_WORK(&ds1305->work, ds1305_work);
                 status = request_irq(spi->irq, ds1305_irq,
-                                0, dev_name(&rtc->dev), ds1305);
+                                0, dev_name(&ds1305->rtc->dev), ds1305);
                 if (status < 0) {
                         dev_dbg(&spi->dev, "request_irq %d --> %d\n",
                                         spi->irq, status);
                         goto fail1;
                 }
+
+                device_set_wakeup_capable(&spi->dev, 1);
         }
 
         /* export NVRAM */
@@ -794,7 +797,7 @@ static int __devinit ds1305_probe(struct spi_device *spi)
 fail2:
         free_irq(spi->irq, ds1305);
 fail1:
-        rtc_device_unregister(rtc);
+        rtc_device_unregister(ds1305->rtc);
 fail0:
         kfree(ds1305);
         return status;
@@ -802,7 +805,7 @@ fail0:
 
 static int __devexit ds1305_remove(struct spi_device *spi)
 {
-        struct ds1305   *ds1305 = spi_get_drvdata(spi);
+        struct ds1305 *ds1305 = spi_get_drvdata(spi);
 
         sysfs_remove_bin_file(&spi->dev.kobj, &nvram);
 
@@ -810,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);
@@ -841,3 +844,4 @@ module_exit(ds1305_exit);
 
 MODULE_DESCRIPTION("RTC driver for DS1305 and DS1306 chips");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:rtc-ds1305");
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index 47a93c022d91..0d559b6416dd 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];
@@ -556,7 +556,8 @@ static const struct rtc_class_ops ds13xx_rtc_ops = {
 #define NVRAM_SIZE      56
 
 static ssize_t
-ds1307_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
+ds1307_nvram_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t off, size_t count)
 {
         struct i2c_client       *client;
@@ -580,7 +581,8 @@ ds1307_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 }
 
 static ssize_t
-ds1307_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
+ds1307_nvram_write(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t off, size_t count)
 {
         struct i2c_client       *client;
@@ -775,7 +777,7 @@ static int __devinit ds1307_probe(struct i2c_client *client,
 
 read_rtc:
         /* read RTC registers */
-        tmp = ds1307->read_block_data(ds1307->client, 0, 8, buf);
+        tmp = ds1307->read_block_data(ds1307->client, ds1307->offset, 8, buf);
         if (tmp != 8) {
                 pr_debug("read error %d\n", tmp);
                 err = -EIO;
@@ -860,7 +862,7 @@ read_rtc:
                 if (ds1307->regs[DS1307_REG_HOUR] & DS1307_BIT_PM)
                         tmp += 12;
                 i2c_smbus_write_byte_data(client,
-                                DS1307_REG_HOUR,
+                                ds1307->offset + DS1307_REG_HOUR,
                                 bin2bcd(tmp));
         }
 
@@ -874,13 +876,15 @@ read_rtc:
         }
 
         if (want_irq) {
-                err = request_irq(client->irq, ds1307_irq, 0,
+                err = request_irq(client->irq, ds1307_irq, IRQF_SHARED,
                           ds1307->rtc->name, client);
                 if (err) {
                         dev_err(&client->dev,
                                 "unable to request IRQ!\n");
                         goto exit_irq;
                 }
+
+                device_set_wakeup_capable(&client->dev, 1);
                 set_bit(HAS_ALARM, &ds1307->flags);
                 dev_dbg(&client->dev, "got IRQ %d\n", client->irq);
         }
@@ -896,8 +900,7 @@ read_rtc:
         return 0;
 
 exit_irq:
-        if (ds1307->rtc)
-                rtc_device_unregister(ds1307->rtc);
+        rtc_device_unregister(ds1307->rtc);
 exit_free:
         kfree(ds1307);
         return err;
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 32b27739ec2a..47fb6357c346 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -24,6 +24,7 @@
 #include <linux/rtc.h>
 #include <linux/bcd.h>
 #include <linux/workqueue.h>
+#include <linux/slab.h>
 
 #define DS1374_REG_TOD0         0x00 /* Time of Day */
 #define DS1374_REG_TOD1         0x01
@@ -283,7 +284,7 @@ static void ds1374_work(struct work_struct *work)
 
         stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
         if (stat < 0)
-                return;
+                goto unlock;
 
         if (stat & DS1374_REG_SR_AF) {
                 stat &= ~DS1374_REG_SR_AF;
@@ -302,7 +303,7 @@ static void ds1374_work(struct work_struct *work)
 out:
         if (!ds1374->exiting)
                 enable_irq(client->irq);
-
+unlock:
         mutex_unlock(&ds1374->mutex);
 }
 
@@ -383,6 +384,8 @@ static int ds1374_probe(struct i2c_client *client,
                         dev_err(&client->dev, "unable to request IRQ\n");
                         goto out_free;
                 }
+
+                device_set_wakeup_capable(&client->dev, 1);
         }
 
         ds1374->rtc = rtc_device_register(client->name, &client->dev,
@@ -400,7 +403,6 @@ out_irq:
                 free_irq(client->irq, client);
 
 out_free:
-        i2c_set_clientdata(client, NULL);
         kfree(ds1374);
         return ret;
 }
@@ -415,11 +417,10 @@ 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);
-        i2c_set_clientdata(client, NULL);
         kfree(ds1374);
         return 0;
 }
diff --git a/drivers/rtc/rtc-ds1390.c b/drivers/rtc/rtc-ds1390.c
index e01b955db077..26a86d235051 100644
--- a/drivers/rtc/rtc-ds1390.c
+++ b/drivers/rtc/rtc-ds1390.c
@@ -19,6 +19,7 @@
 #include <linux/rtc.h>
 #include <linux/spi/spi.h>
 #include <linux/bcd.h>
+#include <linux/slab.h>
 
 #define DS1390_REG_100THS               0x00
 #define DS1390_REG_SECONDS              0x01
@@ -189,3 +190,4 @@ module_exit(ds1390_exit);
 MODULE_DESCRIPTION("Dallas/Maxim DS1390/93/94 SPI RTC driver");
 MODULE_AUTHOR("Mark Jackson <mpfj@mimc.co.uk>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:rtc-ds1390");
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 0b6b7730c716..37268e97de49 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -2,7 +2,7 @@
  * An rtc driver for the Dallas DS1511
  *
  * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
- * Copyright (C) 2007 Andrew Sharp <andy.sharp@onstor.com>
+ * Copyright (C) 2007 Andrew Sharp <andy.sharp@lsi.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -17,6 +17,7 @@
 #include <linux/bcd.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/rtc.h>
@@ -87,7 +88,6 @@ enum ds1511reg {
 struct rtc_plat_data {
         struct rtc_device *rtc;
         void __iomem *ioaddr;           /* virtual base address */
-        unsigned long baseaddr;         /* physical base address */
         int size;                               /* amount of memory mapped */
         int irq;
         unsigned int irqen;
@@ -95,6 +95,7 @@ struct rtc_plat_data {
         int alrm_min;
         int alrm_hour;
         int alrm_mday;
+        spinlock_t lock;
 };
 
 static DEFINE_SPINLOCK(ds1511_lock);
@@ -302,7 +303,7 @@ ds1511_rtc_update_alarm(struct rtc_plat_data *pdata)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
+        spin_lock_irqsave(&pdata->lock, flags);
         rtc_write(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
                0x80 : bin2bcd(pdata->alrm_mday) & 0x3f,
                RTC_ALARM_DATE);
@@ -317,7 +318,7 @@ ds1511_rtc_update_alarm(struct rtc_plat_data *pdata)
                RTC_ALARM_SEC);
         rtc_write(rtc_read(RTC_CMD) | (pdata->irqen ? RTC_TIE : 0), RTC_CMD);
         rtc_read(RTC_CMD1);     /* clear interrupts */
-        spin_unlock_irqrestore(&pdata->rtc->irq_lock, flags);
+        spin_unlock_irqrestore(&pdata->lock, flags);
 }
 
  static int
@@ -362,66 +363,69 @@ ds1511_interrupt(int irq, void *dev_id)
 {
         struct platform_device *pdev = dev_id;
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        unsigned long events = RTC_IRQF;
+        unsigned long events = 0;
 
+        spin_lock(&pdata->lock);
         /*
          * read and clear interrupt
          */
-        if (!(rtc_read(RTC_CMD1) & DS1511_IRQF)) {
-                return IRQ_NONE;
-        }
-        if (rtc_read(RTC_ALARM_SEC) & 0x80) {
-                events |= RTC_UF;
-        } else {
-                events |= RTC_AF;
-        }
-        rtc_update_irq(pdata->rtc, 1, events);
-        return IRQ_HANDLED;
+        if (rtc_read(RTC_CMD1) & DS1511_IRQF) {
+                events = RTC_IRQF;
+                if (rtc_read(RTC_ALARM_SEC) & 0x80)
+                        events |= RTC_UF;
+                else
+                        events |= RTC_AF;
+                if (likely(pdata->rtc))
+                        rtc_update_irq(pdata->rtc, 1, events);
+        }
+        spin_unlock(&pdata->lock);
+        return events ? IRQ_HANDLED : IRQ_NONE;
 }
 
- static int
-ds1511_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int ds1511_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);
 
-        if (pdata->irq <= 0) {
-                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
-        }
-        switch (cmd) {
-        case RTC_AIE_OFF:
-                pdata->irqen &= ~RTC_AF;
-                ds1511_rtc_update_alarm(pdata);
-                break;
-        case RTC_AIE_ON:
+        if (pdata->irq <= 0)
+                return -EINVAL;
+        if (enabled)
                 pdata->irqen |= RTC_AF;
-                ds1511_rtc_update_alarm(pdata);
-                break;
-        case RTC_UIE_OFF:
-                pdata->irqen &= ~RTC_UF;
-                ds1511_rtc_update_alarm(pdata);
-                break;
-        case RTC_UIE_ON:
+        else
+                pdata->irqen &= ~RTC_AF;
+        ds1511_rtc_update_alarm(pdata);
+        return 0;
+}
+
+static int ds1511_rtc_update_irq_enable(struct device *dev,
+        unsigned int enabled)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq <= 0)
+                return -EINVAL;
+        if (enabled)
                 pdata->irqen |= RTC_UF;
-                ds1511_rtc_update_alarm(pdata);
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
+        else
+                pdata->irqen &= ~RTC_UF;
+        ds1511_rtc_update_alarm(pdata);
         return 0;
 }
 
 static const struct rtc_class_ops ds1511_rtc_ops = {
-        .read_time      = ds1511_rtc_read_time,
-        .set_time       = ds1511_rtc_set_time,
-        .read_alarm     = ds1511_rtc_read_alarm,
-        .set_alarm      = ds1511_rtc_set_alarm,
-        .ioctl          = ds1511_rtc_ioctl,
+        .read_time              = ds1511_rtc_read_time,
+        .set_time               = ds1511_rtc_set_time,
+        .read_alarm             = ds1511_rtc_read_alarm,
+        .set_alarm              = ds1511_rtc_set_alarm,
+        .alarm_irq_enable       = ds1511_rtc_alarm_irq_enable,
+        .update_irq_enable      = ds1511_rtc_update_irq_enable,
 };
 
  static ssize_t
-ds1511_nvram_read(struct kobject *kobj, struct bin_attribute *ba,
-                                char *buf, loff_t pos, size_t size)
+ds1511_nvram_read(struct file *filp, struct kobject *kobj,
+                  struct bin_attribute *ba,
+                  char *buf, loff_t pos, size_t size)
 {
         ssize_t count;
 
@@ -449,8 +453,9 @@ ds1511_nvram_read(struct kobject *kobj, struct bin_attribute *ba,
 }
 
  static ssize_t
-ds1511_nvram_write(struct kobject *kobj, struct bin_attribute *bin_attr,
-                                char *buf, loff_t pos, size_t size)
+ds1511_nvram_write(struct file *filp, struct kobject *kobj,
+                   struct bin_attribute *bin_attr,
+                   char *buf, loff_t pos, size_t size)
 {
         ssize_t count;
 
@@ -492,29 +497,23 @@ ds1511_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         struct resource *res;
-        struct rtc_plat_data *pdata = NULL;
+        struct rtc_plat_data *pdata;
         int ret = 0;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 return -ENODEV;
         }
-        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
-        if (!pdata) {
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
                 return -ENOMEM;
-        }
         pdata->size = res->end - res->start + 1;
-        if (!request_mem_region(res->start, pdata->size, pdev->name)) {
-                ret = -EBUSY;
-                goto out;
-        }
-        pdata->baseaddr = res->start;
-        pdata->size = pdata->size;
-        ds1511_base = ioremap(pdata->baseaddr, pdata->size);
-        if (!ds1511_base) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        if (!devm_request_mem_region(&pdev->dev, res->start, pdata->size,
+                        pdev->name))
+                return -EBUSY;
+        ds1511_base = devm_ioremap(&pdev->dev, res->start, pdata->size);
+        if (!ds1511_base)
+                return -ENOMEM;
         pdata->ioaddr = ds1511_base;
         pdata->irq = platform_get_irq(pdev, 0);
 
@@ -540,13 +539,15 @@ ds1511_rtc_probe(struct platform_device *pdev)
                 dev_warn(&pdev->dev, "voltage-low detected.\n");
         }
 
+        spin_lock_init(&pdata->lock);
+        platform_set_drvdata(pdev, pdata);
         /*
          * if the platform has an interrupt in mind for this device,
          * then by all means, set it
          */
         if (pdata->irq > 0) {
                 rtc_read(RTC_CMD1);
-                if (request_irq(pdata->irq, ds1511_interrupt,
+                if (devm_request_irq(&pdev->dev, pdata->irq, ds1511_interrupt,
                         IRQF_DISABLED | IRQF_SHARED, pdev->name, pdev) < 0) {
 
                         dev_warn(&pdev->dev, "interrupt not available.\n");
@@ -556,33 +557,13 @@ ds1511_rtc_probe(struct platform_device *pdev)
 
         rtc = rtc_device_register(pdev->name, &pdev->dev, &ds1511_rtc_ops,
                 THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                goto out;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
         pdata->rtc = rtc;
-        platform_set_drvdata(pdev, pdata);
+
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1511_nvram_attr);
-        if (ret) {
-                goto out;
-        }
-        return 0;
- out:
-        if (pdata->rtc) {
+        if (ret)
                 rtc_device_unregister(pdata->rtc);
-        }
-        if (pdata->irq > 0) {
-                free_irq(pdata->irq, pdev);
-        }
-        if (ds1511_base) {
-                iounmap(ds1511_base);
-                ds1511_base = NULL;
-        }
-        if (pdata->baseaddr) {
-                release_mem_region(pdata->baseaddr, pdata->size);
-        }
-
-        kfree(pdata);
         return ret;
 }
 
@@ -593,19 +574,13 @@ ds1511_rtc_remove(struct platform_device *pdev)
 
         sysfs_remove_bin_file(&pdev->dev.kobj, &ds1511_nvram_attr);
         rtc_device_unregister(pdata->rtc);
-        pdata->rtc = NULL;
         if (pdata->irq > 0) {
                 /*
                  * disable the alarm interrupt
                  */
                 rtc_write(rtc_read(RTC_CMD) & ~RTC_TIE, RTC_CMD);
                 rtc_read(RTC_CMD1);
-                free_irq(pdata->irq, pdev);
         }
-        iounmap(pdata->ioaddr);
-        ds1511_base = NULL;
-        release_mem_region(pdata->baseaddr, pdata->size);
-        kfree(pdata);
         return 0;
 }
 
@@ -636,7 +611,7 @@ ds1511_rtc_exit(void)
 module_init(ds1511_rtc_init);
 module_exit(ds1511_rtc_exit);
 
-MODULE_AUTHOR("Andrew Sharp <andy.sharp@onstor.com>");
+MODULE_AUTHOR("Andrew Sharp <andy.sharp@lsi.com>");
 MODULE_DESCRIPTION("Dallas DS1511 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index 717288527c6b..ff432e2ca275 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -11,6 +11,7 @@
 #include <linux/bcd.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/delay.h>
 #include <linux/jiffies.h>
 #include <linux/interrupt.h>
@@ -18,7 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#define DRV_VERSION "0.2"
+#define DRV_VERSION "0.3"
 
 #define RTC_REG_SIZE            0x2000
 #define RTC_OFFSET              0x1ff0
@@ -61,7 +62,6 @@
 struct rtc_plat_data {
         struct rtc_device *rtc;
         void __iomem *ioaddr;
-        resource_size_t baseaddr;
         unsigned long last_jiffies;
         int irq;
         unsigned int irqen;
@@ -69,6 +69,7 @@ struct rtc_plat_data {
         int alrm_min;
         int alrm_hour;
         int alrm_mday;
+        spinlock_t lock;
 };
 
 static int ds1553_rtc_set_time(struct device *dev, struct rtc_time *tm)
@@ -139,7 +140,7 @@ static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata)
         void __iomem *ioaddr = pdata->ioaddr;
         unsigned long flags;
 
-        spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
+        spin_lock_irqsave(&pdata->lock, flags);
         writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
                0x80 : bin2bcd(pdata->alrm_mday),
                ioaddr + RTC_DATE_ALARM);
@@ -154,7 +155,7 @@ static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata)
                ioaddr + RTC_SECONDS_ALARM);
         writeb(pdata->irqen ? RTC_INTS_AE : 0, ioaddr + RTC_INTERRUPTS);
         readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
-        spin_unlock_irqrestore(&pdata->rtc->irq_lock, flags);
+        spin_unlock_irqrestore(&pdata->lock, flags);
 }
 
 static int ds1553_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
@@ -194,64 +195,69 @@ static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id)
         struct platform_device *pdev = dev_id;
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
-        unsigned long events = RTC_IRQF;
+        unsigned long events = 0;
 
+        spin_lock(&pdata->lock);
         /* read and clear interrupt */
-        if (!(readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF))
-                return IRQ_NONE;
-        if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
-                events |= RTC_UF;
-        else
-                events |= RTC_AF;
-        rtc_update_irq(pdata->rtc, 1, events);
-        return IRQ_HANDLED;
+        if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF) {
+                events = RTC_IRQF;
+                if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
+                        events |= RTC_UF;
+                else
+                        events |= RTC_AF;
+                if (likely(pdata->rtc))
+                        rtc_update_irq(pdata->rtc, 1, events);
+        }
+        spin_unlock(&pdata->lock);
+        return events ? IRQ_HANDLED : IRQ_NONE;
 }
 
-static int ds1553_rtc_ioctl(struct device *dev, unsigned int cmd,
-                            unsigned long arg)
+static int ds1553_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);
 
         if (pdata->irq <= 0)
-                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
-        switch (cmd) {
-        case RTC_AIE_OFF:
-                pdata->irqen &= ~RTC_AF;
-                ds1553_rtc_update_alarm(pdata);
-                break;
-        case RTC_AIE_ON:
+                return -EINVAL;
+        if (enabled)
                 pdata->irqen |= RTC_AF;
-                ds1553_rtc_update_alarm(pdata);
-                break;
-        case RTC_UIE_OFF:
-                pdata->irqen &= ~RTC_UF;
-                ds1553_rtc_update_alarm(pdata);
-                break;
-        case RTC_UIE_ON:
+        else
+                pdata->irqen &= ~RTC_AF;
+        ds1553_rtc_update_alarm(pdata);
+        return 0;
+}
+
+static int ds1553_rtc_update_irq_enable(struct device *dev,
+        unsigned int enabled)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq <= 0)
+                return -EINVAL;
+        if (enabled)
                 pdata->irqen |= RTC_UF;
-                ds1553_rtc_update_alarm(pdata);
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
+        else
+                pdata->irqen &= ~RTC_UF;
+        ds1553_rtc_update_alarm(pdata);
         return 0;
 }
 
 static const struct rtc_class_ops ds1553_rtc_ops = {
-        .read_time      = ds1553_rtc_read_time,
-        .set_time       = ds1553_rtc_set_time,
-        .read_alarm     = ds1553_rtc_read_alarm,
-        .set_alarm      = ds1553_rtc_set_alarm,
-        .ioctl          = ds1553_rtc_ioctl,
+        .read_time              = ds1553_rtc_read_time,
+        .set_time               = ds1553_rtc_set_time,
+        .read_alarm             = ds1553_rtc_read_alarm,
+        .set_alarm              = ds1553_rtc_set_alarm,
+        .alarm_irq_enable       = ds1553_rtc_alarm_irq_enable,
+        .update_irq_enable      = ds1553_rtc_update_irq_enable,
 };
 
-static ssize_t ds1553_nvram_read(struct kobject *kobj,
+static ssize_t ds1553_nvram_read(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *bin_attr,
                                  char *buf, loff_t pos, size_t size)
 {
-        struct platform_device *pdev =
-                to_platform_device(container_of(kobj, struct device, kobj));
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
         ssize_t count;
@@ -261,12 +267,12 @@ static ssize_t ds1553_nvram_read(struct kobject *kobj,
         return count;
 }
 
-static ssize_t ds1553_nvram_write(struct kobject *kobj,
+static ssize_t ds1553_nvram_write(struct file *filp, struct kobject *kobj,
                                   struct bin_attribute *bin_attr,
                                   char *buf, loff_t pos, size_t size)
 {
-        struct platform_device *pdev =
-                to_platform_device(container_of(kobj, struct device, kobj));
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
         ssize_t count;
@@ -291,26 +297,23 @@ static int __devinit ds1553_rtc_probe(struct platform_device *pdev)
         struct rtc_device *rtc;
         struct resource *res;
         unsigned int cen, sec;
-        struct rtc_plat_data *pdata = NULL;
-        void __iomem *ioaddr = NULL;
+        struct rtc_plat_data *pdata;
+        void __iomem *ioaddr;
         int ret = 0;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res)
                 return -ENODEV;
-        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
                 return -ENOMEM;
-        if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) {
-                ret = -EBUSY;
-                goto out;
-        }
-        pdata->baseaddr = res->start;
-        ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE);
-        if (!ioaddr) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        if (!devm_request_mem_region(&pdev->dev, res->start, RTC_REG_SIZE,
+                        pdev->name))
+                return -EBUSY;
+
+        ioaddr = devm_ioremap(&pdev->dev, res->start, RTC_REG_SIZE);
+        if (!ioaddr)
+                return -ENOMEM;
         pdata->ioaddr = ioaddr;
         pdata->irq = platform_get_irq(pdev, 0);
 
@@ -326,9 +329,13 @@ static int __devinit ds1553_rtc_probe(struct platform_device *pdev)
         if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_BLF)
                 dev_warn(&pdev->dev, "voltage-low detected.\n");
 
+        spin_lock_init(&pdata->lock);
+        pdata->last_jiffies = jiffies;
+        platform_set_drvdata(pdev, pdata);
         if (pdata->irq > 0) {
                 writeb(0, ioaddr + RTC_INTERRUPTS);
-                if (request_irq(pdata->irq, ds1553_rtc_interrupt,
+                if (devm_request_irq(&pdev->dev, pdata->irq,
+                                ds1553_rtc_interrupt,
                                 IRQF_DISABLED, pdev->name, pdev) < 0) {
                         dev_warn(&pdev->dev, "interrupt not available.\n");
                         pdata->irq = 0;
@@ -337,27 +344,13 @@ static int __devinit ds1553_rtc_probe(struct platform_device *pdev)
 
         rtc = rtc_device_register(pdev->name, &pdev->dev,
                                   &ds1553_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                goto out;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
         pdata->rtc = rtc;
-        pdata->last_jiffies = jiffies;
-        platform_set_drvdata(pdev, pdata);
+
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
         if (ret)
-                goto out;
-        return 0;
- out:
-        if (pdata->rtc)
-                rtc_device_unregister(pdata->rtc);
-        if (pdata->irq > 0)
-                free_irq(pdata->irq, pdev);
-        if (ioaddr)
-                iounmap(ioaddr);
-        if (pdata->baseaddr)
-                release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
-        kfree(pdata);
+                rtc_device_unregister(rtc);
         return ret;
 }
 
@@ -367,13 +360,8 @@ static int __devexit ds1553_rtc_remove(struct platform_device *pdev)
 
         sysfs_remove_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
         rtc_device_unregister(pdata->rtc);
-        if (pdata->irq > 0) {
+        if (pdata->irq > 0)
                 writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
-                free_irq(pdata->irq, pdev);
-        }
-        iounmap(pdata->ioaddr);
-        release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
-        kfree(pdata);
         return 0;
 }
 
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 09249459e9a4..042630c90dd3 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -15,13 +15,14 @@
 #include <linux/bcd.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/delay.h>
 #include <linux/jiffies.h>
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#define DRV_VERSION "0.3"
+#define DRV_VERSION "0.4"
 
 #define RTC_SIZE                8
 
@@ -55,7 +56,6 @@ struct rtc_plat_data {
         void __iomem *ioaddr_rtc;
         size_t size_nvram;
         size_t size;
-        resource_size_t baseaddr;
         unsigned long last_jiffies;
         struct bin_attribute nvram_attr;
 };
@@ -128,12 +128,12 @@ static const struct rtc_class_ops ds1742_rtc_ops = {
         .set_time       = ds1742_rtc_set_time,
 };
 
-static ssize_t ds1742_nvram_read(struct kobject *kobj,
+static ssize_t ds1742_nvram_read(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *bin_attr,
                                  char *buf, loff_t pos, size_t size)
 {
-        struct platform_device *pdev =
-                to_platform_device(container_of(kobj, struct device, kobj));
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr_nvram;
         ssize_t count;
@@ -143,12 +143,12 @@ static ssize_t ds1742_nvram_read(struct kobject *kobj,
         return count;
 }
 
-static ssize_t ds1742_nvram_write(struct kobject *kobj,
+static ssize_t ds1742_nvram_write(struct file *filp, struct kobject *kobj,
                                   struct bin_attribute *bin_attr,
                                   char *buf, loff_t pos, size_t size)
 {
-        struct platform_device *pdev =
-                to_platform_device(container_of(kobj, struct device, kobj));
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr_nvram;
         ssize_t count;
@@ -163,31 +163,29 @@ static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
         struct rtc_device *rtc;
         struct resource *res;
         unsigned int cen, sec;
-        struct rtc_plat_data *pdata = NULL;
-        void __iomem *ioaddr = NULL;
+        struct rtc_plat_data *pdata;
+        void __iomem *ioaddr;
         int ret = 0;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res)
                 return -ENODEV;
-        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
                 return -ENOMEM;
         pdata->size = res->end - res->start + 1;
-        if (!request_mem_region(res->start, pdata->size, pdev->name)) {
-                ret = -EBUSY;
-                goto out;
-        }
-        pdata->baseaddr = res->start;
-        ioaddr = ioremap(pdata->baseaddr, pdata->size);
-        if (!ioaddr) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        if (!devm_request_mem_region(&pdev->dev, res->start, pdata->size,
+                pdev->name))
+                return -EBUSY;
+        ioaddr = devm_ioremap(&pdev->dev, res->start, pdata->size);
+        if (!ioaddr)
+                return -ENOMEM;
+
         pdata->ioaddr_nvram = ioaddr;
         pdata->size_nvram = pdata->size - RTC_SIZE;
         pdata->ioaddr_rtc = ioaddr + pdata->size_nvram;
 
+        sysfs_bin_attr_init(&pdata->nvram_attr);
         pdata->nvram_attr.attr.name = "nvram";
         pdata->nvram_attr.attr.mode = S_IRUGO | S_IWUSR;
         pdata->nvram_attr.read = ds1742_nvram_read;
@@ -207,31 +205,19 @@ static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
         if (!(readb(ioaddr + RTC_DAY) & RTC_BATT_FLAG))
                 dev_warn(&pdev->dev, "voltage-low detected.\n");
 
+        pdata->last_jiffies = jiffies;
+        platform_set_drvdata(pdev, pdata);
         rtc = rtc_device_register(pdev->name, &pdev->dev,
                                   &ds1742_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                goto out;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
         pdata->rtc = rtc;
-        pdata->last_jiffies = jiffies;
-        platform_set_drvdata(pdev, pdata);
 
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
         if (ret) {
                 dev_err(&pdev->dev, "creating nvram file in sysfs failed\n");
-                goto out;
+                rtc_device_unregister(rtc);
         }
-
-        return 0;
- out:
-        if (pdata->rtc)
-                rtc_device_unregister(pdata->rtc);
-        if (pdata->ioaddr_nvram)
-                iounmap(pdata->ioaddr_nvram);
-        if (pdata->baseaddr)
-                release_mem_region(pdata->baseaddr, pdata->size);
-        kfree(pdata);
         return ret;
 }
 
@@ -241,9 +227,6 @@ static int __devexit ds1742_rtc_remove(struct platform_device *pdev)
 
         sysfs_remove_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
         rtc_device_unregister(pdata->rtc);
-        iounmap(pdata->ioaddr_nvram);
-        release_mem_region(pdata->baseaddr, pdata->size);
-        kfree(pdata);
         return 0;
 }
 
diff --git a/drivers/rtc/rtc-ds3232.c b/drivers/rtc/rtc-ds3232.c
new file mode 100644
index 000000000000..23a9ee19764c
--- /dev/null
+++ b/drivers/rtc/rtc-ds3232.c
@@ -0,0 +1,505 @@
+/*
+ * 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
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+/*
+ * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
+ * recommened in .../Documentation/i2c/writing-clients section
+ * "Sending and receiving", using SMBus level communication is preferred.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/workqueue.h>
+#include <linux/slab.h>
+
+#define DS3232_REG_SECONDS      0x00
+#define DS3232_REG_MINUTES      0x01
+#define DS3232_REG_HOURS        0x02
+#define DS3232_REG_AMPM         0x02
+#define DS3232_REG_DAY          0x03
+#define DS3232_REG_DATE         0x04
+#define DS3232_REG_MONTH        0x05
+#define DS3232_REG_CENTURY      0x05
+#define DS3232_REG_YEAR         0x06
+#define DS3232_REG_ALARM1         0x07  /* Alarm 1 BASE */
+#define DS3232_REG_ALARM2         0x0B  /* Alarm 2 BASE */
+#define DS3232_REG_CR           0x0E    /* Control register */
+#       define DS3232_REG_CR_nEOSC        0x80
+#       define DS3232_REG_CR_INTCN        0x04
+#       define DS3232_REG_CR_A2IE        0x02
+#       define DS3232_REG_CR_A1IE        0x01
+
+#define DS3232_REG_SR   0x0F    /* control/status register */
+#       define DS3232_REG_SR_OSF   0x80
+#       define DS3232_REG_SR_BSY   0x04
+#       define DS3232_REG_SR_A2F   0x02
+#       define DS3232_REG_SR_A1F   0x01
+
+struct ds3232 {
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+        struct work_struct work;
+
+        /* The mutex protects alarm operations, and prevents a race
+         * between the enable_irq() in the workqueue and the free_irq()
+         * in the remove function.
+         */
+        struct mutex mutex;
+        int exiting;
+};
+
+static struct i2c_driver ds3232_driver;
+
+static int ds3232_check_rtc_status(struct i2c_client *client)
+{
+        int ret = 0;
+        int control, stat;
+
+        stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
+        if (stat < 0)
+                return stat;
+
+        if (stat & DS3232_REG_SR_OSF)
+                dev_warn(&client->dev,
+                                "oscillator discontinuity flagged, "
+                                "time unreliable\n");
+
+        stat &= ~(DS3232_REG_SR_OSF | DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
+
+        ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
+        if (ret < 0)
+                return ret;
+
+        /* If the alarm is pending, clear it before requesting
+         * the interrupt, so an interrupt event isn't reported
+         * before everything is initialized.
+         */
+
+        control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
+        if (control < 0)
+                return control;
+
+        control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
+        control |= DS3232_REG_CR_INTCN;
+
+        return i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
+}
+
+static int ds3232_read_time(struct device *dev, struct rtc_time *time)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int ret;
+        u8 buf[7];
+        unsigned int year, month, day, hour, minute, second;
+        unsigned int week, twelve_hr, am_pm;
+        unsigned int century, add_century = 0;
+
+        ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_SECONDS, 7, buf);
+
+        if (ret < 0)
+                return ret;
+        if (ret < 7)
+                return -EIO;
+
+        second = buf[0];
+        minute = buf[1];
+        hour = buf[2];
+        week = buf[3];
+        day = buf[4];
+        month = buf[5];
+        year = buf[6];
+
+        /* Extract additional information for AM/PM and century */
+
+        twelve_hr = hour & 0x40;
+        am_pm = hour & 0x20;
+        century = month & 0x80;
+
+        /* Write to rtc_time structure */
+
+        time->tm_sec = bcd2bin(second);
+        time->tm_min = bcd2bin(minute);
+        if (twelve_hr) {
+                /* Convert to 24 hr */
+                if (am_pm)
+                        time->tm_hour = bcd2bin(hour & 0x1F) + 12;
+                else
+                        time->tm_hour = bcd2bin(hour & 0x1F);
+        } else {
+                time->tm_hour = bcd2bin(hour);
+        }
+
+        time->tm_wday = bcd2bin(week);
+        time->tm_mday = bcd2bin(day);
+        time->tm_mon = bcd2bin(month & 0x7F);
+        if (century)
+                add_century = 100;
+
+        time->tm_year = bcd2bin(year) + add_century;
+
+        return rtc_valid_tm(time);
+}
+
+static int ds3232_set_time(struct device *dev, struct rtc_time *time)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        u8 buf[7];
+
+        /* Extract time from rtc_time and load into ds3232*/
+
+        buf[0] = bin2bcd(time->tm_sec);
+        buf[1] = bin2bcd(time->tm_min);
+        buf[2] = bin2bcd(time->tm_hour);
+        buf[3] = bin2bcd(time->tm_wday); /* Day of the week */
+        buf[4] = bin2bcd(time->tm_mday); /* Date */
+        buf[5] = bin2bcd(time->tm_mon);
+        if (time->tm_year >= 100) {
+                buf[5] |= 0x80;
+                buf[6] = bin2bcd(time->tm_year - 100);
+        } else {
+                buf[6] = bin2bcd(time->tm_year);
+        }
+
+        return i2c_smbus_write_i2c_block_data(client,
+                                              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;
+        struct ds3232 *ds3232 = i2c_get_clientdata(client);
+
+        disable_irq_nosync(irq);
+        schedule_work(&ds3232->work);
+        return IRQ_HANDLED;
+}
+
+static void ds3232_work(struct work_struct *work)
+{
+        struct ds3232 *ds3232 = container_of(work, struct ds3232, work);
+        struct i2c_client *client = ds3232->client;
+        int stat, control;
+
+        mutex_lock(&ds3232->mutex);
+
+        stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
+        if (stat < 0)
+                goto unlock;
+
+        if (stat & DS3232_REG_SR_A1F) {
+                control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
+                if (control < 0)
+                        goto out;
+                /* disable alarm1 interrupt */
+                control &= ~(DS3232_REG_CR_A1IE);
+                i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
+
+                /* clear the alarm pend flag */
+                stat &= ~DS3232_REG_SR_A1F;
+                i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
+
+                rtc_update_irq(ds3232->rtc, 1, RTC_AF | RTC_IRQF);
+        }
+
+out:
+        if (!ds3232->exiting)
+                enable_irq(client->irq);
+unlock:
+        mutex_unlock(&ds3232->mutex);
+}
+
+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,
+                const struct i2c_device_id *id)
+{
+        struct ds3232 *ds3232;
+        int ret;
+
+        ds3232 = kzalloc(sizeof(struct ds3232), GFP_KERNEL);
+        if (!ds3232)
+                return -ENOMEM;
+
+        ds3232->client = client;
+        i2c_set_clientdata(client, ds3232);
+
+        INIT_WORK(&ds3232->work, ds3232_work);
+        mutex_init(&ds3232->mutex);
+
+        ret = ds3232_check_rtc_status(client);
+        if (ret)
+                goto out_free;
+
+        ds3232->rtc = rtc_device_register(client->name, &client->dev,
+                                          &ds3232_rtc_ops, THIS_MODULE);
+        if (IS_ERR(ds3232->rtc)) {
+                ret = PTR_ERR(ds3232->rtc);
+                dev_err(&client->dev, "unable to register the class device\n");
+                goto out_irq;
+        }
+
+        if (client->irq >= 0) {
+                ret = request_irq(client->irq, ds3232_irq, 0,
+                                 "ds3232", client);
+                if (ret) {
+                        dev_err(&client->dev, "unable to request IRQ\n");
+                        goto out_free;
+                }
+        }
+
+        return 0;
+
+out_irq:
+        if (client->irq >= 0)
+                free_irq(client->irq, client);
+
+out_free:
+        kfree(ds3232);
+        return ret;
+}
+
+static int __devexit ds3232_remove(struct i2c_client *client)
+{
+        struct ds3232 *ds3232 = i2c_get_clientdata(client);
+
+        if (client->irq >= 0) {
+                mutex_lock(&ds3232->mutex);
+                ds3232->exiting = 1;
+                mutex_unlock(&ds3232->mutex);
+
+                free_irq(client->irq, client);
+                cancel_work_sync(&ds3232->work);
+        }
+
+        rtc_device_unregister(ds3232->rtc);
+        kfree(ds3232);
+        return 0;
+}
+
+static const struct i2c_device_id ds3232_id[] = {
+        { "ds3232", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ds3232_id);
+
+static struct i2c_driver ds3232_driver = {
+        .driver = {
+                .name = "rtc-ds3232",
+                .owner = THIS_MODULE,
+        },
+        .probe = ds3232_probe,
+        .remove = __devexit_p(ds3232_remove),
+        .id_table = ds3232_id,
+};
+
+static int __init ds3232_init(void)
+{
+        return i2c_add_driver(&ds3232_driver);
+}
+
+static void __exit ds3232_exit(void)
+{
+        i2c_del_driver(&ds3232_driver);
+}
+
+module_init(ds3232_init);
+module_exit(ds3232_exit);
+
+MODULE_AUTHOR("Srikanth Srinivasan <srikanth.srinivasan@freescale.com>");
+MODULE_DESCRIPTION("Maxim/Dallas DS3232 RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds3234.c b/drivers/rtc/rtc-ds3234.c
index c51589ede5b7..a774ca35b5f7 100644
--- a/drivers/rtc/rtc-ds3234.c
+++ b/drivers/rtc/rtc-ds3234.c
@@ -188,3 +188,4 @@ module_exit(ds3234_exit);
 MODULE_DESCRIPTION("DS3234 SPI RTC driver");
 MODULE_AUTHOR("Dennis Aberilla <denzzzhome@yahoo.com>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:ds3234");
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 551332e4ed02..11ae64dcbf3c 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -13,6 +13,7 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/gfp.h>
 
 #define EP93XX_RTC_DATA                 0x000
 #define EP93XX_RTC_MATCH                0x004
@@ -115,6 +116,15 @@ static ssize_t ep93xx_rtc_show_comp_delete(struct device *dev,
 }
 static DEVICE_ATTR(comp_delete, S_IRUGO, ep93xx_rtc_show_comp_delete, NULL);
 
+static struct attribute *ep93xx_rtc_attrs[] = {
+        &dev_attr_comp_preload.attr,
+        &dev_attr_comp_delete.attr,
+        NULL
+};
+
+static const struct attribute_group ep93xx_rtc_sysfs_files = {
+        .attrs  = ep93xx_rtc_attrs,
+};
 
 static int __init ep93xx_rtc_probe(struct platform_device *pdev)
 {
@@ -123,23 +133,22 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
         struct rtc_device *rtc;
         int err;
 
-        ep93xx_rtc = kzalloc(sizeof(struct ep93xx_rtc), GFP_KERNEL);
-        if (ep93xx_rtc == NULL)
+        ep93xx_rtc = devm_kzalloc(&pdev->dev, sizeof(*ep93xx_rtc), GFP_KERNEL);
+        if (!ep93xx_rtc)
                 return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL)
+        if (!res)
                 return -ENXIO;
 
-        res = request_mem_region(res->start, resource_size(res), pdev->name);
-        if (res == NULL)
+        if (!devm_request_mem_region(&pdev->dev, res->start,
+                                     resource_size(res), pdev->name))
                 return -EBUSY;
 
-        ep93xx_rtc->mmio_base = ioremap(res->start, resource_size(res));
-        if (ep93xx_rtc->mmio_base == NULL) {
-                err = -ENXIO;
-                goto fail;
-        }
+        ep93xx_rtc->mmio_base = devm_ioremap(&pdev->dev, res->start,
+                                             resource_size(res));
+        if (!ep93xx_rtc->mmio_base)
+                return -ENXIO;
 
         pdev->dev.platform_data = ep93xx_rtc;
 
@@ -147,51 +156,34 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
                                 &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
                 err = PTR_ERR(rtc);
-                goto fail;
+                goto exit;
         }
 
         platform_set_drvdata(pdev, rtc);
 
-        err = device_create_file(&pdev->dev, &dev_attr_comp_preload);
+        err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
         if (err)
                 goto fail;
-        err = device_create_file(&pdev->dev, &dev_attr_comp_delete);
-        if (err) {
-                device_remove_file(&pdev->dev, &dev_attr_comp_preload);
-                goto fail;
-        }
 
         return 0;
 
 fail:
-        if (ep93xx_rtc->mmio_base) {
-                iounmap(ep93xx_rtc->mmio_base);
-                pdev->dev.platform_data = NULL;
-        }
-        release_mem_region(res->start, resource_size(res));
+        platform_set_drvdata(pdev, NULL);
+        rtc_device_unregister(rtc);
+exit:
+        pdev->dev.platform_data = NULL;
         return err;
 }
 
 static int __exit ep93xx_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device *rtc = platform_get_drvdata(pdev);
-        struct ep93xx_rtc *ep93xx_rtc = pdev->dev.platform_data;
-        struct resource *res;
-
-        /* cleanup sysfs */
-        device_remove_file(&pdev->dev, &dev_attr_comp_delete);
-        device_remove_file(&pdev->dev, &dev_attr_comp_preload);
 
+        sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
+        platform_set_drvdata(pdev, NULL);
         rtc_device_unregister(rtc);
-
-        iounmap(ep93xx_rtc->mmio_base);
         pdev->dev.platform_data = NULL;
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, resource_size(res));
-
-        platform_set_drvdata(pdev, NULL);
-
         return 0;
 }
 
diff --git a/drivers/rtc/rtc-fm3130.c b/drivers/rtc/rtc-fm3130.c
index 3a7be11cc6b9..4cf2e70c5078 100644
--- a/drivers/rtc/rtc-fm3130.c
+++ b/drivers/rtc/rtc-fm3130.c
@@ -13,6 +13,7 @@
 #include <linux/i2c.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
+#include <linux/slab.h>
 
 #define FM3130_RTC_CONTROL      (0x0)
 #define FM3130_CAL_CONTROL      (0x1)
@@ -51,8 +52,8 @@ struct fm3130 {
         struct i2c_msg          msg[4];
         struct i2c_client       *client;
         struct rtc_device       *rtc;
+        int                     alarm_valid;
         int                     data_valid;
-        int                     alarm;
 };
 static const struct i2c_device_id fm3130_id[] = {
         { "fm3130", 0 },
@@ -86,11 +87,7 @@ static void fm3130_rtc_mode(struct device *dev, int mode)
                 dev_dbg(dev, "invalid mode %d\n", mode);
                 break;
         }
-        /* Checking for alarm */
-        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AF) {
-                fm3130->alarm = 1;
-                fm3130->regs[FM3130_RTC_CONTROL] &= ~FM3130_RTC_CONTROL_BIT_AF;
-        }
+
         i2c_smbus_write_byte_data(fm3130->client,
                  FM3130_RTC_CONTROL, fm3130->regs[FM3130_RTC_CONTROL]);
 }
@@ -103,7 +100,7 @@ static int fm3130_get_time(struct device *dev, struct rtc_time *t)
         if (!fm3130->data_valid) {
                 /* We have invalid data in RTC, probably due
                 to battery faults or other problems. Return EIO
-                for now, it will allow us to set data later insted
+                for now, it will allow us to set data later instead
                 of error during probing which disables device */
                 return -EIO;
         }
@@ -207,6 +204,17 @@ static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         struct fm3130 *fm3130 = dev_get_drvdata(dev);
         int tmp;
         struct rtc_time *tm = &alrm->time;
+
+        if (!fm3130->alarm_valid) {
+                /*
+                 * We have invalid alarm in RTC, probably due to battery faults
+                 * or other problems. Return EIO for now, it will allow us to
+                 * set alarm value later instead of error during probing which
+                 * disables device
+                 */
+                return -EIO;
+        }
+
         /* read the RTC alarm registers all at once */
         tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
                         &fm3130->msg[2], 2);
@@ -221,20 +229,31 @@ static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
                         fm3130->regs[FM3130_ALARM_DATE],
                         fm3130->regs[FM3130_ALARM_MONTHS]);
 
-
         tm->tm_sec      = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
         tm->tm_min      = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
         tm->tm_hour     = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
         tm->tm_mday     = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
         tm->tm_mon      = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
+
         if (tm->tm_mon > 0)
                 tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
+
         dev_dbg(dev, "%s secs=%d, mins=%d, "
                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
                 "read alarm", tm->tm_sec, tm->tm_min,
                 tm->tm_hour, tm->tm_mday,
                 tm->tm_mon, tm->tm_year, tm->tm_wday);
 
+        /* check if alarm enabled */
+        fm3130->regs[FM3130_RTC_CONTROL] =
+                i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
+
+        if ((fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AEN) &&
+                (~fm3130->regs[FM3130_RTC_CONTROL] &
+                        FM3130_RTC_CONTROL_BIT_CAL)) {
+                alrm->enabled = 1;
+        }
+
         return 0;
 }
 
@@ -250,25 +269,20 @@ static int fm3130_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
                 tm->tm_hour, tm->tm_mday,
                 tm->tm_mon, tm->tm_year, tm->tm_wday);
 
-        if (tm->tm_sec != -1)
-                fm3130->regs[FM3130_ALARM_SECONDS] =
-                        bin2bcd(tm->tm_sec) | 0x80;
+        fm3130->regs[FM3130_ALARM_SECONDS] =
+                (tm->tm_sec != -1) ? bin2bcd(tm->tm_sec) : 0x80;
 
-        if (tm->tm_min != -1)
-                fm3130->regs[FM3130_ALARM_MINUTES] =
-                        bin2bcd(tm->tm_min) | 0x80;
+        fm3130->regs[FM3130_ALARM_MINUTES] =
+                (tm->tm_min != -1) ? bin2bcd(tm->tm_min) : 0x80;
 
-        if (tm->tm_hour != -1)
-                fm3130->regs[FM3130_ALARM_HOURS] =
-                        bin2bcd(tm->tm_hour) | 0x80;
+        fm3130->regs[FM3130_ALARM_HOURS] =
+                (tm->tm_hour != -1) ? bin2bcd(tm->tm_hour) : 0x80;
 
-        if (tm->tm_mday != -1)
-                fm3130->regs[FM3130_ALARM_DATE] =
-                        bin2bcd(tm->tm_mday) | 0x80;
+        fm3130->regs[FM3130_ALARM_DATE] =
+                (tm->tm_mday != -1) ? bin2bcd(tm->tm_mday) : 0x80;
 
-        if (tm->tm_mon != -1)
-                fm3130->regs[FM3130_ALARM_MONTHS] =
-                        bin2bcd(tm->tm_mon + 1) | 0x80;
+        fm3130->regs[FM3130_ALARM_MONTHS] =
+                (tm->tm_mon != -1) ? bin2bcd(tm->tm_mon + 1) : 0x80;
 
         dev_dbg(dev, "alarm write %02x %02x %02x %02x %02x\n",
                         fm3130->regs[FM3130_ALARM_SECONDS],
@@ -284,11 +298,8 @@ static int fm3130_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         }
         fm3130->regs[FM3130_RTC_CONTROL] =
                 i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
-        /* Checking for alarm */
-        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AF) {
-                fm3130->alarm = 1;
-                fm3130->regs[FM3130_RTC_CONTROL] &= ~FM3130_RTC_CONTROL_BIT_AF;
-        }
+
+        /* enable or disable alarm */
         if (alrm->enabled) {
                 i2c_smbus_write_byte_data(fm3130->client, FM3130_RTC_CONTROL,
                         (fm3130->regs[FM3130_RTC_CONTROL] &
@@ -297,16 +308,55 @@ static int fm3130_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         } else {
                 i2c_smbus_write_byte_data(fm3130->client, FM3130_RTC_CONTROL,
                         fm3130->regs[FM3130_RTC_CONTROL] &
-                                ~(FM3130_RTC_CONTROL_BIT_AEN));
+                                ~(FM3130_RTC_CONTROL_BIT_CAL) &
+                                        ~(FM3130_RTC_CONTROL_BIT_AEN));
         }
+
+        /* We assume here that data is valid once written */
+        if (!fm3130->alarm_valid)
+                fm3130->alarm_valid = 1;
+
         return 0;
 }
 
+static int fm3130_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct fm3130 *fm3130 = dev_get_drvdata(dev);
+        int ret = 0;
+
+        fm3130->regs[FM3130_RTC_CONTROL] =
+                i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
+
+        dev_dbg(dev, "alarm_irq_enable: enable=%d, FM3130_RTC_CONTROL=%02x\n",
+                enabled, fm3130->regs[FM3130_RTC_CONTROL]);
+
+        switch (enabled) {
+        case 0:         /* alarm off */
+                ret = i2c_smbus_write_byte_data(fm3130->client,
+                        FM3130_RTC_CONTROL, fm3130->regs[FM3130_RTC_CONTROL] &
+                                ~(FM3130_RTC_CONTROL_BIT_CAL) &
+                                        ~(FM3130_RTC_CONTROL_BIT_AEN));
+                break;
+        case 1:         /* alarm on */
+                ret = i2c_smbus_write_byte_data(fm3130->client,
+                        FM3130_RTC_CONTROL, (fm3130->regs[FM3130_RTC_CONTROL] &
+                                ~(FM3130_RTC_CONTROL_BIT_CAL)) |
+                                        FM3130_RTC_CONTROL_BIT_AEN);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
 static const struct rtc_class_ops fm3130_rtc_ops = {
         .read_time      = fm3130_get_time,
         .set_time       = fm3130_set_time,
         .read_alarm     = fm3130_read_alarm,
         .set_alarm      = fm3130_set_alarm,
+        .alarm_irq_enable = fm3130_alarm_irq_enable,
 };
 
 static struct i2c_driver fm3130_driver;
@@ -355,6 +405,7 @@ static int __devinit fm3130_probe(struct i2c_client *client,
         fm3130->msg[3].len = FM3130_ALARM_REGS;
         fm3130->msg[3].buf = &fm3130->regs[FM3130_ALARM_SECONDS];
 
+        fm3130->alarm_valid = 0;
         fm3130->data_valid = 0;
 
         tmp = i2c_transfer(adapter, fm3130->msg, 4);
@@ -369,27 +420,23 @@ static int __devinit fm3130_probe(struct i2c_client *client,
         fm3130->regs[FM3130_CAL_CONTROL] =
                 i2c_smbus_read_byte_data(client, FM3130_CAL_CONTROL);
 
-        /* Checking for alarm */
-        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AF) {
-                fm3130->alarm = 1;
-                fm3130->regs[FM3130_RTC_CONTROL] &= ~FM3130_RTC_CONTROL_BIT_AF;
-        }
-
         /* Disabling calibration mode */
-        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_CAL)
+        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_CAL) {
                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
                         fm3130->regs[FM3130_RTC_CONTROL] &
                                 ~(FM3130_RTC_CONTROL_BIT_CAL));
                 dev_warn(&client->dev, "Disabling calibration mode!\n");
+        }
 
         /* Disabling read and write modes */
         if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_WRITE ||
-            fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_READ)
+            fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_READ) {
                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
                         fm3130->regs[FM3130_RTC_CONTROL] &
                                 ~(FM3130_RTC_CONTROL_BIT_READ |
                                         FM3130_RTC_CONTROL_BIT_WRITE));
                 dev_warn(&client->dev, "Disabling READ or WRITE mode!\n");
+        }
 
         /* oscillator off?  turn it on, so clock can tick. */
         if (fm3130->regs[FM3130_CAL_CONTROL] & FM3130_CAL_CONTROL_BIT_nOSCEN)
@@ -397,44 +444,79 @@ static int __devinit fm3130_probe(struct i2c_client *client,
                         fm3130->regs[FM3130_CAL_CONTROL] &
                                 ~(FM3130_CAL_CONTROL_BIT_nOSCEN));
 
-        /* oscillator fault?  clear flag, and warn */
-        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_LB)
+        /* low battery?  clear flag, and warn */
+        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_LB) {
+                i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
+                        fm3130->regs[FM3130_RTC_CONTROL] &
+                                ~(FM3130_RTC_CONTROL_BIT_LB));
                 dev_warn(&client->dev, "Low battery!\n");
+        }
 
-        /* oscillator fault?  clear flag, and warn */
+        /* check if Power On Reset bit is set */
         if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_POR) {
                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
                         fm3130->regs[FM3130_RTC_CONTROL] &
                                 ~FM3130_RTC_CONTROL_BIT_POR);
-                dev_warn(&client->dev, "SET TIME!\n");
+                dev_dbg(&client->dev, "POR bit is set\n");
         }
         /* ACS is controlled by alarm */
         i2c_smbus_write_byte_data(client, FM3130_ALARM_WP_CONTROL, 0x80);
 
-        /* TODO */
-        /* TODO need to sanity check alarm */
-        tmp = fm3130->regs[FM3130_RTC_SECONDS];
-        tmp = bcd2bin(tmp & 0x7f);
-        if (tmp > 60)
-                goto exit_bad;
+        /* alarm registers sanity check */
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
+        if (tmp > 59)
+                goto bad_alarm;
+
         tmp = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
-        if (tmp > 60)
-                goto exit_bad;
+        if (tmp > 59)
+                goto bad_alarm;
+
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_HOURS] & 0x3f);
+        if (tmp > 23)
+                goto bad_alarm;
 
         tmp = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
         if (tmp == 0 || tmp > 31)
-                goto exit_bad;
+                goto bad_alarm;
 
         tmp = bcd2bin(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
         if (tmp == 0 || tmp > 12)
-                goto exit_bad;
+                goto bad_alarm;
 
-        tmp = fm3130->regs[FM3130_RTC_HOURS];
+        fm3130->alarm_valid = 1;
+
+bad_alarm:
+
+        /* clock registers sanity chek */
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
+        if (tmp > 59)
+                goto bad_clock;
+
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
+        if (tmp > 59)
+                goto bad_clock;
+
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_HOURS] & 0x3f);
+        if (tmp > 23)
+                goto bad_clock;
+
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x7);
+        if (tmp == 0 || tmp > 7)
+                goto bad_clock;
+
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
+        if (tmp == 0 || tmp > 31)
+                goto bad_clock;
+
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
+        if (tmp == 0 || tmp > 12)
+                goto bad_clock;
 
         fm3130->data_valid = 1;
 
-exit_bad:
-        if (!fm3130->data_valid)
+bad_clock:
+
+        if (!fm3130->data_valid || !fm3130->alarm_valid)
                 dev_dbg(&client->dev,
                                 "%s: %02x %02x %02x %02x %02x %02x %02x %02x"
                                 "%02x %02x %02x %02x %02x %02x %02x\n",
diff --git a/drivers/rtc/rtc-imxdi.c b/drivers/rtc/rtc-imxdi.c
new file mode 100644
index 000000000000..2dd3c0163272
--- /dev/null
+++ b/drivers/rtc/rtc-imxdi.c
@@ -0,0 +1,519 @@
+/*
+ * Copyright 2008-2009 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2010 Orex Computed Radiography
+ */
+
+/*
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+/* based on rtc-mc13892.c */
+
+/*
+ * This driver uses the 47-bit 32 kHz counter in the Freescale DryIce block
+ * to implement a Linux RTC. Times and alarms are truncated to seconds.
+ * Since the RTC framework performs API locking via rtc->ops_lock the
+ * only simultaneous accesses we need to deal with is updating DryIce
+ * registers while servicing an alarm.
+ *
+ * Note that reading the DSR (DryIce Status Register) automatically clears
+ * the WCF (Write Complete Flag). All DryIce writes are synchronized to the
+ * LP (Low Power) domain and set the WCF upon completion. Writes to the
+ * DIER (DryIce Interrupt Enable Register) are the only exception. These
+ * occur at normal bus speeds and do not set WCF.  Periodic interrupts are
+ * not supported by the hardware.
+ */
+
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/workqueue.h>
+
+/* DryIce Register Definitions */
+
+#define DTCMR     0x00           /* Time Counter MSB Reg */
+#define DTCLR     0x04           /* Time Counter LSB Reg */
+
+#define DCAMR     0x08           /* Clock Alarm MSB Reg */
+#define DCALR     0x0c           /* Clock Alarm LSB Reg */
+#define DCAMR_UNSET  0xFFFFFFFF  /* doomsday - 1 sec */
+
+#define DCR       0x10           /* Control Reg */
+#define DCR_TCE   (1 << 3)       /* Time Counter Enable */
+
+#define DSR       0x14           /* Status Reg */
+#define DSR_WBF   (1 << 10)      /* Write Busy Flag */
+#define DSR_WNF   (1 << 9)       /* Write Next Flag */
+#define DSR_WCF   (1 << 8)       /* Write Complete Flag */
+#define DSR_WEF   (1 << 7)       /* Write Error Flag */
+#define DSR_CAF   (1 << 4)       /* Clock Alarm Flag */
+#define DSR_NVF   (1 << 1)       /* Non-Valid Flag */
+#define DSR_SVF   (1 << 0)       /* Security Violation Flag */
+
+#define DIER      0x18           /* Interrupt Enable Reg */
+#define DIER_WNIE (1 << 9)       /* Write Next Interrupt Enable */
+#define DIER_WCIE (1 << 8)       /* Write Complete Interrupt Enable */
+#define DIER_WEIE (1 << 7)       /* Write Error Interrupt Enable */
+#define DIER_CAIE (1 << 4)       /* Clock Alarm Interrupt Enable */
+
+/**
+ * struct imxdi_dev - private imxdi rtc data
+ * @pdev: pionter to platform dev
+ * @rtc: pointer to rtc struct
+ * @ioaddr: IO registers pointer
+ * @irq: dryice normal interrupt
+ * @clk: input reference clock
+ * @dsr: copy of the DSR register
+ * @irq_lock: interrupt enable register (DIER) lock
+ * @write_wait: registers write complete queue
+ * @write_mutex: serialize registers write
+ * @work: schedule alarm work
+ */
+struct imxdi_dev {
+        struct platform_device *pdev;
+        struct rtc_device *rtc;
+        void __iomem *ioaddr;
+        int irq;
+        struct clk *clk;
+        u32 dsr;
+        spinlock_t irq_lock;
+        wait_queue_head_t write_wait;
+        struct mutex write_mutex;
+        struct work_struct work;
+};
+
+/*
+ * enable a dryice interrupt
+ */
+static void di_int_enable(struct imxdi_dev *imxdi, u32 intr)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&imxdi->irq_lock, flags);
+        __raw_writel(__raw_readl(imxdi->ioaddr + DIER) | intr,
+                        imxdi->ioaddr + DIER);
+        spin_unlock_irqrestore(&imxdi->irq_lock, flags);
+}
+
+/*
+ * disable a dryice interrupt
+ */
+static void di_int_disable(struct imxdi_dev *imxdi, u32 intr)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&imxdi->irq_lock, flags);
+        __raw_writel(__raw_readl(imxdi->ioaddr + DIER) & ~intr,
+                        imxdi->ioaddr + DIER);
+        spin_unlock_irqrestore(&imxdi->irq_lock, flags);
+}
+
+/*
+ * This function attempts to clear the dryice write-error flag.
+ *
+ * A dryice write error is similar to a bus fault and should not occur in
+ * normal operation.  Clearing the flag requires another write, so the root
+ * cause of the problem may need to be fixed before the flag can be cleared.
+ */
+static void clear_write_error(struct imxdi_dev *imxdi)
+{
+        int cnt;
+
+        dev_warn(&imxdi->pdev->dev, "WARNING: Register write error!\n");
+
+        /* clear the write error flag */
+        __raw_writel(DSR_WEF, imxdi->ioaddr + DSR);
+
+        /* wait for it to take effect */
+        for (cnt = 0; cnt < 1000; cnt++) {
+                if ((__raw_readl(imxdi->ioaddr + DSR) & DSR_WEF) == 0)
+                        return;
+                udelay(10);
+        }
+        dev_err(&imxdi->pdev->dev,
+                        "ERROR: Cannot clear write-error flag!\n");
+}
+
+/*
+ * Write a dryice register and wait until it completes.
+ *
+ * This function uses interrupts to determine when the
+ * write has completed.
+ */
+static int di_write_wait(struct imxdi_dev *imxdi, u32 val, int reg)
+{
+        int ret;
+        int rc = 0;
+
+        /* serialize register writes */
+        mutex_lock(&imxdi->write_mutex);
+
+        /* enable the write-complete interrupt */
+        di_int_enable(imxdi, DIER_WCIE);
+
+        imxdi->dsr = 0;
+
+        /* do the register write */
+        __raw_writel(val, imxdi->ioaddr + reg);
+
+        /* wait for the write to finish */
+        ret = wait_event_interruptible_timeout(imxdi->write_wait,
+                        imxdi->dsr & (DSR_WCF | DSR_WEF), msecs_to_jiffies(1));
+        if (ret < 0) {
+                rc = ret;
+                goto out;
+        } else if (ret == 0) {
+                dev_warn(&imxdi->pdev->dev,
+                                "Write-wait timeout "
+                                "val = 0x%08x reg = 0x%08x\n", val, reg);
+        }
+
+        /* check for write error */
+        if (imxdi->dsr & DSR_WEF) {
+                clear_write_error(imxdi);
+                rc = -EIO;
+        }
+
+out:
+        mutex_unlock(&imxdi->write_mutex);
+
+        return rc;
+}
+
+/*
+ * read the seconds portion of the current time from the dryice time counter
+ */
+static int dryice_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct imxdi_dev *imxdi = dev_get_drvdata(dev);
+        unsigned long now;
+
+        now = __raw_readl(imxdi->ioaddr + DTCMR);
+        rtc_time_to_tm(now, tm);
+
+        return 0;
+}
+
+/*
+ * set the seconds portion of dryice time counter and clear the
+ * fractional part.
+ */
+static int dryice_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct imxdi_dev *imxdi = dev_get_drvdata(dev);
+        int rc;
+
+        /* zero the fractional part first */
+        rc = di_write_wait(imxdi, 0, DTCLR);
+        if (rc == 0)
+                rc = di_write_wait(imxdi, secs, DTCMR);
+
+        return rc;
+}
+
+static int dryice_rtc_alarm_irq_enable(struct device *dev,
+                unsigned int enabled)
+{
+        struct imxdi_dev *imxdi = dev_get_drvdata(dev);
+
+        if (enabled)
+                di_int_enable(imxdi, DIER_CAIE);
+        else
+                di_int_disable(imxdi, DIER_CAIE);
+
+        return 0;
+}
+
+/*
+ * read the seconds portion of the alarm register.
+ * the fractional part of the alarm register is always zero.
+ */
+static int dryice_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct imxdi_dev *imxdi = dev_get_drvdata(dev);
+        u32 dcamr;
+
+        dcamr = __raw_readl(imxdi->ioaddr + DCAMR);
+        rtc_time_to_tm(dcamr, &alarm->time);
+
+        /* alarm is enabled if the interrupt is enabled */
+        alarm->enabled = (__raw_readl(imxdi->ioaddr + DIER) & DIER_CAIE) != 0;
+
+        /* don't allow the DSR read to mess up DSR_WCF */
+        mutex_lock(&imxdi->write_mutex);
+
+        /* alarm is pending if the alarm flag is set */
+        alarm->pending = (__raw_readl(imxdi->ioaddr + DSR) & DSR_CAF) != 0;
+
+        mutex_unlock(&imxdi->write_mutex);
+
+        return 0;
+}
+
+/*
+ * set the seconds portion of dryice alarm register
+ */
+static int dryice_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct imxdi_dev *imxdi = dev_get_drvdata(dev);
+        unsigned long now;
+        unsigned long alarm_time;
+        int rc;
+
+        rc = rtc_tm_to_time(&alarm->time, &alarm_time);
+        if (rc)
+                return rc;
+
+        /* don't allow setting alarm in the past */
+        now = __raw_readl(imxdi->ioaddr + DTCMR);
+        if (alarm_time < now)
+                return -EINVAL;
+
+        /* write the new alarm time */
+        rc = di_write_wait(imxdi, (u32)alarm_time, DCAMR);
+        if (rc)
+                return rc;
+
+        if (alarm->enabled)
+                di_int_enable(imxdi, DIER_CAIE);  /* enable alarm intr */
+        else
+                di_int_disable(imxdi, DIER_CAIE); /* disable alarm intr */
+
+        return 0;
+}
+
+static struct rtc_class_ops dryice_rtc_ops = {
+        .read_time              = dryice_rtc_read_time,
+        .set_mmss               = dryice_rtc_set_mmss,
+        .alarm_irq_enable       = dryice_rtc_alarm_irq_enable,
+        .read_alarm             = dryice_rtc_read_alarm,
+        .set_alarm              = dryice_rtc_set_alarm,
+};
+
+/*
+ * dryice "normal" interrupt handler
+ */
+static irqreturn_t dryice_norm_irq(int irq, void *dev_id)
+{
+        struct imxdi_dev *imxdi = dev_id;
+        u32 dsr, dier;
+        irqreturn_t rc = IRQ_NONE;
+
+        dier = __raw_readl(imxdi->ioaddr + DIER);
+
+        /* handle write complete and write error cases */
+        if ((dier & DIER_WCIE)) {
+                /*If the write wait queue is empty then there is no pending
+                  operations. It means the interrupt is for DryIce -Security.
+                  IRQ must be returned as none.*/
+                if (list_empty_careful(&imxdi->write_wait.task_list))
+                        return rc;
+
+                /* DSR_WCF clears itself on DSR read */
+                dsr = __raw_readl(imxdi->ioaddr + DSR);
+                if ((dsr & (DSR_WCF | DSR_WEF))) {
+                        /* mask the interrupt */
+                        di_int_disable(imxdi, DIER_WCIE);
+
+                        /* save the dsr value for the wait queue */
+                        imxdi->dsr |= dsr;
+
+                        wake_up_interruptible(&imxdi->write_wait);
+                        rc = IRQ_HANDLED;
+                }
+        }
+
+        /* handle the alarm case */
+        if ((dier & DIER_CAIE)) {
+                /* DSR_WCF clears itself on DSR read */
+                dsr = __raw_readl(imxdi->ioaddr + DSR);
+                if (dsr & DSR_CAF) {
+                        /* mask the interrupt */
+                        di_int_disable(imxdi, DIER_CAIE);
+
+                        /* finish alarm in user context */
+                        schedule_work(&imxdi->work);
+                        rc = IRQ_HANDLED;
+                }
+        }
+        return rc;
+}
+
+/*
+ * post the alarm event from user context so it can sleep
+ * on the write completion.
+ */
+static void dryice_work(struct work_struct *work)
+{
+        struct imxdi_dev *imxdi = container_of(work,
+                        struct imxdi_dev, work);
+
+        /* dismiss the interrupt (ignore error) */
+        di_write_wait(imxdi, DSR_CAF, DSR);
+
+        /* pass the alarm event to the rtc framework. */
+        rtc_update_irq(imxdi->rtc, 1, RTC_AF | RTC_IRQF);
+}
+
+/*
+ * probe for dryice rtc device
+ */
+static int dryice_rtc_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct imxdi_dev *imxdi;
+        int rc;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        imxdi = devm_kzalloc(&pdev->dev, sizeof(*imxdi), GFP_KERNEL);
+        if (!imxdi)
+                return -ENOMEM;
+
+        imxdi->pdev = pdev;
+
+        if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res),
+                                pdev->name))
+                return -EBUSY;
+
+        imxdi->ioaddr = devm_ioremap(&pdev->dev, res->start,
+                        resource_size(res));
+        if (imxdi->ioaddr == NULL)
+                return -ENOMEM;
+
+        imxdi->irq = platform_get_irq(pdev, 0);
+        if (imxdi->irq < 0)
+                return imxdi->irq;
+
+        init_waitqueue_head(&imxdi->write_wait);
+
+        INIT_WORK(&imxdi->work, dryice_work);
+
+        mutex_init(&imxdi->write_mutex);
+
+        imxdi->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(imxdi->clk))
+                return PTR_ERR(imxdi->clk);
+        clk_enable(imxdi->clk);
+
+        /*
+         * Initialize dryice hardware
+         */
+
+        /* mask all interrupts */
+        __raw_writel(0, imxdi->ioaddr + DIER);
+
+        rc = devm_request_irq(&pdev->dev, imxdi->irq, dryice_norm_irq,
+                        IRQF_SHARED, pdev->name, imxdi);
+        if (rc) {
+                dev_warn(&pdev->dev, "interrupt not available.\n");
+                goto err;
+        }
+
+        /* put dryice into valid state */
+        if (__raw_readl(imxdi->ioaddr + DSR) & DSR_NVF) {
+                rc = di_write_wait(imxdi, DSR_NVF | DSR_SVF, DSR);
+                if (rc)
+                        goto err;
+        }
+
+        /* initialize alarm */
+        rc = di_write_wait(imxdi, DCAMR_UNSET, DCAMR);
+        if (rc)
+                goto err;
+        rc = di_write_wait(imxdi, 0, DCALR);
+        if (rc)
+                goto err;
+
+        /* clear alarm flag */
+        if (__raw_readl(imxdi->ioaddr + DSR) & DSR_CAF) {
+                rc = di_write_wait(imxdi, DSR_CAF, DSR);
+                if (rc)
+                        goto err;
+        }
+
+        /* the timer won't count if it has never been written to */
+        if (__raw_readl(imxdi->ioaddr + DTCMR) == 0) {
+                rc = di_write_wait(imxdi, 0, DTCMR);
+                if (rc)
+                        goto err;
+        }
+
+        /* start keeping time */
+        if (!(__raw_readl(imxdi->ioaddr + DCR) & DCR_TCE)) {
+                rc = di_write_wait(imxdi,
+                                __raw_readl(imxdi->ioaddr + DCR) | DCR_TCE,
+                                DCR);
+                if (rc)
+                        goto err;
+        }
+
+        platform_set_drvdata(pdev, imxdi);
+        imxdi->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                  &dryice_rtc_ops, THIS_MODULE);
+        if (IS_ERR(imxdi->rtc)) {
+                rc = PTR_ERR(imxdi->rtc);
+                goto err;
+        }
+
+        return 0;
+
+err:
+        clk_disable(imxdi->clk);
+        clk_put(imxdi->clk);
+
+        return rc;
+}
+
+static int __devexit dryice_rtc_remove(struct platform_device *pdev)
+{
+        struct imxdi_dev *imxdi = platform_get_drvdata(pdev);
+
+        flush_work(&imxdi->work);
+
+        /* mask all interrupts */
+        __raw_writel(0, imxdi->ioaddr + DIER);
+
+        rtc_device_unregister(imxdi->rtc);
+
+        clk_disable(imxdi->clk);
+        clk_put(imxdi->clk);
+
+        return 0;
+}
+
+static struct platform_driver dryice_rtc_driver = {
+        .driver = {
+                   .name = "imxdi_rtc",
+                   .owner = THIS_MODULE,
+                   },
+        .remove = __devexit_p(dryice_rtc_remove),
+};
+
+static int __init dryice_rtc_init(void)
+{
+        return platform_driver_probe(&dryice_rtc_driver, dryice_rtc_probe);
+}
+
+static void __exit dryice_rtc_exit(void)
+{
+        platform_driver_unregister(&dryice_rtc_driver);
+}
+
+module_init(dryice_rtc_init);
+module_exit(dryice_rtc_exit);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
+MODULE_DESCRIPTION("IMX DryIce Realtime Clock Driver (RTC)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-isl12022.c b/drivers/rtc/rtc-isl12022.c
new file mode 100644
index 000000000000..ddbc797ea6cd
--- /dev/null
+++ b/drivers/rtc/rtc-isl12022.c
@@ -0,0 +1,327 @@
+/*
+ * An I2C driver for the Intersil ISL 12022
+ *
+ * Author: Roman Fietze <roman.fietze@telemotive.de>
+ *
+ * Based on the Philips PCF8563 RTC
+ * by Alessandro Zummo <a.zummo@towertech.it>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ */
+
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+
+#define DRV_VERSION "0.1"
+
+/* ISL register offsets */
+#define ISL12022_REG_SC         0x00
+#define ISL12022_REG_MN         0x01
+#define ISL12022_REG_HR         0x02
+#define ISL12022_REG_DT         0x03
+#define ISL12022_REG_MO         0x04
+#define ISL12022_REG_YR         0x05
+#define ISL12022_REG_DW         0x06
+
+#define ISL12022_REG_SR         0x07
+#define ISL12022_REG_INT        0x08
+
+/* ISL register bits */
+#define ISL12022_HR_MIL         (1 << 7)        /* military or 24 hour time */
+
+#define ISL12022_SR_LBAT85      (1 << 2)
+#define ISL12022_SR_LBAT75      (1 << 1)
+
+#define ISL12022_INT_WRTC       (1 << 6)
+
+
+static struct i2c_driver isl12022_driver;
+
+struct isl12022 {
+        struct rtc_device *rtc;
+
+        bool write_enabled;     /* true if write enable is set */
+};
+
+
+static int isl12022_read_regs(struct i2c_client *client, uint8_t reg,
+                              uint8_t *data, size_t n)
+{
+        struct i2c_msg msgs[] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0,
+                        .len    = 1,
+                        .buf    = data
+                },              /* setup read ptr */
+                {
+                        .addr   = client->addr,
+                        .flags  = I2C_M_RD,
+                        .len    = n,
+                        .buf    = data
+                }
+        };
+
+        int ret;
+
+        data[0] = reg;
+        ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+        if (ret != ARRAY_SIZE(msgs)) {
+                dev_err(&client->dev, "%s: read error, ret=%d\n",
+                        __func__, ret);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+
+static int isl12022_write_reg(struct i2c_client *client,
+                              uint8_t reg, uint8_t val)
+{
+        uint8_t data[2] = { reg, val };
+        int err;
+
+        err = i2c_master_send(client, data, sizeof(data));
+        if (err != sizeof(data)) {
+                dev_err(&client->dev,
+                        "%s: err=%d addr=%02x, data=%02x\n",
+                        __func__, err, data[0], data[1]);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+
+/*
+ * In the routines that deal directly with the isl12022 hardware, we use
+ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
+ */
+static int isl12022_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        uint8_t buf[ISL12022_REG_INT + 1];
+        int ret;
+
+        ret = isl12022_read_regs(client, ISL12022_REG_SC, buf, sizeof(buf));
+        if (ret)
+                return ret;
+
+        if (buf[ISL12022_REG_SR] & (ISL12022_SR_LBAT85 | ISL12022_SR_LBAT75)) {
+                dev_warn(&client->dev,
+                         "voltage dropped below %u%%, "
+                         "date and time is not reliable.\n",
+                         buf[ISL12022_REG_SR] & ISL12022_SR_LBAT85 ? 85 : 75);
+        }
+
+        dev_dbg(&client->dev,
+                "%s: raw data is sec=%02x, min=%02x, hr=%02x, "
+                "mday=%02x, mon=%02x, year=%02x, wday=%02x, "
+                "sr=%02x, int=%02x",
+                __func__,
+                buf[ISL12022_REG_SC],
+                buf[ISL12022_REG_MN],
+                buf[ISL12022_REG_HR],
+                buf[ISL12022_REG_DT],
+                buf[ISL12022_REG_MO],
+                buf[ISL12022_REG_YR],
+                buf[ISL12022_REG_DW],
+                buf[ISL12022_REG_SR],
+                buf[ISL12022_REG_INT]);
+
+        tm->tm_sec = bcd2bin(buf[ISL12022_REG_SC] & 0x7F);
+        tm->tm_min = bcd2bin(buf[ISL12022_REG_MN] & 0x7F);
+        tm->tm_hour = bcd2bin(buf[ISL12022_REG_HR] & 0x3F);
+        tm->tm_mday = bcd2bin(buf[ISL12022_REG_DT] & 0x3F);
+        tm->tm_wday = buf[ISL12022_REG_DW] & 0x07;
+        tm->tm_mon = bcd2bin(buf[ISL12022_REG_MO] & 0x1F) - 1;
+        tm->tm_year = bcd2bin(buf[ISL12022_REG_YR]) + 100;
+
+        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __func__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* The clock can give out invalid datetime, but we cannot return
+         * -EINVAL otherwise hwclock will refuse to set the time on bootup. */
+        if (rtc_valid_tm(tm) < 0)
+                dev_err(&client->dev, "retrieved date and time is invalid.\n");
+
+        return 0;
+}
+
+static int isl12022_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        struct isl12022 *isl12022 = i2c_get_clientdata(client);
+        size_t i;
+        int ret;
+        uint8_t buf[ISL12022_REG_DW + 1];
+
+        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __func__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        if (!isl12022->write_enabled) {
+
+                ret = isl12022_read_regs(client, ISL12022_REG_INT, buf, 1);
+                if (ret)
+                        return ret;
+
+                /* Check if WRTC (write rtc enable) is set factory default is
+                 * 0 (not set) */
+                if (!(buf[0] & ISL12022_INT_WRTC)) {
+                        dev_info(&client->dev,
+                                 "init write enable and 24 hour format\n");
+
+                        /* Set the write enable bit. */
+                        ret = isl12022_write_reg(client,
+                                                 ISL12022_REG_INT,
+                                                 buf[0] | ISL12022_INT_WRTC);
+                        if (ret)
+                                return ret;
+
+                        /* Write to any RTC register to start RTC, we use the
+                         * HR register, setting the MIL bit to use the 24 hour
+                         * format. */
+                        ret = isl12022_read_regs(client, ISL12022_REG_HR,
+                                                 buf, 1);
+                        if (ret)
+                                return ret;
+
+                        ret = isl12022_write_reg(client,
+                                                 ISL12022_REG_HR,
+                                                 buf[0] | ISL12022_HR_MIL);
+                        if (ret)
+                                return ret;
+                }
+
+                isl12022->write_enabled = 1;
+        }
+
+        /* hours, minutes and seconds */
+        buf[ISL12022_REG_SC] = bin2bcd(tm->tm_sec);
+        buf[ISL12022_REG_MN] = bin2bcd(tm->tm_min);
+        buf[ISL12022_REG_HR] = bin2bcd(tm->tm_hour) | ISL12022_HR_MIL;
+
+        buf[ISL12022_REG_DT] = bin2bcd(tm->tm_mday);
+
+        /* month, 1 - 12 */
+        buf[ISL12022_REG_MO] = bin2bcd(tm->tm_mon + 1);
+
+        /* year and century */
+        buf[ISL12022_REG_YR] = bin2bcd(tm->tm_year % 100);
+
+        buf[ISL12022_REG_DW] = tm->tm_wday & 0x07;
+
+        /* write register's data */
+        for (i = 0; i < ARRAY_SIZE(buf); i++) {
+                ret = isl12022_write_reg(client, ISL12022_REG_SC + i,
+                                         buf[ISL12022_REG_SC + i]);
+                if (ret)
+                        return -EIO;
+        };
+
+        return 0;
+}
+
+static int isl12022_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return isl12022_get_datetime(to_i2c_client(dev), tm);
+}
+
+static int isl12022_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return isl12022_set_datetime(to_i2c_client(dev), tm);
+}
+
+static const struct rtc_class_ops isl12022_rtc_ops = {
+        .read_time      = isl12022_rtc_read_time,
+        .set_time       = isl12022_rtc_set_time,
+};
+
+static int isl12022_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        struct isl12022 *isl12022;
+
+        int ret = 0;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+                return -ENODEV;
+
+        isl12022 = kzalloc(sizeof(struct isl12022), GFP_KERNEL);
+        if (!isl12022)
+                return -ENOMEM;
+
+        dev_dbg(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+
+        i2c_set_clientdata(client, isl12022);
+
+        isl12022->rtc = rtc_device_register(isl12022_driver.driver.name,
+                                            &client->dev,
+                                            &isl12022_rtc_ops,
+                                            THIS_MODULE);
+
+        if (IS_ERR(isl12022->rtc)) {
+                ret = PTR_ERR(isl12022->rtc);
+                goto exit_kfree;
+        }
+
+        return 0;
+
+exit_kfree:
+        kfree(isl12022);
+
+        return ret;
+}
+
+static int isl12022_remove(struct i2c_client *client)
+{
+        struct isl12022 *isl12022 = i2c_get_clientdata(client);
+
+        rtc_device_unregister(isl12022->rtc);
+        kfree(isl12022);
+
+        return 0;
+}
+
+static const struct i2c_device_id isl12022_id[] = {
+        { "isl12022", 0 },
+        { "rtc8564", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, isl12022_id);
+
+static struct i2c_driver isl12022_driver = {
+        .driver         = {
+                .name   = "rtc-isl12022",
+        },
+        .probe          = isl12022_probe,
+        .remove         = isl12022_remove,
+        .id_table       = isl12022_id,
+};
+
+static int __init isl12022_init(void)
+{
+        return i2c_add_driver(&isl12022_driver);
+}
+
+static void __exit isl12022_exit(void)
+{
+        i2c_del_driver(&isl12022_driver);
+}
+
+module_init(isl12022_init);
+module_exit(isl12022_exit);
+
+MODULE_AUTHOR("roman.fietze@telemotive.de");
+MODULE_DESCRIPTION("ISL 12022 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index 054e05294af8..468200c38ecb 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -462,39 +462,16 @@ isl1208_sysfs_store_usr(struct device *dev,
 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
                    isl1208_sysfs_store_usr);
 
-static int
-isl1208_sysfs_register(struct device *dev)
-{
-        int err;
-
-        err = device_create_file(dev, &dev_attr_atrim);
-        if (err)
-                return err;
-
-        err = device_create_file(dev, &dev_attr_dtrim);
-        if (err) {
-                device_remove_file(dev, &dev_attr_atrim);
-                return err;
-        }
-
-        err = device_create_file(dev, &dev_attr_usr);
-        if (err) {
-                device_remove_file(dev, &dev_attr_atrim);
-                device_remove_file(dev, &dev_attr_dtrim);
-        }
-
-        return 0;
-}
-
-static int
-isl1208_sysfs_unregister(struct device *dev)
-{
-        device_remove_file(dev, &dev_attr_dtrim);
-        device_remove_file(dev, &dev_attr_atrim);
-        device_remove_file(dev, &dev_attr_usr);
+static struct attribute *isl1208_rtc_attrs[] = {
+        &dev_attr_atrim.attr,
+        &dev_attr_dtrim.attr,
+        &dev_attr_usr.attr,
+        NULL
+};
 
-        return 0;
-}
+static const struct attribute_group isl1208_rtc_sysfs_files = {
+        .attrs  = isl1208_rtc_attrs,
+};
 
 static int
 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
@@ -529,7 +506,7 @@ isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 dev_warn(&client->dev, "rtc power failure detected, "
                          "please set clock.\n");
 
-        rc = isl1208_sysfs_register(&client->dev);
+        rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
         if (rc)
                 goto exit_unregister;
 
@@ -546,7 +523,7 @@ isl1208_remove(struct i2c_client *client)
 {
         struct rtc_device *rtc = i2c_get_clientdata(client);
 
-        isl1208_sysfs_unregister(&client->dev);
+        sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
         rtc_device_unregister(rtc);
 
         return 0;
diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
new file mode 100644
index 000000000000..2e16f72c9056
--- /dev/null
+++ b/drivers/rtc/rtc-jz4740.c
@@ -0,0 +1,380 @@
+/*
+ *  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
+ *  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/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#define JZ_REG_RTC_CTRL         0x00
+#define JZ_REG_RTC_SEC          0x04
+#define JZ_REG_RTC_SEC_ALARM    0x08
+#define JZ_REG_RTC_REGULATOR    0x0C
+#define JZ_REG_RTC_HIBERNATE    0x20
+#define JZ_REG_RTC_SCRATCHPAD   0x34
+
+#define JZ_RTC_CTRL_WRDY        BIT(7)
+#define JZ_RTC_CTRL_1HZ         BIT(6)
+#define JZ_RTC_CTRL_1HZ_IRQ     BIT(5)
+#define JZ_RTC_CTRL_AF          BIT(4)
+#define JZ_RTC_CTRL_AF_IRQ      BIT(3)
+#define JZ_RTC_CTRL_AE          BIT(2)
+#define JZ_RTC_CTRL_ENABLE      BIT(0)
+
+struct jz4740_rtc {
+        struct resource *mem;
+        void __iomem *base;
+
+        struct rtc_device *rtc;
+
+        unsigned int irq;
+
+        spinlock_t lock;
+};
+
+static inline uint32_t jz4740_rtc_reg_read(struct jz4740_rtc *rtc, size_t reg)
+{
+        return readl(rtc->base + reg);
+}
+
+static int jz4740_rtc_wait_write_ready(struct jz4740_rtc *rtc)
+{
+        uint32_t ctrl;
+        int timeout = 1000;
+
+        do {
+                ctrl = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_CTRL);
+        } while (!(ctrl & JZ_RTC_CTRL_WRDY) && --timeout);
+
+        return timeout ? 0 : -EIO;
+}
+
+static inline int jz4740_rtc_reg_write(struct jz4740_rtc *rtc, size_t reg,
+        uint32_t val)
+{
+        int ret;
+        ret = jz4740_rtc_wait_write_ready(rtc);
+        if (ret == 0)
+                writel(val, rtc->base + reg);
+
+        return ret;
+}
+
+static int jz4740_rtc_ctrl_set_bits(struct jz4740_rtc *rtc, uint32_t mask,
+        bool set)
+{
+        int ret;
+        unsigned long flags;
+        uint32_t ctrl;
+
+        spin_lock_irqsave(&rtc->lock, flags);
+
+        ctrl = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_CTRL);
+
+        /* Don't clear interrupt flags by accident */
+        ctrl |= JZ_RTC_CTRL_1HZ | JZ_RTC_CTRL_AF;
+
+        if (set)
+                ctrl |= mask;
+        else
+                ctrl &= ~mask;
+
+        ret = jz4740_rtc_reg_write(rtc, JZ_REG_RTC_CTRL, ctrl);
+
+        spin_unlock_irqrestore(&rtc->lock, flags);
+
+        return ret;
+}
+
+static int jz4740_rtc_read_time(struct device *dev, struct rtc_time *time)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        uint32_t secs, secs2;
+        int timeout = 5;
+
+        /* If the seconds register is read while it is updated, it can contain a
+         * bogus value. This can be avoided by making sure that two consecutive
+         * reads have the same value.
+         */
+        secs = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_SEC);
+        secs2 = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_SEC);
+
+        while (secs != secs2 && --timeout) {
+                secs = secs2;
+                secs2 = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_SEC);
+        }
+
+        if (timeout == 0)
+                return -EIO;
+
+        rtc_time_to_tm(secs, time);
+
+        return rtc_valid_tm(time);
+}
+
+static int jz4740_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+
+        return jz4740_rtc_reg_write(rtc, JZ_REG_RTC_SEC, secs);
+}
+
+static int jz4740_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        uint32_t secs;
+        uint32_t ctrl;
+
+        secs = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_SEC_ALARM);
+
+        ctrl = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_CTRL);
+
+        alrm->enabled = !!(ctrl & JZ_RTC_CTRL_AE);
+        alrm->pending = !!(ctrl & JZ_RTC_CTRL_AF);
+
+        rtc_time_to_tm(secs, &alrm->time);
+
+        return rtc_valid_tm(&alrm->time);
+}
+
+static int jz4740_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        int ret;
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        unsigned long secs;
+
+        rtc_tm_to_time(&alrm->time, &secs);
+
+        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 | JZ_RTC_CTRL_AF_IRQ, alrm->enabled);
+
+        return ret;
+}
+
+static int jz4740_rtc_update_irq_enable(struct device *dev, unsigned int enable)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        return jz4740_rtc_ctrl_set_bits(rtc, JZ_RTC_CTRL_1HZ_IRQ, enable);
+}
+
+static int jz4740_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        return jz4740_rtc_ctrl_set_bits(rtc, JZ_RTC_CTRL_AF_IRQ, enable);
+}
+
+static struct rtc_class_ops jz4740_rtc_ops = {
+        .read_time      = jz4740_rtc_read_time,
+        .set_mmss       = jz4740_rtc_set_mmss,
+        .read_alarm     = jz4740_rtc_read_alarm,
+        .set_alarm      = jz4740_rtc_set_alarm,
+        .update_irq_enable = jz4740_rtc_update_irq_enable,
+        .alarm_irq_enable = jz4740_rtc_alarm_irq_enable,
+};
+
+static irqreturn_t jz4740_rtc_irq(int irq, void *data)
+{
+        struct jz4740_rtc *rtc = data;
+        uint32_t ctrl;
+        unsigned long events = 0;
+
+        ctrl = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_CTRL);
+
+        if (ctrl & JZ_RTC_CTRL_1HZ)
+                events |= (RTC_UF | RTC_IRQF);
+
+        if (ctrl & JZ_RTC_CTRL_AF)
+                events |= (RTC_AF | RTC_IRQF);
+
+        rtc_update_irq(rtc->rtc, 1, events);
+
+        jz4740_rtc_ctrl_set_bits(rtc, JZ_RTC_CTRL_1HZ | JZ_RTC_CTRL_AF, false);
+
+        return IRQ_HANDLED;
+}
+
+void jz4740_rtc_poweroff(struct device *dev)
+{
+        struct jz4740_rtc *rtc = dev_get_drvdata(dev);
+        jz4740_rtc_reg_write(rtc, JZ_REG_RTC_HIBERNATE, 1);
+}
+EXPORT_SYMBOL_GPL(jz4740_rtc_poweroff);
+
+static int __devinit jz4740_rtc_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct jz4740_rtc *rtc;
+        uint32_t scratchpad;
+
+        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        if (!rtc)
+                return -ENOMEM;
+
+        rtc->irq = platform_get_irq(pdev, 0);
+        if (rtc->irq < 0) {
+                ret = -ENOENT;
+                dev_err(&pdev->dev, "Failed to get platform irq\n");
+                goto err_free;
+        }
+
+        rtc->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!rtc->mem) {
+                ret = -ENOENT;
+                dev_err(&pdev->dev, "Failed to get platform mmio memory\n");
+                goto err_free;
+        }
+
+        rtc->mem = request_mem_region(rtc->mem->start, resource_size(rtc->mem),
+                                        pdev->name);
+        if (!rtc->mem) {
+                ret = -EBUSY;
+                dev_err(&pdev->dev, "Failed to request mmio memory region\n");
+                goto err_free;
+        }
+
+        rtc->base = ioremap_nocache(rtc->mem->start, resource_size(rtc->mem));
+        if (!rtc->base) {
+                ret = -EBUSY;
+                dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
+                goto err_release_mem_region;
+        }
+
+        spin_lock_init(&rtc->lock);
+
+        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)) {
+                ret = PTR_ERR(rtc->rtc);
+                dev_err(&pdev->dev, "Failed to register rtc device: %d\n", ret);
+                goto err_iounmap;
+        }
+
+        ret = request_irq(rtc->irq, jz4740_rtc_irq, 0,
+                                pdev->name, rtc);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to request rtc irq: %d\n", ret);
+                goto err_unregister_rtc;
+        }
+
+        scratchpad = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_SCRATCHPAD);
+        if (scratchpad != 0x12345678) {
+                ret = jz4740_rtc_reg_write(rtc, JZ_REG_RTC_SCRATCHPAD, 0x12345678);
+                ret = jz4740_rtc_reg_write(rtc, JZ_REG_RTC_SEC, 0);
+                if (ret) {
+                        dev_err(&pdev->dev, "Could not write write to RTC registers\n");
+                        goto err_free_irq;
+                }
+        }
+
+        return 0;
+
+err_free_irq:
+        free_irq(rtc->irq, rtc);
+err_unregister_rtc:
+        rtc_device_unregister(rtc->rtc);
+err_iounmap:
+        platform_set_drvdata(pdev, NULL);
+        iounmap(rtc->base);
+err_release_mem_region:
+        release_mem_region(rtc->mem->start, resource_size(rtc->mem));
+err_free:
+        kfree(rtc);
+
+        return ret;
+}
+
+static int __devexit jz4740_rtc_remove(struct platform_device *pdev)
+{
+        struct jz4740_rtc *rtc = platform_get_drvdata(pdev);
+
+        free_irq(rtc->irq, rtc);
+
+        rtc_device_unregister(rtc->rtc);
+
+        iounmap(rtc->base);
+        release_mem_region(rtc->mem->start, resource_size(rtc->mem));
+
+        kfree(rtc);
+
+        platform_set_drvdata(pdev, NULL);
+
+        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",
+                .owner = THIS_MODULE,
+                .pm    = JZ4740_RTC_PM_OPS,
+        },
+};
+
+static int __init jz4740_rtc_init(void)
+{
+        return platform_driver_register(&jz4740_rtc_driver);
+}
+module_init(jz4740_rtc_init);
+
+static void __exit jz4740_rtc_exit(void)
+{
+        platform_driver_unregister(&jz4740_rtc_driver);
+}
+module_exit(jz4740_rtc_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("RTC driver for the JZ4740 SoC\n");
+MODULE_ALIAS("platform:jz4740-rtc");
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 60fe266f0f49..5a8daa358066 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 },
@@ -121,7 +122,7 @@ static int m41t80_get_datetime(struct i2c_client *client,
 
         /* assume 20YY not 19YY, and ignore the Century Bit */
         tm->tm_year = bcd2bin(buf[M41T80_REG_YEAR]) + 100;
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 /* Sets the given date and time to the real time clock. */
@@ -595,10 +596,6 @@ static void wdt_disable(void)
 static ssize_t wdt_write(struct file *file, const char __user *buf,
                          size_t count, loff_t *ppos)
 {
-        /*  Can't seek (pwrite) on this device
-        if (ppos != &file->f_pos)
-        return -ESPIPE;
-        */
         if (count) {
                 wdt_ping();
                 return 1;
@@ -623,7 +620,7 @@ static ssize_t wdt_read(struct file *file, char __user *buf,
  *      according to their available features. We only actually usefully support
  *      querying capabilities and current status.
  */
-static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+static int wdt_ioctl(struct file *file, unsigned int cmd,
                      unsigned long arg)
 {
         int new_margin, rv;
@@ -676,6 +673,18 @@ static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         return -ENOTTY;
 }
 
+static long wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
+                               unsigned long arg)
+{
+        int ret;
+
+        mutex_lock(&m41t80_rtc_mutex);
+        ret = wdt_ioctl(file, cmd, arg);
+        mutex_unlock(&m41t80_rtc_mutex);
+
+        return ret;
+}
+
 /**
  *      wdt_open:
  *      @inode: inode of device
@@ -685,17 +694,17 @@ static int wdt_ioctl(struct inode *inode, 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();
-                return 0;
+                mutex_unlock(&m41t80_rtc_mutex);
+                return nonseekable_open(inode, file);
         }
         return -ENODEV;
 }
@@ -736,10 +745,11 @@ static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
 static const struct file_operations wdt_fops = {
         .owner  = THIS_MODULE,
         .read   = wdt_read,
-        .ioctl  = wdt_ioctl,
+        .unlocked_ioctl = wdt_unlocked_ioctl,
         .write  = wdt_write,
         .open   = wdt_open,
         .release = wdt_release,
+        .llseek = no_llseek,
 };
 
 static struct miscdevice wdt_dev = {
diff --git a/drivers/rtc/rtc-m41t94.c b/drivers/rtc/rtc-m41t94.c
index c3a18c58daf6..c8c97a4169d4 100644
--- a/drivers/rtc/rtc-m41t94.c
+++ b/drivers/rtc/rtc-m41t94.c
@@ -171,3 +171,4 @@ module_exit(m41t94_exit);
 MODULE_AUTHOR("Kim B. Heino <Kim.Heino@bluegiga.com>");
 MODULE_DESCRIPTION("Driver for ST M41T94 SPI RTC");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:rtc-m41t94");
diff --git a/drivers/rtc/rtc-m48t35.c b/drivers/rtc/rtc-m48t35.c
index 0b2197559940..7410875e5838 100644
--- a/drivers/rtc/rtc-m48t35.c
+++ b/drivers/rtc/rtc-m48t35.c
@@ -16,6 +16,7 @@
 
 #include <linux/module.h>
 #include <linux/rtc.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/bcd.h>
 #include <linux/io.h>
@@ -142,7 +143,6 @@ static const struct rtc_class_ops m48t35_ops = {
 
 static int __devinit m48t35_probe(struct platform_device *pdev)
 {
-        struct rtc_device *rtc;
         struct resource *res;
         struct m48t35_priv *priv;
         int ret = 0;
@@ -171,20 +171,21 @@ static int __devinit m48t35_probe(struct platform_device *pdev)
                 ret = -ENOMEM;
                 goto out;
         }
+
         spin_lock_init(&priv->lock);
-        rtc = rtc_device_register("m48t35", &pdev->dev,
+
+        platform_set_drvdata(pdev, priv);
+
+        priv->rtc = rtc_device_register("m48t35", &pdev->dev,
                                   &m48t35_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
+        if (IS_ERR(priv->rtc)) {
+                ret = PTR_ERR(priv->rtc);
                 goto out;
         }
-        priv->rtc = rtc;
-        platform_set_drvdata(pdev, priv);
+
         return 0;
 
 out:
-        if (priv->rtc)
-                rtc_device_unregister(priv->rtc);
         if (priv->reg)
                 iounmap(priv->reg);
         if (priv->baseaddr)
diff --git a/drivers/rtc/rtc-m48t59.c b/drivers/rtc/rtc-m48t59.c
index 33921a6b1707..a99a0b554eb8 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -19,6 +19,7 @@
 #include <linux/rtc.h>
 #include <linux/rtc/m48t59.h>
 #include <linux/bcd.h>
+#include <linux/slab.h>
 
 #ifndef NO_IRQ
 #define NO_IRQ  (-1)
@@ -104,7 +105,7 @@ static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
         dev_dbg(dev, "RTC read time %04d-%02d-%02d %02d/%02d/%02d\n",
                 tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
                 tm->tm_hour, tm->tm_min, tm->tm_sec);
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm)
@@ -195,7 +196,7 @@ static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
         dev_dbg(dev, "RTC read alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
                 tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
                 tm->tm_hour, tm->tm_min, tm->tm_sec);
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 /*
@@ -342,7 +343,7 @@ static const struct rtc_class_ops m48t02_rtc_ops = {
         .set_time       = m48t59_rtc_set_time,
 };
 
-static ssize_t m48t59_nvram_read(struct kobject *kobj,
+static ssize_t m48t59_nvram_read(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t pos, size_t size)
 {
@@ -362,7 +363,7 @@ static ssize_t m48t59_nvram_read(struct kobject *kobj,
         return cnt;
 }
 
-static ssize_t m48t59_nvram_write(struct kobject *kobj,
+static ssize_t m48t59_nvram_write(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t pos, size_t size)
 {
@@ -481,6 +482,9 @@ static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
                 goto out;
         }
 
+        spin_lock_init(&m48t59->lock);
+        platform_set_drvdata(pdev, m48t59);
+
         m48t59->rtc = rtc_device_register(name, &pdev->dev, ops, THIS_MODULE);
         if (IS_ERR(m48t59->rtc)) {
                 ret = PTR_ERR(m48t59->rtc);
@@ -490,21 +494,18 @@ static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
         m48t59_nvram_attr.size = pdata->offset;
 
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
-        if (ret)
+        if (ret) {
+                rtc_device_unregister(m48t59->rtc);
                 goto out;
+        }
 
-        spin_lock_init(&m48t59->lock);
-        platform_set_drvdata(pdev, m48t59);
         return 0;
 
 out:
-        if (!IS_ERR(m48t59->rtc))
-                rtc_device_unregister(m48t59->rtc);
         if (m48t59->irq != NO_IRQ)
                 free_irq(m48t59->irq, &pdev->dev);
         if (m48t59->ioaddr)
                 iounmap(m48t59->ioaddr);
-        if (m48t59)
                 kfree(m48t59);
         return ret;
 }
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
index 7c045cffa9ff..f981287d582b 100644
--- a/drivers/rtc/rtc-m48t86.c
+++ b/drivers/rtc/rtc-m48t86.c
@@ -77,7 +77,7 @@ static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 if (ops->readbyte(M48T86_REG_HOUR) & 0x80)
                         tm->tm_hour += 12;
 
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 static int m48t86_rtc_set_time(struct device *dev, struct rtc_time *tm)
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index a4f6665ab3c5..486142c2637a 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -159,7 +159,7 @@ static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
                       bcd2bin(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
         tm->tm_wday = bcd2bin(regs[MAX6900_REG_DW]);
 
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 static int max6900_i2c_clear_write_protect(struct i2c_client *client)
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index 36a8ea9ed8ba..657403ebd54a 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -175,3 +175,4 @@ module_exit(max6902_exit);
 MODULE_DESCRIPTION ("max6902 spi RTC driver");
 MODULE_AUTHOR ("Raphael Assenat");
 MODULE_LICENSE ("GPL");
+MODULE_ALIAS("spi:rtc-max6902");
diff --git a/drivers/rtc/rtc-max8925.c b/drivers/rtc/rtc-max8925.c
new file mode 100644
index 000000000000..174036dda786
--- /dev/null
+++ b/drivers/rtc/rtc-max8925.c
@@ -0,0 +1,315 @@
+/*
+ * RTC driver for Maxim MAX8925
+ *
+ * Copyright (C) 2009-2010 Marvell International Ltd.
+ *      Haojian Zhuang <haojian.zhuang@marvell.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/max8925.h>
+
+enum {
+        RTC_SEC = 0,
+        RTC_MIN,
+        RTC_HOUR,
+        RTC_WEEKDAY,
+        RTC_DATE,
+        RTC_MONTH,
+        RTC_YEAR1,
+        RTC_YEAR2,
+};
+
+#define MAX8925_RTC_SEC                 0x00
+#define MAX8925_RTC_MIN                 0x01
+#define MAX8925_RTC_HOUR                0x02
+#define MAX8925_RTC_WEEKDAY             0x03
+#define MAX8925_RTC_DATE                0x04
+#define MAX8925_RTC_MONTH               0x05
+#define MAX8925_RTC_YEAR1               0x06
+#define MAX8925_RTC_YEAR2               0x07
+#define MAX8925_ALARM0_SEC              0x08
+#define MAX8925_ALARM0_MIN              0x09
+#define MAX8925_ALARM0_HOUR             0x0a
+#define MAX8925_ALARM0_WEEKDAY          0x0b
+#define MAX8925_ALARM0_DATE             0x0c
+#define MAX8925_ALARM0_MON              0x0d
+#define MAX8925_ALARM0_YEAR1            0x0e
+#define MAX8925_ALARM0_YEAR2            0x0f
+#define MAX8925_ALARM1_SEC              0x10
+#define MAX8925_ALARM1_MIN              0x11
+#define MAX8925_ALARM1_HOUR             0x12
+#define MAX8925_ALARM1_WEEKDAY          0x13
+#define MAX8925_ALARM1_DATE             0x14
+#define MAX8925_ALARM1_MON              0x15
+#define MAX8925_ALARM1_YEAR1            0x16
+#define MAX8925_ALARM1_YEAR2            0x17
+#define MAX8925_RTC_CNTL                0x1b
+#define MAX8925_RTC_STATUS              0x20
+
+#define TIME_NUM                        8
+#define ALARM_1SEC                      (1 << 7)
+#define HOUR_12                         (1 << 7)
+#define HOUR_AM_PM                      (1 << 5)
+#define ALARM0_IRQ                      (1 << 3)
+#define ALARM1_IRQ                      (1 << 2)
+#define ALARM0_STATUS                   (1 << 2)
+#define ALARM1_STATUS                   (1 << 1)
+
+
+struct max8925_rtc_info {
+        struct rtc_device       *rtc_dev;
+        struct max8925_chip     *chip;
+        struct i2c_client       *rtc;
+        struct device           *dev;
+};
+
+static irqreturn_t rtc_update_handler(int irq, void *data)
+{
+        struct max8925_rtc_info *info = (struct max8925_rtc_info *)data;
+
+        /* disable ALARM0 except for 1SEC alarm */
+        max8925_set_bits(info->rtc, MAX8925_ALARM0_CNTL, 0x7f, 0);
+        rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
+        return IRQ_HANDLED;
+}
+
+static int tm_calc(struct rtc_time *tm, unsigned char *buf, int len)
+{
+        if (len < TIME_NUM)
+                return -EINVAL;
+        tm->tm_year = (buf[RTC_YEAR2] >> 4) * 1000
+                        + (buf[RTC_YEAR2] & 0xf) * 100
+                        + (buf[RTC_YEAR1] >> 4) * 10
+                        + (buf[RTC_YEAR1] & 0xf);
+        tm->tm_year -= 1900;
+        tm->tm_mon = ((buf[RTC_MONTH] >> 4) & 0x01) * 10
+                        + (buf[RTC_MONTH] & 0x0f);
+        tm->tm_mday = ((buf[RTC_DATE] >> 4) & 0x03) * 10
+                        + (buf[RTC_DATE] & 0x0f);
+        tm->tm_wday = buf[RTC_WEEKDAY] & 0x07;
+        if (buf[RTC_HOUR] & HOUR_12) {
+                tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x1) * 10
+                                + (buf[RTC_HOUR] & 0x0f);
+                if (buf[RTC_HOUR] & HOUR_AM_PM)
+                        tm->tm_hour += 12;
+        } else
+                tm->tm_hour = ((buf[RTC_HOUR] >> 4) & 0x03) * 10
+                                + (buf[RTC_HOUR] & 0x0f);
+        tm->tm_min = ((buf[RTC_MIN] >> 4) & 0x7) * 10
+                        + (buf[RTC_MIN] & 0x0f);
+        tm->tm_sec = ((buf[RTC_SEC] >> 4) & 0x7) * 10
+                        + (buf[RTC_SEC] & 0x0f);
+        return 0;
+}
+
+static int data_calc(unsigned char *buf, struct rtc_time *tm, int len)
+{
+        unsigned char high, low;
+
+        if (len < TIME_NUM)
+                return -EINVAL;
+
+        high = (tm->tm_year + 1900) / 1000;
+        low = (tm->tm_year + 1900) / 100;
+        low = low - high * 10;
+        buf[RTC_YEAR2] = (high << 4) + low;
+        high = (tm->tm_year + 1900) / 10;
+        low = tm->tm_year + 1900;
+        low = low - high * 10;
+        high = high - (high / 10) * 10;
+        buf[RTC_YEAR1] = (high << 4) + low;
+        high = tm->tm_mon / 10;
+        low = tm->tm_mon;
+        low = low - high * 10;
+        buf[RTC_MONTH] = (high << 4) + low;
+        high = tm->tm_mday / 10;
+        low = tm->tm_mday;
+        low = low - high * 10;
+        buf[RTC_DATE] = (high << 4) + low;
+        buf[RTC_WEEKDAY] = tm->tm_wday;
+        high = tm->tm_hour / 10;
+        low = tm->tm_hour;
+        low = low - high * 10;
+        buf[RTC_HOUR] = (high << 4) + low;
+        high = tm->tm_min / 10;
+        low = tm->tm_min;
+        low = low - high * 10;
+        buf[RTC_MIN] = (high << 4) + low;
+        high = tm->tm_sec / 10;
+        low = tm->tm_sec;
+        low = low - high * 10;
+        buf[RTC_SEC] = (high << 4) + low;
+        return 0;
+}
+
+static int max8925_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct max8925_rtc_info *info = dev_get_drvdata(dev);
+        unsigned char buf[TIME_NUM];
+        int ret;
+
+        ret = max8925_bulk_read(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
+        if (ret < 0)
+                goto out;
+        ret = tm_calc(tm, buf, TIME_NUM);
+out:
+        return ret;
+}
+
+static int max8925_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct max8925_rtc_info *info = dev_get_drvdata(dev);
+        unsigned char buf[TIME_NUM];
+        int ret;
+
+        ret = data_calc(buf, tm, TIME_NUM);
+        if (ret < 0)
+                goto out;
+        ret = max8925_bulk_write(info->rtc, MAX8925_RTC_SEC, TIME_NUM, buf);
+out:
+        return ret;
+}
+
+static int max8925_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct max8925_rtc_info *info = dev_get_drvdata(dev);
+        unsigned char buf[TIME_NUM];
+        int ret;
+
+        ret = max8925_bulk_read(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
+        if (ret < 0)
+                goto out;
+        ret = tm_calc(&alrm->time, buf, TIME_NUM);
+        if (ret < 0)
+                goto out;
+        ret = max8925_reg_read(info->rtc, MAX8925_RTC_IRQ_MASK);
+        if (ret < 0)
+                goto out;
+        if ((ret & ALARM0_IRQ) == 0)
+                alrm->enabled = 1;
+        else
+                alrm->enabled = 0;
+        ret = max8925_reg_read(info->rtc, MAX8925_RTC_STATUS);
+        if (ret < 0)
+                goto out;
+        if (ret & ALARM0_STATUS)
+                alrm->pending = 1;
+        else
+                alrm->pending = 0;
+out:
+        return ret;
+}
+
+static int max8925_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct max8925_rtc_info *info = dev_get_drvdata(dev);
+        unsigned char buf[TIME_NUM];
+        int ret;
+
+        ret = data_calc(buf, &alrm->time, TIME_NUM);
+        if (ret < 0)
+                goto out;
+        ret = max8925_bulk_write(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
+        if (ret < 0)
+                goto out;
+        /* only enable alarm on year/month/day/hour/min/sec */
+        ret = max8925_reg_write(info->rtc, MAX8925_ALARM0_CNTL, 0x77);
+        if (ret < 0)
+                goto out;
+out:
+        return ret;
+}
+
+static const struct rtc_class_ops max8925_rtc_ops = {
+        .read_time      = max8925_rtc_read_time,
+        .set_time       = max8925_rtc_set_time,
+        .read_alarm     = max8925_rtc_read_alarm,
+        .set_alarm      = max8925_rtc_set_alarm,
+};
+
+static int __devinit max8925_rtc_probe(struct platform_device *pdev)
+{
+        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+        struct max8925_rtc_info *info;
+        int irq, ret;
+
+        info = kzalloc(sizeof(struct max8925_rtc_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+        info->chip = chip;
+        info->rtc = chip->rtc;
+        info->dev = &pdev->dev;
+        irq = chip->irq_base + MAX8925_IRQ_RTC_ALARM0;
+
+        ret = request_threaded_irq(irq, NULL, rtc_update_handler,
+                                   IRQF_ONESHOT, "rtc-alarm0", info);
+        if (ret < 0) {
+                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+                        irq, ret);
+                goto out_irq;
+        }
+
+        info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
+                                        &max8925_rtc_ops, THIS_MODULE);
+        ret = PTR_ERR(info->rtc_dev);
+        if (IS_ERR(info->rtc_dev)) {
+                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
+                goto out_rtc;
+        }
+
+        dev_set_drvdata(&pdev->dev, info);
+        platform_set_drvdata(pdev, info);
+
+        return 0;
+out_rtc:
+        free_irq(chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
+out_irq:
+        kfree(info);
+        return ret;
+}
+
+static int __devexit max8925_rtc_remove(struct platform_device *pdev)
+{
+        struct max8925_rtc_info *info = platform_get_drvdata(pdev);
+
+        if (info) {
+                free_irq(info->chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
+                rtc_device_unregister(info->rtc_dev);
+                kfree(info);
+        }
+        return 0;
+}
+
+static struct platform_driver max8925_rtc_driver = {
+        .driver         = {
+                .name   = "max8925-rtc",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = max8925_rtc_probe,
+        .remove         = __devexit_p(max8925_rtc_remove),
+};
+
+static int __init max8925_rtc_init(void)
+{
+        return platform_driver_register(&max8925_rtc_driver);
+}
+module_init(max8925_rtc_init);
+
+static void __exit max8925_rtc_exit(void)
+{
+        platform_driver_unregister(&max8925_rtc_driver);
+}
+module_exit(max8925_rtc_exit);
+
+MODULE_DESCRIPTION("Maxim MAX8925 RTC driver");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/rtc/rtc-max8998.c b/drivers/rtc/rtc-max8998.c
new file mode 100644
index 000000000000..f22dee35f330
--- /dev/null
+++ b/drivers/rtc/rtc-max8998.c
@@ -0,0 +1,300 @@
+/*
+ * 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>
+
+#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;
+};
+
+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];
+
+        max8998_tm_to_data(tm, data);
+
+        return max8998_bulk_write(info->rtc, MAX8998_RTC_SEC, 8, data);
+}
+
+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)
+{
+        return max8998_write_reg(info->rtc, MAX8998_ALARM0_CONF, 0);
+}
+
+static int max8998_rtc_start_alarm(struct max8998_rtc_info *info)
+{
+        return max8998_write_reg(info->rtc, MAX8998_ALARM0_CONF, 0x77);
+}
+
+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 (alrm->enabled)
+                return max8998_rtc_start_alarm(info);
+
+        return 0;
+}
+
+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_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);
+
+        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 struct platform_driver max8998_rtc_driver = {
+        .driver         = {
+                .name   = "max8998-rtc",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = max8998_rtc_probe,
+        .remove         = __devexit_p(max8998_rtc_remove),
+};
+
+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-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-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
new file mode 100644
index 000000000000..dfcdf0901d21
--- /dev/null
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -0,0 +1,390 @@
+/*
+ * Real-time clock driver for MPC5121
+ *
+ * Copyright 2007, Domen Puncer <domen.puncer@telargo.com>
+ * Copyright 2008, Freescale Semiconductor, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+
+struct mpc5121_rtc_regs {
+        u8 set_time;            /* RTC + 0x00 */
+        u8 hour_set;            /* RTC + 0x01 */
+        u8 minute_set;          /* RTC + 0x02 */
+        u8 second_set;          /* RTC + 0x03 */
+
+        u8 set_date;            /* RTC + 0x04 */
+        u8 month_set;           /* RTC + 0x05 */
+        u8 weekday_set;         /* RTC + 0x06 */
+        u8 date_set;            /* RTC + 0x07 */
+
+        u8 write_sw;            /* RTC + 0x08 */
+        u8 sw_set;              /* RTC + 0x09 */
+        u16 year_set;           /* RTC + 0x0a */
+
+        u8 alm_enable;          /* RTC + 0x0c */
+        u8 alm_hour_set;        /* RTC + 0x0d */
+        u8 alm_min_set;         /* RTC + 0x0e */
+        u8 int_enable;          /* RTC + 0x0f */
+
+        u8 reserved1;
+        u8 hour;                /* RTC + 0x11 */
+        u8 minute;              /* RTC + 0x12 */
+        u8 second;              /* RTC + 0x13 */
+
+        u8 month;               /* RTC + 0x14 */
+        u8 wday_mday;           /* RTC + 0x15 */
+        u16 year;               /* RTC + 0x16 */
+
+        u8 int_alm;             /* RTC + 0x18 */
+        u8 int_sw;              /* RTC + 0x19 */
+        u8 alm_status;          /* RTC + 0x1a */
+        u8 sw_minute;           /* RTC + 0x1b */
+
+        u8 bus_error_1;         /* RTC + 0x1c */
+        u8 int_day;             /* RTC + 0x1d */
+        u8 int_min;             /* RTC + 0x1e */
+        u8 int_sec;             /* RTC + 0x1f */
+
+        /*
+         * target_time:
+         *      intended to be used for hibernation but hibernation
+         *      does not work on silicon rev 1.5 so use it for non-volatile
+         *      storage of offset between the actual_time register and linux
+         *      time
+         */
+        u32 target_time;        /* RTC + 0x20 */
+        /*
+         * actual_time:
+         *      readonly time since VBAT_RTC was last connected
+         */
+        u32 actual_time;        /* RTC + 0x24 */
+        u32 keep_alive;         /* RTC + 0x28 */
+};
+
+struct mpc5121_rtc_data {
+        unsigned irq;
+        unsigned irq_periodic;
+        struct mpc5121_rtc_regs __iomem *regs;
+        struct rtc_device *rtc;
+        struct rtc_wkalrm wkalarm;
+};
+
+/*
+ * Update second/minute/hour registers.
+ *
+ * This is just so alarm will work.
+ */
+static void mpc5121_rtc_update_smh(struct mpc5121_rtc_regs __iomem *regs,
+                                   struct rtc_time *tm)
+{
+        out_8(&regs->second_set, tm->tm_sec);
+        out_8(&regs->minute_set, tm->tm_min);
+        out_8(&regs->hour_set, tm->tm_hour);
+
+        /* set time sequence */
+        out_8(&regs->set_time, 0x1);
+        out_8(&regs->set_time, 0x3);
+        out_8(&regs->set_time, 0x1);
+        out_8(&regs->set_time, 0x0);
+}
+
+static int mpc5121_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        unsigned long now;
+
+        /*
+         * linux time is actual_time plus the offset saved in target_time
+         */
+        now = in_be32(&regs->actual_time) + in_be32(&regs->target_time);
+
+        rtc_time_to_tm(now, tm);
+
+        /*
+         * update second minute hour registers
+         * so alarms will work
+         */
+        mpc5121_rtc_update_smh(regs, tm);
+
+        return rtc_valid_tm(tm);
+}
+
+static int mpc5121_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        int ret;
+        unsigned long now;
+
+        /*
+         * The actual_time register is read only so we write the offset
+         * between it and linux time to the target_time register.
+         */
+        ret = rtc_tm_to_time(tm, &now);
+        if (ret == 0)
+                out_be32(&regs->target_time, now - in_be32(&regs->actual_time));
+
+        /*
+         * update second minute hour registers
+         * so alarms will work
+         */
+        mpc5121_rtc_update_smh(regs, tm);
+
+        return 0;
+}
+
+static int mpc5121_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        *alarm = rtc->wkalarm;
+
+        alarm->pending = in_8(&regs->alm_status);
+
+        return 0;
+}
+
+static int mpc5121_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        /*
+         * the alarm has no seconds so deal with it
+         */
+        if (alarm->time.tm_sec) {
+                alarm->time.tm_sec = 0;
+                alarm->time.tm_min++;
+                if (alarm->time.tm_min >= 60) {
+                        alarm->time.tm_min = 0;
+                        alarm->time.tm_hour++;
+                        if (alarm->time.tm_hour >= 24)
+                                alarm->time.tm_hour = 0;
+                }
+        }
+
+        alarm->time.tm_mday = -1;
+        alarm->time.tm_mon = -1;
+        alarm->time.tm_year = -1;
+
+        out_8(&regs->alm_min_set, alarm->time.tm_min);
+        out_8(&regs->alm_hour_set, alarm->time.tm_hour);
+
+        out_8(&regs->alm_enable, alarm->enabled);
+
+        rtc->wkalarm = *alarm;
+        return 0;
+}
+
+static irqreturn_t mpc5121_rtc_handler(int irq, void *dev)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata((struct device *)dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        if (in_8(&regs->int_alm)) {
+                /* acknowledge and clear status */
+                out_8(&regs->int_alm, 1);
+                out_8(&regs->alm_status, 1);
+
+                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
+}
+
+static irqreturn_t mpc5121_rtc_handler_upd(int irq, void *dev)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata((struct device *)dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        if (in_8(&regs->int_sec) && (in_8(&regs->int_enable) & 0x1)) {
+                /* acknowledge */
+                out_8(&regs->int_sec, 1);
+
+                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_UF);
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
+}
+
+static int mpc5121_rtc_alarm_irq_enable(struct device *dev,
+                                        unsigned int enabled)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        int val;
+
+        if (enabled)
+                val = 1;
+        else
+                val = 0;
+
+        out_8(&regs->alm_enable, val);
+        rtc->wkalarm.enabled = val;
+
+        return 0;
+}
+
+static int mpc5121_rtc_update_irq_enable(struct device *dev,
+                                         unsigned int enabled)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        int val;
+
+        val = in_8(&regs->int_enable);
+
+        if (enabled)
+                val = (val & ~0x8) | 0x1;
+        else
+                val &= ~0x1;
+
+        out_8(&regs->int_enable, val);
+
+        return 0;
+}
+
+static const struct rtc_class_ops mpc5121_rtc_ops = {
+        .read_time = mpc5121_rtc_read_time,
+        .set_time = mpc5121_rtc_set_time,
+        .read_alarm = mpc5121_rtc_read_alarm,
+        .set_alarm = mpc5121_rtc_set_alarm,
+        .alarm_irq_enable = mpc5121_rtc_alarm_irq_enable,
+        .update_irq_enable = mpc5121_rtc_update_irq_enable,
+};
+
+static int __devinit mpc5121_rtc_probe(struct platform_device *op,
+                                        const struct of_device_id *match)
+{
+        struct mpc5121_rtc_data *rtc;
+        int err = 0;
+        u32 ka;
+
+        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        if (!rtc)
+                return -ENOMEM;
+
+        rtc->regs = of_iomap(op->dev.of_node, 0);
+        if (!rtc->regs) {
+                dev_err(&op->dev, "%s: couldn't map io space\n", __func__);
+                err = -ENOSYS;
+                goto out_free;
+        }
+
+        device_init_wakeup(&op->dev, 1);
+
+        dev_set_drvdata(&op->dev, rtc);
+
+        rtc->irq = irq_of_parse_and_map(op->dev.of_node, 1);
+        err = request_irq(rtc->irq, mpc5121_rtc_handler, IRQF_DISABLED,
+                                                "mpc5121-rtc", &op->dev);
+        if (err) {
+                dev_err(&op->dev, "%s: could not request irq: %i\n",
+                                                        __func__, rtc->irq);
+                goto out_dispose;
+        }
+
+        rtc->irq_periodic = irq_of_parse_and_map(op->dev.of_node, 0);
+        err = request_irq(rtc->irq_periodic, mpc5121_rtc_handler_upd,
+                                IRQF_DISABLED, "mpc5121-rtc_upd", &op->dev);
+        if (err) {
+                dev_err(&op->dev, "%s: could not request irq: %i\n",
+                                                __func__, rtc->irq_periodic);
+                goto out_dispose2;
+        }
+
+        ka = in_be32(&rtc->regs->keep_alive);
+        if (ka & 0x02) {
+                dev_warn(&op->dev,
+                        "mpc5121-rtc: Battery or oscillator failure!\n");
+                out_be32(&rtc->regs->keep_alive, ka);
+        }
+
+        rtc->rtc = rtc_device_register("mpc5121-rtc", &op->dev,
+                                        &mpc5121_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc->rtc)) {
+                err = PTR_ERR(rtc->rtc);
+                goto out_free_irq;
+        }
+
+        return 0;
+
+out_free_irq:
+        free_irq(rtc->irq_periodic, &op->dev);
+out_dispose2:
+        irq_dispose_mapping(rtc->irq_periodic);
+        free_irq(rtc->irq, &op->dev);
+out_dispose:
+        irq_dispose_mapping(rtc->irq);
+        iounmap(rtc->regs);
+out_free:
+        kfree(rtc);
+
+        return err;
+}
+
+static int __devexit mpc5121_rtc_remove(struct platform_device *op)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(&op->dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        /* disable interrupt, so there are no nasty surprises */
+        out_8(&regs->alm_enable, 0);
+        out_8(&regs->int_enable, in_8(&regs->int_enable) & ~0x1);
+
+        rtc_device_unregister(rtc->rtc);
+        iounmap(rtc->regs);
+        free_irq(rtc->irq, &op->dev);
+        free_irq(rtc->irq_periodic, &op->dev);
+        irq_dispose_mapping(rtc->irq);
+        irq_dispose_mapping(rtc->irq_periodic);
+        dev_set_drvdata(&op->dev, NULL);
+        kfree(rtc);
+
+        return 0;
+}
+
+static struct of_device_id mpc5121_rtc_match[] __devinitdata = {
+        { .compatible = "fsl,mpc5121-rtc", },
+        {},
+};
+
+static struct of_platform_driver mpc5121_rtc_driver = {
+        .driver = {
+                .name = "mpc5121-rtc",
+                .owner = THIS_MODULE,
+                .of_match_table = mpc5121_rtc_match,
+        },
+        .probe = mpc5121_rtc_probe,
+        .remove = __devexit_p(mpc5121_rtc_remove),
+};
+
+static int __init mpc5121_rtc_init(void)
+{
+        return of_register_platform_driver(&mpc5121_rtc_driver);
+}
+module_init(mpc5121_rtc_init);
+
+static void __exit mpc5121_rtc_exit(void)
+{
+        of_unregister_platform_driver(&mpc5121_rtc_driver);
+}
+module_exit(mpc5121_rtc_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("John Rigby <jcrigby@gmail.com>");
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-msm6242.c b/drivers/rtc/rtc-msm6242.c
new file mode 100644
index 000000000000..b2fff0ca49f8
--- /dev/null
+++ b/drivers/rtc/rtc-msm6242.c
@@ -0,0 +1,270 @@
+/*
+ *  Oki MSM6242 RTC Driver
+ *
+ *  Copyright 2009 Geert Uytterhoeven
+ *
+ *  Based on the A2000 TOD code in arch/m68k/amiga/config.c
+ *  Copyright (C) 1993 Hamish Macdonald
+ */
+
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+
+
+enum {
+        MSM6242_SECOND1         = 0x0,  /* 1-second digit register */
+        MSM6242_SECOND10        = 0x1,  /* 10-second digit register */
+        MSM6242_MINUTE1         = 0x2,  /* 1-minute digit register */
+        MSM6242_MINUTE10        = 0x3,  /* 10-minute digit register */
+        MSM6242_HOUR1           = 0x4,  /* 1-hour digit register */
+        MSM6242_HOUR10          = 0x5,  /* PM/AM, 10-hour digit register */
+        MSM6242_DAY1            = 0x6,  /* 1-day digit register */
+        MSM6242_DAY10           = 0x7,  /* 10-day digit register */
+        MSM6242_MONTH1          = 0x8,  /* 1-month digit register */
+        MSM6242_MONTH10         = 0x9,  /* 10-month digit register */
+        MSM6242_YEAR1           = 0xa,  /* 1-year digit register */
+        MSM6242_YEAR10          = 0xb,  /* 10-year digit register */
+        MSM6242_WEEK            = 0xc,  /* Week register */
+        MSM6242_CD              = 0xd,  /* Control Register D */
+        MSM6242_CE              = 0xe,  /* Control Register E */
+        MSM6242_CF              = 0xf,  /* Control Register F */
+};
+
+#define MSM6242_HOUR10_AM       (0 << 2)
+#define MSM6242_HOUR10_PM       (1 << 2)
+#define MSM6242_HOUR10_HR_MASK  (3 << 0)
+
+#define MSM6242_WEEK_SUNDAY     0
+#define MSM6242_WEEK_MONDAY     1
+#define MSM6242_WEEK_TUESDAY    2
+#define MSM6242_WEEK_WEDNESDAY  3
+#define MSM6242_WEEK_THURSDAY   4
+#define MSM6242_WEEK_FRIDAY     5
+#define MSM6242_WEEK_SATURDAY   6
+
+#define MSM6242_CD_30_S_ADJ     (1 << 3)        /* 30-second adjustment */
+#define MSM6242_CD_IRQ_FLAG     (1 << 2)
+#define MSM6242_CD_BUSY         (1 << 1)
+#define MSM6242_CD_HOLD         (1 << 0)
+
+#define MSM6242_CE_T_MASK       (3 << 2)
+#define MSM6242_CE_T_64HZ       (0 << 2)        /* period 1/64 second */
+#define MSM6242_CE_T_1HZ        (1 << 2)        /* period 1 second */
+#define MSM6242_CE_T_1MINUTE    (2 << 2)        /* period 1 minute */
+#define MSM6242_CE_T_1HOUR      (3 << 2)        /* period 1 hour */
+
+#define MSM6242_CE_ITRPT_STND   (1 << 1)
+#define MSM6242_CE_MASK         (1 << 0)        /* STD.P output control */
+
+#define MSM6242_CF_TEST         (1 << 3)
+#define MSM6242_CF_12H          (0 << 2)
+#define MSM6242_CF_24H          (1 << 2)
+#define MSM6242_CF_STOP         (1 << 1)
+#define MSM6242_CF_REST         (1 << 0)        /* reset */
+
+
+struct msm6242_priv {
+        u32 __iomem *regs;
+        struct rtc_device *rtc;
+};
+
+static inline unsigned int msm6242_read(struct msm6242_priv *priv,
+                                       unsigned int reg)
+{
+        return __raw_readl(&priv->regs[reg]) & 0xf;
+}
+
+static inline void msm6242_write(struct msm6242_priv *priv, unsigned int val,
+                                unsigned int reg)
+{
+        return __raw_writel(val, &priv->regs[reg]);
+}
+
+static inline void msm6242_set(struct msm6242_priv *priv, unsigned int val,
+                               unsigned int reg)
+{
+        msm6242_write(priv, msm6242_read(priv, reg) | val, reg);
+}
+
+static inline void msm6242_clear(struct msm6242_priv *priv, unsigned int val,
+                                 unsigned int reg)
+{
+        msm6242_write(priv, msm6242_read(priv, reg) & ~val, reg);
+}
+
+static void msm6242_lock(struct msm6242_priv *priv)
+{
+        int cnt = 5;
+
+        msm6242_set(priv, MSM6242_CD_HOLD, MSM6242_CD);
+
+        while ((msm6242_read(priv, MSM6242_CD) & MSM6242_CD_BUSY) && cnt) {
+                msm6242_clear(priv, MSM6242_CD_HOLD, MSM6242_CD);
+                udelay(70);
+                msm6242_set(priv, MSM6242_CD_HOLD, MSM6242_CD);
+                cnt--;
+        }
+
+        if (!cnt)
+                pr_warning("msm6242: timed out waiting for RTC (0x%x)\n",
+                           msm6242_read(priv, MSM6242_CD));
+}
+
+static void msm6242_unlock(struct msm6242_priv *priv)
+{
+        msm6242_clear(priv, MSM6242_CD_HOLD, MSM6242_CD);
+}
+
+static int msm6242_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct msm6242_priv *priv = dev_get_drvdata(dev);
+
+        msm6242_lock(priv);
+
+        tm->tm_sec  = msm6242_read(priv, MSM6242_SECOND10) * 10 +
+                      msm6242_read(priv, MSM6242_SECOND1);
+        tm->tm_min  = msm6242_read(priv, MSM6242_MINUTE10) * 10 +
+                      msm6242_read(priv, MSM6242_MINUTE1);
+        tm->tm_hour = (msm6242_read(priv, MSM6242_HOUR10 & 3)) * 10 +
+                      msm6242_read(priv, MSM6242_HOUR1);
+        tm->tm_mday = msm6242_read(priv, MSM6242_DAY10) * 10 +
+                      msm6242_read(priv, MSM6242_DAY1);
+        tm->tm_wday = msm6242_read(priv, MSM6242_WEEK);
+        tm->tm_mon  = msm6242_read(priv, MSM6242_MONTH10) * 10 +
+                      msm6242_read(priv, MSM6242_MONTH1) - 1;
+        tm->tm_year = msm6242_read(priv, MSM6242_YEAR10) * 10 +
+                      msm6242_read(priv, MSM6242_YEAR1);
+        if (tm->tm_year <= 69)
+                tm->tm_year += 100;
+
+        if (!(msm6242_read(priv, MSM6242_CF) & MSM6242_CF_24H)) {
+                unsigned int pm = msm6242_read(priv, MSM6242_HOUR10) &
+                                  MSM6242_HOUR10_PM;
+                if (!pm && tm->tm_hour == 12)
+                        tm->tm_hour = 0;
+                else if (pm && tm->tm_hour != 12)
+                        tm->tm_hour += 12;
+        }
+
+        msm6242_unlock(priv);
+
+        return rtc_valid_tm(tm);
+}
+
+static int msm6242_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct msm6242_priv *priv = dev_get_drvdata(dev);
+
+        msm6242_lock(priv);
+
+        msm6242_write(priv, tm->tm_sec / 10, MSM6242_SECOND10);
+        msm6242_write(priv, tm->tm_sec % 10, MSM6242_SECOND1);
+        msm6242_write(priv, tm->tm_min / 10, MSM6242_MINUTE10);
+        msm6242_write(priv, tm->tm_min % 10, MSM6242_MINUTE1);
+        if (msm6242_read(priv, MSM6242_CF) & MSM6242_CF_24H)
+                msm6242_write(priv, tm->tm_hour / 10, MSM6242_HOUR10);
+        else if (tm->tm_hour >= 12)
+                msm6242_write(priv, MSM6242_HOUR10_PM + (tm->tm_hour - 12) / 10,
+                              MSM6242_HOUR10);
+        else
+                msm6242_write(priv, tm->tm_hour / 10, MSM6242_HOUR10);
+        msm6242_write(priv, tm->tm_hour % 10, MSM6242_HOUR1);
+        msm6242_write(priv, tm->tm_mday / 10, MSM6242_DAY10);
+        msm6242_write(priv, tm->tm_mday % 10, MSM6242_DAY1);
+        if (tm->tm_wday != -1)
+                msm6242_write(priv, tm->tm_wday, MSM6242_WEEK);
+        msm6242_write(priv, (tm->tm_mon + 1) / 10, MSM6242_MONTH10);
+        msm6242_write(priv, (tm->tm_mon + 1) % 10, MSM6242_MONTH1);
+        if (tm->tm_year >= 100)
+                tm->tm_year -= 100;
+        msm6242_write(priv, tm->tm_year / 10, MSM6242_YEAR10);
+        msm6242_write(priv, tm->tm_year % 10, MSM6242_YEAR1);
+
+        msm6242_unlock(priv);
+        return 0;
+}
+
+static const struct rtc_class_ops msm6242_rtc_ops = {
+        .read_time      = msm6242_read_time,
+        .set_time       = msm6242_set_time,
+};
+
+static int __init msm6242_rtc_probe(struct platform_device *dev)
+{
+        struct resource *res;
+        struct msm6242_priv *priv;
+        struct rtc_device *rtc;
+        int error;
+
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->regs = ioremap(res->start, resource_size(res));
+        if (!priv->regs) {
+                error = -ENOMEM;
+                goto out_free_priv;
+        }
+
+        rtc = rtc_device_register("rtc-msm6242", &dev->dev, &msm6242_rtc_ops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                error = PTR_ERR(rtc);
+                goto out_unmap;
+        }
+
+        priv->rtc = rtc;
+        platform_set_drvdata(dev, priv);
+        return 0;
+
+out_unmap:
+        iounmap(priv->regs);
+out_free_priv:
+        kfree(priv);
+        return error;
+}
+
+static int __exit msm6242_rtc_remove(struct platform_device *dev)
+{
+        struct msm6242_priv *priv = platform_get_drvdata(dev);
+
+        rtc_device_unregister(priv->rtc);
+        iounmap(priv->regs);
+        kfree(priv);
+        return 0;
+}
+
+static struct platform_driver msm6242_rtc_driver = {
+        .driver = {
+                .name   = "rtc-msm6242",
+                .owner  = THIS_MODULE,
+        },
+        .remove = __exit_p(msm6242_rtc_remove),
+};
+
+static int __init msm6242_rtc_init(void)
+{
+        return platform_driver_probe(&msm6242_rtc_driver, msm6242_rtc_probe);
+}
+
+static void __exit msm6242_rtc_fini(void)
+{
+        platform_driver_unregister(&msm6242_rtc_driver);
+}
+
+module_init(msm6242_rtc_init);
+module_exit(msm6242_rtc_fini);
+
+MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Oki MSM6242 RTC driver");
+MODULE_ALIAS("platform:rtc-msm6242");
diff --git a/drivers/rtc/rtc-mv.c b/drivers/rtc/rtc-mv.c
index e0263d2005ee..bcca47298554 100644
--- a/drivers/rtc/rtc-mv.c
+++ b/drivers/rtc/rtc-mv.c
@@ -13,6 +13,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/delay.h>
+#include <linux/gfp.h>
 
 
 #define RTC_TIME_REG_OFFS       0
@@ -27,10 +28,17 @@
 #define RTC_MONTH_OFFS          8
 #define RTC_YEAR_OFFS           16
 
+#define RTC_ALARM_TIME_REG_OFFS 8
+#define RTC_ALARM_DATE_REG_OFFS 0xc
+#define RTC_ALARM_VALID         (1 << 7)
+
+#define RTC_ALARM_INTERRUPT_MASK_REG_OFFS       0x10
+#define RTC_ALARM_INTERRUPT_CASUE_REG_OFFS      0x14
 
 struct rtc_plat_data {
         struct rtc_device *rtc;
         void __iomem *ioaddr;
+        int             irq;
 };
 
 static int mv_rtc_set_time(struct device *dev, struct rtc_time *tm)
@@ -84,12 +92,134 @@ static int mv_rtc_read_time(struct device *dev, struct rtc_time *tm)
         return rtc_valid_tm(tm);
 }
 
+static int mv_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct rtc_plat_data *pdata = dev_get_drvdata(dev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u32     rtc_time, rtc_date;
+        unsigned int year, month, day, hour, minute, second, wday;
+
+        rtc_time = readl(ioaddr + RTC_ALARM_TIME_REG_OFFS);
+        rtc_date = readl(ioaddr + RTC_ALARM_DATE_REG_OFFS);
+
+        second = rtc_time & 0x7f;
+        minute = (rtc_time >> RTC_MINUTES_OFFS) & 0x7f;
+        hour = (rtc_time >> RTC_HOURS_OFFS) & 0x3f; /* assume 24 hours mode */
+        wday = (rtc_time >> RTC_WDAY_OFFS) & 0x7;
+
+        day = rtc_date & 0x3f;
+        month = (rtc_date >> RTC_MONTH_OFFS) & 0x3f;
+        year = (rtc_date >> RTC_YEAR_OFFS) & 0xff;
+
+        alm->time.tm_sec = bcd2bin(second);
+        alm->time.tm_min = bcd2bin(minute);
+        alm->time.tm_hour = bcd2bin(hour);
+        alm->time.tm_mday = bcd2bin(day);
+        alm->time.tm_wday = bcd2bin(wday);
+        alm->time.tm_mon = bcd2bin(month) - 1;
+        /* hw counts from year 2000, but tm_year is relative to 1900 */
+        alm->time.tm_year = bcd2bin(year) + 100;
+
+        if (rtc_valid_tm(&alm->time) < 0) {
+                dev_err(dev, "retrieved alarm date/time is not valid.\n");
+                rtc_time_to_tm(0, &alm->time);
+        }
+
+        alm->enabled = !!readl(ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
+        return 0;
+}
+
+static int mv_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct rtc_plat_data *pdata = dev_get_drvdata(dev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u32 rtc_reg = 0;
+
+        if (alm->time.tm_sec >= 0)
+                rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_sec))
+                        << RTC_SECONDS_OFFS;
+        if (alm->time.tm_min >= 0)
+                rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_min))
+                        << RTC_MINUTES_OFFS;
+        if (alm->time.tm_hour >= 0)
+                rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_hour))
+                        << RTC_HOURS_OFFS;
+
+        writel(rtc_reg, ioaddr + RTC_ALARM_TIME_REG_OFFS);
+
+        if (alm->time.tm_mday >= 0)
+                rtc_reg = (RTC_ALARM_VALID | bin2bcd(alm->time.tm_mday))
+                        << RTC_MDAY_OFFS;
+        else
+                rtc_reg = 0;
+
+        if (alm->time.tm_mon >= 0)
+                rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_mon + 1))
+                        << RTC_MONTH_OFFS;
+
+        if (alm->time.tm_year >= 0)
+                rtc_reg |= (RTC_ALARM_VALID | bin2bcd(alm->time.tm_year % 100))
+                        << RTC_YEAR_OFFS;
+
+        writel(rtc_reg, ioaddr + RTC_ALARM_DATE_REG_OFFS);
+        writel(0, ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS);
+        writel(alm->enabled ? 1 : 0,
+               ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
+
+        return 0;
+}
+
+static int mv_rtc_ioctl(struct device *dev, unsigned int cmd,
+                        unsigned long arg)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+
+        if (pdata->irq < 0)
+                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
+                break;
+        case RTC_AIE_ON:
+                writel(1, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+static irqreturn_t mv_rtc_interrupt(int irq, void *data)
+{
+        struct rtc_plat_data *pdata = data;
+        void __iomem *ioaddr = pdata->ioaddr;
+
+        /* alarm irq? */
+        if (!readl(ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS))
+                return IRQ_NONE;
+
+        /* clear interrupt */
+        writel(0, ioaddr + RTC_ALARM_INTERRUPT_CASUE_REG_OFFS);
+        rtc_update_irq(pdata->rtc, 1, RTC_IRQF | RTC_AF);
+        return IRQ_HANDLED;
+}
+
 static const struct rtc_class_ops mv_rtc_ops = {
         .read_time      = mv_rtc_read_time,
         .set_time       = mv_rtc_set_time,
 };
 
-static int __init mv_rtc_probe(struct platform_device *pdev)
+static const struct rtc_class_ops mv_rtc_alarm_ops = {
+        .read_time      = mv_rtc_read_time,
+        .set_time       = mv_rtc_set_time,
+        .read_alarm     = mv_rtc_read_alarm,
+        .set_alarm      = mv_rtc_set_alarm,
+        .ioctl          = mv_rtc_ioctl,
+};
+
+static int __devinit mv_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct rtc_plat_data *pdata;
@@ -130,12 +260,31 @@ static int __init mv_rtc_probe(struct platform_device *pdev)
                 }
         }
 
+        pdata->irq = platform_get_irq(pdev, 0);
+
         platform_set_drvdata(pdev, pdata);
-        pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
-                                         &mv_rtc_ops, THIS_MODULE);
+
+        if (pdata->irq >= 0) {
+                device_init_wakeup(&pdev->dev, 1);
+                pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                                 &mv_rtc_alarm_ops,
+                                                 THIS_MODULE);
+        } else
+                pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                                 &mv_rtc_ops, THIS_MODULE);
         if (IS_ERR(pdata->rtc))
                 return PTR_ERR(pdata->rtc);
 
+        if (pdata->irq >= 0) {
+                writel(0, pdata->ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS);
+                if (devm_request_irq(&pdev->dev, pdata->irq, mv_rtc_interrupt,
+                                     IRQF_DISABLED | IRQF_SHARED,
+                                     pdev->name, pdata) < 0) {
+                        dev_warn(&pdev->dev, "interrupt not available.\n");
+                        pdata->irq = -1;
+                }
+        }
+
         return 0;
 }
 
@@ -143,6 +292,9 @@ static int __exit mv_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
+        if (pdata->irq >= 0)
+                device_init_wakeup(&pdev->dev, 0);
+
         rtc_device_unregister(pdata->rtc);
         return 0;
 }
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
new file mode 100644
index 000000000000..0b06c1e03fd5
--- /dev/null
+++ b/drivers/rtc/rtc-mxc.c
@@ -0,0 +1,496 @@
+/*
+ * Copyright 2004-2008 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+#include <linux/io.h>
+#include <linux/rtc.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+#include <mach/hardware.h>
+
+#define RTC_INPUT_CLK_32768HZ   (0x00 << 5)
+#define RTC_INPUT_CLK_32000HZ   (0x01 << 5)
+#define RTC_INPUT_CLK_38400HZ   (0x02 << 5)
+
+#define RTC_SW_BIT      (1 << 0)
+#define RTC_ALM_BIT     (1 << 2)
+#define RTC_1HZ_BIT     (1 << 4)
+#define RTC_2HZ_BIT     (1 << 7)
+#define RTC_SAM0_BIT    (1 << 8)
+#define RTC_SAM1_BIT    (1 << 9)
+#define RTC_SAM2_BIT    (1 << 10)
+#define RTC_SAM3_BIT    (1 << 11)
+#define RTC_SAM4_BIT    (1 << 12)
+#define RTC_SAM5_BIT    (1 << 13)
+#define RTC_SAM6_BIT    (1 << 14)
+#define RTC_SAM7_BIT    (1 << 15)
+#define PIT_ALL_ON      (RTC_2HZ_BIT | RTC_SAM0_BIT | RTC_SAM1_BIT | \
+                         RTC_SAM2_BIT | RTC_SAM3_BIT | RTC_SAM4_BIT | \
+                         RTC_SAM5_BIT | RTC_SAM6_BIT | RTC_SAM7_BIT)
+
+#define RTC_ENABLE_BIT  (1 << 7)
+
+#define MAX_PIE_NUM     9
+#define MAX_PIE_FREQ    512
+static const u32 PIE_BIT_DEF[MAX_PIE_NUM][2] = {
+        { 2,            RTC_2HZ_BIT },
+        { 4,            RTC_SAM0_BIT },
+        { 8,            RTC_SAM1_BIT },
+        { 16,           RTC_SAM2_BIT },
+        { 32,           RTC_SAM3_BIT },
+        { 64,           RTC_SAM4_BIT },
+        { 128,          RTC_SAM5_BIT },
+        { 256,          RTC_SAM6_BIT },
+        { MAX_PIE_FREQ, RTC_SAM7_BIT },
+};
+
+/* Those are the bits from a classic RTC we want to mimic */
+#define RTC_IRQF        0x80    /* any of the following 3 is active */
+#define RTC_PF          0x40    /* Periodic interrupt */
+#define RTC_AF          0x20    /* Alarm interrupt */
+#define RTC_UF          0x10    /* Update interrupt for 1Hz RTC */
+
+#define MXC_RTC_TIME    0
+#define MXC_RTC_ALARM   1
+
+#define RTC_HOURMIN     0x00    /*  32bit rtc hour/min counter reg */
+#define RTC_SECOND      0x04    /*  32bit rtc seconds counter reg */
+#define RTC_ALRM_HM     0x08    /*  32bit rtc alarm hour/min reg */
+#define RTC_ALRM_SEC    0x0C    /*  32bit rtc alarm seconds reg */
+#define RTC_RTCCTL      0x10    /*  32bit rtc control reg */
+#define RTC_RTCISR      0x14    /*  32bit rtc interrupt status reg */
+#define RTC_RTCIENR     0x18    /*  32bit rtc interrupt enable reg */
+#define RTC_STPWCH      0x1C    /*  32bit rtc stopwatch min reg */
+#define RTC_DAYR        0x20    /*  32bit rtc days counter reg */
+#define RTC_DAYALARM    0x24    /*  32bit rtc day alarm reg */
+#define RTC_TEST1       0x28    /*  32bit rtc test reg 1 */
+#define RTC_TEST2       0x2C    /*  32bit rtc test reg 2 */
+#define RTC_TEST3       0x30    /*  32bit rtc test reg 3 */
+
+struct rtc_plat_data {
+        struct rtc_device *rtc;
+        void __iomem *ioaddr;
+        int irq;
+        struct clk *clk;
+        struct rtc_time g_rtc_alarm;
+};
+
+/*
+ * This function is used to obtain the RTC time or the alarm value in
+ * second.
+ */
+static u32 get_alarm_or_time(struct device *dev, int time_alarm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u32 day = 0, hr = 0, min = 0, sec = 0, hr_min = 0;
+
+        switch (time_alarm) {
+        case MXC_RTC_TIME:
+                day = readw(ioaddr + RTC_DAYR);
+                hr_min = readw(ioaddr + RTC_HOURMIN);
+                sec = readw(ioaddr + RTC_SECOND);
+                break;
+        case MXC_RTC_ALARM:
+                day = readw(ioaddr + RTC_DAYALARM);
+                hr_min = readw(ioaddr + RTC_ALRM_HM) & 0xffff;
+                sec = readw(ioaddr + RTC_ALRM_SEC);
+                break;
+        }
+
+        hr = hr_min >> 8;
+        min = hr_min & 0xff;
+
+        return (((day * 24 + hr) * 60) + min) * 60 + sec;
+}
+
+/*
+ * This function sets the RTC alarm value or the time value.
+ */
+static void set_alarm_or_time(struct device *dev, int time_alarm, u32 time)
+{
+        u32 day, hr, min, sec, temp;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+
+        day = time / 86400;
+        time -= day * 86400;
+
+        /* time is within a day now */
+        hr = time / 3600;
+        time -= hr * 3600;
+
+        /* time is within an hour now */
+        min = time / 60;
+        sec = time - min * 60;
+
+        temp = (hr << 8) + min;
+
+        switch (time_alarm) {
+        case MXC_RTC_TIME:
+                writew(day, ioaddr + RTC_DAYR);
+                writew(sec, ioaddr + RTC_SECOND);
+                writew(temp, ioaddr + RTC_HOURMIN);
+                break;
+        case MXC_RTC_ALARM:
+                writew(day, ioaddr + RTC_DAYALARM);
+                writew(sec, ioaddr + RTC_ALRM_SEC);
+                writew(temp, ioaddr + RTC_ALRM_HM);
+                break;
+        }
+}
+
+/*
+ * This function updates the RTC alarm registers and then clears all the
+ * interrupt status bits.
+ */
+static int rtc_update_alarm(struct device *dev, struct rtc_time *alrm)
+{
+        struct rtc_time alarm_tm, now_tm;
+        unsigned long now, time;
+        int ret;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+
+        now = get_alarm_or_time(dev, MXC_RTC_TIME);
+        rtc_time_to_tm(now, &now_tm);
+        alarm_tm.tm_year = now_tm.tm_year;
+        alarm_tm.tm_mon = now_tm.tm_mon;
+        alarm_tm.tm_mday = now_tm.tm_mday;
+        alarm_tm.tm_hour = alrm->tm_hour;
+        alarm_tm.tm_min = alrm->tm_min;
+        alarm_tm.tm_sec = alrm->tm_sec;
+        rtc_tm_to_time(&now_tm, &now);
+        rtc_tm_to_time(&alarm_tm, &time);
+
+        if (time < now) {
+                time += 60 * 60 * 24;
+                rtc_time_to_tm(time, &alarm_tm);
+        }
+
+        ret = rtc_tm_to_time(&alarm_tm, &time);
+
+        /* clear all the interrupt status bits */
+        writew(readw(ioaddr + RTC_RTCISR), ioaddr + RTC_RTCISR);
+        set_alarm_or_time(dev, MXC_RTC_ALARM, time);
+
+        return ret;
+}
+
+/* This function is the RTC interrupt service routine. */
+static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u32 status;
+        u32 events = 0;
+
+        spin_lock_irq(&pdata->rtc->irq_lock);
+        status = readw(ioaddr + RTC_RTCISR) & readw(ioaddr + RTC_RTCIENR);
+        /* clear interrupt sources */
+        writew(status, ioaddr + RTC_RTCISR);
+
+        /* clear alarm interrupt if it has occurred */
+        if (status & RTC_ALM_BIT)
+                status &= ~RTC_ALM_BIT;
+
+        /* update irq data & counter */
+        if (status & RTC_ALM_BIT)
+                events |= (RTC_AF | RTC_IRQF);
+
+        if (status & RTC_1HZ_BIT)
+                events |= (RTC_UF | RTC_IRQF);
+
+        if (status & PIT_ALL_ON)
+                events |= (RTC_PF | RTC_IRQF);
+
+        if ((status & RTC_ALM_BIT) && rtc_valid_tm(&pdata->g_rtc_alarm))
+                rtc_update_alarm(&pdev->dev, &pdata->g_rtc_alarm);
+
+        rtc_update_irq(pdata->rtc, 1, events);
+        spin_unlock_irq(&pdata->rtc->irq_lock);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * Clear all interrupts and release the IRQ
+ */
+static void mxc_rtc_release(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+
+        spin_lock_irq(&pdata->rtc->irq_lock);
+
+        /* Disable all rtc interrupts */
+        writew(0, ioaddr + RTC_RTCIENR);
+
+        /* Clear all interrupt status */
+        writew(0xffffffff, ioaddr + RTC_RTCISR);
+
+        spin_unlock_irq(&pdata->rtc->irq_lock);
+}
+
+static void mxc_rtc_irq_enable(struct device *dev, unsigned int bit,
+                                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;
+        u32 reg;
+
+        spin_lock_irq(&pdata->rtc->irq_lock);
+        reg = readw(ioaddr + RTC_RTCIENR);
+
+        if (enabled)
+                reg |= bit;
+        else
+                reg &= ~bit;
+
+        writew(reg, ioaddr + RTC_RTCIENR);
+        spin_unlock_irq(&pdata->rtc->irq_lock);
+}
+
+static int mxc_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        mxc_rtc_irq_enable(dev, RTC_ALM_BIT, enabled);
+        return 0;
+}
+
+static int mxc_rtc_update_irq_enable(struct device *dev, unsigned int enabled)
+{
+        mxc_rtc_irq_enable(dev, RTC_1HZ_BIT, enabled);
+        return 0;
+}
+
+/*
+ * This function reads the current RTC time into tm in Gregorian date.
+ */
+static int mxc_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        u32 val;
+
+        /* Avoid roll-over from reading the different registers */
+        do {
+                val = get_alarm_or_time(dev, MXC_RTC_TIME);
+        } while (val != get_alarm_or_time(dev, MXC_RTC_TIME));
+
+        rtc_time_to_tm(val, tm);
+
+        return 0;
+}
+
+/*
+ * This function sets the internal RTC time based on tm in Gregorian date.
+ */
+static int mxc_rtc_set_mmss(struct device *dev, unsigned long time)
+{
+        /* Avoid roll-over from reading the different registers */
+        do {
+                set_alarm_or_time(dev, MXC_RTC_TIME, time);
+        } while (time != get_alarm_or_time(dev, MXC_RTC_TIME));
+
+        return 0;
+}
+
+/*
+ * This function reads the current alarm value into the passed in 'alrm'
+ * argument. It updates the alrm's pending field value based on the whether
+ * an alarm interrupt occurs or not.
+ */
+static int mxc_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+
+        rtc_time_to_tm(get_alarm_or_time(dev, MXC_RTC_ALARM), &alrm->time);
+        alrm->pending = ((readw(ioaddr + RTC_RTCISR) & RTC_ALM_BIT)) ? 1 : 0;
+
+        return 0;
+}
+
+/*
+ * This function sets the RTC alarm based on passed in alrm.
+ */
+static int mxc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        int ret;
+
+        if (rtc_valid_tm(&alrm->time)) {
+                if (alrm->time.tm_sec > 59 ||
+                    alrm->time.tm_hour > 23 ||
+                    alrm->time.tm_min > 59)
+                        return -EINVAL;
+
+                ret = rtc_update_alarm(dev, &alrm->time);
+        } else {
+                ret = rtc_valid_tm(&alrm->time);
+                if (ret)
+                        return ret;
+
+                ret = rtc_update_alarm(dev, &alrm->time);
+        }
+
+        if (ret)
+                return ret;
+
+        memcpy(&pdata->g_rtc_alarm, &alrm->time, sizeof(struct rtc_time));
+        mxc_rtc_irq_enable(dev, RTC_ALM_BIT, alrm->enabled);
+
+        return 0;
+}
+
+/* RTC layer */
+static struct rtc_class_ops mxc_rtc_ops = {
+        .release                = mxc_rtc_release,
+        .read_time              = mxc_rtc_read_time,
+        .set_mmss               = mxc_rtc_set_mmss,
+        .read_alarm             = mxc_rtc_read_alarm,
+        .set_alarm              = mxc_rtc_set_alarm,
+        .alarm_irq_enable       = mxc_rtc_alarm_irq_enable,
+        .update_irq_enable      = mxc_rtc_update_irq_enable,
+};
+
+static int __init mxc_rtc_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct rtc_device *rtc;
+        struct rtc_plat_data *pdata = NULL;
+        u32 reg;
+        unsigned long rate;
+        int ret;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        if (!devm_request_mem_region(&pdev->dev, res->start,
+                                     resource_size(res), pdev->name))
+                return -EBUSY;
+
+        pdata->ioaddr = devm_ioremap(&pdev->dev, res->start,
+                                     resource_size(res));
+
+        pdata->clk = clk_get(&pdev->dev, "rtc");
+        if (IS_ERR(pdata->clk)) {
+                dev_err(&pdev->dev, "unable to get clock!\n");
+                ret = PTR_ERR(pdata->clk);
+                goto exit_free_pdata;
+        }
+
+        clk_enable(pdata->clk);
+        rate = clk_get_rate(pdata->clk);
+
+        if (rate == 32768)
+                reg = RTC_INPUT_CLK_32768HZ;
+        else if (rate == 32000)
+                reg = RTC_INPUT_CLK_32000HZ;
+        else if (rate == 38400)
+                reg = RTC_INPUT_CLK_38400HZ;
+        else {
+                dev_err(&pdev->dev, "rtc clock is not valid (%lu)\n", rate);
+                ret = -EINVAL;
+                goto exit_put_clk;
+        }
+
+        reg |= RTC_ENABLE_BIT;
+        writew(reg, (pdata->ioaddr + RTC_RTCCTL));
+        if (((readw(pdata->ioaddr + RTC_RTCCTL)) & RTC_ENABLE_BIT) == 0) {
+                dev_err(&pdev->dev, "hardware module can't be enabled!\n");
+                ret = -EIO;
+                goto exit_put_clk;
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto exit_put_clk;
+        }
+
+        pdata->rtc = rtc;
+        platform_set_drvdata(pdev, pdata);
+
+        /* Configure and enable the RTC */
+        pdata->irq = platform_get_irq(pdev, 0);
+
+        if (pdata->irq >= 0 &&
+            devm_request_irq(&pdev->dev, pdata->irq, mxc_rtc_interrupt,
+                             IRQF_SHARED, pdev->name, pdev) < 0) {
+                dev_warn(&pdev->dev, "interrupt not available.\n");
+                pdata->irq = -1;
+        }
+
+        return 0;
+
+exit_put_clk:
+        clk_disable(pdata->clk);
+        clk_put(pdata->clk);
+
+exit_free_pdata:
+
+        return ret;
+}
+
+static int __exit mxc_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(pdata->rtc);
+
+        clk_disable(pdata->clk);
+        clk_put(pdata->clk);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver mxc_rtc_driver = {
+        .driver = {
+                   .name        = "mxc_rtc",
+                   .owner       = THIS_MODULE,
+        },
+        .remove         = __exit_p(mxc_rtc_remove),
+};
+
+static int __init mxc_rtc_init(void)
+{
+        return platform_driver_probe(&mxc_rtc_driver, mxc_rtc_probe);
+}
+
+static void __exit mxc_rtc_exit(void)
+{
+        platform_driver_unregister(&mxc_rtc_driver);
+}
+
+module_init(mxc_rtc_init);
+module_exit(mxc_rtc_exit);
+
+MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
+MODULE_DESCRIPTION("RTC driver for Freescale MXC");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/rtc/rtc-nuc900.c b/drivers/rtc/rtc-nuc900.c
new file mode 100644
index 000000000000..ddb0857e15a4
--- /dev/null
+++ b/drivers/rtc/rtc-nuc900.c
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2008-2009 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@gmail.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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/rtc.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/bcd.h>
+
+/* RTC Control Registers */
+#define REG_RTC_INIR            0x00
+#define REG_RTC_AER             0x04
+#define REG_RTC_FCR             0x08
+#define REG_RTC_TLR             0x0C
+#define REG_RTC_CLR             0x10
+#define REG_RTC_TSSR            0x14
+#define REG_RTC_DWR             0x18
+#define REG_RTC_TAR             0x1C
+#define REG_RTC_CAR             0x20
+#define REG_RTC_LIR             0x24
+#define REG_RTC_RIER            0x28
+#define REG_RTC_RIIR            0x2C
+#define REG_RTC_TTR             0x30
+
+#define RTCSET                  0x01
+#define AERRWENB                0x10000
+#define INIRRESET               0xa5eb1357
+#define AERPOWERON              0xA965
+#define AERPOWEROFF             0x0000
+#define LEAPYEAR                0x0001
+#define TICKENB                 0x80
+#define TICKINTENB              0x0002
+#define ALARMINTENB             0x0001
+#define MODE24                  0x0001
+
+struct nuc900_rtc {
+        int                     irq_num;
+        void __iomem            *rtc_reg;
+        struct rtc_device       *rtcdev;
+};
+
+struct nuc900_bcd_time {
+        int bcd_sec;
+        int bcd_min;
+        int bcd_hour;
+        int bcd_mday;
+        int bcd_mon;
+        int bcd_year;
+};
+
+static irqreturn_t nuc900_rtc_interrupt(int irq, void *_rtc)
+{
+        struct nuc900_rtc *rtc = _rtc;
+        unsigned long events = 0, rtc_irq;
+
+        rtc_irq = __raw_readl(rtc->rtc_reg + REG_RTC_RIIR);
+
+        if (rtc_irq & ALARMINTENB) {
+                rtc_irq &= ~ALARMINTENB;
+                __raw_writel(rtc_irq, rtc->rtc_reg + REG_RTC_RIIR);
+                events |= RTC_AF | RTC_IRQF;
+        }
+
+        if (rtc_irq & TICKINTENB) {
+                rtc_irq &= ~TICKINTENB;
+                __raw_writel(rtc_irq, rtc->rtc_reg + REG_RTC_RIIR);
+                events |= RTC_UF | RTC_IRQF;
+        }
+
+        rtc_update_irq(rtc->rtcdev, 1, events);
+
+        return IRQ_HANDLED;
+}
+
+static int *check_rtc_access_enable(struct nuc900_rtc *nuc900_rtc)
+{
+        unsigned int timeout = 0x1000;
+        __raw_writel(INIRRESET, nuc900_rtc->rtc_reg + REG_RTC_INIR);
+
+        mdelay(10);
+
+        __raw_writel(AERPOWERON, nuc900_rtc->rtc_reg + REG_RTC_AER);
+
+        while (!(__raw_readl(nuc900_rtc->rtc_reg + REG_RTC_AER) & AERRWENB)
+                                                                && timeout--)
+                mdelay(1);
+
+        if (!timeout)
+                return ERR_PTR(-EPERM);
+
+        return 0;
+}
+
+static int nuc900_rtc_bcd2bin(unsigned int timereg,
+                                unsigned int calreg, struct rtc_time *tm)
+{
+        tm->tm_mday     = bcd2bin(calreg >> 0);
+        tm->tm_mon      = bcd2bin(calreg >> 8);
+        tm->tm_year     = bcd2bin(calreg >> 16) + 100;
+
+        tm->tm_sec      = bcd2bin(timereg >> 0);
+        tm->tm_min      = bcd2bin(timereg >> 8);
+        tm->tm_hour     = bcd2bin(timereg >> 16);
+
+        return rtc_valid_tm(tm);
+}
+
+static void nuc900_rtc_bin2bcd(struct device *dev, struct rtc_time *settm,
+                                                struct nuc900_bcd_time *gettm)
+{
+        gettm->bcd_mday = bin2bcd(settm->tm_mday) << 0;
+        gettm->bcd_mon  = bin2bcd(settm->tm_mon) << 8;
+
+        if (settm->tm_year < 100) {
+                dev_warn(dev, "The year will be between 1970-1999, right?\n");
+                gettm->bcd_year = bin2bcd(settm->tm_year) << 16;
+        } else {
+                gettm->bcd_year = bin2bcd(settm->tm_year - 100) << 16;
+        }
+
+        gettm->bcd_sec  = bin2bcd(settm->tm_sec) << 0;
+        gettm->bcd_min  = bin2bcd(settm->tm_min) << 8;
+        gettm->bcd_hour = bin2bcd(settm->tm_hour) << 16;
+}
+
+static int nuc900_update_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
+
+        if (enabled)
+                __raw_writel(__raw_readl(rtc->rtc_reg + REG_RTC_RIER)|
+                                (TICKINTENB), rtc->rtc_reg + REG_RTC_RIER);
+        else
+                __raw_writel(__raw_readl(rtc->rtc_reg + REG_RTC_RIER)&
+                                (~TICKINTENB), rtc->rtc_reg + REG_RTC_RIER);
+
+        return 0;
+}
+
+static int nuc900_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
+
+        if (enabled)
+                __raw_writel(__raw_readl(rtc->rtc_reg + REG_RTC_RIER)|
+                                (ALARMINTENB), rtc->rtc_reg + REG_RTC_RIER);
+        else
+                __raw_writel(__raw_readl(rtc->rtc_reg + REG_RTC_RIER)&
+                                (~ALARMINTENB), rtc->rtc_reg + REG_RTC_RIER);
+
+        return 0;
+}
+
+static int nuc900_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
+        unsigned int timeval, clrval;
+
+        timeval = __raw_readl(rtc->rtc_reg + REG_RTC_TLR);
+        clrval  = __raw_readl(rtc->rtc_reg + REG_RTC_CLR);
+
+        return nuc900_rtc_bcd2bin(timeval, clrval, tm);
+}
+
+static int nuc900_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
+        struct nuc900_bcd_time gettm;
+        unsigned long val;
+        int *err;
+
+        nuc900_rtc_bin2bcd(dev, tm, &gettm);
+
+        err = check_rtc_access_enable(rtc);
+        if (IS_ERR(err))
+                return PTR_ERR(err);
+
+        val = gettm.bcd_mday | gettm.bcd_mon | gettm.bcd_year;
+        __raw_writel(val, rtc->rtc_reg + REG_RTC_CLR);
+
+        val = gettm.bcd_sec | gettm.bcd_min | gettm.bcd_hour;
+        __raw_writel(val, rtc->rtc_reg + REG_RTC_TLR);
+
+        return 0;
+}
+
+static int nuc900_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
+        unsigned int timeval, carval;
+
+        timeval = __raw_readl(rtc->rtc_reg + REG_RTC_TAR);
+        carval  = __raw_readl(rtc->rtc_reg + REG_RTC_CAR);
+
+        return nuc900_rtc_bcd2bin(timeval, carval, &alrm->time);
+}
+
+static int nuc900_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct nuc900_rtc *rtc = dev_get_drvdata(dev);
+        struct nuc900_bcd_time tm;
+        unsigned long val;
+        int *err;
+
+        nuc900_rtc_bin2bcd(dev, &alrm->time, &tm);
+
+        err = check_rtc_access_enable(rtc);
+        if (IS_ERR(err))
+                return PTR_ERR(err);
+
+        val = tm.bcd_mday | tm.bcd_mon | tm.bcd_year;
+        __raw_writel(val, rtc->rtc_reg + REG_RTC_CAR);
+
+        val = tm.bcd_sec | tm.bcd_min | tm.bcd_hour;
+        __raw_writel(val, rtc->rtc_reg + REG_RTC_TAR);
+
+        return 0;
+}
+
+static struct rtc_class_ops nuc900_rtc_ops = {
+        .read_time = nuc900_rtc_read_time,
+        .set_time = nuc900_rtc_set_time,
+        .read_alarm = nuc900_rtc_read_alarm,
+        .set_alarm = nuc900_rtc_set_alarm,
+        .alarm_irq_enable = nuc900_alarm_irq_enable,
+        .update_irq_enable = nuc900_update_irq_enable,
+};
+
+static int __devinit nuc900_rtc_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct nuc900_rtc *nuc900_rtc;
+        int err = 0;
+
+        nuc900_rtc = kzalloc(sizeof(struct nuc900_rtc), GFP_KERNEL);
+        if (!nuc900_rtc) {
+                dev_err(&pdev->dev, "kzalloc nuc900_rtc failed\n");
+                return -ENOMEM;
+        }
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "platform_get_resource failed\n");
+                err = -ENXIO;
+                goto fail1;
+        }
+
+        if (!request_mem_region(res->start, resource_size(res),
+                                pdev->name)) {
+                dev_err(&pdev->dev, "request_mem_region failed\n");
+                err = -EBUSY;
+                goto fail1;
+        }
+
+        nuc900_rtc->rtc_reg = ioremap(res->start, resource_size(res));
+        if (!nuc900_rtc->rtc_reg) {
+                dev_err(&pdev->dev, "ioremap rtc_reg failed\n");
+                err = -ENOMEM;
+                goto fail2;
+        }
+
+        platform_set_drvdata(pdev, nuc900_rtc);
+
+        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 failed\n");
+                err = PTR_ERR(nuc900_rtc->rtcdev);
+                goto fail3;
+        }
+
+        __raw_writel(__raw_readl(nuc900_rtc->rtc_reg + REG_RTC_TSSR) | MODE24,
+                                        nuc900_rtc->rtc_reg + REG_RTC_TSSR);
+
+        nuc900_rtc->irq_num = platform_get_irq(pdev, 0);
+        if (request_irq(nuc900_rtc->irq_num, nuc900_rtc_interrupt,
+                                IRQF_DISABLED, "nuc900rtc", nuc900_rtc)) {
+                dev_err(&pdev->dev, "NUC900 RTC request irq failed\n");
+                err = -EBUSY;
+                goto fail4;
+        }
+
+        return 0;
+
+fail4:  rtc_device_unregister(nuc900_rtc->rtcdev);
+fail3:  iounmap(nuc900_rtc->rtc_reg);
+fail2:  release_mem_region(res->start, resource_size(res));
+fail1:  kfree(nuc900_rtc);
+        return err;
+}
+
+static int __devexit nuc900_rtc_remove(struct platform_device *pdev)
+{
+        struct nuc900_rtc *nuc900_rtc = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        free_irq(nuc900_rtc->irq_num, nuc900_rtc);
+        rtc_device_unregister(nuc900_rtc->rtcdev);
+        iounmap(nuc900_rtc->rtc_reg);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
+
+        kfree(nuc900_rtc);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver nuc900_rtc_driver = {
+        .remove         = __devexit_p(nuc900_rtc_remove),
+        .driver         = {
+                .name   = "nuc900-rtc",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init nuc900_rtc_init(void)
+{
+        return platform_driver_probe(&nuc900_rtc_driver, nuc900_rtc_probe);
+}
+
+static void __exit nuc900_rtc_exit(void)
+{
+        platform_driver_unregister(&nuc900_rtc_driver);
+}
+
+module_init(nuc900_rtc_init);
+module_exit(nuc900_rtc_exit);
+
+MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
+MODULE_DESCRIPTION("nuc910/nuc920 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:nuc900-rtc");
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index bd1ce8e2bc18..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
@@ -87,9 +88,10 @@
 #define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
 #define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
 
+static void __iomem     *rtc_base;
 
-#define rtc_read(addr)          omap_readb(OMAP_RTC_BASE + (addr))
-#define rtc_write(val, addr)    omap_writeb(val, OMAP_RTC_BASE + (addr))
+#define rtc_read(addr)          __raw_readb(rtc_base + (addr))
+#define rtc_write(val, addr)    __raw_writeb(val, rtc_base + (addr))
 
 
 /* we rely on the rtc framework to handle locking (rtc->ops_lock),
@@ -330,32 +332,31 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                 return -ENOENT;
         }
 
-        /* NOTE:  using static mapping for RTC registers */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res && res->start != OMAP_RTC_BASE) {
-                pr_debug("%s: RTC registers at %08x, expected %08x\n",
-                        pdev->name, (unsigned) res->start, OMAP_RTC_BASE);
+        if (!res) {
+                pr_debug("%s: RTC resource data missing\n", pdev->name);
                 return -ENOENT;
         }
 
-        if (res)
-                mem = request_mem_region(res->start,
-                                res->end - res->start + 1,
-                                pdev->name);
-        else
-                mem = NULL;
+        mem = request_mem_region(res->start, resource_size(res), pdev->name);
         if (!mem) {
                 pr_debug("%s: RTC registers at %08x are not free\n",
-                        pdev->name, OMAP_RTC_BASE);
+                        pdev->name, res->start);
                 return -EBUSY;
         }
 
+        rtc_base = ioremap(res->start, resource_size(res));
+        if (!rtc_base) {
+                pr_debug("%s: RTC registers can't be mapped\n", pdev->name);
+                goto fail;
+        }
+
         rtc = rtc_device_register(pdev->name, &pdev->dev,
                         &omap_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
                 pr_debug("%s: can't register RTC device, err %ld\n",
                         pdev->name, PTR_ERR(rtc));
-                goto fail;
+                goto fail0;
         }
         platform_set_drvdata(pdev, rtc);
         dev_set_drvdata(&rtc->dev, mem);
@@ -380,13 +381,14 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                         dev_name(&rtc->dev), rtc)) {
                 pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
                         pdev->name, omap_rtc_timer);
-                goto fail0;
+                goto fail1;
         }
-        if (request_irq(omap_rtc_alarm, rtc_irq, IRQF_DISABLED,
-                        dev_name(&rtc->dev), rtc)) {
+        if ((omap_rtc_timer != omap_rtc_alarm) &&
+                (request_irq(omap_rtc_alarm, rtc_irq, IRQF_DISABLED,
+                        dev_name(&rtc->dev), rtc))) {
                 pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
                         pdev->name, omap_rtc_alarm);
-                goto fail1;
+                goto fail2;
         }
 
         /* On boards with split power, RTC_ON_NOFF won't reset the RTC */
@@ -400,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);
@@ -419,10 +422,12 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
 
         return 0;
 
-fail1:
+fail2:
         free_irq(omap_rtc_timer, NULL);
-fail0:
+fail1:
         rtc_device_unregister(rtc);
+fail0:
+        iounmap(rtc_base);
 fail:
         release_resource(mem);
         return -EIO;
@@ -430,7 +435,7 @@ fail:
 
 static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device       *rtc = platform_get_drvdata(pdev);;
+        struct rtc_device       *rtc = platform_get_drvdata(pdev);
 
         device_init_wakeup(&pdev->dev, 0);
 
@@ -438,7 +443,9 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 
         free_irq(omap_rtc_timer, rtc);
-        free_irq(omap_rtc_alarm, rtc);
+
+        if (omap_rtc_timer != omap_rtc_alarm)
+                free_irq(omap_rtc_alarm, rtc);
 
         release_resource(dev_get_drvdata(&rtc->dev));
         rtc_device_unregister(rtc);
diff --git a/drivers/rtc/rtc-pcap.c b/drivers/rtc/rtc-pcap.c
new file mode 100644
index 000000000000..25c0b3fd44f1
--- /dev/null
+++ b/drivers/rtc/rtc-pcap.c
@@ -0,0 +1,225 @@
+/*
+ *  pcap rtc code for Motorola EZX phones
+ *
+ *  Copyright (c) 2008 guiming zhuo <gmzhuo@gmail.com>
+ *  Copyright (c) 2009 Daniel Ribeiro <drwyrm@gmail.com>
+ *
+ *  Based on Motorola's rtc.c Copyright (c) 2003-2005 Motorola
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/mfd/ezx-pcap.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+
+struct pcap_rtc {
+        struct pcap_chip *pcap;
+        struct rtc_device *rtc;
+};
+
+static irqreturn_t pcap_rtc_irq(int irq, void *_pcap_rtc)
+{
+        struct pcap_rtc *pcap_rtc = _pcap_rtc;
+        unsigned long rtc_events;
+
+        if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ))
+                rtc_events = RTC_IRQF | RTC_UF;
+        else if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA))
+                rtc_events = RTC_IRQF | RTC_AF;
+        else
+                rtc_events = 0;
+
+        rtc_update_irq(pcap_rtc->rtc, 1, rtc_events);
+        return IRQ_HANDLED;
+}
+
+static int pcap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
+        struct rtc_time *tm = &alrm->time;
+        unsigned long secs;
+        u32 tod;        /* time of day, seconds since midnight */
+        u32 days;       /* days since 1/1/1970 */
+
+        ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TODA, &tod);
+        secs = tod & PCAP_RTC_TOD_MASK;
+
+        ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, &days);
+        secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
+
+        rtc_time_to_tm(secs, tm);
+
+        return 0;
+}
+
+static int pcap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
+        struct rtc_time *tm = &alrm->time;
+        unsigned long secs;
+        u32 tod, days;
+
+        rtc_tm_to_time(tm, &secs);
+
+        tod = secs % SEC_PER_DAY;
+        ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TODA, tod);
+
+        days = secs / SEC_PER_DAY;
+        ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, days);
+
+        return 0;
+}
+
+static int pcap_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
+        unsigned long secs;
+        u32 tod, days;
+
+        ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TOD, &tod);
+        secs = tod & PCAP_RTC_TOD_MASK;
+
+        ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAY, &days);
+        secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
+
+        rtc_time_to_tm(secs, tm);
+
+        return rtc_valid_tm(tm);
+}
+
+static int pcap_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
+        u32 tod, days;
+
+        tod = secs % SEC_PER_DAY;
+        ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TOD, tod);
+
+        days = secs / SEC_PER_DAY;
+        ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAY, days);
+
+        return 0;
+}
+
+static int pcap_rtc_irq_enable(struct device *dev, int pirq, unsigned int en)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
+
+        if (en)
+                enable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
+        else
+                disable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
+
+        return 0;
+}
+
+static int pcap_rtc_alarm_irq_enable(struct device *dev, unsigned int en)
+{
+        return pcap_rtc_irq_enable(dev, PCAP_IRQ_TODA, en);
+}
+
+static int pcap_rtc_update_irq_enable(struct device *dev, unsigned int en)
+{
+        return pcap_rtc_irq_enable(dev, PCAP_IRQ_1HZ, en);
+}
+
+static const struct rtc_class_ops pcap_rtc_ops = {
+        .read_time = pcap_rtc_read_time,
+        .read_alarm = pcap_rtc_read_alarm,
+        .set_alarm = pcap_rtc_set_alarm,
+        .set_mmss = pcap_rtc_set_mmss,
+        .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
+        .update_irq_enable = pcap_rtc_update_irq_enable,
+};
+
+static int __devinit pcap_rtc_probe(struct platform_device *pdev)
+{
+        struct pcap_rtc *pcap_rtc;
+        int timer_irq, alarm_irq;
+        int err = -ENOMEM;
+
+        pcap_rtc = kmalloc(sizeof(struct pcap_rtc), GFP_KERNEL);
+        if (!pcap_rtc)
+                return err;
+
+        pcap_rtc->pcap = dev_get_drvdata(pdev->dev.parent);
+
+        pcap_rtc->rtc = rtc_device_register("pcap", &pdev->dev,
+                                  &pcap_rtc_ops, THIS_MODULE);
+        if (IS_ERR(pcap_rtc->rtc)) {
+                err = PTR_ERR(pcap_rtc->rtc);
+                goto fail_rtc;
+        }
+
+        platform_set_drvdata(pdev, pcap_rtc);
+
+        timer_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ);
+        alarm_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA);
+
+        err = request_irq(timer_irq, pcap_rtc_irq, 0, "RTC Timer", pcap_rtc);
+        if (err)
+                goto fail_timer;
+
+        err = request_irq(alarm_irq, pcap_rtc_irq, 0, "RTC Alarm", pcap_rtc);
+        if (err)
+                goto fail_alarm;
+
+        return 0;
+fail_alarm:
+        free_irq(timer_irq, pcap_rtc);
+fail_timer:
+        rtc_device_unregister(pcap_rtc->rtc);
+fail_rtc:
+        kfree(pcap_rtc);
+        return err;
+}
+
+static int __devexit pcap_rtc_remove(struct platform_device *pdev)
+{
+        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
+
+        free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ), pcap_rtc);
+        free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA), pcap_rtc);
+        rtc_device_unregister(pcap_rtc->rtc);
+        kfree(pcap_rtc);
+
+        return 0;
+}
+
+static struct platform_driver pcap_rtc_driver = {
+        .remove = __devexit_p(pcap_rtc_remove),
+        .driver = {
+                .name  = "pcap-rtc",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init rtc_pcap_init(void)
+{
+        return platform_driver_probe(&pcap_rtc_driver, pcap_rtc_probe);
+}
+
+static void __exit rtc_pcap_exit(void)
+{
+        platform_driver_unregister(&pcap_rtc_driver);
+}
+
+module_init(rtc_pcap_init);
+module_exit(rtc_pcap_exit);
+
+MODULE_DESCRIPTION("Motorola pcap rtc driver");
+MODULE_AUTHOR("guiming zhuo <gmzhuo@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-pcf2123.c b/drivers/rtc/rtc-pcf2123.c
new file mode 100644
index 000000000000..71bab0ef5443
--- /dev/null
+++ b/drivers/rtc/rtc-pcf2123.c
@@ -0,0 +1,365 @@
+/*
+ * An SPI driver for the Philips PCF2123 RTC
+ * Copyright 2009 Cyber Switching, Inc.
+ *
+ * Author: Chris Verges <chrisv@cyberswitching.com>
+ * Maintainers: http://www.cyberswitching.com
+ *
+ * based on the RS5C348 driver in this same directory.
+ *
+ * Thanks to Christian Pellegrin <chripell@fsfe.org> for
+ * the sysfs contributions to this driver.
+ *
+ * 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.
+ *
+ * Please note that the CS is active high, so platform data
+ * should look something like:
+ *
+ * static struct spi_board_info ek_spi_devices[] = {
+ *      ...
+ *      {
+ *              .modalias               = "rtc-pcf2123",
+ *              .chip_select            = 1,
+ *              .controller_data        = (void *)AT91_PIN_PA10,
+ *              .max_speed_hz           = 1000 * 1000,
+ *              .mode                   = SPI_CS_HIGH,
+ *              .bus_num                = 0,
+ *      },
+ *      ...
+ *};
+ *
+ */
+
+#include <linux/bcd.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/rtc.h>
+#include <linux/spi/spi.h>
+
+#define DRV_VERSION "0.6"
+
+#define PCF2123_REG_CTRL1       (0x00)  /* Control Register 1 */
+#define PCF2123_REG_CTRL2       (0x01)  /* Control Register 2 */
+#define PCF2123_REG_SC          (0x02)  /* datetime */
+#define PCF2123_REG_MN          (0x03)
+#define PCF2123_REG_HR          (0x04)
+#define PCF2123_REG_DM          (0x05)
+#define PCF2123_REG_DW          (0x06)
+#define PCF2123_REG_MO          (0x07)
+#define PCF2123_REG_YR          (0x08)
+
+#define PCF2123_SUBADDR         (1 << 4)
+#define PCF2123_WRITE           ((0 << 7) | PCF2123_SUBADDR)
+#define PCF2123_READ            ((1 << 7) | PCF2123_SUBADDR)
+
+static struct spi_driver pcf2123_driver;
+
+struct pcf2123_sysfs_reg {
+        struct device_attribute attr;
+        char name[2];
+};
+
+struct pcf2123_plat_data {
+        struct rtc_device *rtc;
+        struct pcf2123_sysfs_reg regs[16];
+};
+
+/*
+ * Causes a 30 nanosecond delay to ensure that the PCF2123 chip select
+ * is released properly after an SPI write.  This function should be
+ * called after EVERY read/write call over SPI.
+ */
+static inline void pcf2123_delay_trec(void)
+{
+        ndelay(30);
+}
+
+static ssize_t pcf2123_show(struct device *dev, struct device_attribute *attr,
+                            char *buffer)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct pcf2123_sysfs_reg *r;
+        u8 txbuf[1], rxbuf[1];
+        unsigned long reg;
+        int ret;
+
+        r = container_of(attr, struct pcf2123_sysfs_reg, attr);
+
+        if (strict_strtoul(r->name, 16, &reg))
+                return -EINVAL;
+
+        txbuf[0] = PCF2123_READ | reg;
+        ret = spi_write_then_read(spi, txbuf, 1, rxbuf, 1);
+        if (ret < 0)
+                return -EIO;
+        pcf2123_delay_trec();
+        return sprintf(buffer, "0x%x\n", rxbuf[0]);
+}
+
+static ssize_t pcf2123_store(struct device *dev, struct device_attribute *attr,
+                             const char *buffer, size_t count) {
+        struct spi_device *spi = to_spi_device(dev);
+        struct pcf2123_sysfs_reg *r;
+        u8 txbuf[2];
+        unsigned long reg;
+        unsigned long val;
+
+        int ret;
+
+        r = container_of(attr, struct pcf2123_sysfs_reg, attr);
+
+        if (strict_strtoul(r->name, 16, &reg)
+                || strict_strtoul(buffer, 10, &val))
+                return -EINVAL;
+
+        txbuf[0] = PCF2123_WRITE | reg;
+        txbuf[1] = val;
+        ret = spi_write(spi, txbuf, sizeof(txbuf));
+        if (ret < 0)
+                return -EIO;
+        pcf2123_delay_trec();
+        return count;
+}
+
+static int pcf2123_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        u8 txbuf[1], rxbuf[7];
+        int ret;
+
+        txbuf[0] = PCF2123_READ | PCF2123_REG_SC;
+        ret = spi_write_then_read(spi, txbuf, sizeof(txbuf),
+                        rxbuf, sizeof(rxbuf));
+        if (ret < 0)
+                return ret;
+        pcf2123_delay_trec();
+
+        tm->tm_sec = bcd2bin(rxbuf[0] & 0x7F);
+        tm->tm_min = bcd2bin(rxbuf[1] & 0x7F);
+        tm->tm_hour = bcd2bin(rxbuf[2] & 0x3F); /* rtc hr 0-23 */
+        tm->tm_mday = bcd2bin(rxbuf[3] & 0x3F);
+        tm->tm_wday = rxbuf[4] & 0x07;
+        tm->tm_mon = bcd2bin(rxbuf[5] & 0x1F) - 1; /* rtc mn 1-12 */
+        tm->tm_year = bcd2bin(rxbuf[6]);
+        if (tm->tm_year < 70)
+                tm->tm_year += 100;     /* assume we are in 1970...2069 */
+
+        dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                        "mday=%d, mon=%d, year=%d, wday=%d\n",
+                        __func__,
+                        tm->tm_sec, tm->tm_min, tm->tm_hour,
+                        tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* the clock can give out invalid datetime, but we cannot return
+         * -EINVAL otherwise hwclock will refuse to set the time on bootup.
+         */
+        if (rtc_valid_tm(tm) < 0)
+                dev_err(dev, "retrieved date/time is not valid.\n");
+
+        return 0;
+}
+
+static int pcf2123_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        u8 txbuf[8];
+        int ret;
+
+        dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                        "mday=%d, mon=%d, year=%d, wday=%d\n",
+                        __func__,
+                        tm->tm_sec, tm->tm_min, tm->tm_hour,
+                        tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* Stop the counter first */
+        txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
+        txbuf[1] = 0x20;
+        ret = spi_write(spi, txbuf, 2);
+        if (ret < 0)
+                return ret;
+        pcf2123_delay_trec();
+
+        /* Set the new time */
+        txbuf[0] = PCF2123_WRITE | PCF2123_REG_SC;
+        txbuf[1] = bin2bcd(tm->tm_sec & 0x7F);
+        txbuf[2] = bin2bcd(tm->tm_min & 0x7F);
+        txbuf[3] = bin2bcd(tm->tm_hour & 0x3F);
+        txbuf[4] = bin2bcd(tm->tm_mday & 0x3F);
+        txbuf[5] = tm->tm_wday & 0x07;
+        txbuf[6] = bin2bcd((tm->tm_mon + 1) & 0x1F); /* rtc mn 1-12 */
+        txbuf[7] = bin2bcd(tm->tm_year < 100 ? tm->tm_year : tm->tm_year - 100);
+
+        ret = spi_write(spi, txbuf, sizeof(txbuf));
+        if (ret < 0)
+                return ret;
+        pcf2123_delay_trec();
+
+        /* Start the counter */
+        txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
+        txbuf[1] = 0x00;
+        ret = spi_write(spi, txbuf, 2);
+        if (ret < 0)
+                return ret;
+        pcf2123_delay_trec();
+
+        return 0;
+}
+
+static const struct rtc_class_ops pcf2123_rtc_ops = {
+        .read_time      = pcf2123_rtc_read_time,
+        .set_time       = pcf2123_rtc_set_time,
+};
+
+static int __devinit pcf2123_probe(struct spi_device *spi)
+{
+        struct rtc_device *rtc;
+        struct pcf2123_plat_data *pdata;
+        u8 txbuf[2], rxbuf[2];
+        int ret, i;
+
+        pdata = kzalloc(sizeof(struct pcf2123_plat_data), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+        spi->dev.platform_data = pdata;
+
+        /* Send a software reset command */
+        txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
+        txbuf[1] = 0x58;
+        dev_dbg(&spi->dev, "resetting RTC (0x%02X 0x%02X)\n",
+                        txbuf[0], txbuf[1]);
+        ret = spi_write(spi, txbuf, 2 * sizeof(u8));
+        if (ret < 0)
+                goto kfree_exit;
+        pcf2123_delay_trec();
+
+        /* Stop the counter */
+        txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
+        txbuf[1] = 0x20;
+        dev_dbg(&spi->dev, "stopping RTC (0x%02X 0x%02X)\n",
+                        txbuf[0], txbuf[1]);
+        ret = spi_write(spi, txbuf, 2 * sizeof(u8));
+        if (ret < 0)
+                goto kfree_exit;
+        pcf2123_delay_trec();
+
+        /* See if the counter was actually stopped */
+        txbuf[0] = PCF2123_READ | PCF2123_REG_CTRL1;
+        dev_dbg(&spi->dev, "checking for presence of RTC (0x%02X)\n",
+                        txbuf[0]);
+        ret = spi_write_then_read(spi, txbuf, 1 * sizeof(u8),
+                                        rxbuf, 2 * sizeof(u8));
+        dev_dbg(&spi->dev, "received data from RTC (0x%02X 0x%02X)\n",
+                        rxbuf[0], rxbuf[1]);
+        if (ret < 0)
+                goto kfree_exit;
+        pcf2123_delay_trec();
+
+        if (!(rxbuf[0] & 0x20)) {
+                dev_err(&spi->dev, "chip not found\n");
+                goto kfree_exit;
+        }
+
+        dev_info(&spi->dev, "chip found, driver version " DRV_VERSION "\n");
+        dev_info(&spi->dev, "spiclk %u KHz.\n",
+                        (spi->max_speed_hz + 500) / 1000);
+
+        /* Start the counter */
+        txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
+        txbuf[1] = 0x00;
+        ret = spi_write(spi, txbuf, sizeof(txbuf));
+        if (ret < 0)
+                goto kfree_exit;
+        pcf2123_delay_trec();
+
+        /* Finalize the initialization */
+        rtc = rtc_device_register(pcf2123_driver.driver.name, &spi->dev,
+                        &pcf2123_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                dev_err(&spi->dev, "failed to register.\n");
+                ret = PTR_ERR(rtc);
+                goto kfree_exit;
+        }
+
+        pdata->rtc = rtc;
+
+        for (i = 0; i < 16; i++) {
+                sprintf(pdata->regs[i].name, "%1x", i);
+                pdata->regs[i].attr.attr.mode = S_IRUGO | S_IWUSR;
+                pdata->regs[i].attr.attr.name = pdata->regs[i].name;
+                pdata->regs[i].attr.show = pcf2123_show;
+                pdata->regs[i].attr.store = pcf2123_store;
+                ret = device_create_file(&spi->dev, &pdata->regs[i].attr);
+                if (ret) {
+                        dev_err(&spi->dev, "Unable to create sysfs %s\n",
+                                pdata->regs[i].name);
+                        goto sysfs_exit;
+                }
+        }
+
+        return 0;
+
+sysfs_exit:
+        for (i--; i >= 0; i--)
+                device_remove_file(&spi->dev, &pdata->regs[i].attr);
+
+kfree_exit:
+        kfree(pdata);
+        spi->dev.platform_data = NULL;
+        return ret;
+}
+
+static int __devexit pcf2123_remove(struct spi_device *spi)
+{
+        struct pcf2123_plat_data *pdata = spi->dev.platform_data;
+        int i;
+
+        if (pdata) {
+                struct rtc_device *rtc = pdata->rtc;
+
+                if (rtc)
+                        rtc_device_unregister(rtc);
+                for (i = 0; i < 16; i++)
+                        if (pdata->regs[i].name[0])
+                                device_remove_file(&spi->dev,
+                                                   &pdata->regs[i].attr);
+                kfree(pdata);
+        }
+
+        return 0;
+}
+
+static struct spi_driver pcf2123_driver = {
+        .driver = {
+                        .name   = "rtc-pcf2123",
+                        .bus    = &spi_bus_type,
+                        .owner  = THIS_MODULE,
+        },
+        .probe  = pcf2123_probe,
+        .remove = __devexit_p(pcf2123_remove),
+};
+
+static int __init pcf2123_init(void)
+{
+        return spi_register_driver(&pcf2123_driver);
+}
+
+static void __exit pcf2123_exit(void)
+{
+        spi_unregister_driver(&pcf2123_driver);
+}
+
+MODULE_AUTHOR("Chris Verges <chrisv@cyberswitching.com>");
+MODULE_DESCRIPTION("NXP PCF2123 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(pcf2123_init);
+module_exit(pcf2123_exit);
diff --git a/drivers/rtc/rtc-pcf50633.c b/drivers/rtc/rtc-pcf50633.c
index f4dd87e29075..16edf94ab42f 100644
--- a/drivers/rtc/rtc-pcf50633.c
+++ b/drivers/rtc/rtc-pcf50633.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/device.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
@@ -58,6 +59,7 @@ struct pcf50633_time {
 struct pcf50633_rtc {
         int alarm_enabled;
         int second_enabled;
+        int alarm_pending;
 
         struct pcf50633 *pcf;
         struct rtc_device *rtc_dev;
@@ -70,7 +72,7 @@ static void pcf2rtc_time(struct rtc_time *rtc, struct pcf50633_time *pcf)
         rtc->tm_hour = bcd2bin(pcf->time[PCF50633_TI_HOUR]);
         rtc->tm_wday = bcd2bin(pcf->time[PCF50633_TI_WKDAY]);
         rtc->tm_mday = bcd2bin(pcf->time[PCF50633_TI_DAY]);
-        rtc->tm_mon = bcd2bin(pcf->time[PCF50633_TI_MONTH]);
+        rtc->tm_mon = bcd2bin(pcf->time[PCF50633_TI_MONTH]) - 1;
         rtc->tm_year = bcd2bin(pcf->time[PCF50633_TI_YEAR]) + 100;
 }
 
@@ -81,7 +83,7 @@ static void rtc2pcf_time(struct pcf50633_time *pcf, struct rtc_time *rtc)
         pcf->time[PCF50633_TI_HOUR] = bin2bcd(rtc->tm_hour);
         pcf->time[PCF50633_TI_WKDAY] = bin2bcd(rtc->tm_wday);
         pcf->time[PCF50633_TI_DAY] = bin2bcd(rtc->tm_mday);
-        pcf->time[PCF50633_TI_MONTH] = bin2bcd(rtc->tm_mon);
+        pcf->time[PCF50633_TI_MONTH] = bin2bcd(rtc->tm_mon + 1);
         pcf->time[PCF50633_TI_YEAR] = bin2bcd(rtc->tm_year % 100);
 }
 
@@ -209,6 +211,7 @@ static int pcf50633_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         rtc = dev_get_drvdata(dev);
 
         alrm->enabled = rtc->alarm_enabled;
+        alrm->pending = rtc->alarm_pending;
 
         ret = pcf50633_read_block(rtc->pcf, PCF50633_REG_RTCSCA,
                                 PCF50633_TI_EXTENT, &pcf_tm.time[0]);
@@ -244,9 +247,12 @@ static int pcf50633_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         /* Returns 0 on success */
         ret = pcf50633_write_block(rtc->pcf, PCF50633_REG_RTCSCA,
                                 PCF50633_TI_EXTENT, &pcf_tm.time[0]);
+        if (!alrm->enabled)
+                rtc->alarm_pending = 0;
 
-        if (!alarm_masked)
+        if (!alarm_masked || alrm->enabled)
                 pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_ALARM);
+        rtc->alarm_enabled = alrm->enabled;
 
         return ret;
 }
@@ -267,6 +273,7 @@ static void pcf50633_rtc_irq(int irq, void *data)
         switch (irq) {
         case PCF50633_IRQ_ALARM:
                 rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
+                rtc->alarm_pending = 1;
                 break;
         case PCF50633_IRQ_SECOND:
                 rtc_update_irq(rtc->rtc_dev, 1, RTC_UF | RTC_IRQF);
@@ -276,23 +283,21 @@ static void pcf50633_rtc_irq(int irq, void *data)
 
 static int __devinit pcf50633_rtc_probe(struct platform_device *pdev)
 {
-        struct pcf50633_subdev_pdata *pdata;
         struct pcf50633_rtc *rtc;
 
-
         rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
         if (!rtc)
                 return -ENOMEM;
 
-        pdata = pdev->dev.platform_data;
-        rtc->pcf = pdata->pcf;
+        rtc->pcf = dev_to_pcf50633(pdev->dev.parent);
         platform_set_drvdata(pdev, rtc);
         rtc->rtc_dev = rtc_device_register("pcf50633-rtc", &pdev->dev,
                                 &pcf50633_rtc_ops, THIS_MODULE);
 
         if (IS_ERR(rtc->rtc_dev)) {
+                int ret =  PTR_ERR(rtc->rtc_dev);
                 kfree(rtc);
-                return PTR_ERR(rtc->rtc_dev);
+                return ret;
         }
 
         pcf50633_register_irq(rtc->pcf, PCF50633_IRQ_ALARM,
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index b725913ccbe8..b42c0c679266 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -17,6 +17,7 @@
 #include <linux/i2c.h>
 #include <linux/bcd.h>
 #include <linux/rtc.h>
+#include <linux/slab.h>
 
 #define DRV_VERSION "0.4.3"
 
@@ -171,14 +172,6 @@ static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm)
         return 0;
 }
 
-struct pcf8563_limit
-{
-        unsigned char reg;
-        unsigned char mask;
-        unsigned char min;
-        unsigned char max;
-};
-
 static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         return pcf8563_get_datetime(to_i2c_client(dev), tm);
@@ -212,6 +205,8 @@ static int pcf8563_probe(struct i2c_client *client,
 
         dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
 
+        i2c_set_clientdata(client, pcf8563);
+
         pcf8563->rtc = rtc_device_register(pcf8563_driver.driver.name,
                                 &client->dev, &pcf8563_rtc_ops, THIS_MODULE);
 
@@ -220,8 +215,6 @@ static int pcf8563_probe(struct i2c_client *client,
                 goto exit_kfree;
         }
 
-        i2c_set_clientdata(client, pcf8563);
-
         return 0;
 
 exit_kfree:
diff --git a/drivers/rtc/rtc-pcf8583.c b/drivers/rtc/rtc-pcf8583.c
index 7d33cda3f8f6..2d201afead3b 100644
--- a/drivers/rtc/rtc-pcf8583.c
+++ b/drivers/rtc/rtc-pcf8583.c
@@ -277,6 +277,8 @@ static int pcf8583_probe(struct i2c_client *client,
         if (!pcf8583)
                 return -ENOMEM;
 
+        i2c_set_clientdata(client, pcf8583);
+
         pcf8583->rtc = rtc_device_register(pcf8583_driver.driver.name,
                         &client->dev, &pcf8583_rtc_ops, THIS_MODULE);
 
@@ -285,7 +287,6 @@ static int pcf8583_probe(struct i2c_client *client,
                 goto exit_kfree;
         }
 
-        i2c_set_clientdata(client, pcf8583);
         return 0;
 
 exit_kfree:
diff --git a/drivers/rtc/rtc-pl030.c b/drivers/rtc/rtc-pl030.c
index 457231bb1029..bbdb2f02798a 100644
--- a/drivers/rtc/rtc-pl030.c
+++ b/drivers/rtc/rtc-pl030.c
@@ -13,6 +13,7 @@
 #include <linux/interrupt.h>
 #include <linux/amba/bus.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #define RTC_DR          (0)
 #define RTC_MR          (4)
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index f41873f98f66..b7a6690e5b35 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -7,6 +7,9 @@
  *
  * Copyright 2006 (c) MontaVista Software, Inc.
  *
+ * Author: Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
+ * Copyright 2010 (c) ST-Ericsson AB
+ *
  * 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
@@ -18,6 +21,9 @@
 #include <linux/interrupt.h>
 #include <linux/amba/bus.h>
 #include <linux/io.h>
+#include <linux/bcd.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
 
 /*
  * Register definitions
@@ -30,42 +36,214 @@
 #define RTC_RIS         0x14    /* Raw interrupt status register */
 #define RTC_MIS         0x18    /* Masked interrupt status register */
 #define RTC_ICR         0x1c    /* Interrupt clear register */
+/* ST variants have additional timer functionality */
+#define RTC_TDR         0x20    /* Timer data read register */
+#define RTC_TLR         0x24    /* Timer data load register */
+#define RTC_TCR         0x28    /* Timer control register */
+#define RTC_YDR         0x30    /* Year data read register */
+#define RTC_YMR         0x34    /* Year match register */
+#define RTC_YLR         0x38    /* Year data load register */
+
+#define RTC_CR_CWEN     (1 << 26)       /* Clockwatch enable bit */
+
+#define RTC_TCR_EN      (1 << 1) /* Periodic timer enable bit */
+
+/* Common bit definitions for Interrupt status and control registers */
+#define RTC_BIT_AI      (1 << 0) /* Alarm interrupt bit */
+#define RTC_BIT_PI      (1 << 1) /* Periodic interrupt bit. ST variants only. */
+
+/* Common bit definations for ST v2 for reading/writing time */
+#define RTC_SEC_SHIFT 0
+#define RTC_SEC_MASK (0x3F << RTC_SEC_SHIFT) /* Second [0-59] */
+#define RTC_MIN_SHIFT 6
+#define RTC_MIN_MASK (0x3F << RTC_MIN_SHIFT) /* Minute [0-59] */
+#define RTC_HOUR_SHIFT 12
+#define RTC_HOUR_MASK (0x1F << RTC_HOUR_SHIFT) /* Hour [0-23] */
+#define RTC_WDAY_SHIFT 17
+#define RTC_WDAY_MASK (0x7 << RTC_WDAY_SHIFT) /* Day of Week [1-7] 1=Sunday */
+#define RTC_MDAY_SHIFT 20
+#define RTC_MDAY_MASK (0x1F << RTC_MDAY_SHIFT) /* Day of Month [1-31] */
+#define RTC_MON_SHIFT 25
+#define RTC_MON_MASK (0xF << RTC_MON_SHIFT) /* Month [1-12] 1=January */
+
+#define RTC_TIMER_FREQ 32768
 
 struct pl031_local {
         struct rtc_device *rtc;
         void __iomem *base;
+        u8 hw_designer;
+        u8 hw_revision:4;
 };
 
-static irqreturn_t pl031_interrupt(int irq, void *dev_id)
+static int pl031_alarm_irq_enable(struct device *dev,
+        unsigned int enabled)
 {
-        struct rtc_device *rtc = dev_id;
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+        unsigned long imsc;
+
+        /* Clear any pending alarm interrupts. */
+        writel(RTC_BIT_AI, ldata->base + RTC_ICR);
+
+        imsc = readl(ldata->base + RTC_IMSC);
 
-        rtc_update_irq(rtc, 1, RTC_AF);
+        if (enabled == 1)
+                writel(imsc | RTC_BIT_AI, ldata->base + RTC_IMSC);
+        else
+                writel(imsc & ~RTC_BIT_AI, ldata->base + RTC_IMSC);
 
-        return IRQ_HANDLED;
+        return 0;
 }
 
-static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+/*
+ * Convert Gregorian date to ST v2 RTC format.
+ */
+static int pl031_stv2_tm_to_time(struct device *dev,
+                                 struct rtc_time *tm, unsigned long *st_time,
+        unsigned long *bcd_year)
 {
+        int year = tm->tm_year + 1900;
+        int wday = tm->tm_wday;
+
+        /* wday masking is not working in hardware so wday must be valid */
+        if (wday < -1 || wday > 6) {
+                dev_err(dev, "invalid wday value %d\n", tm->tm_wday);
+                return -EINVAL;
+        } else if (wday == -1) {
+                /* wday is not provided, calculate it here */
+                unsigned long time;
+                struct rtc_time calc_tm;
+
+                rtc_tm_to_time(tm, &time);
+                rtc_time_to_tm(time, &calc_tm);
+                wday = calc_tm.tm_wday;
+        }
+
+        *bcd_year = (bin2bcd(year % 100) | bin2bcd(year / 100) << 8);
+
+        *st_time = ((tm->tm_mon + 1) << RTC_MON_SHIFT)
+                        |       (tm->tm_mday << RTC_MDAY_SHIFT)
+                        |       ((wday + 1) << RTC_WDAY_SHIFT)
+                        |       (tm->tm_hour << RTC_HOUR_SHIFT)
+                        |       (tm->tm_min << RTC_MIN_SHIFT)
+                        |       (tm->tm_sec << RTC_SEC_SHIFT);
+
+        return 0;
+}
+
+/*
+ * Convert ST v2 RTC format to Gregorian date.
+ */
+static int pl031_stv2_time_to_tm(unsigned long st_time, unsigned long bcd_year,
+        struct rtc_time *tm)
+{
+        tm->tm_year = bcd2bin(bcd_year) + (bcd2bin(bcd_year >> 8) * 100);
+        tm->tm_mon  = ((st_time & RTC_MON_MASK) >> RTC_MON_SHIFT) - 1;
+        tm->tm_mday = ((st_time & RTC_MDAY_MASK) >> RTC_MDAY_SHIFT);
+        tm->tm_wday = ((st_time & RTC_WDAY_MASK) >> RTC_WDAY_SHIFT) - 1;
+        tm->tm_hour = ((st_time & RTC_HOUR_MASK) >> RTC_HOUR_SHIFT);
+        tm->tm_min  = ((st_time & RTC_MIN_MASK) >> RTC_MIN_SHIFT);
+        tm->tm_sec  = ((st_time & RTC_SEC_MASK) >> RTC_SEC_SHIFT);
+
+        tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
+        tm->tm_year -= 1900;
+
+        return 0;
+}
+
+static int pl031_stv2_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+
+        pl031_stv2_time_to_tm(readl(ldata->base + RTC_DR),
+                        readl(ldata->base + RTC_YDR), tm);
+
+        return 0;
+}
+
+static int pl031_stv2_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long time;
+        unsigned long bcd_year;
         struct pl031_local *ldata = dev_get_drvdata(dev);
+        int ret;
 
-        switch (cmd) {
-        case RTC_AIE_OFF:
-                __raw_writel(1, ldata->base + RTC_MIS);
-                return 0;
-        case RTC_AIE_ON:
-                __raw_writel(0, ldata->base + RTC_MIS);
-                return 0;
+        ret = pl031_stv2_tm_to_time(dev, tm, &time, &bcd_year);
+        if (ret == 0) {
+                writel(bcd_year, ldata->base + RTC_YLR);
+                writel(time, ldata->base + RTC_LR);
         }
 
-        return -ENOIOCTLCMD;
+        return ret;
+}
+
+static int pl031_stv2_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+        int ret;
+
+        ret = pl031_stv2_time_to_tm(readl(ldata->base + RTC_MR),
+                        readl(ldata->base + RTC_YMR), &alarm->time);
+
+        alarm->pending = readl(ldata->base + RTC_RIS) & RTC_BIT_AI;
+        alarm->enabled = readl(ldata->base + RTC_IMSC) & RTC_BIT_AI;
+
+        return ret;
+}
+
+static int pl031_stv2_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+        unsigned long time;
+        unsigned long bcd_year;
+        int ret;
+
+        /* At the moment, we can only deal with non-wildcarded alarm times. */
+        ret = rtc_valid_tm(&alarm->time);
+        if (ret == 0) {
+                ret = pl031_stv2_tm_to_time(dev, &alarm->time,
+                                            &time, &bcd_year);
+                if (ret == 0) {
+                        writel(bcd_year, ldata->base + RTC_YMR);
+                        writel(time, ldata->base + RTC_MR);
+
+                        pl031_alarm_irq_enable(dev, alarm->enabled);
+                }
+        }
+
+        return ret;
+}
+
+static irqreturn_t pl031_interrupt(int irq, void *dev_id)
+{
+        struct pl031_local *ldata = dev_id;
+        unsigned long rtcmis;
+        unsigned long events = 0;
+
+        rtcmis = readl(ldata->base + RTC_MIS);
+        if (rtcmis) {
+                writel(rtcmis, ldata->base + RTC_ICR);
+
+                if (rtcmis & RTC_BIT_AI)
+                        events |= (RTC_AF | RTC_IRQF);
+
+                /* Timer interrupt is only available in ST variants */
+                if ((rtcmis & RTC_BIT_PI) &&
+                        (ldata->hw_designer == AMBA_VENDOR_ST))
+                        events |= (RTC_PF | RTC_IRQF);
+
+                rtc_update_irq(ldata->rtc, 1, events);
+
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
 }
 
 static int pl031_read_time(struct device *dev, struct rtc_time *tm)
 {
         struct pl031_local *ldata = dev_get_drvdata(dev);
 
-        rtc_time_to_tm(__raw_readl(ldata->base + RTC_DR), tm);
+        rtc_time_to_tm(readl(ldata->base + RTC_DR), tm);
 
         return 0;
 }
@@ -74,20 +252,24 @@ static int pl031_set_time(struct device *dev, struct rtc_time *tm)
 {
         unsigned long time;
         struct pl031_local *ldata = dev_get_drvdata(dev);
+        int ret;
 
-        rtc_tm_to_time(tm, &time);
-        __raw_writel(time, ldata->base + RTC_LR);
+        ret = rtc_tm_to_time(tm, &time);
 
-        return 0;
+        if (ret == 0)
+                writel(time, ldata->base + RTC_LR);
+
+        return ret;
 }
 
 static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
         struct pl031_local *ldata = dev_get_drvdata(dev);
 
-        rtc_time_to_tm(__raw_readl(ldata->base + RTC_MR), &alarm->time);
-        alarm->pending = __raw_readl(ldata->base + RTC_RIS);
-        alarm->enabled = __raw_readl(ldata->base + RTC_IMSC);
+        rtc_time_to_tm(readl(ldata->base + RTC_MR), &alarm->time);
+
+        alarm->pending = readl(ldata->base + RTC_RIS) & RTC_BIT_AI;
+        alarm->enabled = readl(ldata->base + RTC_IMSC) & RTC_BIT_AI;
 
         return 0;
 }
@@ -96,22 +278,71 @@ static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
         struct pl031_local *ldata = dev_get_drvdata(dev);
         unsigned long time;
+        int ret;
+
+        /* At the moment, we can only deal with non-wildcarded alarm times. */
+        ret = rtc_valid_tm(&alarm->time);
+        if (ret == 0) {
+                ret = rtc_tm_to_time(&alarm->time, &time);
+                if (ret == 0) {
+                        writel(time, ldata->base + RTC_MR);
+                        pl031_alarm_irq_enable(dev, alarm->enabled);
+                }
+        }
+
+        return ret;
+}
+
+/* Periodic interrupt is only available in ST variants. */
+static int pl031_irq_set_state(struct device *dev, int enabled)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+
+        if (enabled == 1) {
+                /* Clear any pending timer interrupt. */
+                writel(RTC_BIT_PI, ldata->base + RTC_ICR);
+
+                writel(readl(ldata->base + RTC_IMSC) | RTC_BIT_PI,
+                        ldata->base + RTC_IMSC);
+
+                /* Now start the timer */
+                writel(readl(ldata->base + RTC_TCR) | RTC_TCR_EN,
+                        ldata->base + RTC_TCR);
 
-        rtc_tm_to_time(&alarm->time, &time);
+        } else {
+                writel(readl(ldata->base + RTC_IMSC) & (~RTC_BIT_PI),
+                        ldata->base + RTC_IMSC);
 
-        __raw_writel(time, ldata->base + RTC_MR);
-        __raw_writel(!alarm->enabled, ldata->base + RTC_MIS);
+                /* Also stop the timer */
+                writel(readl(ldata->base + RTC_TCR) & (~RTC_TCR_EN),
+                        ldata->base + RTC_TCR);
+        }
+        /* Wait at least 1 RTC32 clock cycle to ensure next access
+         * to RTC_TCR will succeed.
+         */
+        udelay(40);
 
         return 0;
 }
 
-static const struct rtc_class_ops pl031_ops = {
-        .ioctl = pl031_ioctl,
-        .read_time = pl031_read_time,
-        .set_time = pl031_set_time,
-        .read_alarm = pl031_read_alarm,
-        .set_alarm = pl031_set_alarm,
-};
+static int pl031_irq_set_freq(struct device *dev, int freq)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+
+        /* Cant set timer if it is already enabled */
+        if (readl(ldata->base + RTC_TCR) & RTC_TCR_EN) {
+                dev_err(dev, "can't change frequency while timer enabled\n");
+                return -EINVAL;
+        }
+
+        /* If self start bit in RTC_TCR is set timer will start here,
+         * but we never set that bit. Instead we start the timer when
+         * set_state is called with enabled == 1.
+         */
+        writel(RTC_TIMER_FREQ / freq, ldata->base + RTC_TLR);
+
+        return 0;
+}
 
 static int pl031_remove(struct amba_device *adev)
 {
@@ -131,18 +362,20 @@ static int pl031_probe(struct amba_device *adev, struct amba_id *id)
 {
         int ret;
         struct pl031_local *ldata;
+        struct rtc_class_ops *ops = id->data;
 
         ret = amba_request_regions(adev, NULL);
         if (ret)
                 goto err_req;
 
-        ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
+        ldata = kzalloc(sizeof(struct pl031_local), GFP_KERNEL);
         if (!ldata) {
                 ret = -ENOMEM;
                 goto out;
         }
 
         ldata->base = ioremap(adev->res.start, resource_size(&adev->res));
+
         if (!ldata->base) {
                 ret = -ENOMEM;
                 goto out_no_remap;
@@ -150,24 +383,36 @@ static int pl031_probe(struct amba_device *adev, struct amba_id *id)
 
         amba_set_drvdata(adev, ldata);
 
-        if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED,
-                        "rtc-pl031", ldata->rtc)) {
-                ret = -EIO;
-                goto out_no_irq;
-        }
+        ldata->hw_designer = amba_manf(adev);
+        ldata->hw_revision = amba_rev(adev);
+
+        dev_dbg(&adev->dev, "designer ID = 0x%02x\n", ldata->hw_designer);
+        dev_dbg(&adev->dev, "revision = 0x%01x\n", ldata->hw_revision);
+
+        /* Enable the clockwatch on ST Variants */
+        if ((ldata->hw_designer == AMBA_VENDOR_ST) &&
+            (ldata->hw_revision > 1))
+                writel(readl(ldata->base + RTC_CR) | RTC_CR_CWEN,
+                       ldata->base + RTC_CR);
 
-        ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops,
-                                         THIS_MODULE);
+        ldata->rtc = rtc_device_register("pl031", &adev->dev, ops,
+                                        THIS_MODULE);
         if (IS_ERR(ldata->rtc)) {
                 ret = PTR_ERR(ldata->rtc);
                 goto out_no_rtc;
         }
 
+        if (request_irq(adev->irq[0], pl031_interrupt,
+                        IRQF_DISABLED, "rtc-pl031", ldata)) {
+                ret = -EIO;
+                goto out_no_irq;
+        }
+
         return 0;
 
-out_no_rtc:
-        free_irq(adev->irq[0], ldata->rtc);
 out_no_irq:
+        rtc_device_unregister(ldata->rtc);
+out_no_rtc:
         iounmap(ldata->base);
         amba_set_drvdata(adev, NULL);
 out_no_remap:
@@ -175,13 +420,58 @@ out_no_remap:
 out:
         amba_release_regions(adev);
 err_req:
+
         return ret;
 }
 
-static struct amba_id pl031_ids[] __initdata = {
+/* Operations for the original ARM version */
+static struct rtc_class_ops arm_pl031_ops = {
+        .read_time = pl031_read_time,
+        .set_time = pl031_set_time,
+        .read_alarm = pl031_read_alarm,
+        .set_alarm = pl031_set_alarm,
+        .alarm_irq_enable = pl031_alarm_irq_enable,
+};
+
+/* The First ST derivative */
+static struct rtc_class_ops stv1_pl031_ops = {
+        .read_time = pl031_read_time,
+        .set_time = pl031_set_time,
+        .read_alarm = pl031_read_alarm,
+        .set_alarm = pl031_set_alarm,
+        .alarm_irq_enable = pl031_alarm_irq_enable,
+        .irq_set_state = pl031_irq_set_state,
+        .irq_set_freq = pl031_irq_set_freq,
+};
+
+/* And the second ST derivative */
+static struct rtc_class_ops stv2_pl031_ops = {
+        .read_time = pl031_stv2_read_time,
+        .set_time = pl031_stv2_set_time,
+        .read_alarm = pl031_stv2_read_alarm,
+        .set_alarm = pl031_stv2_set_alarm,
+        .alarm_irq_enable = pl031_alarm_irq_enable,
+        .irq_set_state = pl031_irq_set_state,
+        .irq_set_freq = pl031_irq_set_freq,
+};
+
+static struct amba_id pl031_ids[] = {
+        {
+                .id = 0x00041031,
+                .mask = 0x000fffff,
+                .data = &arm_pl031_ops,
+        },
+        /* ST Micro variants */
+        {
+                .id = 0x00180031,
+                .mask = 0x00ffffff,
+                .data = &stv1_pl031_ops,
+        },
         {
-                 .id = 0x00041031,
-                .mask = 0x000fffff, },
+                .id = 0x00280031,
+                .mask = 0x00ffffff,
+                .data = &stv2_pl031_ops,
+        },
         {0, 0},
 };
 
diff --git a/drivers/rtc/rtc-pxa.c b/drivers/rtc/rtc-pxa.c
index bb8cc05605ac..29e867a1aaa8 100644
--- a/drivers/rtc/rtc-pxa.c
+++ b/drivers/rtc/rtc-pxa.c
@@ -26,6 +26,7 @@
 #include <linux/seq_file.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <mach/hardware.h>
 
@@ -86,7 +87,6 @@ struct pxa_rtc {
         int                     irq_Alrm;
         struct rtc_device       *rtc;
         spinlock_t              lock;           /* Protects this structure */
-        struct rtc_time         rtc_alarm;
 };
 
 static u32 ryxr_calc(struct rtc_time *tm)
@@ -235,32 +235,34 @@ static int pxa_periodic_irq_set_state(struct device *dev, int enabled)
         return 0;
 }
 
-static int pxa_rtc_ioctl(struct device *dev, unsigned int cmd,
-                unsigned long arg)
+static int pxa_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
-        int ret = 0;
 
         spin_lock_irq(&pxa_rtc->lock);
-        switch (cmd) {
-        case RTC_AIE_OFF:
-                rtsr_clear_bits(pxa_rtc, RTSR_RDALE1);
-                break;
-        case RTC_AIE_ON:
+
+        if (enabled)
                 rtsr_set_bits(pxa_rtc, RTSR_RDALE1);
-                break;
-        case RTC_UIE_OFF:
-                rtsr_clear_bits(pxa_rtc, RTSR_HZE);
-                break;
-        case RTC_UIE_ON:
+        else
+                rtsr_clear_bits(pxa_rtc, RTSR_RDALE1);
+
+        spin_unlock_irq(&pxa_rtc->lock);
+        return 0;
+}
+
+static int pxa_update_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
+
+        spin_lock_irq(&pxa_rtc->lock);
+
+        if (enabled)
                 rtsr_set_bits(pxa_rtc, RTSR_HZE);
-                break;
-        default:
-                ret = -ENOIOCTLCMD;
-        }
+        else
+                rtsr_clear_bits(pxa_rtc, RTSR_HZE);
 
         spin_unlock_irq(&pxa_rtc->lock);
-        return ret;
+        return 0;
 }
 
 static int pxa_rtc_read_time(struct device *dev, struct rtc_time *tm)
@@ -339,11 +341,12 @@ static int pxa_rtc_proc(struct device *dev, struct seq_file *seq)
 static const struct rtc_class_ops pxa_rtc_ops = {
         .open = pxa_rtc_open,
         .release = pxa_rtc_release,
-        .ioctl = pxa_rtc_ioctl,
         .read_time = pxa_rtc_read_time,
         .set_time = pxa_rtc_set_time,
         .read_alarm = pxa_rtc_read_alarm,
         .set_alarm = pxa_rtc_set_alarm,
+        .alarm_irq_enable = pxa_alarm_irq_enable,
+        .update_irq_enable = pxa_update_irq_enable,
         .proc = pxa_rtc_proc,
         .irq_set_state = pxa_periodic_irq_set_state,
         .irq_set_freq = pxa_periodic_irq_set_freq,
@@ -438,34 +441,37 @@ static int __exit pxa_rtc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int pxa_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int pxa_rtc_suspend(struct device *dev)
 {
-        struct pxa_rtc *pxa_rtc = platform_get_drvdata(pdev);
+        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
 
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(dev))
                 enable_irq_wake(pxa_rtc->irq_Alrm);
         return 0;
 }
 
-static int pxa_rtc_resume(struct platform_device *pdev)
+static int pxa_rtc_resume(struct device *dev)
 {
-        struct pxa_rtc *pxa_rtc = platform_get_drvdata(pdev);
+        struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
 
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(dev))
                 disable_irq_wake(pxa_rtc->irq_Alrm);
         return 0;
 }
-#else
-#define pxa_rtc_suspend NULL
-#define pxa_rtc_resume  NULL
+
+static const struct dev_pm_ops pxa_rtc_pm_ops = {
+        .suspend        = pxa_rtc_suspend,
+        .resume         = pxa_rtc_resume,
+};
 #endif
 
 static struct platform_driver pxa_rtc_driver = {
         .remove         = __exit_p(pxa_rtc_remove),
-        .suspend        = pxa_rtc_suspend,
-        .resume         = pxa_rtc_resume,
         .driver         = {
-                .name           = "pxa-rtc",
+                .name   = "pxa-rtc",
+#ifdef CONFIG_PM
+                .pm     = &pxa_rtc_pm_ops,
+#endif
         },
 };
 
diff --git a/drivers/rtc/rtc-r9701.c b/drivers/rtc/rtc-r9701.c
index 42028f233bef..9beba49c3c5b 100644
--- a/drivers/rtc/rtc-r9701.c
+++ b/drivers/rtc/rtc-r9701.c
@@ -174,3 +174,4 @@ module_exit(r9701_exit);
 MODULE_DESCRIPTION("r9701 spi RTC driver");
 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:rtc-r9701");
diff --git a/drivers/rtc/rtc-rp5c01.c b/drivers/rtc/rtc-rp5c01.c
new file mode 100644
index 000000000000..36eb66184461
--- /dev/null
+++ b/drivers/rtc/rtc-rp5c01.c
@@ -0,0 +1,312 @@
+/*
+ *  Ricoh RP5C01 RTC Driver
+ *
+ *  Copyright 2009 Geert Uytterhoeven
+ *
+ *  Based on the A3000 TOD code in arch/m68k/amiga/config.c
+ *  Copyright (C) 1993 Hamish Macdonald
+ */
+
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+
+
+enum {
+        RP5C01_1_SECOND         = 0x0,  /* MODE 00 */
+        RP5C01_10_SECOND        = 0x1,  /* MODE 00 */
+        RP5C01_1_MINUTE         = 0x2,  /* MODE 00 and MODE 01 */
+        RP5C01_10_MINUTE        = 0x3,  /* MODE 00 and MODE 01 */
+        RP5C01_1_HOUR           = 0x4,  /* MODE 00 and MODE 01 */
+        RP5C01_10_HOUR          = 0x5,  /* MODE 00 and MODE 01 */
+        RP5C01_DAY_OF_WEEK      = 0x6,  /* MODE 00 and MODE 01 */
+        RP5C01_1_DAY            = 0x7,  /* MODE 00 and MODE 01 */
+        RP5C01_10_DAY           = 0x8,  /* MODE 00 and MODE 01 */
+        RP5C01_1_MONTH          = 0x9,  /* MODE 00 */
+        RP5C01_10_MONTH         = 0xa,  /* MODE 00 */
+        RP5C01_1_YEAR           = 0xb,  /* MODE 00 */
+        RP5C01_10_YEAR          = 0xc,  /* MODE 00 */
+
+        RP5C01_12_24_SELECT     = 0xa,  /* MODE 01 */
+        RP5C01_LEAP_YEAR        = 0xb,  /* MODE 01 */
+
+        RP5C01_MODE             = 0xd,  /* all modes */
+        RP5C01_TEST             = 0xe,  /* all modes */
+        RP5C01_RESET            = 0xf,  /* all modes */
+};
+
+#define RP5C01_12_24_SELECT_12  (0 << 0)
+#define RP5C01_12_24_SELECT_24  (1 << 0)
+
+#define RP5C01_10_HOUR_AM       (0 << 1)
+#define RP5C01_10_HOUR_PM       (1 << 1)
+
+#define RP5C01_MODE_TIMER_EN    (1 << 3)        /* timer enable */
+#define RP5C01_MODE_ALARM_EN    (1 << 2)        /* alarm enable */
+
+#define RP5C01_MODE_MODE_MASK   (3 << 0)
+#define RP5C01_MODE_MODE00      (0 << 0)        /* time */
+#define RP5C01_MODE_MODE01      (1 << 0)        /* alarm, 12h/24h, leap year */
+#define RP5C01_MODE_RAM_BLOCK10 (2 << 0)        /* RAM 4 bits x 13 */
+#define RP5C01_MODE_RAM_BLOCK11 (3 << 0)        /* RAM 4 bits x 13 */
+
+#define RP5C01_RESET_1HZ_PULSE  (1 << 3)
+#define RP5C01_RESET_16HZ_PULSE (1 << 2)
+#define RP5C01_RESET_SECOND     (1 << 1)        /* reset divider stages for */
+                                                /* seconds or smaller units */
+#define RP5C01_RESET_ALARM      (1 << 0)        /* reset all alarm registers */
+
+
+struct rp5c01_priv {
+        u32 __iomem *regs;
+        struct rtc_device *rtc;
+        spinlock_t lock;        /* against concurrent RTC/NVRAM access */
+        struct bin_attribute nvram_attr;
+};
+
+static inline unsigned int rp5c01_read(struct rp5c01_priv *priv,
+                                       unsigned int reg)
+{
+        return __raw_readl(&priv->regs[reg]) & 0xf;
+}
+
+static inline void rp5c01_write(struct rp5c01_priv *priv, unsigned int val,
+                                unsigned int reg)
+{
+        return __raw_writel(val, &priv->regs[reg]);
+}
+
+static void rp5c01_lock(struct rp5c01_priv *priv)
+{
+        rp5c01_write(priv, RP5C01_MODE_MODE00, RP5C01_MODE);
+}
+
+static void rp5c01_unlock(struct rp5c01_priv *priv)
+{
+        rp5c01_write(priv, RP5C01_MODE_TIMER_EN | RP5C01_MODE_MODE01,
+                     RP5C01_MODE);
+}
+
+static int rp5c01_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct rp5c01_priv *priv = dev_get_drvdata(dev);
+
+        spin_lock_irq(&priv->lock);
+        rp5c01_lock(priv);
+
+        tm->tm_sec  = rp5c01_read(priv, RP5C01_10_SECOND) * 10 +
+                      rp5c01_read(priv, RP5C01_1_SECOND);
+        tm->tm_min  = rp5c01_read(priv, RP5C01_10_MINUTE) * 10 +
+                      rp5c01_read(priv, RP5C01_1_MINUTE);
+        tm->tm_hour = rp5c01_read(priv, RP5C01_10_HOUR) * 10 +
+                      rp5c01_read(priv, RP5C01_1_HOUR);
+        tm->tm_mday = rp5c01_read(priv, RP5C01_10_DAY) * 10 +
+                      rp5c01_read(priv, RP5C01_1_DAY);
+        tm->tm_wday = rp5c01_read(priv, RP5C01_DAY_OF_WEEK);
+        tm->tm_mon  = rp5c01_read(priv, RP5C01_10_MONTH) * 10 +
+                      rp5c01_read(priv, RP5C01_1_MONTH) - 1;
+        tm->tm_year = rp5c01_read(priv, RP5C01_10_YEAR) * 10 +
+                      rp5c01_read(priv, RP5C01_1_YEAR);
+        if (tm->tm_year <= 69)
+                tm->tm_year += 100;
+
+        rp5c01_unlock(priv);
+        spin_unlock_irq(&priv->lock);
+
+        return rtc_valid_tm(tm);
+}
+
+static int rp5c01_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct rp5c01_priv *priv = dev_get_drvdata(dev);
+
+        spin_lock_irq(&priv->lock);
+        rp5c01_lock(priv);
+
+        rp5c01_write(priv, tm->tm_sec / 10, RP5C01_10_SECOND);
+        rp5c01_write(priv, tm->tm_sec % 10, RP5C01_1_SECOND);
+        rp5c01_write(priv, tm->tm_min / 10, RP5C01_10_MINUTE);
+        rp5c01_write(priv, tm->tm_min % 10, RP5C01_1_MINUTE);
+        rp5c01_write(priv, tm->tm_hour / 10, RP5C01_10_HOUR);
+        rp5c01_write(priv, tm->tm_hour % 10, RP5C01_1_HOUR);
+        rp5c01_write(priv, tm->tm_mday / 10, RP5C01_10_DAY);
+        rp5c01_write(priv, tm->tm_mday % 10, RP5C01_1_DAY);
+        if (tm->tm_wday != -1)
+                rp5c01_write(priv, tm->tm_wday, RP5C01_DAY_OF_WEEK);
+        rp5c01_write(priv, (tm->tm_mon + 1) / 10, RP5C01_10_MONTH);
+        rp5c01_write(priv, (tm->tm_mon + 1) % 10, RP5C01_1_MONTH);
+        if (tm->tm_year >= 100)
+                tm->tm_year -= 100;
+        rp5c01_write(priv, tm->tm_year / 10, RP5C01_10_YEAR);
+        rp5c01_write(priv, tm->tm_year % 10, RP5C01_1_YEAR);
+
+        rp5c01_unlock(priv);
+        spin_unlock_irq(&priv->lock);
+        return 0;
+}
+
+static const struct rtc_class_ops rp5c01_rtc_ops = {
+        .read_time      = rp5c01_read_time,
+        .set_time       = rp5c01_set_time,
+};
+
+
+/*
+ * The NVRAM is organized as 2 blocks of 13 nibbles of 4 bits.
+ * We provide access to them like AmigaOS does: the high nibble of each 8-bit
+ * byte is stored in BLOCK10, the low nibble in BLOCK11.
+ */
+
+static ssize_t rp5c01_nvram_read(struct file *filp, struct kobject *kobj,
+                                 struct bin_attribute *bin_attr,
+                                 char *buf, loff_t pos, size_t size)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct rp5c01_priv *priv = dev_get_drvdata(dev);
+        ssize_t count;
+
+        spin_lock_irq(&priv->lock);
+
+        for (count = 0; size > 0 && pos < RP5C01_MODE; count++, size--) {
+                u8 data;
+
+                rp5c01_write(priv,
+                             RP5C01_MODE_TIMER_EN | RP5C01_MODE_RAM_BLOCK10,
+                             RP5C01_MODE);
+                data = rp5c01_read(priv, pos) << 4;
+                rp5c01_write(priv,
+                             RP5C01_MODE_TIMER_EN | RP5C01_MODE_RAM_BLOCK11,
+                             RP5C01_MODE);
+                data |= rp5c01_read(priv, pos++);
+                rp5c01_write(priv, RP5C01_MODE_TIMER_EN | RP5C01_MODE_MODE01,
+                             RP5C01_MODE);
+                *buf++ = data;
+        }
+
+        spin_unlock_irq(&priv->lock);
+        return count;
+}
+
+static ssize_t rp5c01_nvram_write(struct file *filp, struct kobject *kobj,
+                                  struct bin_attribute *bin_attr,
+                                  char *buf, loff_t pos, size_t size)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct rp5c01_priv *priv = dev_get_drvdata(dev);
+        ssize_t count;
+
+        spin_lock_irq(&priv->lock);
+
+        for (count = 0; size > 0 && pos < RP5C01_MODE; count++, size--) {
+                u8 data = *buf++;
+
+                rp5c01_write(priv,
+                             RP5C01_MODE_TIMER_EN | RP5C01_MODE_RAM_BLOCK10,
+                             RP5C01_MODE);
+                rp5c01_write(priv, data >> 4, pos);
+                rp5c01_write(priv,
+                             RP5C01_MODE_TIMER_EN | RP5C01_MODE_RAM_BLOCK11,
+                             RP5C01_MODE);
+                rp5c01_write(priv, data & 0xf, pos++);
+                rp5c01_write(priv, RP5C01_MODE_TIMER_EN | RP5C01_MODE_MODE01,
+                             RP5C01_MODE);
+        }
+
+        spin_unlock_irq(&priv->lock);
+        return count;
+}
+
+static int __init rp5c01_rtc_probe(struct platform_device *dev)
+{
+        struct resource *res;
+        struct rp5c01_priv *priv;
+        struct rtc_device *rtc;
+        int error;
+
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->regs = ioremap(res->start, resource_size(res));
+        if (!priv->regs) {
+                error = -ENOMEM;
+                goto out_free_priv;
+        }
+
+        sysfs_bin_attr_init(&priv->nvram_attr);
+        priv->nvram_attr.attr.name = "nvram";
+        priv->nvram_attr.attr.mode = S_IRUGO | S_IWUSR;
+        priv->nvram_attr.read = rp5c01_nvram_read;
+        priv->nvram_attr.write = rp5c01_nvram_write;
+        priv->nvram_attr.size = RP5C01_MODE;
+
+        spin_lock_init(&priv->lock);
+
+        rtc = rtc_device_register("rtc-rp5c01", &dev->dev, &rp5c01_rtc_ops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                error = PTR_ERR(rtc);
+                goto out_unmap;
+        }
+
+        priv->rtc = rtc;
+        platform_set_drvdata(dev, priv);
+
+        error = sysfs_create_bin_file(&dev->dev.kobj, &priv->nvram_attr);
+        if (error)
+                goto out_unregister;
+
+        return 0;
+
+out_unregister:
+        rtc_device_unregister(rtc);
+out_unmap:
+        iounmap(priv->regs);
+out_free_priv:
+        kfree(priv);
+        return error;
+}
+
+static int __exit rp5c01_rtc_remove(struct platform_device *dev)
+{
+        struct rp5c01_priv *priv = platform_get_drvdata(dev);
+
+        sysfs_remove_bin_file(&dev->dev.kobj, &priv->nvram_attr);
+        rtc_device_unregister(priv->rtc);
+        iounmap(priv->regs);
+        kfree(priv);
+        return 0;
+}
+
+static struct platform_driver rp5c01_rtc_driver = {
+        .driver = {
+                .name   = "rtc-rp5c01",
+                .owner  = THIS_MODULE,
+        },
+        .remove = __exit_p(rp5c01_rtc_remove),
+};
+
+static int __init rp5c01_rtc_init(void)
+{
+        return platform_driver_probe(&rp5c01_rtc_driver, rp5c01_rtc_probe);
+}
+
+static void __exit rp5c01_rtc_fini(void)
+{
+        platform_driver_unregister(&rp5c01_rtc_driver);
+}
+
+module_init(rp5c01_rtc_init);
+module_exit(rp5c01_rtc_fini);
+
+MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Ricoh RP5C01 RTC driver");
+MODULE_ALIAS("platform:rtc-rp5c01");
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-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
index dd1e2bc7a472..368d0e63cf83 100644
--- a/drivers/rtc/rtc-rs5c348.c
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -19,6 +19,7 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/rtc.h>
 #include <linux/workqueue.h>
 #include <linux/spi/spi.h>
@@ -251,3 +252,4 @@ MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
 MODULE_DESCRIPTION("Ricoh RS5C348 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+MODULE_ALIAS("spi:rtc-rs5c348");
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index 2f2c68d476da..dd14e202c2c8 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -13,6 +13,7 @@
 #include <linux/i2c.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
+#include <linux/slab.h>
 
 #define DRV_VERSION "0.6"
 
@@ -206,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 "
diff --git a/drivers/rtc/rtc-rx8025.c b/drivers/rtc/rtc-rx8025.c
index b1a29bcfdf13..af32a62e12a8 100644
--- a/drivers/rtc/rtc-rx8025.c
+++ b/drivers/rtc/rtc-rx8025.c
@@ -20,6 +20,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/bcd.h>
 #include <linux/i2c.h>
@@ -460,7 +461,7 @@ static struct rtc_class_ops rx8025_rtc_ops = {
  * Clock precision adjustment support
  *
  * According to the RX8025 SA/NB application manual the frequency and
- * temperature charateristics can be approximated using the following
+ * temperature characteristics can be approximated using the following
  * equation:
  *
  *   df = a * (ut - t)**2
@@ -631,7 +632,6 @@ errout_reg:
         rtc_device_unregister(rx8025->rtc);
 
 errout_free:
-        i2c_set_clientdata(client, NULL);
         kfree(rx8025);
 
 errout:
@@ -650,12 +650,11 @@ 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);
         rtc_device_unregister(rx8025->rtc);
-        i2c_set_clientdata(client, NULL);
         kfree(rx8025);
         return 0;
 }
diff --git a/drivers/rtc/rtc-rx8581.c b/drivers/rtc/rtc-rx8581.c
index c9522f3bc21c..600b890a3c15 100644
--- a/drivers/rtc/rtc-rx8581.c
+++ b/drivers/rtc/rtc-rx8581.c
@@ -1,8 +1,8 @@
 /*
  * An I2C driver for the Epson RX8581 RTC
  *
- * Author: Martyn Welch <martyn.welch@gefanuc.com>
- * Copyright 2008 GE Fanuc Intelligent Platforms Embedded Systems, Inc.
+ * Author: Martyn Welch <martyn.welch@ge.com>
+ * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
  *
  * 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
@@ -168,7 +168,7 @@ static int rx8581_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 return -EIO;
         }
 
-        err = i2c_smbus_write_byte_data(client, RX8581_REG_FLAG,
+        err = i2c_smbus_write_byte_data(client, RX8581_REG_CTRL,
                 (data | RX8581_CTRL_STOP));
         if (err < 0) {
                 dev_err(&client->dev, "Unable to write control register\n");
@@ -182,6 +182,20 @@ static int rx8581_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 return -EIO;
         }
 
+        /* get VLF and clear it */
+        data = i2c_smbus_read_byte_data(client, RX8581_REG_FLAG);
+        if (data < 0) {
+                dev_err(&client->dev, "Unable to read flag register\n");
+                return -EIO;
+        }
+
+        err = i2c_smbus_write_byte_data(client, RX8581_REG_FLAG,
+                (data & ~(RX8581_FLAG_VLF)));
+        if (err != 0) {
+                dev_err(&client->dev, "Unable to write flag register\n");
+                return -EIO;
+        }
+
         /* Restart the clock */
         data = i2c_smbus_read_byte_data(client, RX8581_REG_CTRL);
         if (data < 0) {
@@ -189,8 +203,8 @@ static int rx8581_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 return -EIO;
         }
 
-        err = i2c_smbus_write_byte_data(client, RX8581_REG_FLAG,
-                (data | ~(RX8581_CTRL_STOP)));
+        err = i2c_smbus_write_byte_data(client, RX8581_REG_CTRL,
+                (data & ~(RX8581_CTRL_STOP)));
         if (err != 0) {
                 dev_err(&client->dev, "Unable to write control register\n");
                 return -EIO;
@@ -272,7 +286,7 @@ static void __exit rx8581_exit(void)
         i2c_del_driver(&rx8581_driver);
 }
 
-MODULE_AUTHOR("Martyn Welch <martyn.welch@gefanuc.com>");
+MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com>");
 MODULE_DESCRIPTION("Epson RX-8581 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-s35390a.c b/drivers/rtc/rtc-s35390a.c
index def4d396d0b0..f789e002c9b0 100644
--- a/drivers/rtc/rtc-s35390a.c
+++ b/drivers/rtc/rtc-s35390a.c
@@ -275,7 +275,6 @@ exit_dummy:
                 if (s35390a->client[i])
                         i2c_unregister_device(s35390a->client[i]);
         kfree(s35390a);
-        i2c_set_clientdata(client, NULL);
 
 exit:
         return err;
@@ -292,7 +291,6 @@ static int s35390a_remove(struct i2c_client *client)
 
         rtc_device_unregister(s35390a->rtc);
         kfree(s35390a);
-        i2c_set_clientdata(client, NULL);
 
         return 0;
 }
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index e0d7b9991505..cf953ecbfca9 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -1,5 +1,8 @@
 /* drivers/rtc/rtc-s3c.c
  *
+ * Copyright (c) 2010 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com/
+ *
  * Copyright (c) 2004,2006 Simtec Electronics
  *      Ben Dooks, <ben@simtec.co.uk>
  *      http://armlinux.simtec.co.uk/
@@ -21,6 +24,7 @@
 #include <linux/bcd.h>
 #include <linux/clk.h>
 #include <linux/log2.h>
+#include <linux/slab.h>
 
 #include <mach/hardware.h>
 #include <asm/uaccess.h>
@@ -28,14 +32,21 @@
 #include <asm/irq.h>
 #include <plat/regs-rtc.h>
 
+enum s3c_cpu_type {
+        TYPE_S3C2410,
+        TYPE_S3C64XX,
+};
+
 /* I have yet to find an S3C implementation with more than one
  * of these rtc blocks in */
 
 static struct resource *s3c_rtc_mem;
 
+static struct clk *rtc_clk;
 static void __iomem *s3c_rtc_base;
 static int s3c_rtc_alarmno = NO_IRQ;
 static int s3c_rtc_tickno  = NO_IRQ;
+static enum s3c_cpu_type s3c_rtc_cpu_type;
 
 static DEFINE_SPINLOCK(s3c_rtc_pie_lock);
 
@@ -46,6 +57,10 @@ static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
         struct rtc_device *rdev = id;
 
         rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
+
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX)
+                writeb(S3C2410_INTP_ALM, s3c_rtc_base + S3C2410_INTP);
+
         return IRQ_HANDLED;
 }
 
@@ -54,6 +69,10 @@ static irqreturn_t s3c_rtc_tickirq(int irq, void *id)
         struct rtc_device *rdev = id;
 
         rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
+
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX)
+                writeb(S3C2410_INTP_TIC, s3c_rtc_base + S3C2410_INTP);
+
         return IRQ_HANDLED;
 }
 
@@ -79,12 +98,25 @@ static int s3c_rtc_setpie(struct device *dev, int enabled)
         pr_debug("%s: pie=%d\n", __func__, enabled);
 
         spin_lock_irq(&s3c_rtc_pie_lock);
-        tmp = readb(s3c_rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;
 
-        if (enabled)
-                tmp |= S3C2410_TICNT_ENABLE;
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
+                tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
+                tmp &= ~S3C64XX_RTCCON_TICEN;
+
+                if (enabled)
+                        tmp |= S3C64XX_RTCCON_TICEN;
+
+                writew(tmp, s3c_rtc_base + S3C2410_RTCCON);
+        } else {
+                tmp = readb(s3c_rtc_base + S3C2410_TICNT);
+                tmp &= ~S3C2410_TICNT_ENABLE;
+
+                if (enabled)
+                        tmp |= S3C2410_TICNT_ENABLE;
+
+                writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
+        }
 
-        writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
         spin_unlock_irq(&s3c_rtc_pie_lock);
 
         return 0;
@@ -92,17 +124,23 @@ static int s3c_rtc_setpie(struct device *dev, int enabled)
 
 static int s3c_rtc_setfreq(struct device *dev, int freq)
 {
-        unsigned int tmp;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
+        unsigned int tmp = 0;
 
         if (!is_power_of_2(freq))
                 return -EINVAL;
 
         spin_lock_irq(&s3c_rtc_pie_lock);
 
-        tmp = readb(s3c_rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
-        tmp |= (128 / freq)-1;
+        if (s3c_rtc_cpu_type == TYPE_S3C2410) {
+                tmp = readb(s3c_rtc_base + S3C2410_TICNT);
+                tmp &= S3C2410_TICNT_ENABLE;
+        }
+
+        tmp |= (rtc_dev->max_user_freq / freq)-1;
 
-        writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
+        writel(tmp, s3c_rtc_base + S3C2410_TICNT);
         spin_unlock_irq(&s3c_rtc_pie_lock);
 
         return 0;
@@ -133,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);
@@ -147,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)
@@ -155,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 */
@@ -193,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);
 
 
@@ -204,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;
 }
@@ -242,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;
@@ -272,20 +310,22 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         s3c_rtc_setaie(alrm->enabled);
 
-        if (alrm->enabled)
-                enable_irq_wake(s3c_rtc_alarmno);
-        else
-                disable_irq_wake(s3c_rtc_alarmno);
-
         return 0;
 }
 
 static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
 {
-        unsigned int ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
+        unsigned int ticnt;
 
-        seq_printf(seq, "periodic_IRQ\t: %s\n",
-                     (ticnt & S3C2410_TICNT_ENABLE) ? "yes" : "no" );
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
+                ticnt = readw(s3c_rtc_base + S3C2410_RTCCON);
+                ticnt &= S3C64XX_RTCCON_TICEN;
+        } else {
+                ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
+                ticnt &= S3C2410_TICNT_ENABLE;
+        }
+
+        seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt  ? "yes" : "no");
         return 0;
 }
 
@@ -339,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)
@@ -351,33 +392,42 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
                 return;
 
         if (!en) {
-                tmp = readb(base + S3C2410_RTCCON);
-                writeb(tmp & ~S3C2410_RTCCON_RTCEN, base + S3C2410_RTCCON);
-
-                tmp = readb(base + S3C2410_TICNT);
-                writeb(tmp & ~S3C2410_TICNT_ENABLE, base + S3C2410_TICNT);
+                tmp = readw(base + S3C2410_RTCCON);
+                if (s3c_rtc_cpu_type == TYPE_S3C64XX)
+                        tmp &= ~S3C64XX_RTCCON_TICEN;
+                tmp &= ~S3C2410_RTCCON_RTCEN;
+                writew(tmp, base + S3C2410_RTCCON);
+
+                if (s3c_rtc_cpu_type == TYPE_S3C2410) {
+                        tmp = readb(base + S3C2410_TICNT);
+                        tmp &= ~S3C2410_TICNT_ENABLE;
+                        writeb(tmp, base + S3C2410_TICNT);
+                }
         } 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);
                 }
         }
 }
@@ -392,6 +442,10 @@ static int __devexit s3c_rtc_remove(struct platform_device *dev)
         s3c_rtc_setpie(&dev->dev, 0);
         s3c_rtc_setaie(0);
 
+        clk_disable(rtc_clk);
+        clk_put(rtc_clk);
+        rtc_clk = NULL;
+
         iounmap(s3c_rtc_base);
         release_resource(s3c_rtc_mem);
         kfree(s3c_rtc_mem);
@@ -402,6 +456,7 @@ 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;
         int ret;
 
@@ -449,14 +504,22 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
                 goto err_nomap;
         }
 
+        rtc_clk = clk_get(&pdev->dev, "rtc");
+        if (IS_ERR(rtc_clk)) {
+                dev_err(&pdev->dev, "failed to find rtc clock source\n");
+                ret = PTR_ERR(rtc_clk);
+                rtc_clk = NULL;
+                goto err_clk;
+        }
+
+        clk_enable(rtc_clk);
+
         /* check to see if everything is setup correctly */
 
         s3c_rtc_enable(pdev, 1);
 
-        pr_debug("s3c2410_rtc: RTCCON=%02x\n",
-                 readb(s3c_rtc_base + S3C2410_RTCCON));
-
-        s3c_rtc_setfreq(&pdev->dev, 1);
+        pr_debug("s3c2410_rtc: RTCCON=%02x\n",
+                 readw(s3c_rtc_base + S3C2410_RTCCON));
 
         device_init_wakeup(&pdev->dev, 1);
 
@@ -471,13 +534,42 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
                 goto err_nortc;
         }
 
-        rtc->max_user_freq = 128;
+        s3c_rtc_cpu_type = platform_get_device_id(pdev)->driver_data;
+
+        /* Check RTC Time */
+
+        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);
+
+                dev_warn(&pdev->dev, "warning: invalid RTC value so initializing it\n");
+        }
+
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX)
+                rtc->max_user_freq = 32768;
+        else
+                rtc->max_user_freq = 128;
 
         platform_set_drvdata(pdev, rtc);
+
+        s3c_rtc_setfreq(&pdev->dev, 1);
+
         return 0;
 
  err_nortc:
         s3c_rtc_enable(pdev, 0);
+        clk_disable(rtc_clk);
+        clk_put(rtc_clk);
+
+ err_clk:
         iounmap(s3c_rtc_base);
 
  err_nomap:
@@ -491,20 +583,38 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 
 /* RTC Power management control */
 
-static int ticnt_save;
+static int ticnt_save, ticnt_en_save;
 
 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 = readw(s3c_rtc_base + S3C2410_RTCCON);
+                ticnt_en_save &= S3C64XX_RTCCON_TICEN;
+        }
         s3c_rtc_enable(pdev, 0);
+
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(s3c_rtc_alarmno);
+
         return 0;
 }
 
 static int s3c_rtc_resume(struct platform_device *pdev)
 {
+        unsigned int tmp;
+
         s3c_rtc_enable(pdev, 1);
         writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX && ticnt_en_save) {
+                tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
+                writew(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
+        }
+
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(s3c_rtc_alarmno);
+
         return 0;
 }
 #else
@@ -512,13 +622,27 @@ static int s3c_rtc_resume(struct platform_device *pdev)
 #define s3c_rtc_resume  NULL
 #endif
 
-static struct platform_driver s3c2410_rtc_driver = {
+static struct platform_device_id s3c_rtc_driver_ids[] = {
+        {
+                .name           = "s3c2410-rtc",
+                .driver_data    = TYPE_S3C2410,
+        }, {
+                .name           = "s3c64xx-rtc",
+                .driver_data    = TYPE_S3C64XX,
+        },
+        { }
+};
+
+MODULE_DEVICE_TABLE(platform, s3c_rtc_driver_ids);
+
+static struct platform_driver s3c_rtc_driver = {
         .probe          = s3c_rtc_probe,
         .remove         = __devexit_p(s3c_rtc_remove),
         .suspend        = s3c_rtc_suspend,
         .resume         = s3c_rtc_resume,
+        .id_table       = s3c_rtc_driver_ids,
         .driver         = {
-                .name   = "s3c2410-rtc",
+                .name   = "s3c-rtc",
                 .owner  = THIS_MODULE,
         },
 };
@@ -528,12 +652,12 @@ static char __initdata banner[] = "S3C24XX RTC, (c) 2004,2006 Simtec Electronics
 static int __init s3c_rtc_init(void)
 {
         printk(banner);
-        return platform_driver_register(&s3c2410_rtc_driver);
+        return platform_driver_register(&s3c_rtc_driver);
 }
 
 static void __exit s3c_rtc_exit(void)
 {
-        platform_driver_unregister(&s3c2410_rtc_driver);
+        platform_driver_unregister(&s3c_rtc_driver);
 }
 
 module_init(s3c_rtc_init);
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 4f247e4dd3f9..88ea52b8647a 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -9,7 +9,7 @@
  *
  * Modifications from:
  *   CIH <cih@coventive.com>
- *   Nicolas Pitre <nico@cam.org>
+ *   Nicolas Pitre <nico@fluxnic.net>
  *   Andrew Christian <andrew.christian@hp.com>
  *
  * Converted to the RTC subsystem and Driver Model
@@ -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,38 +479,41 @@ 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;
 }
 
 #ifdef CONFIG_PM
-static int sa1100_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int sa1100_rtc_suspend(struct device *dev)
 {
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(dev))
                 enable_irq_wake(IRQ_RTCAlrm);
         return 0;
 }
 
-static int sa1100_rtc_resume(struct platform_device *pdev)
+static int sa1100_rtc_resume(struct device *dev)
 {
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(dev))
                 disable_irq_wake(IRQ_RTCAlrm);
         return 0;
 }
-#else
-#define sa1100_rtc_suspend      NULL
-#define sa1100_rtc_resume       NULL
+
+static const struct dev_pm_ops sa1100_rtc_pm_ops = {
+        .suspend        = sa1100_rtc_suspend,
+        .resume         = sa1100_rtc_resume,
+};
 #endif
 
 static struct platform_driver sa1100_rtc_driver = {
         .probe          = sa1100_rtc_probe,
         .remove         = sa1100_rtc_remove,
-        .suspend        = sa1100_rtc_suspend,
-        .resume         = sa1100_rtc_resume,
         .driver         = {
-                .name           = "sa1100-rtc",
+                .name   = "sa1100-rtc",
+#ifdef CONFIG_PM
+                .pm     = &sa1100_rtc_pm_ops,
+#endif
         },
 };
 
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index d7310adb7152..06e41ed93230 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -26,10 +26,11 @@
 #include <linux/io.h>
 #include <linux/log2.h>
 #include <linux/clk.h>
+#include <linux/slab.h>
 #include <asm/rtc.h>
 
 #define DRV_NAME        "sh-rtc"
-#define DRV_VERSION     "0.2.2"
+#define DRV_VERSION     "0.2.3"
 
 #define RTC_REG(r)      ((r) * rtc_reg_size)
 
@@ -215,7 +216,7 @@ static irqreturn_t sh_rtc_shared(int irq, void *dev_id)
         return IRQ_RETVAL(ret);
 }
 
-static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
+static int sh_rtc_irq_set_state(struct device *dev, int enable)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
         unsigned int tmp;
@@ -225,17 +226,22 @@ static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
         tmp = readb(rtc->regbase + RCR2);
 
         if (enable) {
+                rtc->periodic_freq |= PF_KOU;
                 tmp &= ~RCR2_PEF;       /* Clear PES bit */
                 tmp |= (rtc->periodic_freq & ~PF_HP);   /* Set PES2-0 */
-        } else
+        } else {
+                rtc->periodic_freq &= ~PF_KOU;
                 tmp &= ~(RCR2_PESMASK | RCR2_PEF);
+        }
 
         writeb(tmp, rtc->regbase + RCR2);
 
         spin_unlock_irq(&rtc->lock);
+
+        return 0;
 }
 
-static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
+static int sh_rtc_irq_set_freq(struct device *dev, int freq)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
         int tmp, ret = 0;
@@ -278,10 +284,8 @@ static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
                 ret = -ENOTSUPP;
         }
 
-        if (ret == 0) {
+        if (ret == 0)
                 rtc->periodic_freq |= tmp;
-                rtc->rtc_dev->irq_freq = freq;
-        }
 
         spin_unlock_irq(&rtc->lock);
         return ret;
@@ -346,10 +350,6 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         unsigned int ret = 0;
 
         switch (cmd) {
-        case RTC_PIE_OFF:
-        case RTC_PIE_ON:
-                sh_rtc_setpie(dev, cmd == RTC_PIE_ON);
-                break;
         case RTC_AIE_OFF:
         case RTC_AIE_ON:
                 sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
@@ -362,13 +362,6 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
                 rtc->periodic_freq |= PF_OXS;
                 sh_rtc_setcie(dev, 1);
                 break;
-        case RTC_IRQP_READ:
-                ret = put_user(rtc->rtc_dev->irq_freq,
-                               (unsigned long __user *)arg);
-                break;
-        case RTC_IRQP_SET:
-                ret = sh_rtc_setfreq(dev, arg);
-                break;
         default:
                 ret = -ENOIOCTLCMD;
         }
@@ -602,28 +595,6 @@ static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
         return 0;
 }
 
-static int sh_rtc_irq_set_state(struct device *dev, int enabled)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct sh_rtc *rtc = platform_get_drvdata(pdev);
-
-        if (enabled) {
-                rtc->periodic_freq |= PF_KOU;
-                return sh_rtc_ioctl(dev, RTC_PIE_ON, 0);
-        } else {
-                rtc->periodic_freq &= ~PF_KOU;
-                return sh_rtc_ioctl(dev, RTC_PIE_OFF, 0);
-        }
-}
-
-static int sh_rtc_irq_set_freq(struct device *dev, int freq)
-{
-        if (!is_power_of_2(freq))
-                return -EINVAL;
-
-        return sh_rtc_ioctl(dev, RTC_IRQP_SET, freq);
-}
-
 static struct rtc_class_ops sh_rtc_ops = {
         .ioctl          = sh_rtc_ioctl,
         .read_time      = sh_rtc_read_time,
@@ -635,7 +606,7 @@ static struct rtc_class_ops sh_rtc_ops = {
         .proc           = sh_rtc_proc,
 };
 
-static int __devinit sh_rtc_probe(struct platform_device *pdev)
+static int __init sh_rtc_probe(struct platform_device *pdev)
 {
         struct sh_rtc *rtc;
         struct resource *res;
@@ -702,13 +673,6 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
 
         clk_enable(rtc->clk);
 
-        rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
-                                           &sh_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto err_unmap;
-        }
-
         rtc->capabilities = RTC_DEF_CAPABILITIES;
         if (pdev->dev.platform_data) {
                 struct sh_rtc_platform_info *pinfo = pdev->dev.platform_data;
@@ -720,10 +684,6 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 rtc->capabilities |= pinfo->capabilities;
         }
 
-        rtc->rtc_dev->max_user_freq = 256;
-
-        platform_set_drvdata(pdev, rtc);
-
         if (rtc->carry_irq <= 0) {
                 /* register shared periodic/carry/alarm irq */
                 ret = request_irq(rtc->periodic_irq, sh_rtc_shared,
@@ -767,13 +727,26 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 }
         }
 
+        platform_set_drvdata(pdev, rtc);
+
         /* everything disabled by default */
-        rtc->periodic_freq = 0;
-        rtc->rtc_dev->irq_freq = 0;
-        sh_rtc_setpie(&pdev->dev, 0);
+        sh_rtc_irq_set_freq(&pdev->dev, 0);
+        sh_rtc_irq_set_state(&pdev->dev, 0);
         sh_rtc_setaie(&pdev->dev, 0);
         sh_rtc_setcie(&pdev->dev, 0);
 
+        rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
+                                           &sh_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc->rtc_dev)) {
+                ret = PTR_ERR(rtc->rtc_dev);
+                free_irq(rtc->periodic_irq, rtc);
+                free_irq(rtc->carry_irq, rtc);
+                free_irq(rtc->alarm_irq, rtc);
+                goto err_unmap;
+        }
+
+        rtc->rtc_dev->max_user_freq = 256;
+
         /* reset rtc to epoch 0 if time is invalid */
         if (rtc_read_time(rtc->rtc_dev, &r) < 0) {
                 rtc_time_to_tm(0, &r);
@@ -788,21 +761,20 @@ 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);
 
         return ret;
 }
 
-static int __devexit sh_rtc_remove(struct platform_device *pdev)
+static int __exit sh_rtc_remove(struct platform_device *pdev)
 {
         struct sh_rtc *rtc = platform_get_drvdata(pdev);
 
-        if (likely(rtc->rtc_dev))
-                rtc_device_unregister(rtc->rtc_dev);
+        rtc_device_unregister(rtc->rtc_dev);
+        sh_rtc_irq_set_state(&pdev->dev, 0);
 
-        sh_rtc_setpie(&pdev->dev, 0);
         sh_rtc_setaie(&pdev->dev, 0);
         sh_rtc_setcie(&pdev->dev, 0);
 
@@ -813,9 +785,8 @@ static int __devexit sh_rtc_remove(struct platform_device *pdev)
                 free_irq(rtc->alarm_irq, rtc);
         }
 
-        release_resource(rtc->res);
-
         iounmap(rtc->regbase);
+        release_mem_region(rtc->res->start, rtc->regsize);
 
         clk_disable(rtc->clk);
         clk_put(rtc->clk);
@@ -856,7 +827,7 @@ static int sh_rtc_resume(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops sh_rtc_dev_pm_ops = {
+static const struct dev_pm_ops sh_rtc_dev_pm_ops = {
         .suspend = sh_rtc_suspend,
         .resume = sh_rtc_resume,
 };
@@ -867,13 +838,12 @@ static struct platform_driver sh_rtc_platform_driver = {
                 .owner  = THIS_MODULE,
                 .pm     = &sh_rtc_dev_pm_ops,
         },
-        .probe          = sh_rtc_probe,
-        .remove         = __devexit_p(sh_rtc_remove),
+        .remove         = __exit_p(sh_rtc_remove),
 };
 
 static int __init sh_rtc_init(void)
 {
-        return platform_driver_register(&sh_rtc_platform_driver);
+        return platform_driver_probe(&sh_rtc_platform_driver, sh_rtc_probe);
 }
 
 static void __exit sh_rtc_exit(void)
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
index 7d1547b0070e..3b943673cd3e 100644
--- a/drivers/rtc/rtc-stk17ta8.c
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -1,7 +1,7 @@
 /*
  * A RTC driver for the Simtek STK17TA8
  *
- * By Thomas Hommel <thomas.hommel@gefanuc.com>
+ * By Thomas Hommel <thomas.hommel@ge.com>
  *
  * Based on the DS1553 driver from
  * Atsushi Nemoto <anemo@mba.ocn.ne.jp>
@@ -14,6 +14,7 @@
 #include <linux/bcd.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/delay.h>
 #include <linux/jiffies.h>
 #include <linux/interrupt.h>
@@ -62,7 +63,6 @@
 struct rtc_plat_data {
         struct rtc_device *rtc;
         void __iomem *ioaddr;
-        unsigned long baseaddr;
         unsigned long last_jiffies;
         int irq;
         unsigned int irqen;
@@ -70,6 +70,7 @@ struct rtc_plat_data {
         int alrm_min;
         int alrm_hour;
         int alrm_mday;
+        spinlock_t lock;
 };
 
 static int stk17ta8_rtc_set_time(struct device *dev, struct rtc_time *tm)
@@ -142,7 +143,7 @@ static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
         unsigned long irqflags;
         u8 flags;
 
-        spin_lock_irqsave(&pdata->rtc->irq_lock, irqflags);
+        spin_lock_irqsave(&pdata->lock, irqflags);
 
         flags = readb(ioaddr + RTC_FLAGS);
         writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
@@ -162,7 +163,7 @@ static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
         writeb(pdata->irqen ? RTC_INTS_AIE : 0, ioaddr + RTC_INTERRUPTS);
         readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
         writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
-        spin_unlock_irqrestore(&pdata->rtc->irq_lock, irqflags);
+        spin_unlock_irqrestore(&pdata->lock, irqflags);
 }
 
 static int stk17ta8_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
@@ -202,56 +203,53 @@ static irqreturn_t stk17ta8_rtc_interrupt(int irq, void *dev_id)
         struct platform_device *pdev = dev_id;
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
-        unsigned long events = RTC_IRQF;
+        unsigned long events = 0;
 
+        spin_lock(&pdata->lock);
         /* read and clear interrupt */
-        if (!(readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF))
-                return IRQ_NONE;
-        if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
-                events |= RTC_UF;
-        else
-                events |= RTC_AF;
-        rtc_update_irq(pdata->rtc, 1, events);
-        return IRQ_HANDLED;
+        if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF) {
+                events = RTC_IRQF;
+                if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
+                        events |= RTC_UF;
+                else
+                        events |= RTC_AF;
+                if (likely(pdata->rtc))
+                        rtc_update_irq(pdata->rtc, 1, events);
+        }
+        spin_unlock(&pdata->lock);
+        return events ? IRQ_HANDLED : IRQ_NONE;
 }
 
-static int stk17ta8_rtc_ioctl(struct device *dev, unsigned int cmd,
-                            unsigned long arg)
+static int stk17ta8_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);
 
         if (pdata->irq <= 0)
-                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
-        switch (cmd) {
-        case RTC_AIE_OFF:
-                pdata->irqen &= ~RTC_AF;
-                stk17ta8_rtc_update_alarm(pdata);
-                break;
-        case RTC_AIE_ON:
+                return -EINVAL;
+        if (enabled)
                 pdata->irqen |= RTC_AF;
-                stk17ta8_rtc_update_alarm(pdata);
-                break;
-        default:
-                return -ENOIOCTLCMD;
-        }
+        else
+                pdata->irqen &= ~RTC_AF;
+        stk17ta8_rtc_update_alarm(pdata);
         return 0;
 }
 
 static const struct rtc_class_ops stk17ta8_rtc_ops = {
-        .read_time      = stk17ta8_rtc_read_time,
-        .set_time       = stk17ta8_rtc_set_time,
-        .read_alarm     = stk17ta8_rtc_read_alarm,
-        .set_alarm      = stk17ta8_rtc_set_alarm,
-        .ioctl          = stk17ta8_rtc_ioctl,
+        .read_time              = stk17ta8_rtc_read_time,
+        .set_time               = stk17ta8_rtc_set_time,
+        .read_alarm             = stk17ta8_rtc_read_alarm,
+        .set_alarm              = stk17ta8_rtc_set_alarm,
+        .alarm_irq_enable       = stk17ta8_rtc_alarm_irq_enable,
 };
 
-static ssize_t stk17ta8_nvram_read(struct kobject *kobj,
+static ssize_t stk17ta8_nvram_read(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *attr, char *buf,
                                  loff_t pos, size_t size)
 {
-        struct platform_device *pdev =
-                to_platform_device(container_of(kobj, struct device, kobj));
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
         ssize_t count;
@@ -261,12 +259,12 @@ static ssize_t stk17ta8_nvram_read(struct kobject *kobj,
         return count;
 }
 
-static ssize_t stk17ta8_nvram_write(struct kobject *kobj,
+static ssize_t stk17ta8_nvram_write(struct file *filp, struct kobject *kobj,
                                   struct bin_attribute *attr, char *buf,
                                   loff_t pos, size_t size)
 {
-        struct platform_device *pdev =
-                to_platform_device(container_of(kobj, struct device, kobj));
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
         ssize_t count;
@@ -286,33 +284,28 @@ static struct bin_attribute stk17ta8_nvram_attr = {
         .write = stk17ta8_nvram_write,
 };
 
-static int __init stk17ta8_rtc_probe(struct platform_device *pdev)
+static int __devinit stk17ta8_rtc_probe(struct platform_device *pdev)
 {
-        struct rtc_device *rtc;
         struct resource *res;
         unsigned int cal;
         unsigned int flags;
         struct rtc_plat_data *pdata;
-        void __iomem *ioaddr = NULL;
+        void __iomem *ioaddr;
         int ret = 0;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res)
                 return -ENODEV;
 
-        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
                 return -ENOMEM;
-        if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) {
-                ret = -EBUSY;
-                goto out;
-        }
-        pdata->baseaddr = res->start;
-        ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE);
-        if (!ioaddr) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        if (!devm_request_mem_region(&pdev->dev, res->start, RTC_REG_SIZE,
+                        pdev->name))
+                return -EBUSY;
+        ioaddr = devm_ioremap(&pdev->dev, res->start, RTC_REG_SIZE);
+        if (!ioaddr)
+                return -ENOMEM;
         pdata->ioaddr = ioaddr;
         pdata->irq = platform_get_irq(pdev, 0);
 
@@ -328,9 +321,13 @@ static int __init stk17ta8_rtc_probe(struct platform_device *pdev)
         if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_PF)
                 dev_warn(&pdev->dev, "voltage-low detected.\n");
 
+        spin_lock_init(&pdata->lock);
+        pdata->last_jiffies = jiffies;
+        platform_set_drvdata(pdev, pdata);
         if (pdata->irq > 0) {
                 writeb(0, ioaddr + RTC_INTERRUPTS);
-                if (request_irq(pdata->irq, stk17ta8_rtc_interrupt,
+                if (devm_request_irq(&pdev->dev, pdata->irq,
+                                stk17ta8_rtc_interrupt,
                                 IRQF_DISABLED | IRQF_SHARED,
                                 pdev->name, pdev) < 0) {
                         dev_warn(&pdev->dev, "interrupt not available.\n");
@@ -338,29 +335,14 @@ static int __init stk17ta8_rtc_probe(struct platform_device *pdev)
                 }
         }
 
-        rtc = rtc_device_register(pdev->name, &pdev->dev,
+        pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
                                   &stk17ta8_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                goto out;
-        }
-        pdata->rtc = rtc;
-        pdata->last_jiffies = jiffies;
-        platform_set_drvdata(pdev, pdata);
+        if (IS_ERR(pdata->rtc))
+                return PTR_ERR(pdata->rtc);
+
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
         if (ret)
-                goto out;
-        return 0;
- out:
-        if (pdata->rtc)
                 rtc_device_unregister(pdata->rtc);
-        if (pdata->irq > 0)
-                free_irq(pdata->irq, pdev);
-        if (ioaddr)
-                iounmap(ioaddr);
-        if (pdata->baseaddr)
-                release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
-        kfree(pdata);
         return ret;
 }
 
@@ -370,13 +352,8 @@ static int __devexit stk17ta8_rtc_remove(struct platform_device *pdev)
 
         sysfs_remove_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
         rtc_device_unregister(pdata->rtc);
-        if (pdata->irq > 0) {
+        if (pdata->irq > 0)
                 writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
-                free_irq(pdata->irq, pdev);
-        }
-        iounmap(pdata->ioaddr);
-        release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
-        kfree(pdata);
         return 0;
 }
 
@@ -405,7 +382,7 @@ static __exit void stk17ta8_exit(void)
 module_init(stk17ta8_init);
 module_exit(stk17ta8_exit);
 
-MODULE_AUTHOR("Thomas Hommel <thomas.hommel@gefanuc.com>");
+MODULE_AUTHOR("Thomas Hommel <thomas.hommel@ge.com>");
 MODULE_DESCRIPTION("Simtek STK17TA8 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-stmp3xxx.c b/drivers/rtc/rtc-stmp3xxx.c
new file mode 100644
index 000000000000..7e7d0c806f2d
--- /dev/null
+++ b/drivers/rtc/rtc-stmp3xxx.c
@@ -0,0 +1,305 @@
+/*
+ * Freescale STMP37XX/STMP378X Real Time Clock driver
+ *
+ * Copyright (c) 2007 Sigmatel, Inc.
+ * Peter Hartley, <peter.hartley@sigmatel.com>
+ *
+ * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
+ */
+
+/*
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+
+#include <mach/platform.h>
+#include <mach/stmp3xxx.h>
+#include <mach/regs-rtc.h>
+
+struct stmp3xxx_rtc_data {
+        struct rtc_device *rtc;
+        unsigned irq_count;
+        void __iomem *io;
+        int irq_alarm, irq_1msec;
+};
+
+static void stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
+{
+        /*
+         * The datasheet doesn't say which way round the
+         * NEW_REGS/STALE_REGS bitfields go. In fact it's 0x1=P0,
+         * 0x2=P1, .., 0x20=P5, 0x40=ALARM, 0x80=SECONDS
+         */
+        while (__raw_readl(rtc_data->io + HW_RTC_STAT) &
+                        BF(0x80, RTC_STAT_STALE_REGS))
+                cpu_relax();
+}
+
+/* Time read/write */
+static int stmp3xxx_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
+{
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
+
+        stmp3xxx_wait_time(rtc_data);
+        rtc_time_to_tm(__raw_readl(rtc_data->io + HW_RTC_SECONDS), rtc_tm);
+        return 0;
+}
+
+static int stmp3xxx_rtc_set_mmss(struct device *dev, unsigned long t)
+{
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
+
+        __raw_writel(t, rtc_data->io + HW_RTC_SECONDS);
+        stmp3xxx_wait_time(rtc_data);
+        return 0;
+}
+
+/* interrupt(s) handler */
+static irqreturn_t stmp3xxx_rtc_interrupt(int irq, void *dev_id)
+{
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev_id);
+        u32 status;
+        u32 events = 0;
+
+        status = __raw_readl(rtc_data->io + HW_RTC_CTRL) &
+                        (BM_RTC_CTRL_ALARM_IRQ | BM_RTC_CTRL_ONEMSEC_IRQ);
+
+        if (status & BM_RTC_CTRL_ALARM_IRQ) {
+                stmp3xxx_clearl(BM_RTC_CTRL_ALARM_IRQ,
+                                rtc_data->io + HW_RTC_CTRL);
+                events |= RTC_AF | RTC_IRQF;
+        }
+
+        if (status & BM_RTC_CTRL_ONEMSEC_IRQ) {
+                stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ,
+                                rtc_data->io + HW_RTC_CTRL);
+                if (++rtc_data->irq_count % 1000 == 0) {
+                        events |= RTC_UF | RTC_IRQF;
+                        rtc_data->irq_count = 0;
+                }
+        }
+
+        if (events)
+                rtc_update_irq(rtc_data->rtc, 1, events);
+
+        return IRQ_HANDLED;
+}
+
+static int stmp3xxx_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
+        void __iomem *p = rtc_data->io + HW_RTC_PERSISTENT0,
+                     *ctl = rtc_data->io + HW_RTC_CTRL;
+
+        if (enabled) {
+                stmp3xxx_setl(BM_RTC_PERSISTENT0_ALARM_EN |
+                              BM_RTC_PERSISTENT0_ALARM_WAKE_EN, p);
+                stmp3xxx_setl(BM_RTC_CTRL_ALARM_IRQ_EN, ctl);
+        } else {
+                stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN |
+                              BM_RTC_PERSISTENT0_ALARM_WAKE_EN, p);
+                stmp3xxx_clearl(BM_RTC_CTRL_ALARM_IRQ_EN, ctl);
+        }
+        return 0;
+}
+
+static int stmp3xxx_update_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
+
+        if (enabled)
+                stmp3xxx_setl(BM_RTC_CTRL_ONEMSEC_IRQ_EN,
+                                rtc_data->io + HW_RTC_CTRL);
+        else
+                stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN,
+                                rtc_data->io + HW_RTC_CTRL);
+        return 0;
+}
+
+static int stmp3xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
+
+        rtc_time_to_tm(__raw_readl(rtc_data->io + HW_RTC_ALARM), &alm->time);
+        return 0;
+}
+
+static int stmp3xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        unsigned long t;
+        struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
+
+        rtc_tm_to_time(&alm->time, &t);
+        __raw_writel(t, rtc_data->io + HW_RTC_ALARM);
+        return 0;
+}
+
+static struct rtc_class_ops stmp3xxx_rtc_ops = {
+        .alarm_irq_enable =
+                          stmp3xxx_alarm_irq_enable,
+        .update_irq_enable =
+                          stmp3xxx_update_irq_enable,
+        .read_time      = stmp3xxx_rtc_gettime,
+        .set_mmss       = stmp3xxx_rtc_set_mmss,
+        .read_alarm     = stmp3xxx_rtc_read_alarm,
+        .set_alarm      = stmp3xxx_rtc_set_alarm,
+};
+
+static int stmp3xxx_rtc_remove(struct platform_device *pdev)
+{
+        struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev);
+
+        if (!rtc_data)
+                return 0;
+
+        stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN | BM_RTC_CTRL_ALARM_IRQ_EN,
+                        rtc_data->io + HW_RTC_CTRL);
+        free_irq(rtc_data->irq_alarm, &pdev->dev);
+        free_irq(rtc_data->irq_1msec, &pdev->dev);
+        rtc_device_unregister(rtc_data->rtc);
+        iounmap(rtc_data->io);
+        kfree(rtc_data);
+
+        return 0;
+}
+
+static int stmp3xxx_rtc_probe(struct platform_device *pdev)
+{
+        struct stmp3xxx_rtc_data *rtc_data;
+        struct resource *r;
+        int err;
+
+        rtc_data = kzalloc(sizeof *rtc_data, GFP_KERNEL);
+        if (!rtc_data)
+                return -ENOMEM;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!r) {
+                dev_err(&pdev->dev, "failed to get resource\n");
+                err = -ENXIO;
+                goto out_free;
+        }
+
+        rtc_data->io = ioremap(r->start, resource_size(r));
+        if (!rtc_data->io) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                err = -EIO;
+                goto out_free;
+        }
+
+        rtc_data->irq_alarm = platform_get_irq(pdev, 0);
+        rtc_data->irq_1msec = platform_get_irq(pdev, 1);
+
+        if (!(__raw_readl(HW_RTC_STAT + rtc_data->io) &
+                        BM_RTC_STAT_RTC_PRESENT)) {
+                dev_err(&pdev->dev, "no device onboard\n");
+                err = -ENODEV;
+                goto out_remap;
+        }
+
+        stmp3xxx_reset_block(rtc_data->io, true);
+        stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN |
+                        BM_RTC_PERSISTENT0_ALARM_WAKE_EN |
+                        BM_RTC_PERSISTENT0_ALARM_WAKE,
+                        rtc_data->io + HW_RTC_PERSISTENT0);
+        rtc_data->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                &stmp3xxx_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc_data->rtc)) {
+                err = PTR_ERR(rtc_data->rtc);
+                goto out_remap;
+        }
+
+        rtc_data->irq_count = 0;
+        err = request_irq(rtc_data->irq_alarm, stmp3xxx_rtc_interrupt,
+                        IRQF_DISABLED, "RTC alarm", &pdev->dev);
+        if (err) {
+                dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
+                        rtc_data->irq_alarm);
+                goto out_irq_alarm;
+        }
+        err = request_irq(rtc_data->irq_1msec, stmp3xxx_rtc_interrupt,
+                        IRQF_DISABLED, "RTC tick", &pdev->dev);
+        if (err) {
+                dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
+                        rtc_data->irq_1msec);
+                goto out_irq1;
+        }
+
+        platform_set_drvdata(pdev, rtc_data);
+
+        return 0;
+
+out_irq1:
+        free_irq(rtc_data->irq_alarm, &pdev->dev);
+out_irq_alarm:
+        stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN | BM_RTC_CTRL_ALARM_IRQ_EN,
+                        rtc_data->io + HW_RTC_CTRL);
+        rtc_device_unregister(rtc_data->rtc);
+out_remap:
+        iounmap(rtc_data->io);
+out_free:
+        kfree(rtc_data);
+        return err;
+}
+
+#ifdef CONFIG_PM
+static int stmp3xxx_rtc_suspend(struct platform_device *dev, pm_message_t state)
+{
+        return 0;
+}
+
+static int stmp3xxx_rtc_resume(struct platform_device *dev)
+{
+        struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(dev);
+
+        stmp3xxx_reset_block(rtc_data->io, true);
+        stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN |
+                        BM_RTC_PERSISTENT0_ALARM_WAKE_EN |
+                        BM_RTC_PERSISTENT0_ALARM_WAKE,
+                        rtc_data->io + HW_RTC_PERSISTENT0);
+        return 0;
+}
+#else
+#define stmp3xxx_rtc_suspend    NULL
+#define stmp3xxx_rtc_resume     NULL
+#endif
+
+static struct platform_driver stmp3xxx_rtcdrv = {
+        .probe          = stmp3xxx_rtc_probe,
+        .remove         = stmp3xxx_rtc_remove,
+        .suspend        = stmp3xxx_rtc_suspend,
+        .resume         = stmp3xxx_rtc_resume,
+        .driver         = {
+                .name   = "stmp3xxx-rtc",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init stmp3xxx_rtc_init(void)
+{
+        return platform_driver_register(&stmp3xxx_rtcdrv);
+}
+
+static void __exit stmp3xxx_rtc_exit(void)
+{
+        platform_driver_unregister(&stmp3xxx_rtcdrv);
+}
+
+module_init(stmp3xxx_rtc_init);
+module_exit(stmp3xxx_rtc_exit);
+
+MODULE_DESCRIPTION("STMP3xxx RTC Driver");
+MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index 2531ce4c9db0..380083ca572f 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -102,6 +102,20 @@ rtc_sysfs_set_max_user_freq(struct device *dev, struct device_attribute *attr,
         return n;
 }
 
+static ssize_t
+rtc_sysfs_show_hctosys(struct device *dev, struct device_attribute *attr,
+                char *buf)
+{
+#ifdef CONFIG_RTC_HCTOSYS_DEVICE
+        if (rtc_hctosys_ret == 0 &&
+                        strcmp(dev_name(&to_rtc_device(dev)->dev),
+                                CONFIG_RTC_HCTOSYS_DEVICE) == 0)
+                return sprintf(buf, "1\n");
+        else
+#endif
+                return sprintf(buf, "0\n");
+}
+
 static struct device_attribute rtc_attrs[] = {
         __ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL),
         __ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL),
@@ -109,6 +123,7 @@ static struct device_attribute rtc_attrs[] = {
         __ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL),
         __ATTR(max_user_freq, S_IRUGO | S_IWUSR, rtc_sysfs_show_max_user_freq,
                         rtc_sysfs_set_max_user_freq),
+        __ATTR(hctosys, S_IRUGO, rtc_sysfs_show_hctosys, NULL),
         { },
 };
 
diff --git a/drivers/rtc/rtc-twl4030.c b/drivers/rtc/rtc-twl.c
index 9c8c70c497dc..ed1b86828124 100644
--- a/drivers/rtc/rtc-twl4030.c
+++ b/drivers/rtc/rtc-twl.c
@@ -1,5 +1,5 @@
 /*
- * rtc-twl4030.c -- TWL4030 Real Time Clock interface
+ * rtc-twl.c -- TWL Real Time Clock interface
  *
  * Copyright (C) 2007 MontaVista Software, Inc
  * Author: Alexandre Rusev <source@mvista.com>
@@ -28,33 +28,81 @@
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 
-#include <linux/i2c/twl4030.h>
+#include <linux/i2c/twl.h>
 
 
 /*
  * RTC block register offsets (use TWL_MODULE_RTC)
  */
-#define REG_SECONDS_REG                          0x00
-#define REG_MINUTES_REG                          0x01
-#define REG_HOURS_REG                            0x02
-#define REG_DAYS_REG                             0x03
-#define REG_MONTHS_REG                           0x04
-#define REG_YEARS_REG                            0x05
-#define REG_WEEKS_REG                            0x06
-
-#define REG_ALARM_SECONDS_REG                    0x07
-#define REG_ALARM_MINUTES_REG                    0x08
-#define REG_ALARM_HOURS_REG                      0x09
-#define REG_ALARM_DAYS_REG                       0x0A
-#define REG_ALARM_MONTHS_REG                     0x0B
-#define REG_ALARM_YEARS_REG                      0x0C
-
-#define REG_RTC_CTRL_REG                         0x0D
-#define REG_RTC_STATUS_REG                       0x0E
-#define REG_RTC_INTERRUPTS_REG                   0x0F
-
-#define REG_RTC_COMP_LSB_REG                     0x10
-#define REG_RTC_COMP_MSB_REG                     0x11
+enum {
+        REG_SECONDS_REG = 0,
+        REG_MINUTES_REG,
+        REG_HOURS_REG,
+        REG_DAYS_REG,
+        REG_MONTHS_REG,
+        REG_YEARS_REG,
+        REG_WEEKS_REG,
+
+        REG_ALARM_SECONDS_REG,
+        REG_ALARM_MINUTES_REG,
+        REG_ALARM_HOURS_REG,
+        REG_ALARM_DAYS_REG,
+        REG_ALARM_MONTHS_REG,
+        REG_ALARM_YEARS_REG,
+
+        REG_RTC_CTRL_REG,
+        REG_RTC_STATUS_REG,
+        REG_RTC_INTERRUPTS_REG,
+
+        REG_RTC_COMP_LSB_REG,
+        REG_RTC_COMP_MSB_REG,
+};
+static const u8 twl4030_rtc_reg_map[] = {
+        [REG_SECONDS_REG] = 0x00,
+        [REG_MINUTES_REG] = 0x01,
+        [REG_HOURS_REG] = 0x02,
+        [REG_DAYS_REG] = 0x03,
+        [REG_MONTHS_REG] = 0x04,
+        [REG_YEARS_REG] = 0x05,
+        [REG_WEEKS_REG] = 0x06,
+
+        [REG_ALARM_SECONDS_REG] = 0x07,
+        [REG_ALARM_MINUTES_REG] = 0x08,
+        [REG_ALARM_HOURS_REG] = 0x09,
+        [REG_ALARM_DAYS_REG] = 0x0A,
+        [REG_ALARM_MONTHS_REG] = 0x0B,
+        [REG_ALARM_YEARS_REG] = 0x0C,
+
+        [REG_RTC_CTRL_REG] = 0x0D,
+        [REG_RTC_STATUS_REG] = 0x0E,
+        [REG_RTC_INTERRUPTS_REG] = 0x0F,
+
+        [REG_RTC_COMP_LSB_REG] = 0x10,
+        [REG_RTC_COMP_MSB_REG] = 0x11,
+};
+static const u8 twl6030_rtc_reg_map[] = {
+        [REG_SECONDS_REG] = 0x00,
+        [REG_MINUTES_REG] = 0x01,
+        [REG_HOURS_REG] = 0x02,
+        [REG_DAYS_REG] = 0x03,
+        [REG_MONTHS_REG] = 0x04,
+        [REG_YEARS_REG] = 0x05,
+        [REG_WEEKS_REG] = 0x06,
+
+        [REG_ALARM_SECONDS_REG] = 0x08,
+        [REG_ALARM_MINUTES_REG] = 0x09,
+        [REG_ALARM_HOURS_REG] = 0x0A,
+        [REG_ALARM_DAYS_REG] = 0x0B,
+        [REG_ALARM_MONTHS_REG] = 0x0C,
+        [REG_ALARM_YEARS_REG] = 0x0D,
+
+        [REG_RTC_CTRL_REG] = 0x10,
+        [REG_RTC_STATUS_REG] = 0x11,
+        [REG_RTC_INTERRUPTS_REG] = 0x12,
+
+        [REG_RTC_COMP_LSB_REG] = 0x13,
+        [REG_RTC_COMP_MSB_REG] = 0x14,
+};
 
 /* RTC_CTRL_REG bitfields */
 #define BIT_RTC_CTRL_REG_STOP_RTC_M              0x01
@@ -84,31 +132,32 @@
 #define ALL_TIME_REGS           6
 
 /*----------------------------------------------------------------------*/
+static u8  *rtc_reg_map;
 
 /*
- * Supports 1 byte read from TWL4030 RTC register.
+ * Supports 1 byte read from TWL RTC register.
  */
-static int twl4030_rtc_read_u8(u8 *data, u8 reg)
+static int twl_rtc_read_u8(u8 *data, u8 reg)
 {
         int ret;
 
-        ret = twl4030_i2c_read_u8(TWL4030_MODULE_RTC, data, reg);
+        ret = twl_i2c_read_u8(TWL_MODULE_RTC, data, (rtc_reg_map[reg]));
         if (ret < 0)
-                pr_err("twl4030_rtc: Could not read TWL4030"
+                pr_err("twl_rtc: Could not read TWL"
                        "register %X - error %d\n", reg, ret);
         return ret;
 }
 
 /*
- * Supports 1 byte write to TWL4030 RTC registers.
+ * Supports 1 byte write to TWL RTC registers.
  */
-static int twl4030_rtc_write_u8(u8 data, u8 reg)
+static int twl_rtc_write_u8(u8 data, u8 reg)
 {
         int ret;
 
-        ret = twl4030_i2c_write_u8(TWL4030_MODULE_RTC, data, reg);
+        ret = twl_i2c_write_u8(TWL_MODULE_RTC, data, (rtc_reg_map[reg]));
         if (ret < 0)
-                pr_err("twl4030_rtc: Could not write TWL4030"
+                pr_err("twl_rtc: Could not write TWL"
                        "register %X - error %d\n", reg, ret);
         return ret;
 }
@@ -129,7 +178,7 @@ static int set_rtc_irq_bit(unsigned char bit)
 
         val = rtc_irq_bits | bit;
         val &= ~BIT_RTC_INTERRUPTS_REG_EVERY_M;
-        ret = twl4030_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
+        ret = twl_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
         if (ret == 0)
                 rtc_irq_bits = val;
 
@@ -145,14 +194,14 @@ static int mask_rtc_irq_bit(unsigned char bit)
         int ret;
 
         val = rtc_irq_bits & ~bit;
-        ret = twl4030_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
+        ret = twl_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
         if (ret == 0)
                 rtc_irq_bits = val;
 
         return ret;
 }
 
-static int twl4030_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
+static int twl_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
 {
         int ret;
 
@@ -164,7 +213,7 @@ static int twl4030_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
         return ret;
 }
 
-static int twl4030_rtc_update_irq_enable(struct device *dev, unsigned enabled)
+static int twl_rtc_update_irq_enable(struct device *dev, unsigned enabled)
 {
         int ret;
 
@@ -177,7 +226,7 @@ static int twl4030_rtc_update_irq_enable(struct device *dev, unsigned enabled)
 }
 
 /*
- * Gets current TWL4030 RTC time and date parameters.
+ * Gets current TWL RTC time and date parameters.
  *
  * The RTC's time/alarm representation is not what gmtime(3) requires
  * Linux to use:
@@ -185,24 +234,24 @@ static int twl4030_rtc_update_irq_enable(struct device *dev, unsigned enabled)
  *  - Months are 1..12 vs Linux 0-11
  *  - Years are 0..99 vs Linux 1900..N (we assume 21st century)
  */
-static int twl4030_rtc_read_time(struct device *dev, struct rtc_time *tm)
+static int twl_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         unsigned char rtc_data[ALL_TIME_REGS + 1];
         int ret;
         u8 save_control;
 
-        ret = twl4030_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
+        ret = twl_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
         if (ret < 0)
                 return ret;
 
         save_control |= BIT_RTC_CTRL_REG_GET_TIME_M;
 
-        ret = twl4030_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
+        ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
         if (ret < 0)
                 return ret;
 
-        ret = twl4030_i2c_read(TWL4030_MODULE_RTC, rtc_data,
-                               REG_SECONDS_REG, ALL_TIME_REGS);
+        ret = twl_i2c_read(TWL_MODULE_RTC, rtc_data,
+                        (rtc_reg_map[REG_SECONDS_REG]), ALL_TIME_REGS);
 
         if (ret < 0) {
                 dev_err(dev, "rtc_read_time error %d\n", ret);
@@ -219,7 +268,7 @@ static int twl4030_rtc_read_time(struct device *dev, struct rtc_time *tm)
         return ret;
 }
 
-static int twl4030_rtc_set_time(struct device *dev, struct rtc_time *tm)
+static int twl_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
         unsigned char save_control;
         unsigned char rtc_data[ALL_TIME_REGS + 1];
@@ -233,18 +282,18 @@ static int twl4030_rtc_set_time(struct device *dev, struct rtc_time *tm)
         rtc_data[6] = bin2bcd(tm->tm_year - 100);
 
         /* Stop RTC while updating the TC registers */
-        ret = twl4030_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
+        ret = twl_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
         if (ret < 0)
                 goto out;
 
         save_control &= ~BIT_RTC_CTRL_REG_STOP_RTC_M;
-        twl4030_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
+        twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
         if (ret < 0)
                 goto out;
 
         /* update all the time registers in one shot */
-        ret = twl4030_i2c_write(TWL4030_MODULE_RTC, rtc_data,
-                        REG_SECONDS_REG, ALL_TIME_REGS);
+        ret = twl_i2c_write(TWL_MODULE_RTC, rtc_data,
+                (rtc_reg_map[REG_SECONDS_REG]), ALL_TIME_REGS);
         if (ret < 0) {
                 dev_err(dev, "rtc_set_time error %d\n", ret);
                 goto out;
@@ -252,22 +301,22 @@ static int twl4030_rtc_set_time(struct device *dev, struct rtc_time *tm)
 
         /* Start back RTC */
         save_control |= BIT_RTC_CTRL_REG_STOP_RTC_M;
-        ret = twl4030_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
+        ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
 
 out:
         return ret;
 }
 
 /*
- * Gets current TWL4030 RTC alarm time.
+ * Gets current TWL RTC alarm time.
  */
-static int twl4030_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+static int twl_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
         unsigned char rtc_data[ALL_TIME_REGS + 1];
         int ret;
 
-        ret = twl4030_i2c_read(TWL4030_MODULE_RTC, rtc_data,
-                               REG_ALARM_SECONDS_REG, ALL_TIME_REGS);
+        ret = twl_i2c_read(TWL_MODULE_RTC, rtc_data,
+                        (rtc_reg_map[REG_ALARM_SECONDS_REG]), ALL_TIME_REGS);
         if (ret < 0) {
                 dev_err(dev, "rtc_read_alarm error %d\n", ret);
                 return ret;
@@ -288,12 +337,12 @@ static int twl4030_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
         return ret;
 }
 
-static int twl4030_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+static int twl_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
         unsigned char alarm_data[ALL_TIME_REGS + 1];
         int ret;
 
-        ret = twl4030_rtc_alarm_irq_enable(dev, 0);
+        ret = twl_rtc_alarm_irq_enable(dev, 0);
         if (ret)
                 goto out;
 
@@ -305,20 +354,20 @@ static int twl4030_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
         alarm_data[6] = bin2bcd(alm->time.tm_year - 100);
 
         /* update all the alarm registers in one shot */
-        ret = twl4030_i2c_write(TWL4030_MODULE_RTC, alarm_data,
-                        REG_ALARM_SECONDS_REG, ALL_TIME_REGS);
+        ret = twl_i2c_write(TWL_MODULE_RTC, alarm_data,
+                (rtc_reg_map[REG_ALARM_SECONDS_REG]), ALL_TIME_REGS);
         if (ret) {
                 dev_err(dev, "rtc_set_alarm error %d\n", ret);
                 goto out;
         }
 
         if (alm->enabled)
-                ret = twl4030_rtc_alarm_irq_enable(dev, 1);
+                ret = twl_rtc_alarm_irq_enable(dev, 1);
 out:
         return ret;
 }
 
-static irqreturn_t twl4030_rtc_interrupt(int irq, void *rtc)
+static irqreturn_t twl_rtc_interrupt(int irq, void *rtc)
 {
         unsigned long events = 0;
         int ret = IRQ_NONE;
@@ -333,7 +382,7 @@ static irqreturn_t twl4030_rtc_interrupt(int irq, void *rtc)
         local_irq_enable();
 #endif
 
-        res = twl4030_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
+        res = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
         if (res)
                 goto out;
         /*
@@ -347,26 +396,28 @@ static irqreturn_t twl4030_rtc_interrupt(int irq, void *rtc)
         else
                 events |= RTC_IRQF | RTC_UF;
 
-        res = twl4030_rtc_write_u8(rd_reg | BIT_RTC_STATUS_REG_ALARM_M,
+        res = twl_rtc_write_u8(rd_reg | BIT_RTC_STATUS_REG_ALARM_M,
                                    REG_RTC_STATUS_REG);
         if (res)
                 goto out;
 
-        /* Clear on Read enabled. RTC_IT bit of TWL4030_INT_PWR_ISR1
-         * needs 2 reads to clear the interrupt. One read is done in
-         * do_twl4030_pwrirq(). Doing the second read, to clear
-         * the bit.
-         *
-         * FIXME the reason PWR_ISR1 needs an extra read is that
-         * RTC_IF retriggered until we cleared REG_ALARM_M above.
-         * But re-reading like this is a bad hack; by doing so we
-         * risk wrongly clearing status for some other IRQ (losing
-         * the interrupt).  Be smarter about handling RTC_UF ...
-         */
-        res = twl4030_i2c_read_u8(TWL4030_MODULE_INT,
+        if (twl_class_is_4030()) {
+                /* Clear on Read enabled. RTC_IT bit of TWL4030_INT_PWR_ISR1
+                 * needs 2 reads to clear the interrupt. One read is done in
+                 * do_twl_pwrirq(). Doing the second read, to clear
+                 * the bit.
+                 *
+                 * FIXME the reason PWR_ISR1 needs an extra read is that
+                 * RTC_IF retriggered until we cleared REG_ALARM_M above.
+                 * But re-reading like this is a bad hack; by doing so we
+                 * risk wrongly clearing status for some other IRQ (losing
+                 * the interrupt).  Be smarter about handling RTC_UF ...
+                 */
+                res = twl_i2c_read_u8(TWL4030_MODULE_INT,
                         &rd_reg, TWL4030_INT_PWR_ISR1);
-        if (res)
-                goto out;
+                if (res)
+                        goto out;
+        }
 
         /* Notify RTC core on event */
         rtc_update_irq(rtc, 1, events);
@@ -376,18 +427,18 @@ out:
         return ret;
 }
 
-static struct rtc_class_ops twl4030_rtc_ops = {
-        .read_time      = twl4030_rtc_read_time,
-        .set_time       = twl4030_rtc_set_time,
-        .read_alarm     = twl4030_rtc_read_alarm,
-        .set_alarm      = twl4030_rtc_set_alarm,
-        .alarm_irq_enable = twl4030_rtc_alarm_irq_enable,
-        .update_irq_enable = twl4030_rtc_update_irq_enable,
+static struct rtc_class_ops twl_rtc_ops = {
+        .read_time      = twl_rtc_read_time,
+        .set_time       = twl_rtc_set_time,
+        .read_alarm     = twl_rtc_read_alarm,
+        .set_alarm      = twl_rtc_set_alarm,
+        .alarm_irq_enable = twl_rtc_alarm_irq_enable,
+        .update_irq_enable = twl_rtc_update_irq_enable,
 };
 
 /*----------------------------------------------------------------------*/
 
-static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
+static int __devinit twl_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         int ret = 0;
@@ -398,7 +449,7 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
                 return -EINVAL;
 
         rtc = rtc_device_register(pdev->name,
-                                  &pdev->dev, &twl4030_rtc_ops, THIS_MODULE);
+                                  &pdev->dev, &twl_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
                 ret = PTR_ERR(rtc);
                 dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
@@ -409,7 +460,7 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, rtc);
 
-        ret = twl4030_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
+        ret = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
         if (ret < 0)
                 goto out1;
 
@@ -420,11 +471,11 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
                 dev_warn(&pdev->dev, "Pending Alarm interrupt detected.\n");
 
         /* Clear RTC Power up reset and pending alarm interrupts */
-        ret = twl4030_rtc_write_u8(rd_reg, REG_RTC_STATUS_REG);
+        ret = twl_rtc_write_u8(rd_reg, REG_RTC_STATUS_REG);
         if (ret < 0)
                 goto out1;
 
-        ret = request_irq(irq, twl4030_rtc_interrupt,
+        ret = request_irq(irq, twl_rtc_interrupt,
                                 IRQF_TRIGGER_RISING,
                                 dev_name(&rtc->dev), rtc);
         if (ret < 0) {
@@ -432,21 +483,28 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
                 goto out1;
         }
 
+        if (twl_class_is_6030()) {
+                twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK,
+                        REG_INT_MSK_LINE_A);
+                twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK,
+                        REG_INT_MSK_STS_A);
+        }
+
         /* Check RTC module status, Enable if it is off */
-        ret = twl4030_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG);
+        ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG);
         if (ret < 0)
                 goto out2;
 
         if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) {
-                dev_info(&pdev->dev, "Enabling TWL4030-RTC.\n");
+                dev_info(&pdev->dev, "Enabling TWL-RTC.\n");
                 rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M;
-                ret = twl4030_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG);
+                ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG);
                 if (ret < 0)
                         goto out2;
         }
 
         /* init cached IRQ enable bits */
-        ret = twl4030_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG);
+        ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG);
         if (ret < 0)
                 goto out2;
 
@@ -461,10 +519,10 @@ out0:
 }
 
 /*
- * Disable all TWL4030 RTC module interrupts.
+ * Disable all TWL RTC module interrupts.
  * Sets status flag to free.
  */
-static int __devexit twl4030_rtc_remove(struct platform_device *pdev)
+static int __devexit twl_rtc_remove(struct platform_device *pdev)
 {
         /* leave rtc running, but disable irqs */
         struct rtc_device *rtc = platform_get_drvdata(pdev);
@@ -472,6 +530,13 @@ static int __devexit twl4030_rtc_remove(struct platform_device *pdev)
 
         mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
         mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
+        if (twl_class_is_6030()) {
+                twl6030_interrupt_mask(TWL6030_RTC_INT_MASK,
+                        REG_INT_MSK_LINE_A);
+                twl6030_interrupt_mask(TWL6030_RTC_INT_MASK,
+                        REG_INT_MSK_STS_A);
+        }
+
 
         free_irq(irq, rtc);
 
@@ -480,7 +545,7 @@ static int __devexit twl4030_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
-static void twl4030_rtc_shutdown(struct platform_device *pdev)
+static void twl_rtc_shutdown(struct platform_device *pdev)
 {
         /* mask timer interrupts, but leave alarm interrupts on to enable
            power-on when alarm is triggered */
@@ -491,7 +556,7 @@ static void twl4030_rtc_shutdown(struct platform_device *pdev)
 
 static unsigned char irqstat;
 
-static int twl4030_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int twl_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
         irqstat = rtc_irq_bits;
 
@@ -499,42 +564,47 @@ static int twl4030_rtc_suspend(struct platform_device *pdev, pm_message_t state)
         return 0;
 }
 
-static int twl4030_rtc_resume(struct platform_device *pdev)
+static int twl_rtc_resume(struct platform_device *pdev)
 {
         set_rtc_irq_bit(irqstat);
         return 0;
 }
 
 #else
-#define twl4030_rtc_suspend NULL
-#define twl4030_rtc_resume  NULL
+#define twl_rtc_suspend NULL
+#define twl_rtc_resume  NULL
 #endif
 
-MODULE_ALIAS("platform:twl4030_rtc");
+MODULE_ALIAS("platform:twl_rtc");
 
 static struct platform_driver twl4030rtc_driver = {
-        .probe          = twl4030_rtc_probe,
-        .remove         = __devexit_p(twl4030_rtc_remove),
-        .shutdown       = twl4030_rtc_shutdown,
-        .suspend        = twl4030_rtc_suspend,
-        .resume         = twl4030_rtc_resume,
+        .probe          = twl_rtc_probe,
+        .remove         = __devexit_p(twl_rtc_remove),
+        .shutdown       = twl_rtc_shutdown,
+        .suspend        = twl_rtc_suspend,
+        .resume         = twl_rtc_resume,
         .driver         = {
                 .owner  = THIS_MODULE,
-                .name   = "twl4030_rtc",
+                .name   = "twl_rtc",
         },
 };
 
-static int __init twl4030_rtc_init(void)
+static int __init twl_rtc_init(void)
 {
+        if (twl_class_is_4030())
+                rtc_reg_map = (u8 *) twl4030_rtc_reg_map;
+        else
+                rtc_reg_map = (u8 *) twl6030_rtc_reg_map;
+
         return platform_driver_register(&twl4030rtc_driver);
 }
-module_init(twl4030_rtc_init);
+module_init(twl_rtc_init);
 
-static void __exit twl4030_rtc_exit(void)
+static void __exit twl_rtc_exit(void)
 {
         platform_driver_unregister(&twl4030rtc_driver);
 }
-module_exit(twl4030_rtc_exit);
+module_exit(twl_rtc_exit);
 
 MODULE_AUTHOR("Texas Instruments, MontaVista Software");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-tx4939.c b/drivers/rtc/rtc-tx4939.c
index 4a6ed1104fbb..ec6313d15359 100644
--- a/drivers/rtc/rtc-tx4939.c
+++ b/drivers/rtc/rtc-tx4939.c
@@ -12,11 +12,13 @@
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
+#include <linux/gfp.h>
 #include <asm/txx9/tx4939.h>
 
 struct tx4939rtc_plat_data {
         struct rtc_device *rtc;
         struct tx4939_rtc_reg __iomem *rtcreg;
+        spinlock_t lock;
 };
 
 static struct tx4939rtc_plat_data *get_tx4939rtc_plat_data(struct device *dev)
@@ -52,14 +54,14 @@ static int tx4939_rtc_set_mmss(struct device *dev, unsigned long secs)
         buf[3] = secs >> 8;
         buf[4] = secs >> 16;
         buf[5] = secs >> 24;
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irq(&pdata->lock);
         __raw_writel(0, &rtcreg->adr);
         for (i = 0; i < 6; i++)
                 __raw_writel(buf[i], &rtcreg->dat);
         ret = tx4939_rtc_cmd(rtcreg,
                              TX4939_RTCCTL_COMMAND_SETTIME |
                              (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irq(&pdata->lock);
         return ret;
 }
 
@@ -71,18 +73,18 @@ static int tx4939_rtc_read_time(struct device *dev, struct rtc_time *tm)
         unsigned long sec;
         unsigned char buf[6];
 
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irq(&pdata->lock);
         ret = tx4939_rtc_cmd(rtcreg,
                              TX4939_RTCCTL_COMMAND_GETTIME |
                              (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
         if (ret) {
-                spin_unlock_irq(&pdata->rtc->irq_lock);
+                spin_unlock_irq(&pdata->lock);
                 return ret;
         }
         __raw_writel(2, &rtcreg->adr);
         for (i = 2; i < 6; i++)
                 buf[i] = __raw_readl(&rtcreg->dat);
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irq(&pdata->lock);
         sec = (buf[5] << 24) | (buf[4] << 16) | (buf[3] << 8) | buf[2];
         rtc_time_to_tm(sec, tm);
         return rtc_valid_tm(tm);
@@ -110,13 +112,13 @@ static int tx4939_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         buf[3] = sec >> 8;
         buf[4] = sec >> 16;
         buf[5] = sec >> 24;
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irq(&pdata->lock);
         __raw_writel(0, &rtcreg->adr);
         for (i = 0; i < 6; i++)
                 __raw_writel(buf[i], &rtcreg->dat);
         ret = tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_SETALARM |
                              (alrm->enabled ? TX4939_RTCCTL_ALME : 0));
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irq(&pdata->lock);
         return ret;
 }
 
@@ -129,12 +131,12 @@ static int tx4939_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         unsigned char buf[6];
         u32 ctl;
 
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irq(&pdata->lock);
         ret = tx4939_rtc_cmd(rtcreg,
                              TX4939_RTCCTL_COMMAND_GETALARM |
                              (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
         if (ret) {
-                spin_unlock_irq(&pdata->rtc->irq_lock);
+                spin_unlock_irq(&pdata->lock);
                 return ret;
         }
         __raw_writel(2, &rtcreg->adr);
@@ -143,7 +145,7 @@ static int tx4939_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         ctl = __raw_readl(&rtcreg->ctl);
         alrm->enabled = (ctl & TX4939_RTCCTL_ALME) ? 1 : 0;
         alrm->pending = (ctl & TX4939_RTCCTL_ALMD) ? 1 : 0;
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irq(&pdata->lock);
         sec = (buf[5] << 24) | (buf[4] << 16) | (buf[3] << 8) | buf[2];
         rtc_time_to_tm(sec, &alrm->time);
         return rtc_valid_tm(&alrm->time);
@@ -153,11 +155,11 @@ static int tx4939_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
 
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irq(&pdata->lock);
         tx4939_rtc_cmd(pdata->rtcreg,
                        TX4939_RTCCTL_COMMAND_NOP |
                        (enabled ? TX4939_RTCCTL_ALME : 0));
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irq(&pdata->lock);
         return 0;
 }
 
@@ -167,13 +169,14 @@ static irqreturn_t tx4939_rtc_interrupt(int irq, void *dev_id)
         struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
         unsigned long events = RTC_IRQF;
 
-        spin_lock(&pdata->rtc->irq_lock);
+        spin_lock(&pdata->lock);
         if (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALMD) {
                 events |= RTC_AF;
                 tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_NOP);
         }
-        spin_unlock(&pdata->rtc->irq_lock);
-        rtc_update_irq(pdata->rtc, 1, events);
+        spin_unlock(&pdata->lock);
+        if (likely(pdata->rtc))
+                rtc_update_irq(pdata->rtc, 1, events);
         return IRQ_HANDLED;
 }
 
@@ -185,7 +188,7 @@ static const struct rtc_class_ops tx4939_rtc_ops = {
         .alarm_irq_enable       = tx4939_rtc_alarm_irq_enable,
 };
 
-static ssize_t tx4939_rtc_nvram_read(struct kobject *kobj,
+static ssize_t tx4939_rtc_nvram_read(struct file *filp, struct kobject *kobj,
                                      struct bin_attribute *bin_attr,
                                      char *buf, loff_t pos, size_t size)
 {
@@ -194,17 +197,17 @@ static ssize_t tx4939_rtc_nvram_read(struct kobject *kobj,
         struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
         ssize_t count;
 
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irq(&pdata->lock);
         for (count = 0; size > 0 && pos < TX4939_RTC_REG_RAMSIZE;
              count++, size--) {
                 __raw_writel(pos++, &rtcreg->adr);
                 *buf++ = __raw_readl(&rtcreg->dat);
         }
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irq(&pdata->lock);
         return count;
 }
 
-static ssize_t tx4939_rtc_nvram_write(struct kobject *kobj,
+static ssize_t tx4939_rtc_nvram_write(struct file *filp, struct kobject *kobj,
                                       struct bin_attribute *bin_attr,
                                       char *buf, loff_t pos, size_t size)
 {
@@ -213,13 +216,13 @@ static ssize_t tx4939_rtc_nvram_write(struct kobject *kobj,
         struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
         ssize_t count;
 
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irq(&pdata->lock);
         for (count = 0; size > 0 && pos < TX4939_RTC_REG_RAMSIZE;
              count++, size--) {
                 __raw_writel(pos++, &rtcreg->adr);
                 __raw_writel(*buf++, &rtcreg->dat);
         }
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irq(&pdata->lock);
         return count;
 }
 
@@ -259,6 +262,7 @@ static int __init tx4939_rtc_probe(struct platform_device *pdev)
         if (!pdata->rtcreg)
                 return -EBUSY;
 
+        spin_lock_init(&pdata->lock);
         tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
         if (devm_request_irq(&pdev->dev, irq, tx4939_rtc_interrupt,
                              IRQF_DISABLED, pdev->name, &pdev->dev) < 0)
@@ -277,14 +281,12 @@ static int __init tx4939_rtc_probe(struct platform_device *pdev)
 static int __exit tx4939_rtc_remove(struct platform_device *pdev)
 {
         struct tx4939rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        struct rtc_device *rtc = pdata->rtc;
 
-        spin_lock_irq(&rtc->irq_lock);
-        tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
-        spin_unlock_irq(&rtc->irq_lock);
         sysfs_remove_bin_file(&pdev->dev.kobj, &tx4939_rtc_nvram_attr);
-        rtc_device_unregister(rtc);
-        platform_set_drvdata(pdev, NULL);
+        rtc_device_unregister(pdata->rtc);
+        spin_lock_irq(&pdata->lock);
+        tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
+        spin_unlock_irq(&pdata->lock);
         return 0;
 }
 
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
index ad164056feb6..f71c3ce18036 100644
--- a/drivers/rtc/rtc-v3020.c
+++ b/drivers/rtc/rtc-v3020.c
@@ -28,6 +28,7 @@
 #include <linux/rtc-v3020.h>
 #include <linux/delay.h>
 #include <linux/gpio.h>
+#include <linux/slab.h>
 
 #include <linux/io.h>
 
@@ -96,7 +97,7 @@ static void v3020_mmio_write_bit(struct v3020 *chip, unsigned char bit)
 
 static unsigned char v3020_mmio_read_bit(struct v3020 *chip)
 {
-        return readl(chip->ioaddress) & (1 << chip->leftshift);
+        return !!(readl(chip->ioaddress) & (1 << chip->leftshift));
 }
 
 static struct v3020_chip_ops v3020_mmio_ops = {
@@ -304,7 +305,6 @@ static int rtc_probe(struct platform_device *pdev)
 {
         struct v3020_platform_data *pdata = pdev->dev.platform_data;
         struct v3020 *chip;
-        struct rtc_device *rtc;
         int retval = -EBUSY;
         int i;
         int temp;
@@ -335,7 +335,7 @@ static int rtc_probe(struct platform_device *pdev)
                 goto err_io;
         }
 
-        /* Make sure frequency measurment mode, test modes, and lock
+        /* Make sure frequency measurement mode, test modes, and lock
          * are all disabled */
         v3020_set_reg(chip, V3020_STATUS_0, 0x0);
 
@@ -353,13 +353,12 @@ static int rtc_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, chip);
 
-        rtc = rtc_device_register("v3020",
+        chip->rtc = rtc_device_register("v3020",
                                 &pdev->dev, &v3020_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                retval = PTR_ERR(rtc);
+        if (IS_ERR(chip->rtc)) {
+                retval = PTR_ERR(chip->rtc);
                 goto err_io;
         }
-        chip->rtc = rtc;
 
         return 0;
 
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index f11297aff854..c3244244e8cf 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -1,7 +1,7 @@
 /*
  *  Driver for NEC VR4100 series Real Time Clock unit.
  *
- *  Copyright (C) 2003-2008  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2003-2008  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
@@ -33,7 +33,7 @@
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
-MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
 MODULE_DESCRIPTION("NEC VR4100 series RTC driver");
 MODULE_LICENSE("GPL v2");
 
@@ -209,19 +209,18 @@ static int vr41xx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
 
 static int vr41xx_rtc_irq_set_freq(struct device *dev, int freq)
 {
-        unsigned long count;
+        u64 count;
 
         if (!is_power_of_2(freq))
                 return -EINVAL;
         count = RTC_FREQUENCY;
         do_div(count, freq);
 
-        periodic_count = count;
-
         spin_lock_irq(&rtc_lock);
 
-        rtc1_write(RTCL1LREG, count);
-        rtc1_write(RTCL1HREG, count >> 16);
+        periodic_count = count;
+        rtc1_write(RTCL1LREG, periodic_count);
+        rtc1_write(RTCL1HREG, periodic_count >> 16);
 
         spin_unlock_irq(&rtc_lock);
 
@@ -328,7 +327,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
         if (!res)
                 return -EBUSY;
 
-        rtc1_base = ioremap(res->start, res->end - res->start + 1);
+        rtc1_base = ioremap(res->start, resource_size(res));
         if (!rtc1_base)
                 return -EBUSY;
 
@@ -338,7 +337,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
                 goto err_rtc1_iounmap;
         }
 
-        rtc2_base = ioremap(res->start, res->end - res->start + 1);
+        rtc2_base = ioremap(res->start, resource_size(res));
         if (!rtc2_base) {
                 retval = -EBUSY;
                 goto err_rtc1_iounmap;
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
new file mode 100644
index 000000000000..82931dc65c0b
--- /dev/null
+++ b/drivers/rtc/rtc-wm831x.c
@@ -0,0 +1,524 @@
+/*
+ *      Real Time Clock driver for Wolfson Microelectronics WM831x
+ *
+ *      Copyright (C) 2009 Wolfson Microelectronics PLC.
+ *
+ *  Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/time.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/bcd.h>
+#include <linux/interrupt.h>
+#include <linux/ioctl.h>
+#include <linux/completion.h>
+#include <linux/mfd/wm831x/core.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+
+
+/*
+ * R16416 (0x4020) - RTC Write Counter
+ */
+#define WM831X_RTC_WR_CNT_MASK                  0xFFFF  /* RTC_WR_CNT - [15:0] */
+#define WM831X_RTC_WR_CNT_SHIFT                      0  /* RTC_WR_CNT - [15:0] */
+#define WM831X_RTC_WR_CNT_WIDTH                     16  /* RTC_WR_CNT - [15:0] */
+
+/*
+ * R16417 (0x4021) - RTC Time 1
+ */
+#define WM831X_RTC_TIME_MASK                    0xFFFF  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_SHIFT                        0  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_WIDTH                       16  /* RTC_TIME - [15:0] */
+
+/*
+ * R16418 (0x4022) - RTC Time 2
+ */
+#define WM831X_RTC_TIME_MASK                    0xFFFF  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_SHIFT                        0  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_WIDTH                       16  /* RTC_TIME - [15:0] */
+
+/*
+ * R16419 (0x4023) - RTC Alarm 1
+ */
+#define WM831X_RTC_ALM_MASK                     0xFFFF  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_SHIFT                         0  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_WIDTH                        16  /* RTC_ALM - [15:0] */
+
+/*
+ * R16420 (0x4024) - RTC Alarm 2
+ */
+#define WM831X_RTC_ALM_MASK                     0xFFFF  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_SHIFT                         0  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_WIDTH                        16  /* RTC_ALM - [15:0] */
+
+/*
+ * R16421 (0x4025) - RTC Control
+ */
+#define WM831X_RTC_VALID                        0x8000  /* RTC_VALID */
+#define WM831X_RTC_VALID_MASK                   0x8000  /* RTC_VALID */
+#define WM831X_RTC_VALID_SHIFT                      15  /* RTC_VALID */
+#define WM831X_RTC_VALID_WIDTH                       1  /* RTC_VALID */
+#define WM831X_RTC_SYNC_BUSY                    0x4000  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_MASK               0x4000  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_SHIFT                  14  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_WIDTH                   1  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_ALM_ENA                      0x0400  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_MASK                 0x0400  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_SHIFT                    10  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_WIDTH                     1  /* RTC_ALM_ENA */
+#define WM831X_RTC_PINT_FREQ_MASK               0x0070  /* RTC_PINT_FREQ - [6:4] */
+#define WM831X_RTC_PINT_FREQ_SHIFT                   4  /* RTC_PINT_FREQ - [6:4] */
+#define WM831X_RTC_PINT_FREQ_WIDTH                   3  /* RTC_PINT_FREQ - [6:4] */
+
+/*
+ * R16422 (0x4026) - RTC Trim
+ */
+#define WM831X_RTC_TRIM_MASK                    0x03FF  /* RTC_TRIM - [9:0] */
+#define WM831X_RTC_TRIM_SHIFT                        0  /* RTC_TRIM - [9:0] */
+#define WM831X_RTC_TRIM_WIDTH                       10  /* RTC_TRIM - [9:0] */
+
+#define WM831X_SET_TIME_RETRIES 5
+#define WM831X_GET_TIME_RETRIES 5
+
+struct wm831x_rtc {
+        struct wm831x *wm831x;
+        struct rtc_device *rtc;
+        unsigned int alarm_enabled:1;
+};
+
+/*
+ * Read current time and date in RTC
+ */
+static int wm831x_rtc_readtime(struct device *dev, struct rtc_time *tm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        u16 time1[2], time2[2];
+        int ret;
+        int count = 0;
+
+        /* Has the RTC been programmed? */
+        ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read RTC control: %d\n", ret);
+                return ret;
+        }
+        if (!(ret & WM831X_RTC_VALID)) {
+                dev_dbg(dev, "RTC not yet configured\n");
+                return -EINVAL;
+        }
+
+        /* Read twice to make sure we don't read a corrupt, partially
+         * incremented, value.
+         */
+        do {
+                ret = wm831x_bulk_read(wm831x, WM831X_RTC_TIME_1,
+                                       2, time1);
+                if (ret != 0)
+                        continue;
+
+                ret = wm831x_bulk_read(wm831x, WM831X_RTC_TIME_1,
+                                       2, time2);
+                if (ret != 0)
+                        continue;
+
+                if (memcmp(time1, time2, sizeof(time1)) == 0) {
+                        u32 time = (time1[0] << 16) | time1[1];
+
+                        rtc_time_to_tm(time, tm);
+                        return rtc_valid_tm(tm);
+                }
+
+        } while (++count < WM831X_GET_TIME_RETRIES);
+
+        dev_err(dev, "Timed out reading current time\n");
+
+        return -EIO;
+}
+
+/*
+ * Set current time and date in RTC
+ */
+static int wm831x_rtc_set_mmss(struct device *dev, unsigned long time)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        struct rtc_time new_tm;
+        unsigned long new_time;
+        int ret;
+        int count = 0;
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_TIME_1,
+                               (time >> 16) & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write TIME_1: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_TIME_2, time & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write TIME_2: %d\n", ret);
+                return ret;
+        }
+
+        /* Wait for the update to complete - should happen first time
+         * round but be conservative.
+         */
+        do {
+                msleep(1);
+
+                ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+                if (ret < 0)
+                        ret = WM831X_RTC_SYNC_BUSY;
+        } while (!(ret & WM831X_RTC_SYNC_BUSY) &&
+                 ++count < WM831X_SET_TIME_RETRIES);
+
+        if (ret & WM831X_RTC_SYNC_BUSY) {
+                dev_err(dev, "Timed out writing RTC update\n");
+                return -EIO;
+        }
+
+        /* Check that the update was accepted; security features may
+         * have caused the update to be ignored.
+         */
+        ret = wm831x_rtc_readtime(dev, &new_tm);
+        if (ret < 0)
+                return ret;
+
+        ret = rtc_tm_to_time(&new_tm, &new_time);
+        if (ret < 0) {
+                dev_err(dev, "Failed to convert time: %d\n", ret);
+                return ret;
+        }
+
+        /* Allow a second of change in case of tick */
+        if (new_time - time > 1) {
+                dev_err(dev, "RTC update not permitted by hardware\n");
+                return -EPERM;
+        }
+
+        return 0;
+}
+
+/*
+ * Read alarm time and date in RTC
+ */
+static int wm831x_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        int ret;
+        u16 data[2];
+        u32 time;
+
+        ret = wm831x_bulk_read(wm831x_rtc->wm831x, WM831X_RTC_ALARM_1,
+                               2, data);
+        if (ret != 0) {
+                dev_err(dev, "Failed to read alarm time: %d\n", ret);
+                return ret;
+        }
+
+        time = (data[0] << 16) | data[1];
+
+        rtc_time_to_tm(time, &alrm->time);
+
+        ret = wm831x_reg_read(wm831x_rtc->wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read RTC control: %d\n", ret);
+                return ret;
+        }
+
+        if (ret & WM831X_RTC_ALM_ENA)
+                alrm->enabled = 1;
+        else
+                alrm->enabled = 0;
+
+        return 0;
+}
+
+static int wm831x_rtc_stop_alarm(struct wm831x_rtc *wm831x_rtc)
+{
+        wm831x_rtc->alarm_enabled = 0;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_ALM_ENA, 0);
+}
+
+static int wm831x_rtc_start_alarm(struct wm831x_rtc *wm831x_rtc)
+{
+        wm831x_rtc->alarm_enabled = 1;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_ALM_ENA, WM831X_RTC_ALM_ENA);
+}
+
+static int wm831x_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        int ret;
+        unsigned long time;
+
+        ret = rtc_tm_to_time(&alrm->time, &time);
+        if (ret < 0) {
+                dev_err(dev, "Failed to convert time: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_rtc_stop_alarm(wm831x_rtc);
+        if (ret < 0) {
+                dev_err(dev, "Failed to stop alarm: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_ALARM_1,
+                               (time >> 16) & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write ALARM_1: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_ALARM_2, time & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write ALARM_2: %d\n", ret);
+                return ret;
+        }
+
+        if (alrm->enabled) {
+                ret = wm831x_rtc_start_alarm(wm831x_rtc);
+                if (ret < 0) {
+                        dev_err(dev, "Failed to start alarm: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static int wm831x_rtc_alarm_irq_enable(struct device *dev,
+                                       unsigned int enabled)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+
+        if (enabled)
+                return wm831x_rtc_start_alarm(wm831x_rtc);
+        else
+                return wm831x_rtc_stop_alarm(wm831x_rtc);
+}
+
+static int wm831x_rtc_update_irq_enable(struct device *dev,
+                                        unsigned int enabled)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        int val;
+
+        if (enabled)
+                val = 1 << WM831X_RTC_PINT_FREQ_SHIFT;
+        else
+                val = 0;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_PINT_FREQ_MASK, val);
+}
+
+static irqreturn_t wm831x_alm_irq(int irq, void *data)
+{
+        struct wm831x_rtc *wm831x_rtc = data;
+
+        rtc_update_irq(wm831x_rtc->rtc, 1, RTC_IRQF | RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t wm831x_per_irq(int irq, void *data)
+{
+        struct wm831x_rtc *wm831x_rtc = data;
+
+        rtc_update_irq(wm831x_rtc->rtc, 1, RTC_IRQF | RTC_UF);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops wm831x_rtc_ops = {
+        .read_time = wm831x_rtc_readtime,
+        .set_mmss = wm831x_rtc_set_mmss,
+        .read_alarm = wm831x_rtc_readalarm,
+        .set_alarm = wm831x_rtc_setalarm,
+        .alarm_irq_enable = wm831x_rtc_alarm_irq_enable,
+        .update_irq_enable = wm831x_rtc_update_irq_enable,
+};
+
+#ifdef CONFIG_PM
+/* Turn off the alarm if it should not be a wake source. */
+static int wm831x_rtc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret, enable;
+
+        if (wm831x_rtc->alarm_enabled && device_may_wakeup(&pdev->dev))
+                enable = WM831X_RTC_ALM_ENA;
+        else
+                enable = 0;
+
+        ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                              WM831X_RTC_ALM_ENA, enable);
+        if (ret != 0)
+                dev_err(&pdev->dev, "Failed to update RTC alarm: %d\n", ret);
+
+        return 0;
+}
+
+/* Enable the alarm if it should be enabled (in case it was disabled to
+ * prevent use as a wake source).
+ */
+static int wm831x_rtc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret;
+
+        if (wm831x_rtc->alarm_enabled) {
+                ret = wm831x_rtc_start_alarm(wm831x_rtc);
+                if (ret != 0)
+                        dev_err(&pdev->dev,
+                                "Failed to restart RTC alarm: %d\n", ret);
+        }
+
+        return 0;
+}
+
+/* Unconditionally disable the alarm */
+static int wm831x_rtc_freeze(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret;
+
+        ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                              WM831X_RTC_ALM_ENA, 0);
+        if (ret != 0)
+                dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n", ret);
+
+        return 0;
+}
+#else
+#define wm831x_rtc_suspend NULL
+#define wm831x_rtc_resume NULL
+#define wm831x_rtc_freeze NULL
+#endif
+
+static int wm831x_rtc_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_rtc *wm831x_rtc;
+        int per_irq = platform_get_irq_byname(pdev, "PER");
+        int alm_irq = platform_get_irq_byname(pdev, "ALM");
+        int ret = 0;
+
+        wm831x_rtc = kzalloc(sizeof(*wm831x_rtc), GFP_KERNEL);
+        if (wm831x_rtc == NULL)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, wm831x_rtc);
+        wm831x_rtc->wm831x = wm831x;
+
+        ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to read RTC control: %d\n", ret);
+                goto err;
+        }
+        if (ret & WM831X_RTC_ALM_ENA)
+                wm831x_rtc->alarm_enabled = 1;
+
+        device_init_wakeup(&pdev->dev, 1);
+
+        wm831x_rtc->rtc = rtc_device_register("wm831x", &pdev->dev,
+                                              &wm831x_rtc_ops, THIS_MODULE);
+        if (IS_ERR(wm831x_rtc->rtc)) {
+                ret = PTR_ERR(wm831x_rtc->rtc);
+                goto err;
+        }
+
+        ret = request_threaded_irq(per_irq, NULL, wm831x_per_irq,
+                                   IRQF_TRIGGER_RISING, "RTC period",
+                                   wm831x_rtc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request periodic IRQ %d: %d\n",
+                        per_irq, ret);
+        }
+
+        ret = request_threaded_irq(alm_irq, NULL, wm831x_alm_irq,
+                                   IRQF_TRIGGER_RISING, "RTC alarm",
+                                   wm831x_rtc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
+                        alm_irq, ret);
+        }
+
+        return 0;
+
+err:
+        kfree(wm831x_rtc);
+        return ret;
+}
+
+static int __devexit wm831x_rtc_remove(struct platform_device *pdev)
+{
+        struct wm831x_rtc *wm831x_rtc = platform_get_drvdata(pdev);
+        int per_irq = platform_get_irq_byname(pdev, "PER");
+        int alm_irq = platform_get_irq_byname(pdev, "ALM");
+
+        free_irq(alm_irq, wm831x_rtc);
+        free_irq(per_irq, wm831x_rtc);
+        rtc_device_unregister(wm831x_rtc->rtc);
+        kfree(wm831x_rtc);
+
+        return 0;
+}
+
+static const struct dev_pm_ops wm831x_rtc_pm_ops = {
+        .suspend = wm831x_rtc_suspend,
+        .resume = wm831x_rtc_resume,
+
+        .freeze = wm831x_rtc_freeze,
+        .thaw = wm831x_rtc_resume,
+        .restore = wm831x_rtc_resume,
+
+        .poweroff = wm831x_rtc_suspend,
+};
+
+static struct platform_driver wm831x_rtc_driver = {
+        .probe = wm831x_rtc_probe,
+        .remove = __devexit_p(wm831x_rtc_remove),
+        .driver = {
+                .name = "wm831x-rtc",
+                .pm = &wm831x_rtc_pm_ops,
+        },
+};
+
+static int __init wm831x_rtc_init(void)
+{
+        return platform_driver_register(&wm831x_rtc_driver);
+}
+module_init(wm831x_rtc_init);
+
+static void __exit wm831x_rtc_exit(void)
+{
+        platform_driver_unregister(&wm831x_rtc_driver);
+}
+module_exit(wm831x_rtc_exit);
+
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("RTC driver for the WM831x series PMICs");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-rtc");
diff --git a/drivers/rtc/rtc-wm8350.c b/drivers/rtc/rtc-wm8350.c
index c91edc572eb6..3d0dc76b38af 100644
--- a/drivers/rtc/rtc-wm8350.c
+++ b/drivers/rtc/rtc-wm8350.c
@@ -307,17 +307,24 @@ static int wm8350_rtc_update_irq_enable(struct device *dev,
 {
         struct wm8350 *wm8350 = dev_get_drvdata(dev);
 
+        /* Suppress duplicate changes since genirq nests enable and
+         * disable calls. */
+        if (enabled == wm8350->rtc.update_enabled)
+                return 0;
+
         if (enabled)
                 wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_SEC);
         else
                 wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
 
+        wm8350->rtc.update_enabled = enabled;
+
         return 0;
 }
 
-static void wm8350_rtc_alarm_handler(struct wm8350 *wm8350, int irq,
-                                     void *data)
+static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data)
 {
+        struct wm8350 *wm8350 = data;
         struct rtc_device *rtc = wm8350->rtc.rtc;
         int ret;
 
@@ -330,14 +337,18 @@ static void wm8350_rtc_alarm_handler(struct wm8350 *wm8350, int irq,
                 dev_err(&(wm8350->rtc.pdev->dev),
                         "Failed to disable alarm: %d\n", ret);
         }
+
+        return IRQ_HANDLED;
 }
 
-static void wm8350_rtc_update_handler(struct wm8350 *wm8350, int irq,
-                                      void *data)
+static irqreturn_t wm8350_rtc_update_handler(int irq, void *data)
 {
+        struct wm8350 *wm8350 = data;
         struct rtc_device *rtc = wm8350->rtc.rtc;
 
         rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF);
+
+        return IRQ_HANDLED;
 }
 
 static const struct rtc_class_ops wm8350_rtc_ops = {
@@ -350,8 +361,9 @@ static const struct rtc_class_ops wm8350_rtc_ops = {
 };
 
 #ifdef CONFIG_PM
-static int wm8350_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+static int wm8350_rtc_suspend(struct device *dev)
 {
+        struct platform_device *pdev = to_platform_device(dev);
         struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);
         int ret = 0;
         u16 reg;
@@ -369,8 +381,9 @@ static int wm8350_rtc_suspend(struct platform_device *pdev, pm_message_t state)
         return ret;
 }
 
-static int wm8350_rtc_resume(struct platform_device *pdev)
+static int wm8350_rtc_resume(struct device *dev)
 {
+        struct platform_device *pdev = to_platform_device(dev);
         struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);
         int ret;
 
@@ -455,15 +468,14 @@ static int wm8350_rtc_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
-        wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_PER);
-
         wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC,
-                            wm8350_rtc_update_handler, NULL);
+                            wm8350_rtc_update_handler, 0,
+                            "RTC Seconds", wm8350);
+        wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
 
         wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,
-                            wm8350_rtc_alarm_handler, NULL);
-        wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_ALM);
+                            wm8350_rtc_alarm_handler, 0,
+                            "RTC Alarm", wm8350);
 
         return 0;
 }
@@ -473,23 +485,25 @@ static int __devexit wm8350_rtc_remove(struct platform_device *pdev)
         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
         struct wm8350_rtc *wm_rtc = &wm8350->rtc;
 
-        wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
-
-        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC);
-        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM);
+        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
+        wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);
 
         rtc_device_unregister(wm_rtc->rtc);
 
         return 0;
 }
 
+static struct dev_pm_ops wm8350_rtc_pm_ops = {
+        .suspend = wm8350_rtc_suspend,
+        .resume = wm8350_rtc_resume,
+};
+
 static struct platform_driver wm8350_rtc_driver = {
         .probe = wm8350_rtc_probe,
         .remove = __devexit_p(wm8350_rtc_remove),
-        .suspend = wm8350_rtc_suspend,
-        .resume = wm8350_rtc_resume,
         .driver = {
                 .name = "wm8350-rtc",
+                .pm = &wm8350_rtc_pm_ops,
         },
 };
 
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index 310c10795e9a..9aae49139a0a 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -155,11 +155,11 @@ static int x1205_get_status(struct i2c_client *client, unsigned char *sr)
 }
 
 static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
-                        int datetoo, u8 reg_base, unsigned char alm_enable)
+                        u8 reg_base, unsigned char alm_enable)
 {
-        int i, xfer, nbytes;
-        unsigned char buf[8];
+        int i, xfer;
         unsigned char rdata[10] = { 0, reg_base };
+        unsigned char *buf = rdata + 2;
 
         static const unsigned char wel[3] = { 0, X1205_REG_SR,
                                                 X1205_SR_WEL };
@@ -170,9 +170,9 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
         static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
 
         dev_dbg(&client->dev,
-                "%s: secs=%d, mins=%d, hours=%d\n",
-                __func__,
-                tm->tm_sec, tm->tm_min, tm->tm_hour);
+                "%s: sec=%d min=%d hour=%d mday=%d mon=%d year=%d wday=%d\n",
+                __func__, tm->tm_sec, tm->tm_min, tm->tm_hour, tm->tm_mday,
+                tm->tm_mon, tm->tm_year, tm->tm_wday);
 
         buf[CCR_SEC] = bin2bcd(tm->tm_sec);
         buf[CCR_MIN] = bin2bcd(tm->tm_min);
@@ -180,23 +180,15 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
         /* set hour and 24hr bit */
         buf[CCR_HOUR] = bin2bcd(tm->tm_hour) | X1205_HR_MIL;
 
-        /* should we also set the date? */
-        if (datetoo) {
-                dev_dbg(&client->dev,
-                        "%s: mday=%d, mon=%d, year=%d, wday=%d\n",
-                        __func__,
-                        tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+        buf[CCR_MDAY] = bin2bcd(tm->tm_mday);
 
-                buf[CCR_MDAY] = bin2bcd(tm->tm_mday);
+        /* month, 1 - 12 */
+        buf[CCR_MONTH] = bin2bcd(tm->tm_mon + 1);
 
-                /* month, 1 - 12 */
-                buf[CCR_MONTH] = bin2bcd(tm->tm_mon + 1);
-
-                /* year, since the rtc epoch*/
-                buf[CCR_YEAR] = bin2bcd(tm->tm_year % 100);
-                buf[CCR_WDAY] = tm->tm_wday & 0x07;
-                buf[CCR_Y2K] = bin2bcd(tm->tm_year / 100);
-        }
+        /* year, since the rtc epoch*/
+        buf[CCR_YEAR] = bin2bcd(tm->tm_year % 100);
+        buf[CCR_WDAY] = tm->tm_wday & 0x07;
+        buf[CCR_Y2K] = bin2bcd((tm->tm_year + 1900) / 100);
 
         /* If writing alarm registers, set compare bits on registers 0-4 */
         if (reg_base < X1205_CCR_BASE)
@@ -214,17 +206,8 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                 return -EIO;
         }
 
-
-        /* write register's data */
-        if (datetoo)
-                nbytes = 8;
-        else
-                nbytes = 3;
-        for (i = 0; i < nbytes; i++)
-                rdata[2+i] = buf[i];
-
-        xfer = i2c_master_send(client, rdata, nbytes+2);
-        if (xfer != nbytes+2) {
+        xfer = i2c_master_send(client, rdata, sizeof(rdata));
+        if (xfer != sizeof(rdata)) {
                 dev_err(&client->dev,
                         "%s: result=%d addr=%02x, data=%02x\n",
                         __func__,
@@ -280,9 +263,9 @@ static int x1205_fix_osc(struct i2c_client *client)
         int err;
         struct rtc_time tm;
 
-        tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
+        memset(&tm, 0, sizeof(tm));
 
-        err = x1205_set_datetime(client, &tm, 0, X1205_CCR_BASE, 0);
+        err = x1205_set_datetime(client, &tm, X1205_CCR_BASE, 0);
         if (err < 0)
                 dev_err(&client->dev, "unable to restart the oscillator\n");
 
@@ -481,7 +464,7 @@ static int x1205_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 static int x1205_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
         return x1205_set_datetime(to_i2c_client(dev),
-                &alrm->time, 1, X1205_ALM0_BASE, alrm->enabled);
+                &alrm->time, X1205_ALM0_BASE, alrm->enabled);
 }
 
 static int x1205_rtc_read_time(struct device *dev, struct rtc_time *tm)
@@ -493,7 +476,7 @@ static int x1205_rtc_read_time(struct device *dev, struct rtc_time *tm)
 static int x1205_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
         return x1205_set_datetime(to_i2c_client(dev),
-                tm, 1, X1205_CCR_BASE, 0);
+                tm, X1205_CCR_BASE, 0);
 }
 
 static int x1205_rtc_proc(struct device *dev, struct seq_file *seq)