Patched in Tegra support.

105 files changed, 2401 insertions, 5710 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 923a9da9c82..45f4c804084 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -8,7 +8,7 @@ config RTC_LIB
 menuconfig RTC_CLASS
         bool "Real Time Clock"
         default n
-        depends on !S390 && !UML
+        depends on !S390
         select RTC_LIB
         help
           Generic RTC class support. If you say yes here, you will
@@ -19,6 +19,7 @@ if RTC_CLASS
 
 config RTC_HCTOSYS
         bool "Set system time from RTC on startup and resume"
+        depends on RTC_CLASS = y
         default y
         help
           If you say yes here, the system time (wall clock) will be set using
@@ -50,6 +51,7 @@ config RTC_HCTOSYS_DEVICE
 
 config RTC_DEBUG
         bool "RTC debug support"
+        depends on RTC_CLASS = y
         help
           Say yes here to enable debugging support in the RTC framework
           and individual RTC drivers.
@@ -67,15 +69,13 @@ config RTC_INTF_SYSFS
           If unsure, say Y.
 
 config RTC_INTF_PROC
-        boolean "/proc/driver/rtc (procfs for rtcN)"
+        boolean "/proc/driver/rtc (procfs for rtc0)"
         depends on PROC_FS
         default RTC_CLASS
         help
-          Say yes here if you want to use your system clock RTC through
-          the proc interface, /proc/driver/rtc.
-          Other RTCs will not be available through that API.
-          If there is no RTC for the system clock, then the first RTC(rtc0)
-          is used by default.
+          Say yes here if you want to use your first RTC through the proc
+          interface, /proc/driver/rtc. Other RTCs will not be available
+          through that API.
 
           If unsure, say Y.
 
@@ -106,6 +106,24 @@ config RTC_INTF_DEV_UIE_EMUL
           clock several times per second, please enable this option
           only if you know that you really need it.
 
+config RTC_INTF_ALARM
+        bool "Android alarm driver"
+        depends on RTC_CLASS
+        default y
+        help
+          Provides non-wakeup and rtc backed wakeup alarms based on rtc or
+          elapsed realtime, and a non-wakeup alarm on the monotonic clock.
+          Also provides an interface to set the wall time which must be used
+          for elapsed realtime to work.
+
+config RTC_INTF_ALARM_DEV
+        bool "Android alarm device"
+        depends on RTC_INTF_ALARM
+        default y
+        help
+          Exports the alarm interface to user-space.
+
+
 config RTC_DRV_TEST
         tristate "Test driver/device"
         help
@@ -127,7 +145,7 @@ if I2C
 
 config RTC_DRV_88PM860X
         tristate "Marvell 88PM860x"
-        depends on I2C && MFD_88PM860X
+        depends on RTC_CLASS && I2C && MFD_88PM860X
         help
           If you say yes here you get support for RTC function in Marvell
           88PM860x chips.
@@ -135,16 +153,6 @@ config RTC_DRV_88PM860X
           This driver can also be built as a module. If so, the module
           will be called rtc-88pm860x.
 
-config RTC_DRV_88PM80X
-        tristate "Marvell 88PM80x"
-        depends on I2C && MFD_88PM800
-        help
-          If you say yes here you get support for RTC function in Marvell
-          88PM80x chips.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-88pm80x.
-
 config RTC_DRV_DS1307
         tristate "Dallas/Maxim DS1307/37/38/39/40, ST M41T00, EPSON RX-8025"
         help
@@ -165,7 +173,7 @@ config RTC_DRV_DS1307
 
 config RTC_DRV_DS1374
         tristate "Dallas/Maxim DS1374"
-        depends on I2C
+        depends on RTC_CLASS && I2C
         help
           If you say yes here you get support for Dallas Semiconductor
           DS1374 real-time clock chips. If an interrupt is associated
@@ -185,7 +193,7 @@ config RTC_DRV_DS1672
 
 config RTC_DRV_DS3232
         tristate "Dallas/Maxim DS3232"
-        depends on I2C
+        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
@@ -203,16 +211,6 @@ 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_MAX8907
-        tristate "Maxim MAX8907"
-        depends on MFD_MAX8907
-        help
-          If you say yes here you will get support for the
-          RTC of Maxim MAX8907 PMIC.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-max8907.
-
 config RTC_DRV_MAX8925
         tristate "Maxim MAX8925"
         depends on MFD_MAX8925
@@ -233,6 +231,26 @@ config RTC_DRV_MAX8998
           This driver can also be built as a module. If so, the module
           will be called rtc-max8998.
 
+config RTC_DRV_MAX8907C
+        tristate "Maxim MAX8907C"
+        depends on MFD_MAX8907C
+        help
+          If you say yes here you will get support for the
+          RTC of Maxim MAX8907C PMIC.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-max8907c.
+
+config RTC_DRV_MAX77663
+        tristate "Maxim MAX77663"
+        depends on MFD_MAX77663
+        help
+          If you say yes here you will get support for the
+          RTC of Maxim MAX77663 PMIC.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-max77663.
+
 config RTC_DRV_RS5C372
         tristate "Ricoh R2025S/D, RS5C372A/B, RV5C386, RV5C387A"
         help
@@ -269,15 +287,6 @@ config RTC_DRV_X1205
           This driver can also be built as a module. If so, the module
           will be called rtc-x1205.
 
-config RTC_DRV_PCF8523
-        tristate "NXP PCF8523"
-        help
-          If you say yes here you get support for the NXP PCF8523 RTC
-          chips.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-pcf8523.
-
 config RTC_DRV_PCF8563
         tristate "Philips PCF8563/Epson RTC8564"
         help
@@ -333,6 +342,12 @@ config RTC_DRV_DM355EVM
         help
           Supports the RTC firmware in the MSP430 on the DM355 EVM.
 
+config RTC_DRV_TPS6586X
+        tristate "TI TPS6586X RTC"
+        depends on MFD_TPS6586X
+        help
+          This driver supports TPS6586X RTC
+
 config RTC_DRV_TWL92330
         boolean "TI TWL92330/Menelaus"
         depends on MENELAUS
@@ -344,7 +359,7 @@ config RTC_DRV_TWL92330
 
 config RTC_DRV_TWL4030
         tristate "TI TWL4030/TWL5030/TWL6030/TPS659x0"
-        depends on TWL4030_CORE
+        depends on RTC_CLASS && TWL4030_CORE
         help
           If you say yes here you get support for the RTC on the
           TWL4030/TWL5030/TWL6030 family chips, used mostly with OMAP3 platforms.
@@ -352,34 +367,6 @@ config RTC_DRV_TWL4030
           This driver can also be built as a module. If so, the module
           will be called rtc-twl.
 
-config RTC_DRV_TPS6586X
-        tristate "TI TPS6586X RTC driver"
-        depends on MFD_TPS6586X
-        help
-          TI Power Managment IC TPS6586X supports RTC functionality
-          along with alarm. This driver supports the RTC driver for
-          the TPS6586X RTC module.
-
-config RTC_DRV_TPS65910
-        tristate "TI TPS65910 RTC driver"
-        depends on RTC_CLASS && MFD_TPS65910
-        help
-          If you say yes here you get support for the RTC on the
-          TPS65910 chips.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-tps65910.
-
-config RTC_DRV_RC5T583
-        tristate "RICOH 5T583 RTC driver"
-        depends on MFD_RC5T583
-        help
-          If you say yes here you get support for the RTC on the
-          RICOH 5T583 chips.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-rc5t583.
-
 config RTC_DRV_S35390A
         tristate "Seiko Instruments S-35390A"
         select BITREVERSE
@@ -555,9 +542,9 @@ config RTC_DRV_CMOS
           will be called rtc-cmos.
 
 config RTC_DRV_VRTC
-        tristate "Virtual RTC for Intel MID platforms"
-        depends on X86_INTEL_MID
-        default y if X86_INTEL_MID
+        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
@@ -585,6 +572,7 @@ config RTC_DRV_DS1302
 
 config RTC_DRV_DS1511
         tristate "Dallas DS1511"
+        depends on RTC_CLASS
         help
           If you say yes here you get support for the
           Dallas DS1511 timekeeping/watchdog chip.
@@ -610,23 +598,6 @@ config RTC_DRV_DS1742
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1742.
 
-config RTC_DRV_DA9052
-        tristate "Dialog DA9052/DA9053 RTC"
-        depends on PMIC_DA9052
-        help
-          Say y here to support the RTC driver for Dialog Semiconductor
-          DA9052-BC and DA9053-AA/Bx PMICs.
-
-config RTC_DRV_DA9055
-        tristate "Dialog Semiconductor DA9055 RTC"
-        depends on MFD_DA9055
-        help
-          If you say yes here you will get support for the
-          RTC of the Dialog DA9055 PMIC.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-da9055
-
 config RTC_DRV_EFI
         tristate "EFI RTC"
         depends on IA64
@@ -639,6 +610,7 @@ config RTC_DRV_EFI
 
 config RTC_DRV_STK17TA8
         tristate "Simtek STK17TA8"
+        depends on RTC_CLASS
         help
           If you say yes here you get support for the
           Simtek STK17TA8 timekeeping chip.
@@ -685,6 +657,27 @@ config RTC_DRV_MSM6242
           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
@@ -713,15 +706,6 @@ 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_DS2404
-        tristate "Dallas DS2404"
-        help
-          If you say yes here you get support for the
-          Dallas DS2404 RTC chip.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-ds2404.
-
 config RTC_DRV_WM831X
         tristate "Wolfson Microelectronics WM831x RTC"
         depends on MFD_WM831X
@@ -768,15 +752,13 @@ config RTC_DRV_AB3100
 config RTC_DRV_AB8500
         tristate "ST-Ericsson AB8500 RTC"
         depends on AB8500_CORE
-        select RTC_INTF_DEV
-        select RTC_INTF_DEV_UIE_EMUL
         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 ARCH_W90X900
+        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.
@@ -793,24 +775,13 @@ config RTC_DRV_DAVINCI
           This driver can also be built as a module. If so, the module
           will be called rtc-davinci.
 
-config RTC_DRV_IMXDI
-        tristate "Freescale IMX DryIce Real Time Clock"
-        depends on ARCH_MXC
-        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_DRV_OMAP
         tristate "TI OMAP1"
-        depends on ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 || ARCH_DAVINCI_DA8XX || SOC_AM33XX
+        depends on ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 || ARCH_DAVINCI_DA8XX
         help
-          Say "yes" here to support the on chip real time clock
-          present on TI OMAP1, AM33xx and DA8xx/OMAP-L13x.
-
-          This driver can also be built as a module, if so, module
-          will be called rtc-omap.
+          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
@@ -821,7 +792,7 @@ config HAVE_S3C_RTC
 
 config RTC_DRV_S3C
         tristate "Samsung S3C series SoC RTC"
-        depends on ARCH_S3C64XX || HAVE_S3C_RTC
+        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
@@ -846,8 +817,8 @@ config RTC_DRV_EP93XX
           will be called rtc-ep93xx.
 
 config RTC_DRV_SA1100
-        tristate "SA11x0/PXA2xx/PXA910"
-        depends on ARCH_SA1100 || ARCH_PXA || ARCH_MMP
+        tristate "SA11x0/PXA2xx"
+        depends on ARCH_SA1100 || ARCH_PXA
         help
           If you say Y here you will get access to the real time clock
           built into your SA11x0 or PXA2xx CPU.
@@ -857,7 +828,7 @@ config RTC_DRV_SA1100
 
 config RTC_DRV_SH
         tristate "SuperH On-Chip RTC"
-        depends on SUPERH && HAVE_CLK
+        depends on RTC_CLASS && SUPERH && HAVE_CLK
         help
           Say Y here to enable support for the on-chip RTC found in
           most SuperH processors.
@@ -904,7 +875,7 @@ config RTC_DRV_AT32AP700X
 
 config RTC_DRV_AT91RM9200
         tristate "AT91RM9200 or some AT91SAM9 RTC"
-        depends on ARCH_AT91
+        depends on ARCH_AT91RM9200 || ARCH_AT91SAM9RL || ARCH_AT91SAM9G45
         help
           Driver for the internal RTC (Realtime Clock) module found on
           Atmel AT91RM9200's and some  AT91SAM9 chips. On AT91SAM9 chips
@@ -1089,6 +1060,7 @@ config RTC_DRV_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
@@ -1118,10 +1090,9 @@ config RTC_DRV_PM8XXX
 
 config RTC_DRV_TEGRA
         tristate "NVIDIA Tegra Internal RTC driver"
-        depends on ARCH_TEGRA
+        depends on RTC_CLASS && ARCH_TEGRA
         help
-          If you say yes here you get support for the
-          Tegra 200 series internal RTC module.
+          If you say yes here you get support for the Tegra internal RTC module.
 
           This drive can also be built as a module. If so, the module
           will be called rtc-tegra.
@@ -1133,44 +1104,43 @@ config RTC_DRV_TILE
           Enable support for the Linux driver side of the Tilera
           hypervisor's real-time clock interface.
 
-config RTC_DRV_PUV3
-        tristate "PKUnity v3 RTC support"
-        depends on ARCH_PUV3
+config RTC_DRV_TPS6591x
+        tristate "TPS6591x RTC driver"
+        depends on MFD_TPS6591X
+        default n
         help
-          This enables support for the RTC in the PKUnity-v3 SoCs.
+          If you say yes here you get support for the TPS6591x RTC module.
 
-          This drive can also be built as a module. If so, the module
-          will be called rtc-puv3.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-tps6591x.
 
-config RTC_DRV_LOONGSON1
-        tristate "loongson1 RTC support"
-        depends on MACH_LOONGSON1
+config RTC_DRV_TPS80031
+        tristate "TPS80031 RTC driver"
+        depends on MFD_TPS80031
+        default n
         help
-          This is a driver for the loongson1 on-chip Counter0 (Time-Of-Year
-          counter) to be used as a RTC.
+          If you say yes here you get support for the TPS80031 RTC module.
 
           This driver can also be built as a module. If so, the module
-          will be called rtc-ls1x.
+          will be called rtc-tps6591x.
 
-config RTC_DRV_MXC
-        tristate "Freescale MXC Real Time Clock"
-        depends on ARCH_MXC
+config RTC_DRV_PUV3
+        tristate "PKUnity v3 RTC support"
+        depends on ARCH_PUV3
         help
-           If you say yes here you get support for the Freescale MXC
-           RTC module.
+          This enables support for the RTC in the PKUnity-v3 SoCs.
 
-           This driver can also be built as a module, if so, the module
-           will be called "rtc-mxc".
+          This drive can also be built as a module. If so, the module
+          will be called rtc-puv3.
 
-config RTC_DRV_SNVS
-        tristate "Freescale SNVS RTC support"
-        depends on HAS_IOMEM
-        depends on OF
+config RTC_DRV_RC5T583
+        tristate "RICOH RC5T583 PMU RTC driver"
+        depends on MFD_RICOH583
+        default n
         help
-           If you say yes here you get support for the Freescale SNVS
-           Low Power (LP) RTC module.
+          If you say yes here you get support for the RICOH RC5T583 RTC module.
 
-           This driver can also be built as a module, if so, the module
-           will be called "rtc-snvs".
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rc5t583.
 
 endif # RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 4418ef3f9ec..be5b16284db 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -9,6 +9,8 @@ obj-$(CONFIG_RTC_HCTOSYS)	+= hctosys.o
 obj-$(CONFIG_RTC_CLASS)         += rtc-core.o
 rtc-core-y                      := class.o interface.o
 
+obj-$(CONFIG_RTC_INTF_ALARM) += alarm.o
+obj-$(CONFIG_RTC_INTF_ALARM_DEV) += alarm-dev.o
 rtc-core-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o
 rtc-core-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o
 rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
@@ -16,7 +18,6 @@ rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
 # Keep the list ordered.
 
 obj-$(CONFIG_RTC_DRV_88PM860X)  += rtc-88pm860x.o
-obj-$(CONFIG_RTC_DRV_88PM80X)   += rtc-88pm80x.o
 obj-$(CONFIG_RTC_DRV_AB3100)    += rtc-ab3100.o
 obj-$(CONFIG_RTC_DRV_AB8500)    += rtc-ab8500.o
 obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
@@ -28,8 +29,6 @@ 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_DA9052)    += rtc-da9052.o
-obj-$(CONFIG_RTC_DRV_DA9055)    += rtc-da9055.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
@@ -44,7 +43,6 @@ 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_DS2404)    += rtc-ds2404.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
@@ -57,27 +55,26 @@ 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_LOONGSON1) += rtc-ls1x.o
 obj-$(CONFIG_RTC_DRV_M41T80)    += rtc-m41t80.o
 obj-$(CONFIG_RTC_DRV_M41T93)    += rtc-m41t93.o
 obj-$(CONFIG_RTC_DRV_M41T94)    += rtc-m41t94.o
 obj-$(CONFIG_RTC_DRV_M48T35)    += rtc-m48t35.o
 obj-$(CONFIG_RTC_DRV_M48T59)    += rtc-m48t59.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
-obj-$(CONFIG_RTC_DRV_MXC)       += rtc-mxc.o
+obj-$(CONFIG_RTC_MXC)           += rtc-mxc.o
 obj-$(CONFIG_RTC_DRV_MAX6900)   += rtc-max6900.o
-obj-$(CONFIG_RTC_DRV_MAX8907)   += rtc-max8907.o
 obj-$(CONFIG_RTC_DRV_MAX8925)   += rtc-max8925.o
 obj-$(CONFIG_RTC_DRV_MAX8998)   += rtc-max8998.o
+obj-$(CONFIG_RTC_DRV_MAX8907C)  += rtc-max8907c.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
 obj-$(CONFIG_RTC_DRV_MC13XXX)   += rtc-mc13xxx.o
+obj-$(CONFIG_RTC_DRV_MAX77663)  += rtc-max77663.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_PCF8523)   += rtc-pcf8523.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
@@ -89,7 +86,6 @@ obj-$(CONFIG_RTC_DRV_PS3)	+= rtc-ps3.o
 obj-$(CONFIG_RTC_DRV_PUV3)      += rtc-puv3.o
 obj-$(CONFIG_RTC_DRV_PXA)       += rtc-pxa.o
 obj-$(CONFIG_RTC_DRV_R9701)     += rtc-r9701.o
-obj-$(CONFIG_RTC_DRV_RC5T583)   += rtc-rc5t583.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
@@ -101,7 +97,6 @@ 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_SNVS)      += rtc-snvs.o
 obj-$(CONFIG_RTC_DRV_SPEAR)     += rtc-spear.o
 obj-$(CONFIG_RTC_DRV_STARFIRE)  += rtc-starfire.o
 obj-$(CONFIG_RTC_DRV_STK17TA8)  += rtc-stk17ta8.o
@@ -110,9 +105,11 @@ obj-$(CONFIG_RTC_DRV_SUN4V)	+= rtc-sun4v.o
 obj-$(CONFIG_RTC_DRV_TEGRA)     += rtc-tegra.o
 obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
 obj-$(CONFIG_RTC_DRV_TILE)      += rtc-tile.o
-obj-$(CONFIG_RTC_DRV_TWL4030)   += rtc-twl.o
 obj-$(CONFIG_RTC_DRV_TPS6586X)  += rtc-tps6586x.o
-obj-$(CONFIG_RTC_DRV_TPS65910)  += rtc-tps65910.o
+obj-$(CONFIG_RTC_DRV_TPS6591x)  += rtc-tps6591x.o
+obj-$(CONFIG_RTC_DRV_TPS80031)  += rtc-tps80031.o
+obj-$(CONFIG_RTC_DRV_RC5T583)   += rtc-ricoh583.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
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 5143629dedb..b82a1554cdc 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -21,22 +21,21 @@
 #include "rtc-core.h"
 
 
-static DEFINE_IDA(rtc_ida);
+static DEFINE_IDR(rtc_idr);
+static DEFINE_MUTEX(idr_lock);
 struct class *rtc_class;
 
 static void rtc_device_release(struct device *dev)
 {
         struct rtc_device *rtc = to_rtc_device(dev);
-        ida_simple_remove(&rtc_ida, rtc->id);
+        mutex_lock(&idr_lock);
+        idr_remove(&rtc_idr, rtc->id);
+        mutex_unlock(&idr_lock);
         kfree(rtc);
 }
 
-#ifdef CONFIG_RTC_HCTOSYS_DEVICE
-/* Result of the last RTC to system clock attempt. */
-int rtc_hctosys_ret = -ENODEV;
-#endif
-
 #if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
+
 /*
  * On suspend(), measure the delta between one RTC and the
  * system's wall clock; restore it on resume().
@@ -88,7 +87,6 @@ static int rtc_resume(struct device *dev)
         struct timespec         new_system, new_rtc;
         struct timespec         sleep_time;
 
-        rtc_hctosys_ret = -ENODEV;
         if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
                 return 0;
 
@@ -122,7 +120,6 @@ static int rtc_resume(struct device *dev)
 
         if (sleep_time.tv_sec >= 0)
                 timekeeping_inject_sleeptime(&sleep_time);
-        rtc_hctosys_ret = 0;
         return 0;
 }
 
@@ -149,16 +146,25 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
         struct rtc_wkalrm alrm;
         int id, err;
 
-        id = ida_simple_get(&rtc_ida, 0, 0, GFP_KERNEL);
-        if (id < 0) {
-                err = id;
+        if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
+                err = -ENOMEM;
                 goto exit;
         }
 
+
+        mutex_lock(&idr_lock);
+        err = idr_get_new(&rtc_idr, NULL, &id);
+        mutex_unlock(&idr_lock);
+
+        if (err < 0)
+                goto exit;
+
+        id = id & MAX_ID_MASK;
+
         rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
         if (rtc == NULL) {
                 err = -ENOMEM;
-                goto exit_ida;
+                goto exit_idr;
         }
 
         rtc->id = id;
@@ -216,8 +222,10 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
 exit_kfree:
         kfree(rtc);
 
-exit_ida:
-        ida_simple_remove(&rtc_ida, id);
+exit_idr:
+        mutex_lock(&idr_lock);
+        idr_remove(&rtc_idr, id);
+        mutex_unlock(&idr_lock);
 
 exit:
         dev_err(dev, "rtc core: unable to register %s, err = %d\n",
@@ -268,7 +276,7 @@ static void __exit rtc_exit(void)
 {
         rtc_dev_exit();
         class_destroy(rtc_class);
-        ida_destroy(&rtc_ida);
+        idr_destroy(&rtc_idr);
 }
 
 subsys_initcall(rtc_init);
diff --git a/drivers/rtc/hctosys.c b/drivers/rtc/hctosys.c
index 4aa60d74004..bc90b091f19 100644
--- a/drivers/rtc/hctosys.c
+++ b/drivers/rtc/hctosys.c
@@ -22,6 +22,8 @@
  * the best guess is to add 0.5s.
  */
 
+int rtc_hctosys_ret = -ENODEV;
+
 static int __init rtc_hctosys(void)
 {
         int err = -ENODEV;
@@ -54,7 +56,7 @@ static int __init rtc_hctosys(void)
 
         rtc_tm_to_time(&tm, &tv.tv_sec);
 
-        err = do_settimeofday(&tv);
+        do_settimeofday(&tv);
 
         dev_info(rtc->dev.parent,
                 "setting system clock to "
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 9592b936b71..a86f3013747 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -13,7 +13,6 @@
 
 #include <linux/rtc.h>
 #include <linux/sched.h>
-#include <linux/module.h>
 #include <linux/log2.h>
 #include <linux/workqueue.h>
 
@@ -73,8 +72,6 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
                 err = -EINVAL;
 
         mutex_unlock(&rtc->ops_lock);
-        /* A timer might have just expired */
-        schedule_work(&rtc->irqwork);
         return err;
 }
 EXPORT_SYMBOL_GPL(rtc_set_time);
@@ -114,8 +111,6 @@ int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
                 err = -EINVAL;
 
         mutex_unlock(&rtc->ops_lock);
-        /* A timer might have just expired */
-        schedule_work(&rtc->irqwork);
 
         return err;
 }
@@ -384,27 +379,18 @@ EXPORT_SYMBOL_GPL(rtc_set_alarm);
 int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
         int err;
-        struct rtc_time now;
 
         err = rtc_valid_tm(&alarm->time);
         if (err != 0)
                 return err;
 
-        err = rtc_read_time(rtc, &now);
-        if (err)
-                return err;
-
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
                 return err;
 
         rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
         rtc->aie_timer.period = ktime_set(0, 0);
-
-        /* Alarm has to be enabled & in the futrure for us to enqueue it */
-        if (alarm->enabled && (rtc_tm_to_ktime(now).tv64 <
-                         rtc->aie_timer.node.expires.tv64)) {
-
+        if (alarm->enabled) {
                 rtc->aie_timer.enabled = 1;
                 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
         }
@@ -458,11 +444,6 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
         if (rtc->uie_rtctimer.enabled == enabled)
                 goto out;
 
-        if (rtc->uie_unsupported) {
-                err = -EINVAL;
-                goto out;
-        }
-
         if (enabled) {
                 struct rtc_time tm;
                 ktime_t now, onesec;
@@ -582,7 +563,6 @@ enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
 void rtc_update_irq(struct rtc_device *rtc,
                 unsigned long num, unsigned long events)
 {
-        pm_stay_awake(rtc->dev.parent);
         schedule_work(&rtc->irqwork);
 }
 EXPORT_SYMBOL_GPL(rtc_update_irq);
@@ -782,14 +762,6 @@ static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
         return 0;
 }
 
-static void rtc_alarm_disable(struct rtc_device *rtc)
-{
-        if (!rtc->ops || !rtc->ops->alarm_irq_enable)
-                return;
-
-        rtc->ops->alarm_irq_enable(rtc->dev.parent, false);
-}
-
 /**
  * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
  * @rtc rtc device
@@ -811,10 +783,8 @@ static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
                 struct rtc_wkalrm alarm;
                 int err;
                 next = timerqueue_getnext(&rtc->timerqueue);
-                if (!next) {
-                        rtc_alarm_disable(rtc);
+                if (!next)
                         return;
-                }
                 alarm.time = rtc_ktime_to_tm(next->expires);
                 alarm.enabled = 1;
                 err = __rtc_set_alarm(rtc, &alarm);
@@ -845,7 +815,6 @@ void rtc_timer_do_work(struct work_struct *work)
 
         mutex_lock(&rtc->ops_lock);
 again:
-        pm_relax(rtc->dev.parent);
         __rtc_read_time(rtc, &tm);
         now = rtc_tm_to_ktime(tm);
         while ((next = timerqueue_getnext(&rtc->timerqueue))) {
@@ -877,8 +846,7 @@ again:
                 err = __rtc_set_alarm(rtc, &alarm);
                 if (err == -ETIME)
                         goto again;
-        } else
-                rtc_alarm_disable(rtc);
+        }
 
         mutex_unlock(&rtc->ops_lock);
 }
diff --git a/drivers/rtc/rtc-88pm80x.c b/drivers/rtc/rtc-88pm80x.c
deleted file mode 100644
index 63b17ebe90e..00000000000
--- a/drivers/rtc/rtc-88pm80x.c
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- * Real Time Clock driver for Marvell 88PM80x PMIC
- *
- * Copyright (c) 2012 Marvell International Ltd.
- *  Wenzeng Chen<wzch@marvell.com>
- *  Qiao Zhou <zhouqiao@marvell.com>
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License. See the file "COPYING" in the main directory of this
- * archive for more details.
- *
- * 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/module.h>
-#include <linux/slab.h>
-#include <linux/regmap.h>
-#include <linux/mfd/core.h>
-#include <linux/mfd/88pm80x.h>
-#include <linux/rtc.h>
-
-#define PM800_RTC_COUNTER1              (0xD1)
-#define PM800_RTC_COUNTER2              (0xD2)
-#define PM800_RTC_COUNTER3              (0xD3)
-#define PM800_RTC_COUNTER4              (0xD4)
-#define PM800_RTC_EXPIRE1_1             (0xD5)
-#define PM800_RTC_EXPIRE1_2             (0xD6)
-#define PM800_RTC_EXPIRE1_3             (0xD7)
-#define PM800_RTC_EXPIRE1_4             (0xD8)
-#define PM800_RTC_TRIM1                 (0xD9)
-#define PM800_RTC_TRIM2                 (0xDA)
-#define PM800_RTC_TRIM3                 (0xDB)
-#define PM800_RTC_TRIM4                 (0xDC)
-#define PM800_RTC_EXPIRE2_1             (0xDD)
-#define PM800_RTC_EXPIRE2_2             (0xDE)
-#define PM800_RTC_EXPIRE2_3             (0xDF)
-#define PM800_RTC_EXPIRE2_4             (0xE0)
-
-#define PM800_POWER_DOWN_LOG1   (0xE5)
-#define PM800_POWER_DOWN_LOG2   (0xE6)
-
-struct pm80x_rtc_info {
-        struct pm80x_chip *chip;
-        struct regmap *map;
-        struct rtc_device *rtc_dev;
-        struct device *dev;
-        struct delayed_work calib_work;
-
-        int irq;
-        int vrtc;
-};
-
-static irqreturn_t rtc_update_handler(int irq, void *data)
-{
-        struct pm80x_rtc_info *info = (struct pm80x_rtc_info *)data;
-        int mask;
-
-        mask = PM800_ALARM | PM800_ALARM_WAKEUP;
-        regmap_update_bits(info->map, PM800_RTC_CONTROL, mask | PM800_ALARM1_EN,
-                           mask);
-        rtc_update_irq(info->rtc_dev, 1, RTC_AF);
-        return IRQ_HANDLED;
-}
-
-static int pm80x_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct pm80x_rtc_info *info = dev_get_drvdata(dev);
-
-        if (enabled)
-                regmap_update_bits(info->map, PM800_RTC_CONTROL,
-                                   PM800_ALARM1_EN, PM800_ALARM1_EN);
-        else
-                regmap_update_bits(info->map, PM800_RTC_CONTROL,
-                                   PM800_ALARM1_EN, 0);
-        return 0;
-}
-
-/*
- * Calculate the next alarm time given the requested alarm time mask
- * and the current time.
- */
-static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now,
-                                struct rtc_time *alrm)
-{
-        unsigned long next_time;
-        unsigned long now_time;
-
-        next->tm_year = now->tm_year;
-        next->tm_mon = now->tm_mon;
-        next->tm_mday = now->tm_mday;
-        next->tm_hour = alrm->tm_hour;
-        next->tm_min = alrm->tm_min;
-        next->tm_sec = alrm->tm_sec;
-
-        rtc_tm_to_time(now, &now_time);
-        rtc_tm_to_time(next, &next_time);
-
-        if (next_time < now_time) {
-                /* Advance one day */
-                next_time += 60 * 60 * 24;
-                rtc_time_to_tm(next_time, next);
-        }
-}
-
-static int pm80x_rtc_read_time(struct device *dev, struct rtc_time *tm)
-{
-        struct pm80x_rtc_info *info = dev_get_drvdata(dev);
-        unsigned char buf[4];
-        unsigned long ticks, base, data;
-        regmap_raw_read(info->map, PM800_RTC_EXPIRE2_1, buf, 4);
-        base = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-        dev_dbg(info->dev, "%x-%x-%x-%x\n", buf[0], buf[1], buf[2], buf[3]);
-
-        /* load 32-bit read-only counter */
-        regmap_raw_read(info->map, PM800_RTC_COUNTER1, buf, 4);
-        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-        ticks = base + data;
-        dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
-                base, data, ticks);
-        rtc_time_to_tm(ticks, tm);
-        return 0;
-}
-
-static int pm80x_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        struct pm80x_rtc_info *info = dev_get_drvdata(dev);
-        unsigned char buf[4];
-        unsigned long ticks, base, data;
-        if ((tm->tm_year < 70) || (tm->tm_year > 138)) {
-                dev_dbg(info->dev,
-                        "Set time %d out of range. Please set time between 1970 to 2038.\n",
-                        1900 + tm->tm_year);
-                return -EINVAL;
-        }
-        rtc_tm_to_time(tm, &ticks);
-
-        /* load 32-bit read-only counter */
-        regmap_raw_read(info->map, PM800_RTC_COUNTER1, buf, 4);
-        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-        base = ticks - data;
-        dev_dbg(info->dev, "set base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
-                base, data, ticks);
-        buf[0] = base & 0xFF;
-        buf[1] = (base >> 8) & 0xFF;
-        buf[2] = (base >> 16) & 0xFF;
-        buf[3] = (base >> 24) & 0xFF;
-        regmap_raw_write(info->map, PM800_RTC_EXPIRE2_1, buf, 4);
-
-        return 0;
-}
-
-static int pm80x_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        struct pm80x_rtc_info *info = dev_get_drvdata(dev);
-        unsigned char buf[4];
-        unsigned long ticks, base, data;
-        int ret;
-
-        regmap_raw_read(info->map, PM800_RTC_EXPIRE2_1, buf, 4);
-        base = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-        dev_dbg(info->dev, "%x-%x-%x-%x\n", buf[0], buf[1], buf[2], buf[3]);
-
-        regmap_raw_read(info->map, PM800_RTC_EXPIRE1_1, buf, 4);
-        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-        ticks = base + data;
-        dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
-                base, data, ticks);
-
-        rtc_time_to_tm(ticks, &alrm->time);
-        regmap_read(info->map, PM800_RTC_CONTROL, &ret);
-        alrm->enabled = (ret & PM800_ALARM1_EN) ? 1 : 0;
-        alrm->pending = (ret & (PM800_ALARM | PM800_ALARM_WAKEUP)) ? 1 : 0;
-        return 0;
-}
-
-static int pm80x_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        struct pm80x_rtc_info *info = dev_get_drvdata(dev);
-        struct rtc_time now_tm, alarm_tm;
-        unsigned long ticks, base, data;
-        unsigned char buf[4];
-        int mask;
-
-        regmap_update_bits(info->map, PM800_RTC_CONTROL, PM800_ALARM1_EN, 0);
-
-        regmap_raw_read(info->map, PM800_RTC_EXPIRE2_1, buf, 4);
-        base = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-        dev_dbg(info->dev, "%x-%x-%x-%x\n", buf[0], buf[1], buf[2], buf[3]);
-
-        /* load 32-bit read-only counter */
-        regmap_raw_read(info->map, PM800_RTC_COUNTER1, buf, 4);
-        data = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
-        ticks = base + data;
-        dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n",
-                base, data, ticks);
-
-        rtc_time_to_tm(ticks, &now_tm);
-        dev_dbg(info->dev, "%s, now time : %lu\n", __func__, ticks);
-        rtc_next_alarm_time(&alarm_tm, &now_tm, &alrm->time);
-        /* get new ticks for alarm in 24 hours */
-        rtc_tm_to_time(&alarm_tm, &ticks);
-        dev_dbg(info->dev, "%s, alarm time: %lu\n", __func__, ticks);
-        data = ticks - base;
-
-        buf[0] = data & 0xff;
-        buf[1] = (data >> 8) & 0xff;
-        buf[2] = (data >> 16) & 0xff;
-        buf[3] = (data >> 24) & 0xff;
-        regmap_raw_write(info->map, PM800_RTC_EXPIRE1_1, buf, 4);
-        if (alrm->enabled) {
-                mask = PM800_ALARM | PM800_ALARM_WAKEUP | PM800_ALARM1_EN;
-                regmap_update_bits(info->map, PM800_RTC_CONTROL, mask, mask);
-        } else {
-                mask = PM800_ALARM | PM800_ALARM_WAKEUP | PM800_ALARM1_EN;
-                regmap_update_bits(info->map, PM800_RTC_CONTROL, mask,
-                                   PM800_ALARM | PM800_ALARM_WAKEUP);
-        }
-        return 0;
-}
-
-static const struct rtc_class_ops pm80x_rtc_ops = {
-        .read_time = pm80x_rtc_read_time,
-        .set_time = pm80x_rtc_set_time,
-        .read_alarm = pm80x_rtc_read_alarm,
-        .set_alarm = pm80x_rtc_set_alarm,
-        .alarm_irq_enable = pm80x_rtc_alarm_irq_enable,
-};
-
-#ifdef CONFIG_PM
-static int pm80x_rtc_suspend(struct device *dev)
-{
-        return pm80x_dev_suspend(dev);
-}
-
-static int pm80x_rtc_resume(struct device *dev)
-{
-        return pm80x_dev_resume(dev);
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(pm80x_rtc_pm_ops, pm80x_rtc_suspend, pm80x_rtc_resume);
-
-static int pm80x_rtc_probe(struct platform_device *pdev)
-{
-        struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);
-        struct pm80x_platform_data *pm80x_pdata;
-        struct pm80x_rtc_pdata *pdata = NULL;
-        struct pm80x_rtc_info *info;
-        struct rtc_time tm;
-        unsigned long ticks = 0;
-        int ret;
-
-        pdata = pdev->dev.platform_data;
-        if (pdata == NULL)
-                dev_warn(&pdev->dev, "No platform data!\n");
-
-        info =
-            devm_kzalloc(&pdev->dev, sizeof(struct pm80x_rtc_info), GFP_KERNEL);
-        if (!info)
-                return -ENOMEM;
-        info->irq = platform_get_irq(pdev, 0);
-        if (info->irq < 0) {
-                dev_err(&pdev->dev, "No IRQ resource!\n");
-                ret = -EINVAL;
-                goto out;
-        }
-
-        info->chip = chip;
-        info->map = chip->regmap;
-        if (!info->map) {
-                dev_err(&pdev->dev, "no regmap!\n");
-                ret = -EINVAL;
-                goto out;
-        }
-
-        info->dev = &pdev->dev;
-        dev_set_drvdata(&pdev->dev, info);
-
-        ret = pm80x_request_irq(chip, info->irq, rtc_update_handler,
-                                IRQF_ONESHOT, "rtc", info);
-        if (ret < 0) {
-                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
-                        info->irq, ret);
-                goto out;
-        }
-
-        ret = pm80x_rtc_read_time(&pdev->dev, &tm);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "Failed to read initial time.\n");
-                goto out_rtc;
-        }
-        if ((tm.tm_year < 70) || (tm.tm_year > 138)) {
-                tm.tm_year = 70;
-                tm.tm_mon = 0;
-                tm.tm_mday = 1;
-                tm.tm_hour = 0;
-                tm.tm_min = 0;
-                tm.tm_sec = 0;
-                ret = pm80x_rtc_set_time(&pdev->dev, &tm);
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "Failed to set initial time.\n");
-                        goto out_rtc;
-                }
-        }
-        rtc_tm_to_time(&tm, &ticks);
-
-        info->rtc_dev = rtc_device_register("88pm80x-rtc", &pdev->dev,
-                                            &pm80x_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;
-        }
-        /*
-         * enable internal XO instead of internal 3.25MHz clock since it can
-         * free running in PMIC power-down state.
-         */
-        regmap_update_bits(info->map, PM800_RTC_CONTROL, PM800_RTC1_USE_XO,
-                           PM800_RTC1_USE_XO);
-
-        if (pdev->dev.parent->platform_data) {
-                pm80x_pdata = pdev->dev.parent->platform_data;
-                pdata = pm80x_pdata->rtc;
-                if (pdata)
-                        info->rtc_dev->dev.platform_data = &pdata->rtc_wakeup;
-        }
-
-        device_init_wakeup(&pdev->dev, 1);
-
-        return 0;
-out_rtc:
-        pm80x_free_irq(chip, info->irq, info);
-out:
-        return ret;
-}
-
-static int pm80x_rtc_remove(struct platform_device *pdev)
-{
-        struct pm80x_rtc_info *info = platform_get_drvdata(pdev);
-        platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(info->rtc_dev);
-        pm80x_free_irq(info->chip, info->irq, info);
-        return 0;
-}
-
-static struct platform_driver pm80x_rtc_driver = {
-        .driver = {
-                   .name = "88pm80x-rtc",
-                   .owner = THIS_MODULE,
-                   .pm = &pm80x_rtc_pm_ops,
-                   },
-        .probe = pm80x_rtc_probe,
-        .remove = pm80x_rtc_remove,
-};
-
-module_platform_driver(pm80x_rtc_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Marvell 88PM80x RTC driver");
-MODULE_AUTHOR("Qiao Zhou <zhouqiao@marvell.com>");
-MODULE_ALIAS("platform:88pm80x-rtc");
diff --git a/drivers/rtc/rtc-88pm860x.c b/drivers/rtc/rtc-88pm860x.c
index f663746f460..64b847b7f97 100644
--- a/drivers/rtc/rtc-88pm860x.c
+++ b/drivers/rtc/rtc-88pm860x.c
@@ -11,7 +11,6 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/mutex.h>
@@ -73,9 +72,9 @@ static int pm860x_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
         struct pm860x_rtc_info *info = dev_get_drvdata(dev);
 
         if (enabled)
-                pm860x_set_bits(info->i2c, PM8607_RTC1, ALARM_EN, ALARM_EN);
+                pm860x_set_bits(info->i2c, PM8607_RTC1, ALARM, ALARM);
         else
-                pm860x_set_bits(info->i2c, PM8607_RTC1, ALARM_EN, 0);
+                pm860x_set_bits(info->i2c, PM8607_RTC1, ALARM, 0);
         return 0;
 }
 
@@ -285,29 +284,7 @@ out:
 }
 #endif
 
-#ifdef CONFIG_OF
-static int pm860x_rtc_dt_init(struct platform_device *pdev,
-                              struct pm860x_rtc_info *info)
-{
-        struct device_node *np = pdev->dev.parent->of_node;
-        int ret;
-        if (!np)
-                return -ENODEV;
-        np = of_find_node_by_name(np, "rtc");
-        if (!np) {
-                dev_err(&pdev->dev, "failed to find rtc node\n");
-                return -ENODEV;
-        }
-        ret = of_property_read_u32(np, "marvell,88pm860x-vrtc", &info->vrtc);
-        if (ret)
-                info->vrtc = 0;
-        return 0;
-}
-#else
-#define pm860x_rtc_dt_init(x, y)        (-1)
-#endif
-
-static int pm860x_rtc_probe(struct platform_device *pdev)
+static int __devinit pm860x_rtc_probe(struct platform_device *pdev)
 {
         struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
         struct pm860x_rtc_pdata *pdata = NULL;
@@ -317,6 +294,8 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
         int ret;
 
         pdata = pdev->dev.platform_data;
+        if (pdata == NULL)
+                dev_warn(&pdev->dev, "No platform data!\n");
 
         info = kzalloc(sizeof(struct pm860x_rtc_info), GFP_KERNEL);
         if (!info)
@@ -366,11 +345,9 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
                 }
         }
         rtc_tm_to_time(&tm, &ticks);
-        if (pm860x_rtc_dt_init(pdev, info)) {
-                if (pdata && pdata->sync) {
-                        pdata->sync(ticks);
-                        info->sync = pdata->sync;
-                }
+        if (pdata && pdata->sync) {
+                pdata->sync(ticks);
+                info->sync = pdata->sync;
         }
 
         info->rtc_dev = rtc_device_register("88pm860x-rtc", &pdev->dev,
@@ -389,21 +366,16 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
 
 #ifdef VRTC_CALIBRATION
         /* <00> -- 2.7V, <01> -- 2.9V, <10> -- 3.1V, <11> -- 3.3V */
-        if (pm860x_rtc_dt_init(pdev, info)) {
-                if (pdata && pdata->vrtc)
-                        info->vrtc = pdata->vrtc & 0x3;
-                else
-                        info->vrtc = 1;
-        }
+        if (pdata && pdata->vrtc)
+                info->vrtc = pdata->vrtc & 0x3;
+        else
+                info->vrtc = 1;
         pm860x_set_bits(info->i2c, PM8607_MEAS_EN2, MEAS2_VRTC, MEAS2_VRTC);
 
         /* calibrate VRTC */
         INIT_DELAYED_WORK(&info->calib_work, calibrate_vrtc_work);
         schedule_delayed_work(&info->calib_work, VRTC_CALIB_INTERVAL);
 #endif  /* VRTC_CALIBRATION */
-
-        device_init_wakeup(&pdev->dev, 1);
-
         return 0;
 out_rtc:
         free_irq(info->irq, info);
@@ -412,7 +384,7 @@ out:
         return ret;
 }
 
-static int pm860x_rtc_remove(struct platform_device *pdev)
+static int __devexit pm860x_rtc_remove(struct platform_device *pdev)
 {
         struct pm860x_rtc_info *info = platform_get_drvdata(pdev);
 
@@ -429,40 +401,26 @@ static int pm860x_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int pm860x_rtc_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
-
-        if (device_may_wakeup(dev))
-                chip->wakeup_flag |= 1 << PM8607_IRQ_RTC;
-        return 0;
-}
-static int pm860x_rtc_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
-
-        if (device_may_wakeup(dev))
-                chip->wakeup_flag &= ~(1 << PM8607_IRQ_RTC);
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(pm860x_rtc_pm_ops, pm860x_rtc_suspend, pm860x_rtc_resume);
-
 static struct platform_driver pm860x_rtc_driver = {
         .driver         = {
                 .name   = "88pm860x-rtc",
                 .owner  = THIS_MODULE,
-                .pm     = &pm860x_rtc_pm_ops,
         },
         .probe          = pm860x_rtc_probe,
-        .remove         = pm860x_rtc_remove,
+        .remove         = __devexit_p(pm860x_rtc_remove),
 };
 
-module_platform_driver(pm860x_rtc_driver);
+static int __init pm860x_rtc_init(void)
+{
+        return platform_driver_register(&pm860x_rtc_driver);
+}
+module_init(pm860x_rtc_init);
+
+static void __exit pm860x_rtc_exit(void)
+{
+        platform_driver_unregister(&pm860x_rtc_driver);
+}
+module_exit(pm860x_rtc_exit);
 
 MODULE_DESCRIPTION("Marvell 88PM860x RTC driver");
 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index 57cde2b061e..e346705aae9 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -15,9 +15,8 @@
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/abx500/ab8500.h>
+#include <linux/mfd/ab8500.h>
 #include <linux/delay.h>
-#include <linux/of.h>
 
 #define AB8500_RTC_SOFF_STAT_REG        0x00
 #define AB8500_RTC_CC_CONF_REG          0x01
@@ -89,17 +88,22 @@ static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
         if (retval < 0)
                 return retval;
 
-        /* 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;
-
-                usleep_range(1000, 5000);
+        /* 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 */
@@ -220,8 +224,7 @@ 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, cursec = 0;
-        struct rtc_time curtm;
+        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",
@@ -233,18 +236,6 @@ static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         rtc_tm_to_time(&alarm->time, &secs);
 
         /*
-         * Check whether alarm is set less than 1min.
-         * Since our RTC doesn't support alarm resolution less than 1min,
-         * return -EINVAL, so UIE EMUL can take it up, incase of UIE_ON
-         */
-        ab8500_rtc_read_time(dev, &curtm); /* Read current time */
-        rtc_tm_to_time(&curtm, &cursec);
-        if ((secs - cursec) < 59) {
-                dev_dbg(dev, "Alarm less than 1 minute not supported\r\n");
-                return -EINVAL;
-        }
-
-        /*
          * Convert it to the number of seconds since 01-01-2000 00:00:00, since
          * we only have a small counter in the RTC.
          */
@@ -267,109 +258,6 @@ static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         return ab8500_rtc_irq_enable(dev, alarm->enabled);
 }
 
-
-static int ab8500_rtc_set_calibration(struct device *dev, int calibration)
-{
-        int retval;
-        u8  rtccal = 0;
-
-        /*
-         * Check that the calibration value (which is in units of 0.5
-         * parts-per-million) is in the AB8500's range for RtcCalibration
-         * register. -128 (0x80) is not permitted because the AB8500 uses
-         * a sign-bit rather than two's complement, so 0x80 is just another
-         * representation of zero.
-         */
-        if ((calibration < -127) || (calibration > 127)) {
-                dev_err(dev, "RtcCalibration value outside permitted range\n");
-                return -EINVAL;
-        }
-
-        /*
-         * The AB8500 uses sign (in bit7) and magnitude (in bits0-7)
-         * so need to convert to this sort of representation before writing
-         * into RtcCalibration register...
-         */
-        if (calibration >= 0)
-                rtccal = 0x7F & calibration;
-        else
-                rtccal = ~(calibration - 1) | 0x80;
-
-        retval = abx500_set_register_interruptible(dev, AB8500_RTC,
-                        AB8500_RTC_CALIB_REG, rtccal);
-
-        return retval;
-}
-
-static int ab8500_rtc_get_calibration(struct device *dev, int *calibration)
-{
-        int retval;
-        u8  rtccal = 0;
-
-        retval =  abx500_get_register_interruptible(dev, AB8500_RTC,
-                        AB8500_RTC_CALIB_REG, &rtccal);
-        if (retval >= 0) {
-                /*
-                 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7)
-                 * so need to convert value from RtcCalibration register into
-                 * a two's complement signed value...
-                 */
-                if (rtccal & 0x80)
-                        *calibration = 0 - (rtccal & 0x7F);
-                else
-                        *calibration = 0x7F & rtccal;
-        }
-
-        return retval;
-}
-
-static ssize_t ab8500_sysfs_store_rtc_calibration(struct device *dev,
-                                struct device_attribute *attr,
-                                const char *buf, size_t count)
-{
-        int retval;
-        int calibration = 0;
-
-        if (sscanf(buf, " %i ", &calibration) != 1) {
-                dev_err(dev, "Failed to store RTC calibration attribute\n");
-                return -EINVAL;
-        }
-
-        retval = ab8500_rtc_set_calibration(dev, calibration);
-
-        return retval ? retval : count;
-}
-
-static ssize_t ab8500_sysfs_show_rtc_calibration(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        int  retval = 0;
-        int  calibration = 0;
-
-        retval = ab8500_rtc_get_calibration(dev, &calibration);
-        if (retval < 0) {
-                dev_err(dev, "Failed to read RTC calibration attribute\n");
-                sprintf(buf, "0\n");
-                return retval;
-        }
-
-        return sprintf(buf, "%d\n", calibration);
-}
-
-static DEVICE_ATTR(rtc_calibration, S_IRUGO | S_IWUSR,
-                   ab8500_sysfs_show_rtc_calibration,
-                   ab8500_sysfs_store_rtc_calibration);
-
-static int ab8500_sysfs_rtc_register(struct device *dev)
-{
-        return device_create_file(dev, &dev_attr_rtc_calibration);
-}
-
-static void ab8500_sysfs_rtc_unregister(struct device *dev)
-{
-        device_remove_file(dev, &dev_attr_rtc_calibration);
-}
-
 static irqreturn_t rtc_alarm_handler(int irq, void *data)
 {
         struct rtc_device *rtc = data;
@@ -389,7 +277,7 @@ static const struct rtc_class_ops ab8500_rtc_ops = {
         .alarm_irq_enable       = ab8500_rtc_irq_enable,
 };
 
-static int ab8500_rtc_probe(struct platform_device *pdev)
+static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
 {
         int err;
         struct rtc_device *rtc;
@@ -407,7 +295,7 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
                 return err;
 
         /* Wait for reset by the PorRtc */
-        usleep_range(1000, 5000);
+        msleep(1);
 
         err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC,
                 AB8500_RTC_STAT_REG, &rtc_ctrl);
@@ -420,8 +308,6 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        device_init_wakeup(&pdev->dev, true);
-
         rtc = rtc_device_register("ab8500-rtc", &pdev->dev, &ab8500_rtc_ops,
                         THIS_MODULE);
         if (IS_ERR(rtc)) {
@@ -430,8 +316,8 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
                 return err;
         }
 
-        err = request_threaded_irq(irq, NULL, rtc_alarm_handler,
-                IRQF_NO_SUSPEND | IRQF_ONESHOT, "ab8500-rtc", rtc);
+        err = request_threaded_irq(irq, NULL, rtc_alarm_handler, 0,
+                                   "ab8500-rtc", rtc);
         if (err < 0) {
                 rtc_device_unregister(rtc);
                 return err;
@@ -439,22 +325,14 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, rtc);
 
-        err = ab8500_sysfs_rtc_register(&pdev->dev);
-        if (err) {
-                dev_err(&pdev->dev, "sysfs RTC failed to register\n");
-                return err;
-        }
-
         return 0;
 }
 
-static int ab8500_rtc_remove(struct platform_device *pdev)
+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");
 
-        ab8500_sysfs_rtc_unregister(&pdev->dev);
-
         free_irq(irq, rtc);
         rtc_device_unregister(rtc);
         platform_set_drvdata(pdev, NULL);
@@ -468,11 +346,21 @@ static struct platform_driver ab8500_rtc_driver = {
                 .owner = THIS_MODULE,
         },
         .probe  = ab8500_rtc_probe,
-        .remove = ab8500_rtc_remove,
+        .remove = __devexit_p(ab8500_rtc_remove),
 };
 
-module_platform_driver(ab8500_rtc_driver);
+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-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index b6469e2cae8..e39b77a4609 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -27,23 +27,16 @@
 #include <linux/interrupt.h>
 #include <linux/ioctl.h>
 #include <linux/completion.h>
-#include <linux/io.h>
 
 #include <asm/uaccess.h>
 
-#include "rtc-at91rm9200.h"
+#include <mach/at91_rtc.h>
 
-#define at91_rtc_read(field) \
-        __raw_readl(at91_rtc_regs + field)
-#define at91_rtc_write(field, val) \
-        __raw_writel((val), at91_rtc_regs + field)
 
 #define AT91_RTC_EPOCH          1900UL  /* just like arch/arm/common/rtctime.c */
 
 static DECLARE_COMPLETION(at91_rtc_updated);
 static unsigned int at91_alarm_year = AT91_RTC_EPOCH;
-static void __iomem *at91_rtc_regs;
-static int irq;
 
 /*
  * Decode time/date into rtc_time structure
@@ -55,10 +48,10 @@ static void at91_rtc_decodetime(unsigned int timereg, unsigned int calreg,
 
         /* must read twice in case it changes */
         do {
-                time = at91_rtc_read(timereg);
-                date = at91_rtc_read(calreg);
-        } while ((time != at91_rtc_read(timereg)) ||
-                        (date != at91_rtc_read(calreg)));
+                time = at91_sys_read(timereg);
+                date = at91_sys_read(calreg);
+        } while ((time != at91_sys_read(timereg)) ||
+                        (date != at91_sys_read(calreg)));
 
         tm->tm_sec  = bcd2bin((time & AT91_RTC_SEC) >> 0);
         tm->tm_min  = bcd2bin((time & AT91_RTC_MIN) >> 8);
@@ -105,19 +98,19 @@ static int at91_rtc_settime(struct device *dev, struct rtc_time *tm)
                 tm->tm_hour, tm->tm_min, tm->tm_sec);
 
         /* Stop Time/Calendar from counting */
-        cr = at91_rtc_read(AT91_RTC_CR);
-        at91_rtc_write(AT91_RTC_CR, cr | AT91_RTC_UPDCAL | AT91_RTC_UPDTIM);
+        cr = at91_sys_read(AT91_RTC_CR);
+        at91_sys_write(AT91_RTC_CR, cr | AT91_RTC_UPDCAL | AT91_RTC_UPDTIM);
 
-        at91_rtc_write(AT91_RTC_IER, AT91_RTC_ACKUPD);
+        at91_sys_write(AT91_RTC_IER, AT91_RTC_ACKUPD);
         wait_for_completion(&at91_rtc_updated); /* wait for ACKUPD interrupt */
-        at91_rtc_write(AT91_RTC_IDR, AT91_RTC_ACKUPD);
+        at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD);
 
-        at91_rtc_write(AT91_RTC_TIMR,
+        at91_sys_write(AT91_RTC_TIMR,
                           bin2bcd(tm->tm_sec) << 0
                         | bin2bcd(tm->tm_min) << 8
                         | bin2bcd(tm->tm_hour) << 16);
 
-        at91_rtc_write(AT91_RTC_CALR,
+        at91_sys_write(AT91_RTC_CALR,
                           bin2bcd((tm->tm_year + 1900) / 100)   /* century */
                         | bin2bcd(tm->tm_year % 100) << 8       /* year */
                         | bin2bcd(tm->tm_mon + 1) << 16         /* tm_mon starts at zero */
@@ -125,8 +118,8 @@ static int at91_rtc_settime(struct device *dev, struct rtc_time *tm)
                         | bin2bcd(tm->tm_mday) << 24);
 
         /* Restart Time/Calendar */
-        cr = at91_rtc_read(AT91_RTC_CR);
-        at91_rtc_write(AT91_RTC_CR, cr & ~(AT91_RTC_UPDCAL | AT91_RTC_UPDTIM));
+        cr = at91_sys_read(AT91_RTC_CR);
+        at91_sys_write(AT91_RTC_CR, cr & ~(AT91_RTC_UPDCAL | AT91_RTC_UPDTIM));
 
         return 0;
 }
@@ -142,7 +135,7 @@ static int at91_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
         tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
         tm->tm_year = at91_alarm_year - 1900;
 
-        alrm->enabled = (at91_rtc_read(AT91_RTC_IMR) & AT91_RTC_ALARM)
+        alrm->enabled = (at91_sys_read(AT91_RTC_IMR) & AT91_RTC_ALARM)
                         ? 1 : 0;
 
         pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __func__,
@@ -167,20 +160,20 @@ static int at91_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
         tm.tm_min = alrm->time.tm_min;
         tm.tm_sec = alrm->time.tm_sec;
 
-        at91_rtc_write(AT91_RTC_IDR, AT91_RTC_ALARM);
-        at91_rtc_write(AT91_RTC_TIMALR,
+        at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
+        at91_sys_write(AT91_RTC_TIMALR,
                   bin2bcd(tm.tm_sec) << 0
                 | bin2bcd(tm.tm_min) << 8
                 | bin2bcd(tm.tm_hour) << 16
                 | AT91_RTC_HOUREN | AT91_RTC_MINEN | AT91_RTC_SECEN);
-        at91_rtc_write(AT91_RTC_CALALR,
+        at91_sys_write(AT91_RTC_CALALR,
                   bin2bcd(tm.tm_mon + 1) << 16          /* tm_mon starts at zero */
                 | bin2bcd(tm.tm_mday) << 24
                 | AT91_RTC_DATEEN | AT91_RTC_MTHEN);
 
         if (alrm->enabled) {
-                at91_rtc_write(AT91_RTC_SCCR, AT91_RTC_ALARM);
-                at91_rtc_write(AT91_RTC_IER, AT91_RTC_ALARM);
+                at91_sys_write(AT91_RTC_SCCR, AT91_RTC_ALARM);
+                at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM);
         }
 
         pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __func__,
@@ -195,10 +188,10 @@ static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
         pr_debug("%s(): cmd=%08x\n", __func__, enabled);
 
         if (enabled) {
-                at91_rtc_write(AT91_RTC_SCCR, AT91_RTC_ALARM);
-                at91_rtc_write(AT91_RTC_IER, AT91_RTC_ALARM);
+                at91_sys_write(AT91_RTC_SCCR, AT91_RTC_ALARM);
+                at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM);
         } else
-                at91_rtc_write(AT91_RTC_IDR, AT91_RTC_ALARM);
+                at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
 
         return 0;
 }
@@ -207,7 +200,7 @@ static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  */
 static int at91_rtc_proc(struct device *dev, struct seq_file *seq)
 {
-        unsigned long imr = at91_rtc_read(AT91_RTC_IMR);
+        unsigned long imr = at91_sys_read(AT91_RTC_IMR);
 
         seq_printf(seq, "update_IRQ\t: %s\n",
                         (imr & AT91_RTC_ACKUPD) ? "yes" : "no");
@@ -227,7 +220,7 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id)
         unsigned int rtsr;
         unsigned long events = 0;
 
-        rtsr = at91_rtc_read(AT91_RTC_SR) & at91_rtc_read(AT91_RTC_IMR);
+        rtsr = at91_sys_read(AT91_RTC_SR) & at91_sys_read(AT91_RTC_IMR);
         if (rtsr) {             /* this interrupt is shared!  Is it ours? */
                 if (rtsr & AT91_RTC_ALARM)
                         events |= (RTC_AF | RTC_IRQF);
@@ -236,7 +229,7 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id)
                 if (rtsr & AT91_RTC_ACKUPD)
                         complete(&at91_rtc_updated);
 
-                at91_rtc_write(AT91_RTC_SCCR, rtsr);    /* clear status reg */
+                at91_sys_write(AT91_RTC_SCCR, rtsr);    /* clear status reg */
 
                 rtc_update_irq(rtc, 1, events);
 
@@ -263,41 +256,22 @@ static const struct rtc_class_ops at91_rtc_ops = {
 static int __init at91_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
-        struct resource *regs;
-        int ret = 0;
+        int ret;
 
-        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!regs) {
-                dev_err(&pdev->dev, "no mmio resource defined\n");
-                return -ENXIO;
-        }
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                dev_err(&pdev->dev, "no irq resource defined\n");
-                return -ENXIO;
-        }
-
-        at91_rtc_regs = ioremap(regs->start, resource_size(regs));
-        if (!at91_rtc_regs) {
-                dev_err(&pdev->dev, "failed to map registers, aborting.\n");
-                return -ENOMEM;
-        }
-
-        at91_rtc_write(AT91_RTC_CR, 0);
-        at91_rtc_write(AT91_RTC_MR, 0);         /* 24 hour mode */
+        at91_sys_write(AT91_RTC_CR, 0);
+        at91_sys_write(AT91_RTC_MR, 0);         /* 24 hour mode */
 
         /* Disable all interrupts */
-        at91_rtc_write(AT91_RTC_IDR, AT91_RTC_ACKUPD | AT91_RTC_ALARM |
+        at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD | AT91_RTC_ALARM |
                                         AT91_RTC_SECEV | AT91_RTC_TIMEV |
                                         AT91_RTC_CALEV);
 
-        ret = request_irq(irq, at91_rtc_interrupt,
+        ret = request_irq(AT91_ID_SYS, at91_rtc_interrupt,
                                 IRQF_SHARED,
                                 "at91_rtc", pdev);
         if (ret) {
                 printk(KERN_ERR "at91_rtc: IRQ %d already in use.\n",
-                                irq);
+                                AT91_ID_SYS);
                 return ret;
         }
 
@@ -310,7 +284,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
         rtc = rtc_device_register(pdev->name, &pdev->dev,
                                 &at91_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
-                free_irq(irq, pdev);
+                free_irq(AT91_ID_SYS, pdev);
                 return PTR_ERR(rtc);
         }
         platform_set_drvdata(pdev, rtc);
@@ -327,10 +301,10 @@ static int __exit at91_rtc_remove(struct platform_device *pdev)
         struct rtc_device *rtc = platform_get_drvdata(pdev);
 
         /* Disable all interrupts */
-        at91_rtc_write(AT91_RTC_IDR, AT91_RTC_ACKUPD | AT91_RTC_ALARM |
+        at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD | AT91_RTC_ALARM |
                                         AT91_RTC_SECEV | AT91_RTC_TIMEV |
                                         AT91_RTC_CALEV);
-        free_irq(irq, pdev);
+        free_irq(AT91_ID_SYS, pdev);
 
         rtc_device_unregister(rtc);
         platform_set_drvdata(pdev, NULL);
@@ -349,13 +323,13 @@ 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...
          */
-        at91_rtc_imr = at91_rtc_read(AT91_RTC_IMR)
+        at91_rtc_imr = at91_sys_read(AT91_RTC_IMR)
                         & (AT91_RTC_ALARM|AT91_RTC_SECEV);
         if (at91_rtc_imr) {
                 if (device_may_wakeup(dev))
-                        enable_irq_wake(irq);
+                        enable_irq_wake(AT91_ID_SYS);
                 else
-                        at91_rtc_write(AT91_RTC_IDR, at91_rtc_imr);
+                        at91_sys_write(AT91_RTC_IDR, at91_rtc_imr);
         }
         return 0;
 }
@@ -364,9 +338,9 @@ static int at91_rtc_resume(struct device *dev)
 {
         if (at91_rtc_imr) {
                 if (device_may_wakeup(dev))
-                        disable_irq_wake(irq);
+                        disable_irq_wake(AT91_ID_SYS);
                 else
-                        at91_rtc_write(AT91_RTC_IER, at91_rtc_imr);
+                        at91_sys_write(AT91_RTC_IER, at91_rtc_imr);
         }
         return 0;
 }
diff --git a/drivers/rtc/rtc-at91rm9200.h b/drivers/rtc/rtc-at91rm9200.h
deleted file mode 100644
index da1945e5f71..00000000000
--- a/drivers/rtc/rtc-at91rm9200.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * arch/arm/mach-at91/include/mach/at91_rtc.h
- *
- * Copyright (C) 2005 Ivan Kokshaysky
- * Copyright (C) SAN People
- *
- * Real Time Clock (RTC) - System peripheral registers.
- * Based on AT91RM9200 datasheet revision E.
- *
- * 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.
- */
-
-#ifndef AT91_RTC_H
-#define AT91_RTC_H
-
-#define AT91_RTC_CR             0x00                    /* Control Register */
-#define         AT91_RTC_UPDTIM         (1 <<  0)               /* Update Request Time Register */
-#define         AT91_RTC_UPDCAL         (1 <<  1)               /* Update Request Calendar Register */
-#define         AT91_RTC_TIMEVSEL       (3 <<  8)               /* Time Event Selection */
-#define                 AT91_RTC_TIMEVSEL_MINUTE        (0 << 8)
-#define                 AT91_RTC_TIMEVSEL_HOUR          (1 << 8)
-#define                 AT91_RTC_TIMEVSEL_DAY24         (2 << 8)
-#define                 AT91_RTC_TIMEVSEL_DAY12         (3 << 8)
-#define         AT91_RTC_CALEVSEL       (3 << 16)               /* Calendar Event Selection */
-#define                 AT91_RTC_CALEVSEL_WEEK          (0 << 16)
-#define                 AT91_RTC_CALEVSEL_MONTH         (1 << 16)
-#define                 AT91_RTC_CALEVSEL_YEAR          (2 << 16)
-
-#define AT91_RTC_MR             0x04                    /* Mode Register */
-#define                 AT91_RTC_HRMOD          (1 <<  0)               /* 12/24 Hour Mode */
-
-#define AT91_RTC_TIMR           0x08                    /* Time Register */
-#define         AT91_RTC_SEC            (0x7f <<  0)            /* Current Second */
-#define         AT91_RTC_MIN            (0x7f <<  8)            /* Current Minute */
-#define         AT91_RTC_HOUR           (0x3f << 16)            /* Current Hour */
-#define         AT91_RTC_AMPM           (1    << 22)            /* Ante Meridiem Post Meridiem Indicator */
-
-#define AT91_RTC_CALR           0x0c                    /* Calendar Register */
-#define         AT91_RTC_CENT           (0x7f <<  0)            /* Current Century */
-#define         AT91_RTC_YEAR           (0xff <<  8)            /* Current Year */
-#define         AT91_RTC_MONTH          (0x1f << 16)            /* Current Month */
-#define         AT91_RTC_DAY            (7    << 21)            /* Current Day */
-#define         AT91_RTC_DATE           (0x3f << 24)            /* Current Date */
-
-#define AT91_RTC_TIMALR         0x10                    /* Time Alarm Register */
-#define         AT91_RTC_SECEN          (1 <<  7)               /* Second Alarm Enable */
-#define         AT91_RTC_MINEN          (1 << 15)               /* Minute Alarm Enable */
-#define         AT91_RTC_HOUREN         (1 << 23)               /* Hour Alarm Enable */
-
-#define AT91_RTC_CALALR         0x14                    /* Calendar Alarm Register */
-#define         AT91_RTC_MTHEN          (1 << 23)               /* Month Alarm Enable */
-#define         AT91_RTC_DATEEN         (1 << 31)               /* Date Alarm Enable */
-
-#define AT91_RTC_SR             0x18                    /* Status Register */
-#define         AT91_RTC_ACKUPD         (1 <<  0)               /* Acknowledge for Update */
-#define         AT91_RTC_ALARM          (1 <<  1)               /* Alarm Flag */
-#define         AT91_RTC_SECEV          (1 <<  2)               /* Second Event */
-#define         AT91_RTC_TIMEV          (1 <<  3)               /* Time Event */
-#define         AT91_RTC_CALEV          (1 <<  4)               /* Calendar Event */
-
-#define AT91_RTC_SCCR           0x1c                    /* Status Clear Command Register */
-#define AT91_RTC_IER            0x20                    /* Interrupt Enable Register */
-#define AT91_RTC_IDR            0x24                    /* Interrupt Disable Register */
-#define AT91_RTC_IMR            0x28                    /* Interrupt Mask Register */
-
-#define AT91_RTC_VER            0x2c                    /* Valid Entry Register */
-#define         AT91_RTC_NVTIM          (1 <<  0)               /* Non valid Time */
-#define         AT91_RTC_NVCAL          (1 <<  1)               /* Non valid Calendar */
-#define         AT91_RTC_NVTIMALR       (1 <<  2)               /* Non valid Time Alarm */
-#define         AT91_RTC_NVCALALR       (1 <<  3)               /* Non valid Calendar Alarm */
-
-#endif
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 39cfd2ee004..a3ad957507d 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -19,8 +19,8 @@
 #include <linux/interrupt.h>
 #include <linux/ioctl.h>
 #include <linux/slab.h>
-#include <linux/platform_data/atmel.h>
 
+#include <mach/board.h>
 #include <mach/at91_rtt.h>
 #include <mach/cpu.h>
 
@@ -57,8 +57,6 @@ struct sam9_rtc {
         void __iomem            *rtt;
         struct rtc_device       *rtcdev;
         u32                     imr;
-        void __iomem            *gpbr;
-        int                     irq;
 };
 
 #define rtt_readl(rtc, field) \
@@ -67,9 +65,9 @@ struct sam9_rtc {
         __raw_writel((val), (rtc)->rtt + AT91_RTT_ ## field)
 
 #define gpbr_readl(rtc) \
-        __raw_readl((rtc)->gpbr)
+        at91_sys_read(AT91_GPBR + 4 * CONFIG_RTC_DRV_AT91SAM9_GPBR)
 #define gpbr_writel(rtc, val) \
-        __raw_writel((val), (rtc)->gpbr)
+        at91_sys_write(AT91_GPBR + 4 * CONFIG_RTC_DRV_AT91SAM9_GPBR, (val))
 
 /*
  * Read current time and date in RTC
@@ -289,50 +287,28 @@ static const struct rtc_class_ops at91_rtc_ops = {
 /*
  * Initialize and install RTC driver
  */
-static int at91_rtc_probe(struct platform_device *pdev)
+static int __init at91_rtc_probe(struct platform_device *pdev)
 {
-        struct resource *r, *r_gpbr;
+        struct resource *r;
         struct sam9_rtc *rtc;
-        int             ret, irq;
+        int             ret;
         u32             mr;
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        r_gpbr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        if (!r || !r_gpbr) {
-                dev_err(&pdev->dev, "need 2 ressources\n");
+        if (!r)
                 return -ENODEV;
-        }
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                dev_err(&pdev->dev, "failed to get interrupt resource\n");
-                return irq;
-        }
 
         rtc = kzalloc(sizeof *rtc, GFP_KERNEL);
         if (!rtc)
                 return -ENOMEM;
 
-        rtc->irq = irq;
-
         /* platform setup code should have handled this; sigh */
         if (!device_can_wakeup(&pdev->dev))
                 device_init_wakeup(&pdev->dev, 1);
 
         platform_set_drvdata(pdev, rtc);
-        rtc->rtt = ioremap(r->start, resource_size(r));
-        if (!rtc->rtt) {
-                dev_err(&pdev->dev, "failed to map registers, aborting.\n");
-                ret = -ENOMEM;
-                goto fail;
-        }
-
-        rtc->gpbr = ioremap(r_gpbr->start, resource_size(r_gpbr));
-        if (!rtc->gpbr) {
-                dev_err(&pdev->dev, "failed to map gpbr registers, aborting.\n");
-                ret = -ENOMEM;
-                goto fail_gpbr;
-        }
+        rtc->rtt = (void __force __iomem *) (AT91_VA_BASE_SYS - AT91_BASE_SYS);
+        rtc->rtt += r->start;
 
         mr = rtt_readl(rtc, MR);
 
@@ -350,16 +326,17 @@ static int at91_rtc_probe(struct platform_device *pdev)
                                 &at91_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc->rtcdev)) {
                 ret = PTR_ERR(rtc->rtcdev);
-                goto fail_register;
+                goto fail;
         }
 
         /* register irq handler after we know what name we'll use */
-        ret = request_irq(rtc->irq, at91_rtc_interrupt, IRQF_SHARED,
+        ret = request_irq(AT91_ID_SYS, at91_rtc_interrupt,
+                                IRQF_DISABLED | IRQF_SHARED,
                                 dev_name(&rtc->rtcdev->dev), rtc);
         if (ret) {
-                dev_dbg(&pdev->dev, "can't share IRQ %d?\n", rtc->irq);
+                dev_dbg(&pdev->dev, "can't share IRQ %d?\n", AT91_ID_SYS);
                 rtc_device_unregister(rtc->rtcdev);
-                goto fail_register;
+                goto fail;
         }
 
         /* NOTE:  sam9260 rev A silicon has a ROM bug which resets the
@@ -374,10 +351,6 @@ static int at91_rtc_probe(struct platform_device *pdev)
 
         return 0;
 
-fail_register:
-        iounmap(rtc->gpbr);
-fail_gpbr:
-        iounmap(rtc->rtt);
 fail:
         platform_set_drvdata(pdev, NULL);
         kfree(rtc);
@@ -387,19 +360,17 @@ fail:
 /*
  * Disable and remove the RTC driver
  */
-static int at91_rtc_remove(struct platform_device *pdev)
+static int __exit at91_rtc_remove(struct platform_device *pdev)
 {
         struct sam9_rtc *rtc = platform_get_drvdata(pdev);
         u32             mr = rtt_readl(rtc, MR);
 
         /* disable all interrupts */
         rtt_writel(rtc, MR, mr & ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN));
-        free_irq(rtc->irq, rtc);
+        free_irq(AT91_ID_SYS, rtc);
 
         rtc_device_unregister(rtc->rtcdev);
 
-        iounmap(rtc->gpbr);
-        iounmap(rtc->rtt);
         platform_set_drvdata(pdev, NULL);
         kfree(rtc);
         return 0;
@@ -431,7 +402,7 @@ static int at91_rtc_suspend(struct platform_device *pdev,
         rtc->imr = mr & (AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN);
         if (rtc->imr) {
                 if (device_may_wakeup(&pdev->dev) && (mr & AT91_RTT_ALMIEN)) {
-                        enable_irq_wake(rtc->irq);
+                        enable_irq_wake(AT91_ID_SYS);
                         /* don't let RTTINC cause wakeups */
                         if (mr & AT91_RTT_RTTINCIEN)
                                 rtt_writel(rtc, MR, mr & ~AT91_RTT_RTTINCIEN);
@@ -449,7 +420,7 @@ static int at91_rtc_resume(struct platform_device *pdev)
 
         if (rtc->imr) {
                 if (device_may_wakeup(&pdev->dev))
-                        disable_irq_wake(rtc->irq);
+                        disable_irq_wake(AT91_ID_SYS);
                 mr = rtt_readl(rtc, MR);
                 rtt_writel(rtc, MR, mr | rtc->imr);
         }
@@ -462,18 +433,72 @@ static int at91_rtc_resume(struct platform_device *pdev)
 #endif
 
 static struct platform_driver at91_rtc_driver = {
-        .probe          = at91_rtc_probe,
-        .remove         = at91_rtc_remove,
+        .driver.name    = "rtc-at91sam9",
+        .driver.owner   = THIS_MODULE,
+        .remove         = __exit_p(at91_rtc_remove),
         .shutdown       = at91_rtc_shutdown,
         .suspend        = at91_rtc_suspend,
         .resume         = at91_rtc_resume,
-        .driver         = {
-                .name   = "rtc-at91sam9",
-                .owner  = THIS_MODULE,
-        },
 };
 
-module_platform_driver(at91_rtc_driver);
+/* Chips can have more than one RTT module, and they can be used for more
+ * than just RTCs.  So we can't just register as "the" RTT driver.
+ *
+ * A normal approach in such cases is to create a library to allocate and
+ * free the modules.  Here we just use bus_find_device() as like such a
+ * library, binding directly ... no runtime "library" footprint is needed.
+ */
+static int __init at91_rtc_match(struct device *dev, void *v)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        int ret;
+
+        /* continue searching if this isn't the RTT we need */
+        if (strcmp("at91_rtt", pdev->name) != 0
+                        || pdev->id != CONFIG_RTC_DRV_AT91SAM9_RTT)
+                goto fail;
+
+        /* else we found it ... but fail unless we can bind to the RTC driver */
+        if (dev->driver) {
+                dev_dbg(dev, "busy, can't use as RTC!\n");
+                goto fail;
+        }
+        dev->driver = &at91_rtc_driver.driver;
+        if (device_attach(dev) == 0) {
+                dev_dbg(dev, "can't attach RTC!\n");
+                goto fail;
+        }
+        ret = at91_rtc_probe(pdev);
+        if (ret == 0)
+                return true;
+
+        dev_dbg(dev, "RTC probe err %d!\n", ret);
+fail:
+        return false;
+}
+
+static int __init at91_rtc_init(void)
+{
+        int status;
+        struct device *rtc;
+
+        status = platform_driver_register(&at91_rtc_driver);
+        if (status)
+                return status;
+        rtc = bus_find_device(&platform_bus_type, NULL,
+                        NULL, at91_rtc_match);
+        if (!rtc)
+                platform_driver_unregister(&at91_rtc_driver);
+        return rtc ? 0 : -ENODEV;
+}
+module_init(at91_rtc_init);
+
+static void __exit at91_rtc_exit(void)
+{
+        platform_driver_unregister(&at91_rtc_driver);
+}
+module_exit(at91_rtc_exit);
+
 
 MODULE_AUTHOR("Michel Benoit");
 MODULE_DESCRIPTION("RTC driver for Atmel AT91SAM9x");
diff --git a/drivers/rtc/rtc-au1xxx.c b/drivers/rtc/rtc-au1xxx.c
index b309da4ec74..979ed0406ce 100644
--- a/drivers/rtc/rtc-au1xxx.c
+++ b/drivers/rtc/rtc-au1xxx.c
@@ -62,7 +62,7 @@ static struct rtc_class_ops au1xtoy_rtc_ops = {
         .set_time       = au1xtoy_rtc_set_time,
 };
 
-static int au1xtoy_rtc_probe(struct platform_device *pdev)
+static int __devinit au1xtoy_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtcdev;
         unsigned long t;
@@ -116,7 +116,7 @@ out_err:
         return ret;
 }
 
-static int au1xtoy_rtc_remove(struct platform_device *pdev)
+static int __devexit au1xtoy_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device *rtcdev = platform_get_drvdata(pdev);
 
@@ -131,7 +131,7 @@ static struct platform_driver au1xrtc_driver = {
                 .name   = "rtc-au1xxx",
                 .owner  = THIS_MODULE,
         },
-        .remove         = au1xtoy_rtc_remove,
+        .remove         = __devexit_p(au1xtoy_rtc_remove),
 };
 
 static int __init au1xtoy_rtc_init(void)
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index 4ec614b0954..90d866272c8 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -342,7 +342,7 @@ static struct rtc_class_ops bfin_rtc_ops = {
         .alarm_irq_enable = bfin_rtc_alarm_irq_enable,
 };
 
-static int bfin_rtc_probe(struct platform_device *pdev)
+static int __devinit bfin_rtc_probe(struct platform_device *pdev)
 {
         struct bfin_rtc *rtc;
         struct device *dev = &pdev->dev;
@@ -388,7 +388,7 @@ err:
         return ret;
 }
 
-static int bfin_rtc_remove(struct platform_device *pdev)
+static int __devexit bfin_rtc_remove(struct platform_device *pdev)
 {
         struct bfin_rtc *rtc = platform_get_drvdata(pdev);
         struct device *dev = &pdev->dev;
@@ -451,12 +451,23 @@ static struct platform_driver bfin_rtc_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = bfin_rtc_probe,
-        .remove         = bfin_rtc_remove,
+        .remove         = __devexit_p(bfin_rtc_remove),
         .suspend        = bfin_rtc_suspend,
         .resume         = bfin_rtc_resume,
 };
 
-module_platform_driver(bfin_rtc_driver);
+static int __init bfin_rtc_init(void)
+{
+        return platform_driver_register(&bfin_rtc_driver);
+}
+
+static void __exit bfin_rtc_exit(void)
+{
+        platform_driver_unregister(&bfin_rtc_driver);
+}
+
+module_init(bfin_rtc_init);
+module_exit(bfin_rtc_exit);
 
 MODULE_DESCRIPTION("Blackfin On-Chip Real Time Clock Driver");
 MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
diff --git a/drivers/rtc/rtc-bq32k.c b/drivers/rtc/rtc-bq32k.c
index 036cb89f818..408cc8f735b 100644
--- a/drivers/rtc/rtc-bq32k.c
+++ b/drivers/rtc/rtc-bq32k.c
@@ -163,7 +163,7 @@ static int bq32k_probe(struct i2c_client *client,
         return 0;
 }
 
-static int bq32k_remove(struct i2c_client *client)
+static int __devexit bq32k_remove(struct i2c_client *client)
 {
         struct rtc_device *rtc = i2c_get_clientdata(client);
 
@@ -183,11 +183,21 @@ static struct i2c_driver bq32k_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = bq32k_probe,
-        .remove         = bq32k_remove,
+        .remove         = __devexit_p(bq32k_remove),
         .id_table       = bq32k_id,
 };
 
-module_i2c_driver(bq32k_driver);
+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");
diff --git a/drivers/rtc/rtc-bq4802.c b/drivers/rtc/rtc-bq4802.c
index 693be71b5b1..128270ce355 100644
--- a/drivers/rtc/rtc-bq4802.c
+++ b/drivers/rtc/rtc-bq4802.c
@@ -140,7 +140,7 @@ static const struct rtc_class_ops bq4802_ops = {
         .set_time       = bq4802_set_time,
 };
 
-static int bq4802_probe(struct platform_device *pdev)
+static int __devinit bq4802_probe(struct platform_device *pdev)
 {
         struct bq4802 *p = kzalloc(sizeof(*p), GFP_KERNEL);
         int err = -ENOMEM;
@@ -191,7 +191,7 @@ out_free:
         goto out;
 }
 
-static int bq4802_remove(struct platform_device *pdev)
+static int __devexit bq4802_remove(struct platform_device *pdev)
 {
         struct bq4802 *p = platform_get_drvdata(pdev);
 
@@ -215,7 +215,18 @@ static struct platform_driver bq4802_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = bq4802_probe,
-        .remove         = bq4802_remove,
+        .remove         = __devexit_p(bq4802_remove),
 };
 
-module_platform_driver(bq4802_driver);
+static int __init bq4802_init(void)
+{
+        return platform_driver_register(&bq4802_driver);
+}
+
+static void __exit bq4802_exit(void)
+{
+        platform_driver_unregister(&bq4802_driver);
+}
+
+module_init(bq4802_init);
+module_exit(bq4802_exit);
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 16630aa87f4..05beb6c1ca7 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -164,7 +164,7 @@ static inline unsigned char cmos_read_bank2(unsigned char addr)
 static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
 {
         outb(addr, RTC_PORT(2));
-        outb(val, RTC_PORT(3));
+        outb(val, RTC_PORT(2));
 }
 
 #else
@@ -714,7 +714,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                         rtc_cmos_int_handler = cmos_interrupt;
 
                 retval = request_irq(rtc_irq, rtc_cmos_int_handler,
-                                0, dev_name(&cmos_rtc.rtc->dev),
+                                IRQF_DISABLED, dev_name(&cmos_rtc.rtc->dev),
                                 cmos_rtc.rtc);
                 if (retval < 0) {
                         dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
@@ -910,17 +910,14 @@ static inline int cmos_poweroff(struct device *dev)
 
 static u32 rtc_handler(void *context)
 {
-        struct device *dev = context;
-
-        pm_wakeup_event(dev, 0);
         acpi_clear_event(ACPI_EVENT_RTC);
         acpi_disable_event(ACPI_EVENT_RTC, 0);
         return ACPI_INTERRUPT_HANDLED;
 }
 
-static inline void rtc_wake_setup(struct device *dev)
+static inline void rtc_wake_setup(void)
 {
-        acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, dev);
+        acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
         /*
          * After the RTC handler is installed, the Fixed_RTC event should
          * be disabled. Only when the RTC alarm is set will it be enabled.
@@ -947,12 +944,13 @@ static void rtc_wake_off(struct device *dev)
  */
 static struct cmos_rtc_board_info acpi_rtc_info;
 
-static void cmos_wake_setup(struct device *dev)
+static void __devinit
+cmos_wake_setup(struct device *dev)
 {
         if (acpi_disabled)
                 return;
 
-        rtc_wake_setup(dev);
+        rtc_wake_setup();
         acpi_rtc_info.wake_on = rtc_wake_on;
         acpi_rtc_info.wake_off = rtc_wake_off;
 
@@ -979,7 +977,8 @@ static void cmos_wake_setup(struct device *dev)
 
 #else
 
-static void cmos_wake_setup(struct device *dev)
+static void __devinit
+cmos_wake_setup(struct device *dev)
 {
 }
 
@@ -989,7 +988,8 @@ static void cmos_wake_setup(struct device *dev)
 
 #include <linux/pnp.h>
 
-static int cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
+static int __devinit
+cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
 {
         cmos_wake_setup(&pnp->dev);
 
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index c8115b83e5a..80f9c88214c 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -155,10 +155,13 @@ 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_unprepare(rtap->clk);
                 clk_put(rtap->clk);
+                iounmap(rtap->virtbase);
+                release_mem_region(rtap->phybase, rtap->physize);
                 platform_set_drvdata(pdev, NULL);
+                kfree(rtap);
         }
 
         return 0;
@@ -171,43 +174,49 @@ static int __init coh901331_probe(struct platform_device *pdev)
         struct coh901331_port *rtap;
         struct resource *res;
 
-        rtap = devm_kzalloc(&pdev->dev,
-                            sizeof(struct coh901331_port), GFP_KERNEL);
+        rtap = kzalloc(sizeof(struct coh901331_port), GFP_KERNEL);
         if (!rtap)
                 return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -ENOENT;
-
+        if (!res) {
+                ret = -ENOENT;
+                goto out_no_resource;
+        }
         rtap->phybase = res->start;
         rtap->physize = resource_size(res);
 
-        if (devm_request_mem_region(&pdev->dev, rtap->phybase, rtap->physize,
-                                    "rtc-coh901331") == NULL)
-                return -EBUSY;
+        if (request_mem_region(rtap->phybase, rtap->physize,
+                               "rtc-coh901331") == NULL) {
+                ret = -EBUSY;
+                goto out_no_memregion;
+        }
 
-        rtap->virtbase = devm_ioremap(&pdev->dev, rtap->phybase, rtap->physize);
-        if (!rtap->virtbase)
-                return -ENOMEM;
+        rtap->virtbase = ioremap(rtap->phybase, rtap->physize);
+        if (!rtap->virtbase) {
+                ret = -ENOMEM;
+                goto out_no_remap;
+        }
 
         rtap->irq = platform_get_irq(pdev, 0);
-        if (devm_request_irq(&pdev->dev, rtap->irq, coh901331_interrupt, 0,
-                             "RTC COH 901 331 Alarm", rtap))
-                return -EIO;
+        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");
-                return ret;
+                goto out_no_clk;
         }
 
         /* We enable/disable the clock only to assure it works */
-        ret = clk_prepare_enable(rtap->clk);
+        ret = clk_enable(rtap->clk);
         if (ret) {
                 dev_err(&pdev->dev, "could not enable clock\n");
-                goto out_no_clk_prepenable;
+                goto out_no_clk_enable;
         }
         clk_disable(rtap->clk);
 
@@ -223,9 +232,18 @@ static int __init coh901331_probe(struct platform_device *pdev)
 
  out_no_rtc:
         platform_set_drvdata(pdev, NULL);
-        clk_unprepare(rtap->clk);
- out_no_clk_prepenable:
+ 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;
 }
 
@@ -247,7 +265,6 @@ static int coh901331_suspend(struct platform_device *pdev, pm_message_t state)
                 writel(0, rtap->virtbase + COH901331_IRQ_MASK);
                 clk_disable(rtap->clk);
         }
-        clk_unprepare(rtap->clk);
         return 0;
 }
 
@@ -255,7 +272,6 @@ static int coh901331_resume(struct platform_device *pdev)
 {
         struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
 
-        clk_prepare(rtap->clk);
         if (device_may_wakeup(&pdev->dev)) {
                 disable_irq_wake(rtap->irq);
         } else {
@@ -276,7 +292,7 @@ static void coh901331_shutdown(struct platform_device *pdev)
 
         clk_enable(rtap->clk);
         writel(0, rtap->virtbase + COH901331_IRQ_MASK);
-        clk_disable_unprepare(rtap->clk);
+        clk_disable(rtap->clk);
 }
 
 static struct platform_driver coh901331_driver = {
diff --git a/drivers/rtc/rtc-da9052.c b/drivers/rtc/rtc-da9052.c
deleted file mode 100644
index 60b826e520e..00000000000
--- a/drivers/rtc/rtc-da9052.c
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Real time clock driver for DA9052
- *
- * Copyright(c) 2012 Dialog Semiconductor Ltd.
- *
- * Author: Dajun Dajun Chen <dajun.chen@diasemi.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/platform_device.h>
-#include <linux/rtc.h>
-
-#include <linux/mfd/da9052/da9052.h>
-#include <linux/mfd/da9052/reg.h>
-
-#define rtc_err(da9052, fmt, ...) \
-                dev_err(da9052->dev, "%s: " fmt, __func__, ##__VA_ARGS__)
-
-struct da9052_rtc {
-        struct rtc_device *rtc;
-        struct da9052 *da9052;
-        int irq;
-};
-
-static int da9052_rtc_enable_alarm(struct da9052 *da9052, bool enable)
-{
-        int ret;
-        if (enable) {
-                ret = da9052_reg_update(da9052, DA9052_ALARM_Y_REG,
-                                        DA9052_ALARM_Y_ALARM_ON,
-                                        DA9052_ALARM_Y_ALARM_ON);
-                if (ret != 0)
-                        rtc_err(da9052, "Failed to enable ALM: %d\n", ret);
-        } else {
-                ret = da9052_reg_update(da9052, DA9052_ALARM_Y_REG,
-                                        DA9052_ALARM_Y_ALARM_ON, 0);
-                if (ret != 0)
-                        rtc_err(da9052, "Write error: %d\n", ret);
-        }
-        return ret;
-}
-
-static irqreturn_t da9052_rtc_irq(int irq, void *data)
-{
-        struct da9052_rtc *rtc = data;
-        int ret;
-
-        ret = da9052_reg_read(rtc->da9052, DA9052_ALARM_MI_REG);
-        if (ret < 0) {
-                rtc_err(rtc->da9052, "Read error: %d\n", ret);
-                return IRQ_NONE;
-        }
-
-        if (ret & DA9052_ALARMMI_ALARMTYPE) {
-                da9052_rtc_enable_alarm(rtc->da9052, 0);
-                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
-        } else
-                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_PF);
-
-        return IRQ_HANDLED;
-}
-
-static int da9052_read_alarm(struct da9052 *da9052, struct rtc_time *rtc_tm)
-{
-        int ret;
-        uint8_t v[5];
-
-        ret = da9052_group_read(da9052, DA9052_ALARM_MI_REG, 5, v);
-        if (ret != 0) {
-                rtc_err(da9052, "Failed to group read ALM: %d\n", ret);
-                return ret;
-        }
-
-        rtc_tm->tm_year = (v[4] & DA9052_RTC_YEAR) + 100;
-        rtc_tm->tm_mon  = (v[3] & DA9052_RTC_MONTH) - 1;
-        rtc_tm->tm_mday = v[2] & DA9052_RTC_DAY;
-        rtc_tm->tm_hour = v[1] & DA9052_RTC_HOUR;
-        rtc_tm->tm_min  = v[0] & DA9052_RTC_MIN;
-
-        ret = rtc_valid_tm(rtc_tm);
-        if (ret != 0)
-                return ret;
-        return ret;
-}
-
-static int da9052_set_alarm(struct da9052 *da9052, struct rtc_time *rtc_tm)
-{
-        int ret;
-        uint8_t v[3];
-
-        rtc_tm->tm_year -= 100;
-        rtc_tm->tm_mon += 1;
-
-        ret = da9052_reg_update(da9052, DA9052_ALARM_MI_REG,
-                                DA9052_RTC_MIN, rtc_tm->tm_min);
-        if (ret != 0) {
-                rtc_err(da9052, "Failed to write ALRM MIN: %d\n", ret);
-                return ret;
-        }
-
-        v[0] = rtc_tm->tm_hour;
-        v[1] = rtc_tm->tm_mday;
-        v[2] = rtc_tm->tm_mon;
-
-        ret = da9052_group_write(da9052, DA9052_ALARM_H_REG, 3, v);
-        if (ret < 0)
-                return ret;
-
-        ret = da9052_reg_update(da9052, DA9052_ALARM_Y_REG,
-                                DA9052_RTC_YEAR, rtc_tm->tm_year);
-        if (ret != 0)
-                rtc_err(da9052, "Failed to write ALRM YEAR: %d\n", ret);
-
-        return ret;
-}
-
-static int da9052_rtc_get_alarm_status(struct da9052 *da9052)
-{
-        int ret;
-
-        ret = da9052_reg_read(da9052, DA9052_ALARM_Y_REG);
-        if (ret < 0) {
-                rtc_err(da9052, "Failed to read ALM: %d\n", ret);
-                return ret;
-        }
-        ret &= DA9052_ALARM_Y_ALARM_ON;
-        return (ret > 0) ? 1 : 0;
-}
-
-static int da9052_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
-{
-        struct da9052_rtc *rtc = dev_get_drvdata(dev);
-        uint8_t v[6];
-        int ret;
-
-        ret = da9052_group_read(rtc->da9052, DA9052_COUNT_S_REG, 6, v);
-        if (ret < 0) {
-                rtc_err(rtc->da9052, "Failed to read RTC time : %d\n", ret);
-                return ret;
-        }
-
-        rtc_tm->tm_year = (v[5] & DA9052_RTC_YEAR) + 100;
-        rtc_tm->tm_mon  = (v[4] & DA9052_RTC_MONTH) - 1;
-        rtc_tm->tm_mday = v[3] & DA9052_RTC_DAY;
-        rtc_tm->tm_hour = v[2] & DA9052_RTC_HOUR;
-        rtc_tm->tm_min  = v[1] & DA9052_RTC_MIN;
-        rtc_tm->tm_sec  = v[0] & DA9052_RTC_SEC;
-
-        ret = rtc_valid_tm(rtc_tm);
-        if (ret != 0) {
-                rtc_err(rtc->da9052, "rtc_valid_tm failed: %d\n", ret);
-                return ret;
-        }
-
-        return 0;
-}
-
-static int da9052_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        struct da9052_rtc *rtc;
-        uint8_t v[6];
-
-        rtc = dev_get_drvdata(dev);
-
-        v[0] = tm->tm_sec;
-        v[1] = tm->tm_min;
-        v[2] = tm->tm_hour;
-        v[3] = tm->tm_mday;
-        v[4] = tm->tm_mon + 1;
-        v[5] = tm->tm_year - 100;
-
-        return da9052_group_write(rtc->da9052, DA9052_COUNT_S_REG, 6, v);
-}
-
-static int da9052_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        int ret;
-        struct rtc_time *tm = &alrm->time;
-        struct da9052_rtc *rtc = dev_get_drvdata(dev);
-
-        ret = da9052_read_alarm(rtc->da9052, tm);
-
-        if (ret)
-                return ret;
-
-        alrm->enabled = da9052_rtc_get_alarm_status(rtc->da9052);
-
-        return 0;
-}
-
-static int da9052_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        int ret;
-        struct rtc_time *tm = &alrm->time;
-        struct da9052_rtc *rtc = dev_get_drvdata(dev);
-
-        ret = da9052_rtc_enable_alarm(rtc->da9052, 0);
-        if (ret < 0)
-                return ret;
-
-        ret = da9052_set_alarm(rtc->da9052, tm);
-        if (ret)
-                return ret;
-
-        ret = da9052_rtc_enable_alarm(rtc->da9052, 1);
-
-        return ret;
-}
-
-static int da9052_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct da9052_rtc *rtc = dev_get_drvdata(dev);
-
-        return da9052_rtc_enable_alarm(rtc->da9052, enabled);
-}
-
-static const struct rtc_class_ops da9052_rtc_ops = {
-        .read_time      = da9052_rtc_read_time,
-        .set_time       = da9052_rtc_set_time,
-        .read_alarm     = da9052_rtc_read_alarm,
-        .set_alarm      = da9052_rtc_set_alarm,
-        .alarm_irq_enable = da9052_rtc_alarm_irq_enable,
-};
-
-static int da9052_rtc_probe(struct platform_device *pdev)
-{
-        struct da9052_rtc *rtc;
-        int ret;
-
-        rtc = devm_kzalloc(&pdev->dev, sizeof(struct da9052_rtc), GFP_KERNEL);
-        if (!rtc)
-                return -ENOMEM;
-
-        rtc->da9052 = dev_get_drvdata(pdev->dev.parent);
-        platform_set_drvdata(pdev, rtc);
-        rtc->irq = platform_get_irq_byname(pdev, "ALM");
-        ret = request_threaded_irq(rtc->irq, NULL, da9052_rtc_irq,
-                                   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
-                                   "ALM", rtc);
-        if (ret != 0) {
-                rtc_err(rtc->da9052, "irq registration failed: %d\n", ret);
-                return ret;
-        }
-
-        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
-                                       &da9052_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc)) {
-                ret = PTR_ERR(rtc->rtc);
-                goto err_free_irq;
-        }
-
-        return 0;
-
-err_free_irq:
-        free_irq(rtc->irq, rtc);
-        return ret;
-}
-
-static int da9052_rtc_remove(struct platform_device *pdev)
-{
-        struct da9052_rtc *rtc = pdev->dev.platform_data;
-
-        rtc_device_unregister(rtc->rtc);
-        free_irq(rtc->irq, rtc);
-        platform_set_drvdata(pdev, NULL);
-
-        return 0;
-}
-
-static struct platform_driver da9052_rtc_driver = {
-        .probe  = da9052_rtc_probe,
-        .remove = da9052_rtc_remove,
-        .driver = {
-                .name   = "da9052-rtc",
-                .owner  = THIS_MODULE,
-        },
-};
-
-module_platform_driver(da9052_rtc_driver);
-
-MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
-MODULE_DESCRIPTION("RTC driver for Dialog DA9052 PMIC");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:da9052-rtc");
diff --git a/drivers/rtc/rtc-da9055.c b/drivers/rtc/rtc-da9055.c
deleted file mode 100644
index 8f0dcfedb83..00000000000
--- a/drivers/rtc/rtc-da9055.c
+++ /dev/null
@@ -1,413 +0,0 @@
-/*
- * Real time clock driver for DA9055
- *
- * Copyright(c) 2012 Dialog Semiconductor Ltd.
- *
- * Author: Dajun Dajun Chen <dajun.chen@diasemi.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/platform_device.h>
-#include <linux/rtc.h>
-
-#include <linux/mfd/da9055/core.h>
-#include <linux/mfd/da9055/reg.h>
-#include <linux/mfd/da9055/pdata.h>
-
-struct da9055_rtc {
-        struct rtc_device *rtc;
-        struct da9055 *da9055;
-        int alarm_enable;
-};
-
-static int da9055_rtc_enable_alarm(struct da9055_rtc *rtc, bool enable)
-{
-        int ret;
-        if (enable) {
-                ret = da9055_reg_update(rtc->da9055, DA9055_REG_ALARM_Y,
-                                        DA9055_RTC_ALM_EN,
-                                        DA9055_RTC_ALM_EN);
-                if (ret != 0)
-                        dev_err(rtc->da9055->dev, "Failed to enable ALM: %d\n",
-                                ret);
-                rtc->alarm_enable = 1;
-        } else {
-                ret = da9055_reg_update(rtc->da9055, DA9055_REG_ALARM_Y,
-                                        DA9055_RTC_ALM_EN, 0);
-                if (ret != 0)
-                        dev_err(rtc->da9055->dev,
-                                "Failed to disable ALM: %d\n", ret);
-                rtc->alarm_enable = 0;
-        }
-        return ret;
-}
-
-static irqreturn_t da9055_rtc_alm_irq(int irq, void *data)
-{
-        struct da9055_rtc *rtc = data;
-
-        da9055_rtc_enable_alarm(rtc, 0);
-        rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
-
-        return IRQ_HANDLED;
-}
-
-static int da9055_read_alarm(struct da9055 *da9055, struct rtc_time *rtc_tm)
-{
-        int ret;
-        uint8_t v[5];
-
-        ret = da9055_group_read(da9055, DA9055_REG_ALARM_MI, 5, v);
-        if (ret != 0) {
-                dev_err(da9055->dev, "Failed to group read ALM: %d\n", ret);
-                return ret;
-        }
-
-        rtc_tm->tm_year = (v[4] & DA9055_RTC_ALM_YEAR) + 100;
-        rtc_tm->tm_mon  = (v[3] & DA9055_RTC_ALM_MONTH) - 1;
-        rtc_tm->tm_mday = v[2] & DA9055_RTC_ALM_DAY;
-        rtc_tm->tm_hour = v[1] & DA9055_RTC_ALM_HOUR;
-        rtc_tm->tm_min  = v[0] & DA9055_RTC_ALM_MIN;
-
-        return rtc_valid_tm(rtc_tm);
-}
-
-static int da9055_set_alarm(struct da9055 *da9055, struct rtc_time *rtc_tm)
-{
-        int ret;
-        uint8_t v[2];
-
-        rtc_tm->tm_year -= 100;
-        rtc_tm->tm_mon += 1;
-
-        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_MI,
-                                DA9055_RTC_ALM_MIN, rtc_tm->tm_min);
-        if (ret != 0) {
-                dev_err(da9055->dev, "Failed to write ALRM MIN: %d\n", ret);
-                return ret;
-        }
-
-        v[0] = rtc_tm->tm_hour;
-        v[1] = rtc_tm->tm_mday;
-
-        ret = da9055_group_write(da9055, DA9055_REG_ALARM_H, 2, v);
-        if (ret < 0)
-                return ret;
-
-        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_MO,
-                                DA9055_RTC_ALM_MONTH, rtc_tm->tm_mon);
-        if (ret < 0)
-                dev_err(da9055->dev, "Failed to write ALM Month:%d\n", ret);
-
-        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_Y,
-                                DA9055_RTC_ALM_YEAR, rtc_tm->tm_year);
-        if (ret < 0)
-                dev_err(da9055->dev, "Failed to write ALM Year:%d\n", ret);
-
-        return ret;
-}
-
-static int da9055_rtc_get_alarm_status(struct da9055 *da9055)
-{
-        int ret;
-
-        ret = da9055_reg_read(da9055, DA9055_REG_ALARM_Y);
-        if (ret < 0) {
-                dev_err(da9055->dev, "Failed to read ALM: %d\n", ret);
-                return ret;
-        }
-        ret &= DA9055_RTC_ALM_EN;
-        return (ret > 0) ? 1 : 0;
-}
-
-static int da9055_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
-{
-        struct da9055_rtc *rtc = dev_get_drvdata(dev);
-        uint8_t v[6];
-        int ret;
-
-        ret = da9055_reg_read(rtc->da9055, DA9055_REG_COUNT_S);
-        if (ret < 0)
-                return ret;
-
-        /*
-         * Registers are only valid when RTC_READ
-         * status bit is asserted
-         */
-        if (!(ret & DA9055_RTC_READ))
-                return -EBUSY;
-
-        ret = da9055_group_read(rtc->da9055, DA9055_REG_COUNT_S, 6, v);
-        if (ret < 0) {
-                dev_err(rtc->da9055->dev, "Failed to read RTC time : %d\n",
-                        ret);
-                return ret;
-        }
-
-        rtc_tm->tm_year = (v[5] & DA9055_RTC_YEAR) + 100;
-        rtc_tm->tm_mon  = (v[4] & DA9055_RTC_MONTH) - 1;
-        rtc_tm->tm_mday = v[3] & DA9055_RTC_DAY;
-        rtc_tm->tm_hour = v[2] & DA9055_RTC_HOUR;
-        rtc_tm->tm_min  = v[1] & DA9055_RTC_MIN;
-        rtc_tm->tm_sec  = v[0] & DA9055_RTC_SEC;
-
-        return rtc_valid_tm(rtc_tm);
-}
-
-static int da9055_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        struct da9055_rtc *rtc;
-        uint8_t v[6];
-
-        rtc = dev_get_drvdata(dev);
-
-        v[0] = tm->tm_sec;
-        v[1] = tm->tm_min;
-        v[2] = tm->tm_hour;
-        v[3] = tm->tm_mday;
-        v[4] = tm->tm_mon + 1;
-        v[5] = tm->tm_year - 100;
-
-        return da9055_group_write(rtc->da9055, DA9055_REG_COUNT_S, 6, v);
-}
-
-static int da9055_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        int ret;
-        struct rtc_time *tm = &alrm->time;
-        struct da9055_rtc *rtc = dev_get_drvdata(dev);
-
-        ret = da9055_read_alarm(rtc->da9055, tm);
-
-        if (ret)
-                return ret;
-
-        alrm->enabled = da9055_rtc_get_alarm_status(rtc->da9055);
-
-        return 0;
-}
-
-static int da9055_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        int ret;
-        struct rtc_time *tm = &alrm->time;
-        struct da9055_rtc *rtc = dev_get_drvdata(dev);
-
-        ret = da9055_rtc_enable_alarm(rtc, 0);
-        if (ret < 0)
-                return ret;
-
-        ret = da9055_set_alarm(rtc->da9055, tm);
-        if (ret)
-                return ret;
-
-        ret = da9055_rtc_enable_alarm(rtc, 1);
-
-        return ret;
-}
-
-static int da9055_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct da9055_rtc *rtc = dev_get_drvdata(dev);
-
-        return da9055_rtc_enable_alarm(rtc, enabled);
-}
-
-static const struct rtc_class_ops da9055_rtc_ops = {
-        .read_time      = da9055_rtc_read_time,
-        .set_time       = da9055_rtc_set_time,
-        .read_alarm     = da9055_rtc_read_alarm,
-        .set_alarm      = da9055_rtc_set_alarm,
-        .alarm_irq_enable = da9055_rtc_alarm_irq_enable,
-};
-
-static int da9055_rtc_device_init(struct da9055 *da9055,
-                                        struct da9055_pdata *pdata)
-{
-        int ret;
-
-        /* Enable RTC and the internal Crystal */
-        ret = da9055_reg_update(da9055, DA9055_REG_CONTROL_B,
-                                DA9055_RTC_EN, DA9055_RTC_EN);
-        if (ret < 0)
-                return ret;
-        ret = da9055_reg_update(da9055, DA9055_REG_EN_32K,
-                                DA9055_CRYSTAL_EN, DA9055_CRYSTAL_EN);
-        if (ret < 0)
-                return ret;
-
-        /* Enable RTC in Power Down mode */
-        ret = da9055_reg_update(da9055, DA9055_REG_CONTROL_B,
-                                DA9055_RTC_MODE_PD, DA9055_RTC_MODE_PD);
-        if (ret < 0)
-                return ret;
-
-        /* Enable RTC in Reset mode */
-        if (pdata && pdata->reset_enable) {
-                ret = da9055_reg_update(da9055, DA9055_REG_CONTROL_B,
-                                        DA9055_RTC_MODE_SD,
-                                        DA9055_RTC_MODE_SD <<
-                                        DA9055_RTC_MODE_SD_SHIFT);
-                if (ret < 0)
-                        return ret;
-        }
-
-        /* Disable the RTC TICK ALM */
-        ret = da9055_reg_update(da9055, DA9055_REG_ALARM_MO,
-                                DA9055_RTC_TICK_WAKE_MASK, 0);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static int da9055_rtc_probe(struct platform_device *pdev)
-{
-        struct da9055_rtc *rtc;
-        struct da9055_pdata *pdata = NULL;
-        int ret, alm_irq;
-
-        rtc = devm_kzalloc(&pdev->dev, sizeof(struct da9055_rtc), GFP_KERNEL);
-        if (!rtc)
-                return -ENOMEM;
-
-        rtc->da9055 = dev_get_drvdata(pdev->dev.parent);
-        pdata = rtc->da9055->dev->platform_data;
-        platform_set_drvdata(pdev, rtc);
-
-        ret = da9055_rtc_device_init(rtc->da9055, pdata);
-        if (ret < 0)
-                goto err_rtc;
-
-        ret = da9055_reg_read(rtc->da9055, DA9055_REG_ALARM_Y);
-        if (ret < 0)
-                goto err_rtc;
-
-        if (ret & DA9055_RTC_ALM_EN)
-                rtc->alarm_enable = 1;
-
-        device_init_wakeup(&pdev->dev, 1);
-
-        rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
-                                        &da9055_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc)) {
-                ret = PTR_ERR(rtc->rtc);
-                goto err_rtc;
-        }
-
-        alm_irq = platform_get_irq_byname(pdev, "ALM");
-        alm_irq = regmap_irq_get_virq(rtc->da9055->irq_data, alm_irq);
-        ret = devm_request_threaded_irq(&pdev->dev, alm_irq, NULL,
-                                        da9055_rtc_alm_irq,
-                                        IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
-                                        "ALM", rtc);
-        if (ret != 0)
-                dev_err(rtc->da9055->dev, "irq registration failed: %d\n", ret);
-
-err_rtc:
-        return ret;
-
-}
-
-static int da9055_rtc_remove(struct platform_device *pdev)
-{
-        struct da9055_rtc *rtc = pdev->dev.platform_data;
-
-        rtc_device_unregister(rtc->rtc);
-        platform_set_drvdata(pdev, NULL);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-/* Turn off the alarm if it should not be a wake source. */
-static int da9055_rtc_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct da9055_rtc *rtc = dev_get_drvdata(&pdev->dev);
-        int ret;
-
-        if (!device_may_wakeup(&pdev->dev)) {
-                /* Disable the ALM IRQ */
-                ret = da9055_rtc_enable_alarm(rtc, 0);
-                if (ret < 0)
-                        dev_err(&pdev->dev, "Failed to disable RTC ALM\n");
-        }
-
-        return 0;
-}
-
-/* Enable the alarm if it should be enabled (in case it was disabled to
- * prevent use as a wake source).
- */
-static int da9055_rtc_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct da9055_rtc *rtc = dev_get_drvdata(&pdev->dev);
-        int ret;
-
-        if (!device_may_wakeup(&pdev->dev)) {
-                if (rtc->alarm_enable) {
-                        ret = da9055_rtc_enable_alarm(rtc, 1);
-                        if (ret < 0)
-                                dev_err(&pdev->dev,
-                                        "Failed to restart RTC ALM\n");
-                }
-        }
-
-        return 0;
-}
-
-/* Unconditionally disable the alarm */
-static int da9055_rtc_freeze(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct da9055_rtc *rtc = dev_get_drvdata(&pdev->dev);
-        int ret;
-
-        ret = da9055_rtc_enable_alarm(rtc, 0);
-        if (ret < 0)
-                dev_err(&pdev->dev, "Failed to freeze RTC ALMs\n");
-
-        return 0;
-
-}
-#else
-#define da9055_rtc_suspend NULL
-#define da9055_rtc_resume NULL
-#define da9055_rtc_freeze NULL
-#endif
-
-static const struct dev_pm_ops da9055_rtc_pm_ops = {
-        .suspend = da9055_rtc_suspend,
-        .resume = da9055_rtc_resume,
-
-        .freeze = da9055_rtc_freeze,
-        .thaw = da9055_rtc_resume,
-        .restore = da9055_rtc_resume,
-
-        .poweroff = da9055_rtc_suspend,
-};
-
-static struct platform_driver da9055_rtc_driver = {
-        .probe  = da9055_rtc_probe,
-        .remove = da9055_rtc_remove,
-        .driver = {
-                .name   = "da9055-rtc",
-                .owner  = THIS_MODULE,
-                .pm = &da9055_rtc_pm_ops,
-        },
-};
-
-module_platform_driver(da9055_rtc_driver);
-
-MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
-MODULE_DESCRIPTION("RTC driver for Dialog DA9055 PMIC");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:da9055-rtc");
diff --git a/drivers/rtc/rtc-davinci.c b/drivers/rtc/rtc-davinci.c
index 5f7982f7c1b..755e1fe914a 100644
--- a/drivers/rtc/rtc-davinci.c
+++ b/drivers/rtc/rtc-davinci.c
@@ -485,7 +485,7 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
         struct resource *res, *mem;
         int ret = 0;
 
-        davinci_rtc = devm_kzalloc(&pdev->dev, sizeof(struct davinci_rtc), GFP_KERNEL);
+        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;
@@ -494,13 +494,15 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
         davinci_rtc->irq = platform_get_irq(pdev, 0);
         if (davinci_rtc->irq < 0) {
                 dev_err(dev, "no RTC irq\n");
-                return davinci_rtc->irq;
+                ret = davinci_rtc->irq;
+                goto fail1;
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 dev_err(dev, "no mem resource\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto fail1;
         }
 
         davinci_rtc->pbase = res->start;
@@ -511,7 +513,8 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
         if (!mem) {
                 dev_err(dev, "RTC registers at %08x are not free\n",
                         davinci_rtc->pbase);
-                return -EBUSY;
+                ret = -EBUSY;
+                goto fail1;
         }
 
         davinci_rtc->base = ioremap(davinci_rtc->pbase, davinci_rtc->base_size);
@@ -526,9 +529,8 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
         davinci_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
                                     &davinci_rtc_ops, THIS_MODULE);
         if (IS_ERR(davinci_rtc->rtc)) {
-                ret = PTR_ERR(davinci_rtc->rtc);
-                dev_err(dev, "unable to register RTC device, err %d\n",
-                                ret);
+                dev_err(dev, "unable to register RTC device, err %ld\n",
+                                PTR_ERR(davinci_rtc->rtc));
                 goto fail3;
         }
 
@@ -540,7 +542,7 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
         rtcss_write(davinci_rtc, 0, PRTCSS_RTC_CCTRL);
 
         ret = request_irq(davinci_rtc->irq, davinci_rtc_interrupt,
-                          0, "davinci_rtc", davinci_rtc);
+                          IRQF_DISABLED, "davinci_rtc", davinci_rtc);
         if (ret < 0) {
                 dev_err(dev, "unable to register davinci RTC interrupt\n");
                 goto fail4;
@@ -564,10 +566,13 @@ fail3:
         iounmap(davinci_rtc->base);
 fail2:
         release_mem_region(davinci_rtc->pbase, davinci_rtc->base_size);
+fail1:
+        kfree(davinci_rtc);
+
         return ret;
 }
 
-static int davinci_rtc_remove(struct platform_device *pdev)
+static int __devexit davinci_rtc_remove(struct platform_device *pdev)
 {
         struct davinci_rtc *davinci_rtc = platform_get_drvdata(pdev);
 
@@ -584,12 +589,14 @@ static int davinci_rtc_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
+        kfree(davinci_rtc);
+
         return 0;
 }
 
 static struct platform_driver davinci_rtc_driver = {
         .probe          = davinci_rtc_probe,
-        .remove         = davinci_rtc_remove,
+        .remove         = __devexit_p(davinci_rtc_remove),
         .driver         = {
                 .name = "rtc_davinci",
                 .owner = THIS_MODULE,
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 9a86b4bd869..cace6d3aed9 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -379,6 +379,25 @@ static long rtc_dev_ioctl(struct file *file,
                 err = put_user(rtc->irq_freq, (unsigned long __user *)uarg);
                 break;
 
+#if 0
+        case RTC_EPOCH_SET:
+#ifndef rtc_epoch
+                /*
+                 * There were no RTC clocks before 1900.
+                 */
+                if (arg < 1900) {
+                        err = -EINVAL;
+                        break;
+                }
+                rtc_epoch = arg;
+                err = 0;
+#endif
+                break;
+
+        case RTC_EPOCH_READ:
+                err = put_user(rtc_epoch, (unsigned long __user *)uarg);
+                break;
+#endif
         case RTC_WKALM_SET:
                 mutex_unlock(&rtc->ops_lock);
                 if (copy_from_user(&alarm, uarg, sizeof(alarm)))
diff --git a/drivers/rtc/rtc-dm355evm.c b/drivers/rtc/rtc-dm355evm.c
index b2ed2c94b08..58d4e18530d 100644
--- a/drivers/rtc/rtc-dm355evm.c
+++ b/drivers/rtc/rtc-dm355evm.c
@@ -14,7 +14,6 @@
 #include <linux/platform_device.h>
 
 #include <linux/i2c/dm355evm_msp.h>
-#include <linux/module.h>
 
 
 /*
@@ -123,7 +122,7 @@ static struct rtc_class_ops dm355evm_rtc_ops = {
 
 /*----------------------------------------------------------------------*/
 
-static int dm355evm_rtc_probe(struct platform_device *pdev)
+static int __devinit dm355evm_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
 
@@ -139,7 +138,7 @@ static int dm355evm_rtc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int dm355evm_rtc_remove(struct platform_device *pdev)
+static int __devexit dm355evm_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device *rtc = platform_get_drvdata(pdev);
 
@@ -154,13 +153,23 @@ static int dm355evm_rtc_remove(struct platform_device *pdev)
  */
 static struct platform_driver rtc_dm355evm_driver = {
         .probe          = dm355evm_rtc_probe,
-        .remove         = dm355evm_rtc_remove,
+        .remove         = __devexit_p(dm355evm_rtc_remove),
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = "rtc-dm355evm",
         },
 };
 
-module_platform_driver(rtc_dm355evm_driver);
+static int __init dm355evm_rtc_init(void)
+{
+        return platform_driver_register(&rtc_dm355evm_driver);
+}
+module_init(dm355evm_rtc_init);
+
+static void __exit dm355evm_rtc_exit(void)
+{
+        platform_driver_unregister(&rtc_dm355evm_driver);
+}
+module_exit(dm355evm_rtc_exit);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1286.c b/drivers/rtc/rtc-ds1286.c
index d989412a348..68e6caf2549 100644
--- a/drivers/rtc/rtc-ds1286.c
+++ b/drivers/rtc/rtc-ds1286.c
@@ -329,7 +329,7 @@ static const struct rtc_class_ops ds1286_ops = {
         .alarm_irq_enable = ds1286_alarm_irq_enable,
 };
 
-static int ds1286_probe(struct platform_device *pdev)
+static int __devinit ds1286_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         struct resource *res;
@@ -376,7 +376,7 @@ out:
         return ret;
 }
 
-static int ds1286_remove(struct platform_device *pdev)
+static int __devexit ds1286_remove(struct platform_device *pdev)
 {
         struct ds1286_priv *priv = platform_get_drvdata(pdev);
 
@@ -393,13 +393,24 @@ static struct platform_driver ds1286_platform_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = ds1286_probe,
-        .remove         = ds1286_remove,
+        .remove         = __devexit_p(ds1286_remove),
 };
 
-module_platform_driver(ds1286_platform_driver);
+static int __init ds1286_init(void)
+{
+        return platform_driver_register(&ds1286_platform_driver);
+}
+
+static void __exit ds1286_exit(void)
+{
+        platform_driver_unregister(&ds1286_platform_driver);
+}
 
 MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
 MODULE_DESCRIPTION("DS1286 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 MODULE_ALIAS("platform:rtc-ds1286");
+
+module_init(ds1286_init);
+module_exit(ds1286_exit);
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index fdbcdb289d6..f0d63892264 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -234,7 +234,7 @@ static int __init ds1302_rtc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int ds1302_rtc_remove(struct platform_device *pdev)
+static int __devexit ds1302_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device *rtc = platform_get_drvdata(pdev);
 
@@ -249,7 +249,7 @@ static struct platform_driver ds1302_platform_driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
         },
-        .remove         = ds1302_rtc_remove,
+        .remove         = __devexit_p(ds1302_rtc_remove),
 };
 
 static int __init ds1302_rtc_init(void)
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index d578773f5ce..57fbcc149ba 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -17,7 +17,6 @@
 
 #include <linux/spi/spi.h>
 #include <linux/spi/ds1305.h>
-#include <linux/module.h>
 
 
 /*
@@ -601,7 +600,7 @@ static struct bin_attribute nvram = {
  * Interface to SPI stack
  */
 
-static int ds1305_probe(struct spi_device *spi)
+static int __devinit ds1305_probe(struct spi_device *spi)
 {
         struct ds1305                   *ds1305;
         int                             status;
@@ -787,7 +786,7 @@ fail0:
         return status;
 }
 
-static int ds1305_remove(struct spi_device *spi)
+static int __devexit ds1305_remove(struct spi_device *spi)
 {
         struct ds1305 *ds1305 = spi_get_drvdata(spi);
 
@@ -810,11 +809,21 @@ static struct spi_driver ds1305_driver = {
         .driver.name    = "rtc-ds1305",
         .driver.owner   = THIS_MODULE,
         .probe          = ds1305_probe,
-        .remove         = ds1305_remove,
+        .remove         = __devexit_p(ds1305_remove),
         /* REVISIT add suspend/resume */
 };
 
-module_spi_driver(ds1305_driver);
+static int __init ds1305_init(void)
+{
+        return spi_register_driver(&ds1305_driver);
+}
+module_init(ds1305_init);
+
+static void __exit ds1305_exit(void)
+{
+        spi_unregister_driver(&ds1305_driver);
+}
+module_exit(ds1305_exit);
 
 MODULE_DESCRIPTION("RTC driver for DS1305 and DS1306 chips");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index e0d0ba4de03..b2005b44e4f 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -17,10 +17,10 @@
 #include <linux/string.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
-#include <linux/rtc/ds1307.h>
 
-/*
- * We can't determine type by probing, but if we expect pre-Linux code
+
+
+/* We can't determine type by probing, but if we expect pre-Linux code
  * to have set the chip up as a clock (turning on the oscillator and
  * setting the date and time), Linux can ignore the non-clock features.
  * That's a natural job for a factory or repair bench.
@@ -34,10 +34,8 @@ enum ds_type {
         ds_1388,
         ds_3231,
         m41t00,
-        mcp7941x,
         rx_8025,
-        last_ds_type /* always last */
-        /* rs5c372 too?  different address... */
+        // rs5c372 too?  different address...
 };
 
 
@@ -45,7 +43,6 @@ enum ds_type {
 #define DS1307_REG_SECS         0x00    /* 00-59 */
 #       define DS1307_BIT_CH            0x80
 #       define DS1340_BIT_nEOSC         0x80
-#       define MCP7941X_BIT_ST          0x80
 #define DS1307_REG_MIN          0x01    /* 00-59 */
 #define DS1307_REG_HOUR         0x02    /* 00-23, or 1-12{am,pm} */
 #       define DS1307_BIT_12HR          0x40    /* in REG_HOUR */
@@ -53,14 +50,12 @@ enum ds_type {
 #       define DS1340_BIT_CENTURY_EN    0x80    /* in REG_HOUR */
 #       define DS1340_BIT_CENTURY       0x40    /* in REG_HOUR */
 #define DS1307_REG_WDAY         0x03    /* 01-07 */
-#       define MCP7941X_BIT_VBATEN      0x08
 #define DS1307_REG_MDAY         0x04    /* 01-31 */
 #define DS1307_REG_MONTH        0x05    /* 01-12 */
 #       define DS1337_BIT_CENTURY       0x80    /* in REG_MONTH */
 #define DS1307_REG_YEAR         0x06    /* 00-99 */
 
-/*
- * Other registers (control, status, alarms, trickle charge, NVRAM, etc)
+/* Other registers (control, status, alarms, trickle charge, NVRAM, etc)
  * start at 7, and they differ a LOT. Only control and status matter for
  * basic RTC date and time functionality; be careful using them.
  */
@@ -91,8 +86,7 @@ enum ds_type {
 #       define DS1337_BIT_A2I           0x02
 #       define DS1337_BIT_A1I           0x01
 #define DS1339_REG_ALARM1_SECS  0x07
-
-#define DS13XX_TRICKLE_CHARGER_MAGIC    0xa0
+#define DS1339_REG_TRICKLE      0x10
 
 #define RX8025_REG_CTRL1        0x0e
 #       define RX8025_BIT_2412          0x20
@@ -105,8 +99,6 @@ enum ds_type {
 struct ds1307 {
         u8                      offset; /* register's offset */
         u8                      regs[11];
-        u16                     nvram_offset;
-        struct bin_attribute    *nvram;
         enum ds_type            type;
         unsigned long           flags;
 #define HAS_NVRAM       0               /* bit 0 == sysfs file active */
@@ -121,43 +113,32 @@ struct ds1307 {
 };
 
 struct chip_desc {
+        unsigned                nvram56:1;
         unsigned                alarm:1;
-        u16                     nvram_offset;
-        u16                     nvram_size;
-        u16                     trickle_charger_reg;
 };
 
-static const struct chip_desc chips[last_ds_type] = {
-        [ds_1307] = {
-                .nvram_offset   = 8,
-                .nvram_size     = 56,
-        },
-        [ds_1337] = {
-                .alarm          = 1,
-        },
-        [ds_1338] = {
-                .nvram_offset   = 8,
-                .nvram_size     = 56,
-        },
-        [ds_1339] = {
-                .alarm          = 1,
-                .trickle_charger_reg = 0x10,
-        },
-        [ds_1340] = {
-                .trickle_charger_reg = 0x08,
-        },
-        [ds_1388] = {
-                .trickle_charger_reg = 0x0a,
-        },
-        [ds_3231] = {
-                .alarm          = 1,
-        },
-        [mcp7941x] = {
-                /* this is battery backed SRAM */
-                .nvram_offset   = 0x20,
-                .nvram_size     = 0x40,
-        },
-};
+static const struct chip_desc chips[] = {
+[ds_1307] = {
+        .nvram56        = 1,
+},
+[ds_1337] = {
+        .alarm          = 1,
+},
+[ds_1338] = {
+        .nvram56        = 1,
+},
+[ds_1339] = {
+        .alarm          = 1,
+},
+[ds_1340] = {
+},
+[ds_3231] = {
+        .alarm          = 1,
+},
+[m41t00] = {
+},
+[rx_8025] = {
+}, };
 
 static const struct i2c_device_id ds1307_id[] = {
         { "ds1307", ds_1307 },
@@ -168,7 +149,6 @@ static const struct i2c_device_id ds1307_id[] = {
         { "ds1340", ds_1340 },
         { "ds3231", ds_3231 },
         { "m41t00", m41t00 },
-        { "mcp7941x", mcp7941x },
         { "pt7c4338", ds_1307 },
         { "rx8025", rx_8025 },
         { }
@@ -385,15 +365,6 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
                 buf[DS1307_REG_HOUR] |= DS1340_BIT_CENTURY_EN
                                 | DS1340_BIT_CENTURY;
                 break;
-        case mcp7941x:
-                /*
-                 * these bits were cleared when preparing the date/time
-                 * values and need to be set again before writing the
-                 * buffer out to the device.
-                 */
-                buf[DS1307_REG_SECS] |= MCP7941X_BIT_ST;
-                buf[DS1307_REG_WDAY] |= MCP7941X_BIT_VBATEN;
-                break;
         default:
                 break;
         }
@@ -436,8 +407,7 @@ static int ds1337_read_alarm(struct device *dev, struct rtc_wkalrm *t)
                         ds1307->regs[6], ds1307->regs[7],
                         ds1307->regs[8]);
 
-        /*
-         * report alarm time (ALARM1); assume 24 hour and day-of-month modes,
+        /* report alarm time (ALARM1); assume 24 hour and day-of-month modes,
          * and that all four fields are checked matches
          */
         t->time.tm_sec = bcd2bin(ds1307->regs[0] & 0x7f);
@@ -465,7 +435,7 @@ static int ds1337_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 
 static int ds1337_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
-        struct i2c_client       *client = to_i2c_client(dev);
+        struct i2c_client       *client = to_i2c_client(dev);
         struct ds1307           *ds1307 = i2c_get_clientdata(client);
         unsigned char           *buf = ds1307->regs;
         u8                      control, status;
@@ -561,6 +531,8 @@ static const struct rtc_class_ops ds13xx_rtc_ops = {
 
 /*----------------------------------------------------------------------*/
 
+#define NVRAM_SIZE      56
+
 static ssize_t
 ds1307_nvram_read(struct file *filp, struct kobject *kobj,
                 struct bin_attribute *attr,
@@ -573,15 +545,14 @@ ds1307_nvram_read(struct file *filp, struct kobject *kobj,
         client = kobj_to_i2c_client(kobj);
         ds1307 = i2c_get_clientdata(client);
 
-        if (unlikely(off >= ds1307->nvram->size))
+        if (unlikely(off >= NVRAM_SIZE))
                 return 0;
-        if ((off + count) > ds1307->nvram->size)
-                count = ds1307->nvram->size - off;
+        if ((off + count) > NVRAM_SIZE)
+                count = NVRAM_SIZE - off;
         if (unlikely(!count))
                 return count;
 
-        result = ds1307->read_block_data(client, ds1307->nvram_offset + off,
-                                                                count, buf);
+        result = ds1307->read_block_data(client, 8 + off, count, buf);
         if (result < 0)
                 dev_err(&client->dev, "%s error %d\n", "nvram read", result);
         return result;
@@ -599,15 +570,14 @@ ds1307_nvram_write(struct file *filp, struct kobject *kobj,
         client = kobj_to_i2c_client(kobj);
         ds1307 = i2c_get_clientdata(client);
 
-        if (unlikely(off >= ds1307->nvram->size))
+        if (unlikely(off >= NVRAM_SIZE))
                 return -EFBIG;
-        if ((off + count) > ds1307->nvram->size)
-                count = ds1307->nvram->size - off;
+        if ((off + count) > NVRAM_SIZE)
+                count = NVRAM_SIZE - off;
         if (unlikely(!count))
                 return count;
 
-        result = ds1307->write_block_data(client, ds1307->nvram_offset + off,
-                                                                count, buf);
+        result = ds1307->write_block_data(client, 8 + off, count, buf);
         if (result < 0) {
                 dev_err(&client->dev, "%s error %d\n", "nvram write", result);
                 return result;
@@ -615,10 +585,23 @@ ds1307_nvram_write(struct file *filp, struct kobject *kobj,
         return count;
 }
 
+static struct bin_attribute nvram = {
+        .attr = {
+                .name   = "nvram",
+                .mode   = S_IRUGO | S_IWUSR,
+        },
+
+        .read   = ds1307_nvram_read,
+        .write  = ds1307_nvram_write,
+        .size   = NVRAM_SIZE,
+};
+
 /*----------------------------------------------------------------------*/
 
-static int ds1307_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id)
+static struct i2c_driver ds1307_driver;
+
+static int __devinit ds1307_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
 {
         struct ds1307           *ds1307;
         int                     err = -ENODEV;
@@ -627,7 +610,6 @@ static int ds1307_probe(struct i2c_client *client,
         struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
         int                     want_irq = false;
         unsigned char           *buf;
-        struct ds1307_platform_data *pdata = client->dev.platform_data;
         static const int        bbsqi_bitpos[] = {
                 [ds_1337] = 0,
                 [ds_1339] = DS1339_BIT_BBSQI,
@@ -638,18 +620,14 @@ static int ds1307_probe(struct i2c_client *client,
             && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
                 return -EIO;
 
-        ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL);
-        if (!ds1307)
+        if (!(ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL)))
                 return -ENOMEM;
 
         i2c_set_clientdata(client, ds1307);
 
         ds1307->client  = client;
         ds1307->type    = id->driver_data;
-
-        if (pdata && pdata->trickle_charger_setup && chip->trickle_charger_reg)
-                i2c_smbus_write_byte_data(client, chip->trickle_charger_reg,
-                        DS13XX_TRICKLE_CHARGER_MAGIC | pdata->trickle_charger_setup);
+        ds1307->offset  = 0;
 
         buf = ds1307->regs;
         if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
@@ -664,6 +642,11 @@ static int ds1307_probe(struct i2c_client *client,
         case ds_1337:
         case ds_1339:
         case ds_3231:
+                /* has IRQ? */
+                if (ds1307->client->irq > 0 && chip->alarm) {
+                        INIT_WORK(&ds1307->work, ds1307_work);
+                        want_irq = true;
+                }
                 /* get registers that the "rtc" read below won't read... */
                 tmp = ds1307->read_block_data(ds1307->client,
                                 DS1337_REG_CONTROL, 2, buf);
@@ -677,19 +660,14 @@ static int ds1307_probe(struct i2c_client *client,
                 if (ds1307->regs[0] & DS1337_BIT_nEOSC)
                         ds1307->regs[0] &= ~DS1337_BIT_nEOSC;
 
-                /*
-                 * Using IRQ?  Disable the square wave and both alarms.
+                /* Using IRQ?  Disable the square wave and both alarms.
                  * For some variants, be sure alarms can trigger when we're
                  * running on Vbackup (BBSQI/BBSQW)
                  */
-                if (ds1307->client->irq > 0 && chip->alarm) {
-                        INIT_WORK(&ds1307->work, ds1307_work);
-
+                if (want_irq) {
                         ds1307->regs[0] |= DS1337_BIT_INTCN
                                         | bbsqi_bitpos[ds1307->type];
                         ds1307->regs[0] &= ~(DS1337_BIT_A2IE | DS1337_BIT_A1IE);
-
-                        want_irq = true;
                 }
 
                 i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL,
@@ -784,8 +762,7 @@ read_rtc:
                 goto exit_free;
         }
 
-        /*
-         * minimal sanity checking; some chips (like DS1340) don't
+        /* minimal sanity checking; some chips (like DS1340) don't
          * specify the extra bits as must-be-zero, but there are
          * still a few values that are clearly out-of-range.
          */
@@ -832,24 +809,11 @@ read_rtc:
                         dev_warn(&client->dev, "SET TIME!\n");
                 }
                 break;
-        case mcp7941x:
-                /* make sure that the backup battery is enabled */
-                if (!(ds1307->regs[DS1307_REG_WDAY] & MCP7941X_BIT_VBATEN)) {
-                        i2c_smbus_write_byte_data(client, DS1307_REG_WDAY,
-                                        ds1307->regs[DS1307_REG_WDAY]
-                                        | MCP7941X_BIT_VBATEN);
-                }
-
-                /* clock halted?  turn it on, so clock can tick. */
-                if (!(tmp & MCP7941X_BIT_ST)) {
-                        i2c_smbus_write_byte_data(client, DS1307_REG_SECS,
-                                        MCP7941X_BIT_ST);
-                        dev_warn(&client->dev, "SET TIME!\n");
-                        goto read_rtc;
-                }
-
-                break;
-        default:
+        case rx_8025:
+        case ds_1337:
+        case ds_1339:
+        case ds_1388:
+        case ds_3231:
                 break;
         }
 
@@ -857,8 +821,7 @@ read_rtc:
         switch (ds1307->type) {
         case ds_1340:
         case m41t00:
-                /*
-                 * NOTE: ignores century bits; fix before deploying
+                /* NOTE: ignores century bits; fix before deploying
                  * systems that will run through year 2100.
                  */
                 break;
@@ -868,8 +831,7 @@ read_rtc:
                 if (!(tmp & DS1307_BIT_12HR))
                         break;
 
-                /*
-                 * Be sure we're in 24 hour mode.  Multi-master systems
+                /* Be sure we're in 24 hour mode.  Multi-master systems
                  * take note...
                  */
                 tmp = bcd2bin(tmp & 0x1f);
@@ -905,32 +867,16 @@ read_rtc:
                 dev_dbg(&client->dev, "got IRQ %d\n", client->irq);
         }
 
-        if (chip->nvram_size) {
-                ds1307->nvram = kzalloc(sizeof(struct bin_attribute),
-                                                        GFP_KERNEL);
-                if (!ds1307->nvram) {
-                        err = -ENOMEM;
-                        goto exit_nvram;
-                }
-                ds1307->nvram->attr.name = "nvram";
-                ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
-                sysfs_bin_attr_init(ds1307->nvram);
-                ds1307->nvram->read = ds1307_nvram_read,
-                ds1307->nvram->write = ds1307_nvram_write,
-                ds1307->nvram->size = chip->nvram_size;
-                ds1307->nvram_offset = chip->nvram_offset;
-                err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram);
-                if (err) {
-                        kfree(ds1307->nvram);
-                        goto exit_nvram;
+        if (chip->nvram56) {
+                err = sysfs_create_bin_file(&client->dev.kobj, &nvram);
+                if (err == 0) {
+                        set_bit(HAS_NVRAM, &ds1307->flags);
+                        dev_info(&client->dev, "56 bytes nvram\n");
                 }
-                set_bit(HAS_NVRAM, &ds1307->flags);
-                dev_info(&client->dev, "%zu bytes nvram\n", ds1307->nvram->size);
         }
 
         return 0;
 
-exit_nvram:
 exit_irq:
         rtc_device_unregister(ds1307->rtc);
 exit_free:
@@ -938,19 +884,17 @@ exit_free:
         return err;
 }
 
-static int ds1307_remove(struct i2c_client *client)
+static int __devexit ds1307_remove(struct i2c_client *client)
 {
-        struct ds1307 *ds1307 = i2c_get_clientdata(client);
+        struct ds1307           *ds1307 = i2c_get_clientdata(client);
 
         if (test_and_clear_bit(HAS_ALARM, &ds1307->flags)) {
                 free_irq(client->irq, client);
                 cancel_work_sync(&ds1307->work);
         }
 
-        if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags)) {
-                sysfs_remove_bin_file(&client->dev.kobj, ds1307->nvram);
-                kfree(ds1307->nvram);
-        }
+        if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags))
+                sysfs_remove_bin_file(&client->dev.kobj, &nvram);
 
         rtc_device_unregister(ds1307->rtc);
         kfree(ds1307);
@@ -963,11 +907,21 @@ static struct i2c_driver ds1307_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = ds1307_probe,
-        .remove         = ds1307_remove,
+        .remove         = __devexit_p(ds1307_remove),
         .id_table       = ds1307_id,
 };
 
-module_i2c_driver(ds1307_driver);
+static int __init ds1307_init(void)
+{
+        return i2c_add_driver(&ds1307_driver);
+}
+module_init(ds1307_init);
+
+static void __exit ds1307_exit(void)
+{
+        i2c_del_driver(&ds1307_driver);
+}
+module_exit(ds1307_exit);
 
 MODULE_DESCRIPTION("RTC driver for DS1307 and similar chips");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index fef76868aae..e6e71deb188 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -391,7 +391,7 @@ out_free:
         return ret;
 }
 
-static int ds1374_remove(struct i2c_client *client)
+static int __devexit ds1374_remove(struct i2c_client *client)
 {
         struct ds1374 *ds1374 = i2c_get_clientdata(client);
 
@@ -442,11 +442,22 @@ static struct i2c_driver ds1374_driver = {
                 .pm = DS1374_PM,
         },
         .probe = ds1374_probe,
-        .remove = ds1374_remove,
+        .remove = __devexit_p(ds1374_remove),
         .id_table = ds1374_id,
 };
 
-module_i2c_driver(ds1374_driver);
+static int __init ds1374_init(void)
+{
+        return i2c_add_driver(&ds1374_driver);
+}
+
+static void __exit ds1374_exit(void)
+{
+        i2c_del_driver(&ds1374_driver);
+}
+
+module_init(ds1374_init);
+module_exit(ds1374_exit);
 
 MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>");
 MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
diff --git a/drivers/rtc/rtc-ds1390.c b/drivers/rtc/rtc-ds1390.c
index f994257981a..b038d2cfef2 100644
--- a/drivers/rtc/rtc-ds1390.c
+++ b/drivers/rtc/rtc-ds1390.c
@@ -121,7 +121,7 @@ static const struct rtc_class_ops ds1390_rtc_ops = {
         .set_time       = ds1390_set_time,
 };
 
-static int ds1390_probe(struct spi_device *spi)
+static int __devinit ds1390_probe(struct spi_device *spi)
 {
         unsigned char tmp;
         struct ds1390 *chip;
@@ -156,7 +156,7 @@ static int ds1390_probe(struct spi_device *spi)
         return res;
 }
 
-static int ds1390_remove(struct spi_device *spi)
+static int __devexit ds1390_remove(struct spi_device *spi)
 {
         struct ds1390 *chip = spi_get_drvdata(spi);
 
@@ -172,10 +172,20 @@ static struct spi_driver ds1390_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe  = ds1390_probe,
-        .remove = ds1390_remove,
+        .remove = __devexit_p(ds1390_remove),
 };
 
-module_spi_driver(ds1390_driver);
+static __init int ds1390_init(void)
+{
+        return spi_register_driver(&ds1390_driver);
+}
+module_init(ds1390_init);
+
+static __exit void ds1390_exit(void)
+{
+        spi_unregister_driver(&ds1390_driver);
+}
+module_exit(ds1390_exit);
 
 MODULE_DESCRIPTION("Dallas/Maxim DS1390/93/94 SPI RTC driver");
 MODULE_AUTHOR("Mark Jackson <mpfj@mimc.co.uk>");
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 6a3fcfe3b0e..568ad30617e 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -23,7 +23,6 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.6"
 
@@ -476,7 +475,8 @@ static struct bin_attribute ds1511_nvram_attr = {
         .write = ds1511_nvram_write,
 };
 
-static int ds1511_rtc_probe(struct platform_device *pdev)
+ static int __devinit
+ds1511_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         struct resource *res;
@@ -531,7 +531,7 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
         if (pdata->irq > 0) {
                 rtc_read(RTC_CMD1);
                 if (devm_request_irq(&pdev->dev, pdata->irq, ds1511_interrupt,
-                        IRQF_SHARED, pdev->name, pdev) < 0) {
+                        IRQF_DISABLED | IRQF_SHARED, pdev->name, pdev) < 0) {
 
                         dev_warn(&pdev->dev, "interrupt not available.\n");
                         pdata->irq = 0;
@@ -550,7 +550,8 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
         return ret;
 }
 
-static int ds1511_rtc_remove(struct platform_device *pdev)
+ static int __devexit
+ds1511_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
@@ -571,14 +572,27 @@ MODULE_ALIAS("platform:ds1511");
 
 static struct platform_driver ds1511_rtc_driver = {
         .probe          = ds1511_rtc_probe,
-        .remove         = ds1511_rtc_remove,
+        .remove         = __devexit_p(ds1511_rtc_remove),
         .driver         = {
                 .name   = "ds1511",
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(ds1511_rtc_driver);
+ static int __init
+ds1511_rtc_init(void)
+{
+        return platform_driver_register(&ds1511_rtc_driver);
+}
+
+ static void __exit
+ds1511_rtc_exit(void)
+{
+        platform_driver_unregister(&ds1511_rtc_driver);
+}
+
+module_init(ds1511_rtc_init);
+module_exit(ds1511_rtc_exit);
 
 MODULE_AUTHOR("Andrew Sharp <andy.sharp@lsi.com>");
 MODULE_DESCRIPTION("Dallas DS1511 RTC driver");
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index 25ce0621ade..fee41b97c9e 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -18,7 +18,6 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.3"
 
@@ -276,7 +275,7 @@ static struct bin_attribute ds1553_nvram_attr = {
         .write = ds1553_nvram_write,
 };
 
-static int ds1553_rtc_probe(struct platform_device *pdev)
+static int __devinit ds1553_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         struct resource *res;
@@ -320,7 +319,7 @@ static int ds1553_rtc_probe(struct platform_device *pdev)
                 writeb(0, ioaddr + RTC_INTERRUPTS);
                 if (devm_request_irq(&pdev->dev, pdata->irq,
                                 ds1553_rtc_interrupt,
-                                0, pdev->name, pdev) < 0) {
+                                IRQF_DISABLED, pdev->name, pdev) < 0) {
                         dev_warn(&pdev->dev, "interrupt not available.\n");
                         pdata->irq = 0;
                 }
@@ -338,7 +337,7 @@ static int ds1553_rtc_probe(struct platform_device *pdev)
         return ret;
 }
 
-static int ds1553_rtc_remove(struct platform_device *pdev)
+static int __devexit ds1553_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
@@ -354,14 +353,25 @@ MODULE_ALIAS("platform:rtc-ds1553");
 
 static struct platform_driver ds1553_rtc_driver = {
         .probe          = ds1553_rtc_probe,
-        .remove         = ds1553_rtc_remove,
+        .remove         = __devexit_p(ds1553_rtc_remove),
         .driver         = {
                 .name   = "rtc-ds1553",
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(ds1553_rtc_driver);
+static __init int ds1553_init(void)
+{
+        return platform_driver_register(&ds1553_rtc_driver);
+}
+
+static __exit void ds1553_exit(void)
+{
+        platform_driver_unregister(&ds1553_rtc_driver);
+}
+
+module_init(ds1553_init);
+module_exit(ds1553_exit);
 
 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
 MODULE_DESCRIPTION("Dallas DS1553 RTC driver");
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 45d65c0b3a8..06dfb54f99b 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -11,7 +11,6 @@
 
 #include <linux/i2c.h>
 #include <linux/rtc.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.4"
 
@@ -37,17 +36,8 @@ static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         unsigned char buf[4];
 
         struct i2c_msg msgs[] = {
-                {/* setup read ptr */
-                        .addr = client->addr,
-                        .len = 1,
-                        .buf = &addr
-                },
-                {/* read date */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 4,
-                        .buf = buf
-                },
+                {client->addr, 0, 1, &addr},    /* setup read ptr */
+                {client->addr, I2C_M_RD, 4, buf},       /* read date */
         };
 
         /* read date registers */
@@ -108,17 +98,8 @@ static int ds1672_get_control(struct i2c_client *client, u8 *status)
         unsigned char addr = DS1672_REG_CONTROL;
 
         struct i2c_msg msgs[] = {
-                {/* setup read ptr */
-                        .addr = client->addr,
-                        .len = 1,
-                        .buf = &addr
-                },
-                {/* read control */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 1,
-                        .buf = status
-                },
+                {client->addr, 0, 1, &addr},    /* setup read ptr */
+                {client->addr, I2C_M_RD, 1, status},    /* read control */
         };
 
         /* read control register */
@@ -220,9 +201,20 @@ static struct i2c_driver ds1672_driver = {
         .id_table = ds1672_id,
 };
 
-module_i2c_driver(ds1672_driver);
+static int __init ds1672_init(void)
+{
+        return i2c_add_driver(&ds1672_driver);
+}
+
+static void __exit ds1672_exit(void)
+{
+        i2c_del_driver(&ds1672_driver);
+}
 
 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 MODULE_DESCRIPTION("Dallas/Maxim DS1672 timekeeper driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+
+module_init(ds1672_init);
+module_exit(ds1672_exit);
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 609c870e2cc..d84a448dd75 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -21,7 +21,6 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.4"
 
@@ -159,7 +158,7 @@ static ssize_t ds1742_nvram_write(struct file *filp, struct kobject *kobj,
         return count;
 }
 
-static int ds1742_rtc_probe(struct platform_device *pdev)
+static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         struct resource *res;
@@ -222,7 +221,7 @@ static int ds1742_rtc_probe(struct platform_device *pdev)
         return ret;
 }
 
-static int ds1742_rtc_remove(struct platform_device *pdev)
+static int __devexit ds1742_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
@@ -233,14 +232,25 @@ static int ds1742_rtc_remove(struct platform_device *pdev)
 
 static struct platform_driver ds1742_rtc_driver = {
         .probe          = ds1742_rtc_probe,
-        .remove         = ds1742_rtc_remove,
+        .remove         = __devexit_p(ds1742_rtc_remove),
         .driver         = {
                 .name   = "rtc-ds1742",
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(ds1742_rtc_driver);
+static __init int ds1742_init(void)
+{
+        return platform_driver_register(&ds1742_rtc_driver);
+}
+
+static __exit void ds1742_exit(void)
+{
+        platform_driver_unregister(&ds1742_rtc_driver);
+}
+
+module_init(ds1742_init);
+module_exit(ds1742_exit);
 
 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
 MODULE_DESCRIPTION("Dallas DS1742 RTC driver");
diff --git a/drivers/rtc/rtc-ds2404.c b/drivers/rtc/rtc-ds2404.c
deleted file mode 100644
index 5ea9df7c8c3..00000000000
--- a/drivers/rtc/rtc-ds2404.c
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * Copyright (C) 2012 Sven Schnelle <svens@stackframe.org>
- *
- * 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/platform_device.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/rtc.h>
-#include <linux/types.h>
-#include <linux/bcd.h>
-#include <linux/rtc-ds2404.h>
-#include <linux/delay.h>
-#include <linux/gpio.h>
-#include <linux/slab.h>
-
-#include <linux/io.h>
-
-#define DS2404_STATUS_REG 0x200
-#define DS2404_CONTROL_REG 0x201
-#define DS2404_RTC_REG 0x202
-
-#define DS2404_WRITE_SCRATCHPAD_CMD 0x0f
-#define DS2404_READ_SCRATCHPAD_CMD 0xaa
-#define DS2404_COPY_SCRATCHPAD_CMD 0x55
-#define DS2404_READ_MEMORY_CMD 0xf0
-
-struct ds2404;
-
-struct ds2404_chip_ops {
-        int (*map_io)(struct ds2404 *chip, struct platform_device *pdev,
-                      struct ds2404_platform_data *pdata);
-        void (*unmap_io)(struct ds2404 *chip);
-};
-
-#define DS2404_RST      0
-#define DS2404_CLK      1
-#define DS2404_DQ       2
-
-struct ds2404_gpio {
-        const char *name;
-        unsigned int gpio;
-};
-
-struct ds2404 {
-        struct ds2404_gpio *gpio;
-        struct ds2404_chip_ops *ops;
-        struct rtc_device *rtc;
-};
-
-static struct ds2404_gpio ds2404_gpio[] = {
-        { "RTC RST", 0 },
-        { "RTC CLK", 0 },
-        { "RTC DQ", 0 },
-};
-
-static int ds2404_gpio_map(struct ds2404 *chip, struct platform_device *pdev,
-                          struct ds2404_platform_data *pdata)
-{
-        int i, err;
-
-        ds2404_gpio[DS2404_RST].gpio = pdata->gpio_rst;
-        ds2404_gpio[DS2404_CLK].gpio = pdata->gpio_clk;
-        ds2404_gpio[DS2404_DQ].gpio = pdata->gpio_dq;
-
-        for (i = 0; i < ARRAY_SIZE(ds2404_gpio); i++) {
-                err = gpio_request(ds2404_gpio[i].gpio, ds2404_gpio[i].name);
-                if (err) {
-                        printk(KERN_ERR "error mapping gpio %s: %d\n",
-                                ds2404_gpio[i].name, err);
-                        goto err_request;
-                }
-                if (i != DS2404_DQ)
-                        gpio_direction_output(ds2404_gpio[i].gpio, 1);
-        }
-
-        chip->gpio = ds2404_gpio;
-        return 0;
-
-err_request:
-        while (--i >= 0)
-                gpio_free(ds2404_gpio[i].gpio);
-        return err;
-}
-
-static void ds2404_gpio_unmap(struct ds2404 *chip)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(ds2404_gpio); i++)
-                gpio_free(ds2404_gpio[i].gpio);
-}
-
-static struct ds2404_chip_ops ds2404_gpio_ops = {
-        .map_io         = ds2404_gpio_map,
-        .unmap_io       = ds2404_gpio_unmap,
-};
-
-static void ds2404_reset(struct device *dev)
-{
-        gpio_set_value(ds2404_gpio[DS2404_RST].gpio, 0);
-        udelay(1000);
-        gpio_set_value(ds2404_gpio[DS2404_RST].gpio, 1);
-        gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 0);
-        gpio_direction_output(ds2404_gpio[DS2404_DQ].gpio, 0);
-        udelay(10);
-}
-
-static void ds2404_write_byte(struct device *dev, u8 byte)
-{
-        int i;
-
-        gpio_direction_output(ds2404_gpio[DS2404_DQ].gpio, 1);
-        for (i = 0; i < 8; i++) {
-                gpio_set_value(ds2404_gpio[DS2404_DQ].gpio, byte & (1 << i));
-                udelay(10);
-                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 1);
-                udelay(10);
-                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 0);
-                udelay(10);
-        }
-}
-
-static u8 ds2404_read_byte(struct device *dev)
-{
-        int i;
-        u8 ret = 0;
-
-        gpio_direction_input(ds2404_gpio[DS2404_DQ].gpio);
-
-        for (i = 0; i < 8; i++) {
-                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 0);
-                udelay(10);
-                if (gpio_get_value(ds2404_gpio[DS2404_DQ].gpio))
-                        ret |= 1 << i;
-                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 1);
-                udelay(10);
-        }
-        return ret;
-}
-
-static void ds2404_read_memory(struct device *dev, u16 offset,
-                               int length, u8 *out)
-{
-        ds2404_reset(dev);
-        ds2404_write_byte(dev, DS2404_READ_MEMORY_CMD);
-        ds2404_write_byte(dev, offset & 0xff);
-        ds2404_write_byte(dev, (offset >> 8) & 0xff);
-        while (length--)
-                *out++ = ds2404_read_byte(dev);
-}
-
-static void ds2404_write_memory(struct device *dev, u16 offset,
-                                int length, u8 *out)
-{
-        int i;
-        u8 ta01, ta02, es;
-
-        ds2404_reset(dev);
-        ds2404_write_byte(dev, DS2404_WRITE_SCRATCHPAD_CMD);
-        ds2404_write_byte(dev, offset & 0xff);
-        ds2404_write_byte(dev, (offset >> 8) & 0xff);
-
-        for (i = 0; i < length; i++)
-                ds2404_write_byte(dev, out[i]);
-
-        ds2404_reset(dev);
-        ds2404_write_byte(dev, DS2404_READ_SCRATCHPAD_CMD);
-
-        ta01 = ds2404_read_byte(dev);
-        ta02 = ds2404_read_byte(dev);
-        es = ds2404_read_byte(dev);
-
-        for (i = 0; i < length; i++) {
-                if (out[i] != ds2404_read_byte(dev)) {
-                        printk(KERN_ERR "read invalid data\n");
-                        return;
-                }
-        }
-
-        ds2404_reset(dev);
-        ds2404_write_byte(dev, DS2404_COPY_SCRATCHPAD_CMD);
-        ds2404_write_byte(dev, ta01);
-        ds2404_write_byte(dev, ta02);
-        ds2404_write_byte(dev, es);
-
-        gpio_direction_input(ds2404_gpio[DS2404_DQ].gpio);
-        while (gpio_get_value(ds2404_gpio[DS2404_DQ].gpio))
-                ;
-}
-
-static void ds2404_enable_osc(struct device *dev)
-{
-        u8 in[1] = { 0x10 }; /* enable oscillator */
-        ds2404_write_memory(dev, 0x201, 1, in);
-}
-
-static int ds2404_read_time(struct device *dev, struct rtc_time *dt)
-{
-        unsigned long time = 0;
-
-        ds2404_read_memory(dev, 0x203, 4, (u8 *)&time);
-        time = le32_to_cpu(time);
-
-        rtc_time_to_tm(time, dt);
-        return rtc_valid_tm(dt);
-}
-
-static int ds2404_set_mmss(struct device *dev, unsigned long secs)
-{
-        u32 time = cpu_to_le32(secs);
-        ds2404_write_memory(dev, 0x203, 4, (u8 *)&time);
-        return 0;
-}
-
-static const struct rtc_class_ops ds2404_rtc_ops = {
-        .read_time      = ds2404_read_time,
-        .set_mmss       = ds2404_set_mmss,
-};
-
-static int rtc_probe(struct platform_device *pdev)
-{
-        struct ds2404_platform_data *pdata = pdev->dev.platform_data;
-        struct ds2404 *chip;
-        int retval = -EBUSY;
-
-        chip = kzalloc(sizeof(struct ds2404), GFP_KERNEL);
-        if (!chip)
-                return -ENOMEM;
-
-        chip->ops = &ds2404_gpio_ops;
-
-        retval = chip->ops->map_io(chip, pdev, pdata);
-        if (retval)
-                goto err_chip;
-
-        dev_info(&pdev->dev, "using GPIOs RST:%d, CLK:%d, DQ:%d\n",
-                 chip->gpio[DS2404_RST].gpio, chip->gpio[DS2404_CLK].gpio,
-                 chip->gpio[DS2404_DQ].gpio);
-
-        platform_set_drvdata(pdev, chip);
-
-        chip->rtc = rtc_device_register("ds2404",
-                                &pdev->dev, &ds2404_rtc_ops, THIS_MODULE);
-        if (IS_ERR(chip->rtc)) {
-                retval = PTR_ERR(chip->rtc);
-                goto err_io;
-        }
-
-        ds2404_enable_osc(&pdev->dev);
-        return 0;
-
-err_io:
-        chip->ops->unmap_io(chip);
-err_chip:
-        kfree(chip);
-        return retval;
-}
-
-static int rtc_remove(struct platform_device *dev)
-{
-        struct ds2404 *chip = platform_get_drvdata(dev);
-        struct rtc_device *rtc = chip->rtc;
-
-        if (rtc)
-                rtc_device_unregister(rtc);
-
-        chip->ops->unmap_io(chip);
-        kfree(chip);
-
-        return 0;
-}
-
-static struct platform_driver rtc_device_driver = {
-        .probe  = rtc_probe,
-        .remove = rtc_remove,
-        .driver = {
-                .name   = "ds2404",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static __init int ds2404_init(void)
-{
-        return platform_driver_register(&rtc_device_driver);
-}
-
-static __exit void ds2404_exit(void)
-{
-        platform_driver_unregister(&rtc_device_driver);
-}
-
-module_init(ds2404_init);
-module_exit(ds2404_exit);
-
-MODULE_DESCRIPTION("DS2404 RTC");
-MODULE_AUTHOR("Sven Schnelle");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:ds2404");
diff --git a/drivers/rtc/rtc-ds3232.c b/drivers/rtc/rtc-ds3232.c
index db0ca08db31..27b7bf672ac 100644
--- a/drivers/rtc/rtc-ds3232.c
+++ b/drivers/rtc/rtc-ds3232.c
@@ -391,8 +391,8 @@ static const struct rtc_class_ops ds3232_rtc_ops = {
         .alarm_irq_enable = ds3232_alarm_irq_enable,
 };
 
-static int ds3232_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id)
+static int __devinit ds3232_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
 {
         struct ds3232 *ds3232;
         int ret;
@@ -439,7 +439,7 @@ out_free:
         return ret;
 }
 
-static int ds3232_remove(struct i2c_client *client)
+static int __devexit ds3232_remove(struct i2c_client *client)
 {
         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 
@@ -469,11 +469,22 @@ static struct i2c_driver ds3232_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = ds3232_probe,
-        .remove = ds3232_remove,
+        .remove = __devexit_p(ds3232_remove),
         .id_table = ds3232_id,
 };
 
-module_i2c_driver(ds3232_driver);
+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");
diff --git a/drivers/rtc/rtc-ds3234.c b/drivers/rtc/rtc-ds3234.c
index 7a4495ef1c3..bbd26228f53 100644
--- a/drivers/rtc/rtc-ds3234.c
+++ b/drivers/rtc/rtc-ds3234.c
@@ -105,7 +105,7 @@ static const struct rtc_class_ops ds3234_rtc_ops = {
         .set_time       = ds3234_set_time,
 };
 
-static int ds3234_probe(struct spi_device *spi)
+static int __devinit ds3234_probe(struct spi_device *spi)
 {
         struct rtc_device *rtc;
         unsigned char tmp;
@@ -156,7 +156,7 @@ static int ds3234_probe(struct spi_device *spi)
         return 0;
 }
 
-static int ds3234_remove(struct spi_device *spi)
+static int __devexit ds3234_remove(struct spi_device *spi)
 {
         struct rtc_device *rtc = spi_get_drvdata(spi);
 
@@ -170,10 +170,20 @@ static struct spi_driver ds3234_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe   = ds3234_probe,
-        .remove = ds3234_remove,
+        .remove = __devexit_p(ds3234_remove),
 };
 
-module_spi_driver(ds3234_driver);
+static __init int ds3234_init(void)
+{
+        return spi_register_driver(&ds3234_driver);
+}
+module_init(ds3234_init);
+
+static __exit void ds3234_exit(void)
+{
+        spi_unregister_driver(&ds3234_driver);
+}
+module_exit(ds3234_exit);
 
 MODULE_DESCRIPTION("DS3234 SPI RTC driver");
 MODULE_AUTHOR("Dennis Aberilla <denzzzhome@yahoo.com>");
diff --git a/drivers/rtc/rtc-efi.c b/drivers/rtc/rtc-efi.c
index c9f890b088d..550292304b0 100644
--- a/drivers/rtc/rtc-efi.c
+++ b/drivers/rtc/rtc-efi.c
@@ -213,6 +213,7 @@ static struct platform_driver efi_rtc_driver = {
                 .name = "rtc-efi",
                 .owner = THIS_MODULE,
         },
+        .probe = efi_rtc_probe,
         .remove = __exit_p(efi_rtc_remove),
 };
 
diff --git a/drivers/rtc/rtc-em3027.c b/drivers/rtc/rtc-em3027.c
index f6c24ce35d3..d8e1c257855 100644
--- a/drivers/rtc/rtc-em3027.c
+++ b/drivers/rtc/rtc-em3027.c
@@ -14,7 +14,6 @@
 #include <linux/i2c.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
-#include <linux/module.h>
 
 /* Registers */
 #define EM3027_REG_ON_OFF_CTRL  0x00
@@ -49,17 +48,8 @@ static int em3027_get_time(struct device *dev, struct rtc_time *tm)
         unsigned char buf[7];
 
         struct i2c_msg msgs[] = {
-                {/* setup read addr */
-                        .addr = client->addr,
-                        .len = 1,
-                        .buf = &addr
-                },
-                {/* read time/date */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 7,
-                        .buf = buf
-                },
+                {client->addr, 0, 1, &addr},            /* setup read addr */
+                {client->addr, I2C_M_RD, 7, buf},       /* read time/date */
         };
 
         /* read time/date registers */
@@ -85,9 +75,7 @@ static int em3027_set_time(struct device *dev, struct rtc_time *tm)
         unsigned char buf[8];
 
         struct i2c_msg msg = {
-                .addr = client->addr,
-                .len = 8,
-                .buf = buf,     /* write time/date */
+                client->addr, 0, 8, buf,        /* write time/date */
         };
 
         buf[0] = EM3027_REG_WATCH_SEC;
@@ -155,8 +143,19 @@ static struct i2c_driver em3027_driver = {
         .id_table = em3027_id,
 };
 
-module_i2c_driver(em3027_driver);
+static int __init em3027_init(void)
+{
+        return i2c_add_driver(&em3027_driver);
+}
+
+static void __exit em3027_exit(void)
+{
+        i2c_del_driver(&em3027_driver);
+}
 
 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 MODULE_DESCRIPTION("EM Microelectronic EM3027 RTC driver");
 MODULE_LICENSE("GPL");
+
+module_init(em3027_init);
+module_exit(em3027_exit);
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 1a4e5e4a70c..14a42a1edc6 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -127,7 +127,7 @@ static const struct attribute_group ep93xx_rtc_sysfs_files = {
         .attrs  = ep93xx_rtc_attrs,
 };
 
-static int ep93xx_rtc_probe(struct platform_device *pdev)
+static int __init ep93xx_rtc_probe(struct platform_device *pdev)
 {
         struct ep93xx_rtc *ep93xx_rtc;
         struct resource *res;
@@ -174,7 +174,7 @@ exit:
         return err;
 }
 
-static int ep93xx_rtc_remove(struct platform_device *pdev)
+static int __exit ep93xx_rtc_remove(struct platform_device *pdev)
 {
         struct ep93xx_rtc *ep93xx_rtc = platform_get_drvdata(pdev);
 
@@ -186,19 +186,31 @@ static int ep93xx_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:ep93xx-rtc");
+
 static struct platform_driver ep93xx_rtc_driver = {
         .driver         = {
                 .name   = "ep93xx-rtc",
                 .owner  = THIS_MODULE,
         },
-        .probe          = ep93xx_rtc_probe,
-        .remove         = ep93xx_rtc_remove,
+        .remove         = __exit_p(ep93xx_rtc_remove),
 };
 
-module_platform_driver(ep93xx_rtc_driver);
+static int __init ep93xx_rtc_init(void)
+{
+        return platform_driver_probe(&ep93xx_rtc_driver, ep93xx_rtc_probe);
+}
+
+static void __exit ep93xx_rtc_exit(void)
+{
+        platform_driver_unregister(&ep93xx_rtc_driver);
+}
 
 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 MODULE_DESCRIPTION("EP93XX RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
-MODULE_ALIAS("platform:ep93xx-rtc");
+
+module_init(ep93xx_rtc_init);
+module_exit(ep93xx_rtc_exit);
diff --git a/drivers/rtc/rtc-fm3130.c b/drivers/rtc/rtc-fm3130.c
index 04e93c6597f..4cf2e70c507 100644
--- a/drivers/rtc/rtc-fm3130.c
+++ b/drivers/rtc/rtc-fm3130.c
@@ -361,8 +361,8 @@ static const struct rtc_class_ops fm3130_rtc_ops = {
 
 static struct i2c_driver fm3130_driver;
 
-static int fm3130_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id)
+static int __devinit fm3130_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
 {
         struct fm3130           *fm3130;
         int                     err = -ENODEV;
@@ -546,7 +546,7 @@ exit_free:
         return err;
 }
 
-static int fm3130_remove(struct i2c_client *client)
+static int __devexit fm3130_remove(struct i2c_client *client)
 {
         struct fm3130 *fm3130 = i2c_get_clientdata(client);
 
@@ -561,11 +561,21 @@ static struct i2c_driver fm3130_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = fm3130_probe,
-        .remove         = fm3130_remove,
+        .remove         = __devexit_p(fm3130_remove),
         .id_table       = fm3130_id,
 };
 
-module_i2c_driver(fm3130_driver);
+static int __init fm3130_init(void)
+{
+        return i2c_add_driver(&fm3130_driver);
+}
+module_init(fm3130_init);
+
+static void __exit fm3130_exit(void)
+{
+        i2c_del_driver(&fm3130_driver);
+}
+module_exit(fm3130_exit);
 
 MODULE_DESCRIPTION("RTC driver for FM3130");
 MODULE_AUTHOR("Sergey Lapin <slapin@ossfans.org>");
diff --git a/drivers/rtc/rtc-imxdi.c b/drivers/rtc/rtc-imxdi.c
index 75d307ab37f..d93a9608b1f 100644
--- a/drivers/rtc/rtc-imxdi.c
+++ b/drivers/rtc/rtc-imxdi.c
@@ -36,9 +36,7 @@
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/sched.h>
-#include <linux/spinlock.h>
 #include <linux/workqueue.h>
-#include <linux/of.h>
 
 /* DryIce Register Definitions */
 
@@ -394,8 +392,6 @@ static int dryice_rtc_probe(struct platform_device *pdev)
         if (imxdi->ioaddr == NULL)
                 return -ENOMEM;
 
-        spin_lock_init(&imxdi->irq_lock);
-
         imxdi->irq = platform_get_irq(pdev, 0);
         if (imxdi->irq < 0)
                 return imxdi->irq;
@@ -409,7 +405,7 @@ static int dryice_rtc_probe(struct platform_device *pdev)
         imxdi->clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(imxdi->clk))
                 return PTR_ERR(imxdi->clk);
-        clk_prepare_enable(imxdi->clk);
+        clk_enable(imxdi->clk);
 
         /*
          * Initialize dryice hardware
@@ -474,13 +470,13 @@ static int dryice_rtc_probe(struct platform_device *pdev)
         return 0;
 
 err:
-        clk_disable_unprepare(imxdi->clk);
+        clk_disable(imxdi->clk);
         clk_put(imxdi->clk);
 
         return rc;
 }
 
-static int dryice_rtc_remove(struct platform_device *pdev)
+static int __devexit dryice_rtc_remove(struct platform_device *pdev)
 {
         struct imxdi_dev *imxdi = platform_get_drvdata(pdev);
 
@@ -491,28 +487,18 @@ static int dryice_rtc_remove(struct platform_device *pdev)
 
         rtc_device_unregister(imxdi->rtc);
 
-        clk_disable_unprepare(imxdi->clk);
+        clk_disable(imxdi->clk);
         clk_put(imxdi->clk);
 
         return 0;
 }
 
-#ifdef CONFIG_OF
-static const struct of_device_id dryice_dt_ids[] = {
-        { .compatible = "fsl,imx25-rtc" },
-        { /* sentinel */ }
-};
-
-MODULE_DEVICE_TABLE(of, dryice_dt_ids);
-#endif
-
 static struct platform_driver dryice_rtc_driver = {
         .driver = {
                    .name = "imxdi_rtc",
                    .owner = THIS_MODULE,
-                   .of_match_table = of_match_ptr(dryice_dt_ids),
                    },
-        .remove = dryice_rtc_remove,
+        .remove = __devexit_p(dryice_rtc_remove),
 };
 
 static int __init dryice_rtc_init(void)
diff --git a/drivers/rtc/rtc-isl12022.c b/drivers/rtc/rtc-isl12022.c
index 1850104705c..ddbc797ea6c 100644
--- a/drivers/rtc/rtc-isl12022.c
+++ b/drivers/rtc/rtc-isl12022.c
@@ -15,7 +15,6 @@
 #include <linux/bcd.h>
 #include <linux/rtc.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.1"
 
@@ -309,7 +308,18 @@ static struct i2c_driver isl12022_driver = {
         .id_table       = isl12022_id,
 };
 
-module_i2c_driver(isl12022_driver);
+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");
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index afb7cfa85cc..da8beb8cae5 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -68,17 +68,9 @@ isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[],
 {
         u8 reg_addr[1] = { reg };
         struct i2c_msg msgs[2] = {
-                {
-                        .addr = client->addr,
-                        .len = sizeof(reg_addr),
-                        .buf = reg_addr
-                },
-                {
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = len,
-                        .buf = buf
-                }
+                {client->addr, 0, sizeof(reg_addr), reg_addr}
+                ,
+                {client->addr, I2C_M_RD, len, buf}
         };
         int ret;
 
@@ -98,11 +90,7 @@ isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
 {
         u8 i2c_buf[ISL1208_REG_USR2 + 2];
         struct i2c_msg msgs[1] = {
-                {
-                        .addr = client->addr,
-                        .len = len + 1,
-                        .buf = i2c_buf
-                }
+                {client->addr, 0, len + 1, i2c_buf}
         };
         int ret;
 
@@ -118,7 +106,7 @@ isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
         return ret;
 }
 
-/* simple check to see whether we have a isl1208 */
+/* simple check to see wether we have a isl1208 */
 static int
 isl1208_i2c_validate_client(struct i2c_client *client)
 {
@@ -709,7 +697,6 @@ isl1208_remove(struct i2c_client *client)
 
 static const struct i2c_device_id isl1208_id[] = {
         { "isl1208", 0 },
-        { "isl1218", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, isl1208_id);
@@ -723,9 +710,22 @@ static struct i2c_driver isl1208_driver = {
         .id_table = isl1208_id,
 };
 
-module_i2c_driver(isl1208_driver);
+static int __init
+isl1208_init(void)
+{
+        return i2c_add_driver(&isl1208_driver);
+}
+
+static void __exit
+isl1208_exit(void)
+{
+        i2c_del_driver(&isl1208_driver);
+}
 
 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+
+module_init(isl1208_init);
+module_exit(isl1208_exit);
diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
index 1e48686ca6d..b6473631d18 100644
--- a/drivers/rtc/rtc-jz4740.c
+++ b/drivers/rtc/rtc-jz4740.c
@@ -42,7 +42,7 @@ struct jz4740_rtc {
 
         struct rtc_device *rtc;
 
-        int irq;
+        unsigned int irq;
 
         spinlock_t lock;
 };
@@ -210,7 +210,7 @@ void jz4740_rtc_poweroff(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(jz4740_rtc_poweroff);
 
-static int jz4740_rtc_probe(struct platform_device *pdev)
+static int __devinit jz4740_rtc_probe(struct platform_device *pdev)
 {
         int ret;
         struct jz4740_rtc *rtc;
@@ -297,7 +297,7 @@ err_free:
         return ret;
 }
 
-static int jz4740_rtc_remove(struct platform_device *pdev)
+static int __devexit jz4740_rtc_remove(struct platform_device *pdev)
 {
         struct jz4740_rtc *rtc = platform_get_drvdata(pdev);
 
@@ -345,9 +345,9 @@ static const struct dev_pm_ops jz4740_pm_ops = {
 #define JZ4740_RTC_PM_OPS NULL
 #endif  /* CONFIG_PM */
 
-static struct platform_driver jz4740_rtc_driver = {
+struct platform_driver jz4740_rtc_driver = {
         .probe   = jz4740_rtc_probe,
-        .remove  = jz4740_rtc_remove,
+        .remove  = __devexit_p(jz4740_rtc_remove),
         .driver  = {
                 .name  = "jz4740-rtc",
                 .owner = THIS_MODULE,
@@ -355,7 +355,17 @@ static struct platform_driver jz4740_rtc_driver = {
         },
 };
 
-module_platform_driver(jz4740_rtc_driver);
+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");
diff --git a/drivers/rtc/rtc-lpc32xx.c b/drivers/rtc/rtc-lpc32xx.c
index 40a598332ba..ae16250c762 100644
--- a/drivers/rtc/rtc-lpc32xx.c
+++ b/drivers/rtc/rtc-lpc32xx.c
@@ -19,7 +19,6 @@
 #include <linux/rtc.h>
 #include <linux/slab.h>
 #include <linux/io.h>
-#include <linux/of.h>
 
 /*
  * Clock and Power control register offsets
@@ -197,7 +196,7 @@ static const struct rtc_class_ops lpc32xx_rtc_ops = {
         .alarm_irq_enable       = lpc32xx_rtc_alarm_irq_enable,
 };
 
-static int lpc32xx_rtc_probe(struct platform_device *pdev)
+static int __devinit lpc32xx_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct lpc32xx_rtc *rtc;
@@ -288,7 +287,7 @@ static int lpc32xx_rtc_probe(struct platform_device *pdev)
         if (rtc->irq >= 0) {
                 if (devm_request_irq(&pdev->dev, rtc->irq,
                                      lpc32xx_rtc_alarm_interrupt,
-                                     0, pdev->name, rtc) < 0) {
+                                     IRQF_DISABLED, pdev->name, rtc) < 0) {
                         dev_warn(&pdev->dev, "Can't request interrupt.\n");
                         rtc->irq = -1;
                 } else {
@@ -299,7 +298,7 @@ static int lpc32xx_rtc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int lpc32xx_rtc_remove(struct platform_device *pdev)
+static int __devexit lpc32xx_rtc_remove(struct platform_device *pdev)
 {
         struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
 
@@ -387,26 +386,27 @@ static const struct dev_pm_ops lpc32xx_rtc_pm_ops = {
 #define LPC32XX_RTC_PM_OPS NULL
 #endif
 
-#ifdef CONFIG_OF
-static const struct of_device_id lpc32xx_rtc_match[] = {
-        { .compatible = "nxp,lpc3220-rtc" },
-        { }
-};
-MODULE_DEVICE_TABLE(of, lpc32xx_rtc_match);
-#endif
-
 static struct platform_driver lpc32xx_rtc_driver = {
         .probe          = lpc32xx_rtc_probe,
-        .remove         = lpc32xx_rtc_remove,
+        .remove         = __devexit_p(lpc32xx_rtc_remove),
         .driver = {
                 .name   = RTC_NAME,
                 .owner  = THIS_MODULE,
-                .pm     = LPC32XX_RTC_PM_OPS,
-                .of_match_table = of_match_ptr(lpc32xx_rtc_match),
+                .pm     = LPC32XX_RTC_PM_OPS
         },
 };
 
-module_platform_driver(lpc32xx_rtc_driver);
+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");
diff --git a/drivers/rtc/rtc-ls1x.c b/drivers/rtc/rtc-ls1x.c
deleted file mode 100644
index f59b6349551..00000000000
--- a/drivers/rtc/rtc-ls1x.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * Copyright (c) 2011 Zhao Zhang <zhzhl555@gmail.com>
- *
- * Derived from driver/rtc/rtc-au1xxx.c
- *
- * 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/rtc.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/delay.h>
-#include <linux/types.h>
-#include <linux/io.h>
-#include <asm/mach-loongson1/loongson1.h>
-
-#define LS1X_RTC_REG_OFFSET     (LS1X_RTC_BASE + 0x20)
-#define LS1X_RTC_REGS(x) \
-                ((void __iomem *)KSEG1ADDR(LS1X_RTC_REG_OFFSET + (x)))
-
-/*RTC programmable counters 0 and 1*/
-#define SYS_COUNTER_CNTRL               (LS1X_RTC_REGS(0x20))
-#define SYS_CNTRL_ERS                   (1 << 23)
-#define SYS_CNTRL_RTS                   (1 << 20)
-#define SYS_CNTRL_RM2                   (1 << 19)
-#define SYS_CNTRL_RM1                   (1 << 18)
-#define SYS_CNTRL_RM0                   (1 << 17)
-#define SYS_CNTRL_RS                    (1 << 16)
-#define SYS_CNTRL_BP                    (1 << 14)
-#define SYS_CNTRL_REN                   (1 << 13)
-#define SYS_CNTRL_BRT                   (1 << 12)
-#define SYS_CNTRL_TEN                   (1 << 11)
-#define SYS_CNTRL_BTT                   (1 << 10)
-#define SYS_CNTRL_E0                    (1 << 8)
-#define SYS_CNTRL_ETS                   (1 << 7)
-#define SYS_CNTRL_32S                   (1 << 5)
-#define SYS_CNTRL_TTS                   (1 << 4)
-#define SYS_CNTRL_TM2                   (1 << 3)
-#define SYS_CNTRL_TM1                   (1 << 2)
-#define SYS_CNTRL_TM0                   (1 << 1)
-#define SYS_CNTRL_TS                    (1 << 0)
-
-/* Programmable Counter 0 Registers */
-#define SYS_TOYTRIM             (LS1X_RTC_REGS(0))
-#define SYS_TOYWRITE0           (LS1X_RTC_REGS(4))
-#define SYS_TOYWRITE1           (LS1X_RTC_REGS(8))
-#define SYS_TOYREAD0            (LS1X_RTC_REGS(0xC))
-#define SYS_TOYREAD1            (LS1X_RTC_REGS(0x10))
-#define SYS_TOYMATCH0           (LS1X_RTC_REGS(0x14))
-#define SYS_TOYMATCH1           (LS1X_RTC_REGS(0x18))
-#define SYS_TOYMATCH2           (LS1X_RTC_REGS(0x1C))
-
-/* Programmable Counter 1 Registers */
-#define SYS_RTCTRIM             (LS1X_RTC_REGS(0x40))
-#define SYS_RTCWRITE0           (LS1X_RTC_REGS(0x44))
-#define SYS_RTCREAD0            (LS1X_RTC_REGS(0x48))
-#define SYS_RTCMATCH0           (LS1X_RTC_REGS(0x4C))
-#define SYS_RTCMATCH1           (LS1X_RTC_REGS(0x50))
-#define SYS_RTCMATCH2           (LS1X_RTC_REGS(0x54))
-
-#define LS1X_SEC_OFFSET         (4)
-#define LS1X_MIN_OFFSET         (10)
-#define LS1X_HOUR_OFFSET        (16)
-#define LS1X_DAY_OFFSET         (21)
-#define LS1X_MONTH_OFFSET       (26)
-
-
-#define LS1X_SEC_MASK           (0x3f)
-#define LS1X_MIN_MASK           (0x3f)
-#define LS1X_HOUR_MASK          (0x1f)
-#define LS1X_DAY_MASK           (0x1f)
-#define LS1X_MONTH_MASK         (0x3f)
-#define LS1X_YEAR_MASK          (0xffffffff)
-
-#define ls1x_get_sec(t)         (((t) >> LS1X_SEC_OFFSET) & LS1X_SEC_MASK)
-#define ls1x_get_min(t)         (((t) >> LS1X_MIN_OFFSET) & LS1X_MIN_MASK)
-#define ls1x_get_hour(t)        (((t) >> LS1X_HOUR_OFFSET) & LS1X_HOUR_MASK)
-#define ls1x_get_day(t)         (((t) >> LS1X_DAY_OFFSET) & LS1X_DAY_MASK)
-#define ls1x_get_month(t)       (((t) >> LS1X_MONTH_OFFSET) & LS1X_MONTH_MASK)
-
-#define RTC_CNTR_OK (SYS_CNTRL_E0 | SYS_CNTRL_32S)
-
-static int ls1x_rtc_read_time(struct device *dev, struct rtc_time *rtm)
-{
-        unsigned long v, t;
-
-        v = readl(SYS_TOYREAD0);
-        t = readl(SYS_TOYREAD1);
-
-        memset(rtm, 0, sizeof(struct rtc_time));
-        t  = mktime((t & LS1X_YEAR_MASK), ls1x_get_month(v),
-                        ls1x_get_day(v), ls1x_get_hour(v),
-                        ls1x_get_min(v), ls1x_get_sec(v));
-        rtc_time_to_tm(t, rtm);
-
-        return rtc_valid_tm(rtm);
-}
-
-static int ls1x_rtc_set_time(struct device *dev, struct  rtc_time *rtm)
-{
-        unsigned long v, t, c;
-        int ret = -ETIMEDOUT;
-
-        v = ((rtm->tm_mon + 1)  << LS1X_MONTH_OFFSET)
-                | (rtm->tm_mday << LS1X_DAY_OFFSET)
-                | (rtm->tm_hour << LS1X_HOUR_OFFSET)
-                | (rtm->tm_min  << LS1X_MIN_OFFSET)
-                | (rtm->tm_sec  << LS1X_SEC_OFFSET);
-
-        writel(v, SYS_TOYWRITE0);
-        c = 0x10000;
-        /* add timeout check counter, for more safe */
-        while ((readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_TS) && --c)
-                usleep_range(1000, 3000);
-
-        if (!c) {
-                dev_err(dev, "set time timeout!\n");
-                goto err;
-        }
-
-        t = rtm->tm_year + 1900;
-        writel(t, SYS_TOYWRITE1);
-        c = 0x10000;
-        while ((readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_TS) && --c)
-                usleep_range(1000, 3000);
-
-        if (!c) {
-                dev_err(dev, "set time timeout!\n");
-                goto err;
-        }
-        return 0;
-err:
-        return ret;
-}
-
-static struct rtc_class_ops  ls1x_rtc_ops = {
-        .read_time      = ls1x_rtc_read_time,
-        .set_time       = ls1x_rtc_set_time,
-};
-
-static int ls1x_rtc_probe(struct platform_device *pdev)
-{
-        struct rtc_device *rtcdev;
-        unsigned long v;
-        int ret;
-
-        v = readl(SYS_COUNTER_CNTRL);
-        if (!(v & RTC_CNTR_OK)) {
-                dev_err(&pdev->dev, "rtc counters not working\n");
-                ret = -ENODEV;
-                goto err;
-        }
-        ret = -ETIMEDOUT;
-        /* set to 1 HZ if needed */
-        if (readl(SYS_TOYTRIM) != 32767) {
-                v = 0x100000;
-                while ((readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_TTS) && --v)
-                        usleep_range(1000, 3000);
-
-                if (!v) {
-                        dev_err(&pdev->dev, "time out\n");
-                        goto err;
-                }
-                writel(32767, SYS_TOYTRIM);
-        }
-        /* this loop coundn't be endless */
-        while (readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_TTS)
-                usleep_range(1000, 3000);
-
-        rtcdev = rtc_device_register("ls1x-rtc", &pdev->dev,
-                                        &ls1x_rtc_ops , THIS_MODULE);
-        if (IS_ERR(rtcdev)) {
-                ret = PTR_ERR(rtcdev);
-                goto err;
-        }
-
-        platform_set_drvdata(pdev, rtcdev);
-        return 0;
-err:
-        return ret;
-}
-
-static int ls1x_rtc_remove(struct platform_device *pdev)
-{
-        struct rtc_device *rtcdev = platform_get_drvdata(pdev);
-
-        rtc_device_unregister(rtcdev);
-        platform_set_drvdata(pdev, NULL);
-
-        return 0;
-}
-
-static struct platform_driver  ls1x_rtc_driver = {
-        .driver         = {
-                .name   = "ls1x-rtc",
-                .owner  = THIS_MODULE,
-        },
-        .remove         = ls1x_rtc_remove,
-        .probe          = ls1x_rtc_probe,
-};
-
-module_platform_driver(ls1x_rtc_driver);
-
-MODULE_AUTHOR("zhao zhang <zhzhl555@gmail.com>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index b885bcd0890..64aedd8cc09 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -213,14 +213,163 @@ static int m41t80_rtc_set_time(struct device *dev, struct rtc_time *tm)
         return m41t80_set_datetime(to_i2c_client(dev), tm);
 }
 
-/*
- * XXX - m41t80 alarm functionality is reported broken.
- * until it is fixed, don't register alarm functions.
- */
+static int m41t80_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int rc;
+
+        rc = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);
+        if (rc < 0)
+                goto err;
+
+        if (enabled)
+                rc |= M41T80_ALMON_AFE;
+        else
+                rc &= ~M41T80_ALMON_AFE;
+
+        if (i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON, rc) < 0)
+                goto err;
+
+        return 0;
+err:
+        return -EIO;
+}
+
+static int m41t80_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        u8 wbuf[1 + M41T80_ALARM_REG_SIZE];
+        u8 *buf = &wbuf[1];
+        u8 *reg = buf - M41T80_REG_ALARM_MON;
+        u8 dt_addr[1] = { M41T80_REG_ALARM_MON };
+        struct i2c_msg msgs_in[] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0,
+                        .len    = 1,
+                        .buf    = dt_addr,
+                },
+                {
+                        .addr   = client->addr,
+                        .flags  = I2C_M_RD,
+                        .len    = M41T80_ALARM_REG_SIZE,
+                        .buf    = buf,
+                },
+        };
+        struct i2c_msg msgs[] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0,
+                        .len    = 1 + M41T80_ALARM_REG_SIZE,
+                        .buf    = wbuf,
+                 },
+        };
+
+        if (i2c_transfer(client->adapter, msgs_in, 2) < 0) {
+                dev_err(&client->dev, "read error\n");
+                return -EIO;
+        }
+        reg[M41T80_REG_ALARM_MON] &= ~(0x1f | M41T80_ALMON_AFE);
+        reg[M41T80_REG_ALARM_DAY] = 0;
+        reg[M41T80_REG_ALARM_HOUR] &= ~(0x3f | 0x80);
+        reg[M41T80_REG_ALARM_MIN] = 0;
+        reg[M41T80_REG_ALARM_SEC] = 0;
+
+        wbuf[0] = M41T80_REG_ALARM_MON; /* offset into rtc's regs */
+        reg[M41T80_REG_ALARM_SEC] |= t->time.tm_sec >= 0 ?
+                bin2bcd(t->time.tm_sec) : 0x80;
+        reg[M41T80_REG_ALARM_MIN] |= t->time.tm_min >= 0 ?
+                bin2bcd(t->time.tm_min) : 0x80;
+        reg[M41T80_REG_ALARM_HOUR] |= t->time.tm_hour >= 0 ?
+                bin2bcd(t->time.tm_hour) : 0x80;
+        reg[M41T80_REG_ALARM_DAY] |= t->time.tm_mday >= 0 ?
+                bin2bcd(t->time.tm_mday) : 0x80;
+        if (t->time.tm_mon >= 0)
+                reg[M41T80_REG_ALARM_MON] |= bin2bcd(t->time.tm_mon + 1);
+        else
+                reg[M41T80_REG_ALARM_DAY] |= 0x40;
+
+        if (i2c_transfer(client->adapter, msgs, 1) != 1) {
+                dev_err(&client->dev, "write error\n");
+                return -EIO;
+        }
+
+        if (t->enabled) {
+                reg[M41T80_REG_ALARM_MON] |= M41T80_ALMON_AFE;
+                if (i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
+                                              reg[M41T80_REG_ALARM_MON]) < 0) {
+                        dev_err(&client->dev, "write error\n");
+                        return -EIO;
+                }
+        }
+        return 0;
+}
+
+static int m41t80_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        u8 buf[M41T80_ALARM_REG_SIZE + 1]; /* all alarm regs and flags */
+        u8 dt_addr[1] = { M41T80_REG_ALARM_MON };
+        u8 *reg = buf - M41T80_REG_ALARM_MON;
+        struct i2c_msg msgs[] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0,
+                        .len    = 1,
+                        .buf    = dt_addr,
+                },
+                {
+                        .addr   = client->addr,
+                        .flags  = I2C_M_RD,
+                        .len    = M41T80_ALARM_REG_SIZE + 1,
+                        .buf    = buf,
+                },
+        };
+
+        if (i2c_transfer(client->adapter, msgs, 2) < 0) {
+                dev_err(&client->dev, "read error\n");
+                return -EIO;
+        }
+        t->time.tm_sec = -1;
+        t->time.tm_min = -1;
+        t->time.tm_hour = -1;
+        t->time.tm_mday = -1;
+        t->time.tm_mon = -1;
+        if (!(reg[M41T80_REG_ALARM_SEC] & 0x80))
+                t->time.tm_sec = bcd2bin(reg[M41T80_REG_ALARM_SEC] & 0x7f);
+        if (!(reg[M41T80_REG_ALARM_MIN] & 0x80))
+                t->time.tm_min = bcd2bin(reg[M41T80_REG_ALARM_MIN] & 0x7f);
+        if (!(reg[M41T80_REG_ALARM_HOUR] & 0x80))
+                t->time.tm_hour = bcd2bin(reg[M41T80_REG_ALARM_HOUR] & 0x3f);
+        if (!(reg[M41T80_REG_ALARM_DAY] & 0x80))
+                t->time.tm_mday = bcd2bin(reg[M41T80_REG_ALARM_DAY] & 0x3f);
+        if (!(reg[M41T80_REG_ALARM_DAY] & 0x40))
+                t->time.tm_mon = bcd2bin(reg[M41T80_REG_ALARM_MON] & 0x1f) - 1;
+        t->time.tm_year = -1;
+        t->time.tm_wday = -1;
+        t->time.tm_yday = -1;
+        t->time.tm_isdst = -1;
+        t->enabled = !!(reg[M41T80_REG_ALARM_MON] & M41T80_ALMON_AFE);
+        t->pending = !!(reg[M41T80_REG_FLAGS] & M41T80_FLAGS_AF);
+        return 0;
+}
+
 static struct rtc_class_ops m41t80_rtc_ops = {
         .read_time = m41t80_rtc_read_time,
         .set_time = m41t80_rtc_set_time,
+        /*
+         * XXX - m41t80 alarm functionality is reported broken.
+         * until it is fixed, don't register alarm functions.
+         *
+        .read_alarm = m41t80_rtc_read_alarm,
+        .set_alarm = m41t80_rtc_set_alarm,
+        */
         .proc = m41t80_rtc_proc,
+        /*
+         * See above comment on broken alarm
+         *
+        .alarm_irq_enable = m41t80_rtc_alarm_irq_enable,
+        */
 };
 
 #if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
@@ -751,9 +900,20 @@ static struct i2c_driver m41t80_driver = {
         .id_table = m41t80_id,
 };
 
-module_i2c_driver(m41t80_driver);
+static int __init m41t80_rtc_init(void)
+{
+        return i2c_add_driver(&m41t80_driver);
+}
+
+static void __exit m41t80_rtc_exit(void)
+{
+        i2c_del_driver(&m41t80_driver);
+}
 
 MODULE_AUTHOR("Alexander Bigga <ab@mycable.de>");
 MODULE_DESCRIPTION("ST Microelectronics M41T80 series RTC I2C Client Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+
+module_init(m41t80_rtc_init);
+module_exit(m41t80_rtc_exit);
diff --git a/drivers/rtc/rtc-m41t93.c b/drivers/rtc/rtc-m41t93.c
index 49169680786..7317d3b9a3d 100644
--- a/drivers/rtc/rtc-m41t93.c
+++ b/drivers/rtc/rtc-m41t93.c
@@ -48,7 +48,6 @@ static inline int m41t93_set_reg(struct spi_device *spi, u8 addr, u8 data)
 static int m41t93_set_time(struct device *dev, struct rtc_time *tm)
 {
         struct spi_device *spi = to_spi_device(dev);
-        int tmp;
         u8 buf[9] = {0x80};        /* write cmd + 8 data bytes */
         u8 * const data = &buf[1]; /* ptr to first data byte */
 
@@ -63,30 +62,6 @@ static int m41t93_set_time(struct device *dev, struct rtc_time *tm)
                 return -EINVAL;
         }
 
-        tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
-        if (tmp < 0)
-                return tmp;
-
-        if (tmp & M41T93_FLAG_OF) {
-                dev_warn(&spi->dev, "OF bit is set, resetting.\n");
-                m41t93_set_reg(spi, M41T93_REG_FLAGS, tmp & ~M41T93_FLAG_OF);
-
-                tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
-                if (tmp < 0) {
-                        return tmp;
-                } else if (tmp & M41T93_FLAG_OF) {
-                        /* OF cannot be immediately reset: oscillator has to be
-                         * restarted. */
-                        u8 reset_osc = buf[M41T93_REG_ST_SEC] | M41T93_FLAG_ST;
-
-                        dev_warn(&spi->dev,
-                                 "OF bit is still set, kickstarting clock.\n");
-                        m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
-                        reset_osc &= ~M41T93_FLAG_ST;
-                        m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
-                }
-        }
-
         data[M41T93_REG_SSEC]           = 0;
         data[M41T93_REG_ST_SEC]         = bin2bcd(tm->tm_sec);
         data[M41T93_REG_MIN]            = bin2bcd(tm->tm_min);
@@ -114,7 +89,10 @@ static int m41t93_get_time(struct device *dev, struct rtc_time *tm)
            1. halt bit (HT) is set: the clock is running but update of readout
               registers has been disabled due to power failure. This is normal
               case after poweron. Time is valid after resetting HT bit.
-           2. oscillator fail bit (OF) is set: time is invalid.
+           2. oscillator fail bit (OF) is set. Oscillator has be stopped and
+              time is invalid:
+              a) OF can be immeditely reset.
+              b) OF cannot be immediately reset: oscillator has to be restarted.
         */
         tmp = spi_w8r8(spi, M41T93_REG_ALM_HOUR_HT);
         if (tmp < 0)
@@ -132,7 +110,21 @@ static int m41t93_get_time(struct device *dev, struct rtc_time *tm)
 
         if (tmp & M41T93_FLAG_OF) {
                 ret = -EINVAL;
-                dev_warn(&spi->dev, "OF bit is set, write time to restart.\n");
+                dev_warn(&spi->dev, "OF bit is set, resetting.\n");
+                m41t93_set_reg(spi, M41T93_REG_FLAGS, tmp & ~M41T93_FLAG_OF);
+
+                tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
+                if (tmp < 0)
+                        return tmp;
+                else if (tmp & M41T93_FLAG_OF) {
+                        u8 reset_osc = buf[M41T93_REG_ST_SEC] | M41T93_FLAG_ST;
+
+                        dev_warn(&spi->dev,
+                                 "OF bit is still set, kickstarting clock.\n");
+                        m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
+                        reset_osc &= ~M41T93_FLAG_ST;
+                        m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
+                }
         }
 
         if (tmp & M41T93_FLAG_BL)
@@ -170,7 +162,7 @@ static const struct rtc_class_ops m41t93_rtc_ops = {
 
 static struct spi_driver m41t93_driver;
 
-static int m41t93_probe(struct spi_device *spi)
+static int __devinit m41t93_probe(struct spi_device *spi)
 {
         struct rtc_device *rtc;
         int res;
@@ -195,7 +187,7 @@ static int m41t93_probe(struct spi_device *spi)
 }
 
 
-static int m41t93_remove(struct spi_device *spi)
+static int __devexit m41t93_remove(struct spi_device *spi)
 {
         struct rtc_device *rtc = spi_get_drvdata(spi);
 
@@ -208,13 +200,24 @@ static int m41t93_remove(struct spi_device *spi)
 static struct spi_driver m41t93_driver = {
         .driver = {
                 .name   = "rtc-m41t93",
+                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
         },
         .probe  = m41t93_probe,
-        .remove = m41t93_remove,
+        .remove = __devexit_p(m41t93_remove),
 };
 
-module_spi_driver(m41t93_driver);
+static __init int m41t93_init(void)
+{
+        return spi_register_driver(&m41t93_driver);
+}
+module_init(m41t93_init);
+
+static __exit void m41t93_exit(void)
+{
+        spi_unregister_driver(&m41t93_driver);
+}
+module_exit(m41t93_exit);
 
 MODULE_AUTHOR("Nikolaus Voss <n.voss@weinmann.de>");
 MODULE_DESCRIPTION("Driver for ST M41T93 SPI RTC");
diff --git a/drivers/rtc/rtc-m41t94.c b/drivers/rtc/rtc-m41t94.c
index 89266c6764b..e259ed76ae8 100644
--- a/drivers/rtc/rtc-m41t94.c
+++ b/drivers/rtc/rtc-m41t94.c
@@ -110,7 +110,7 @@ static const struct rtc_class_ops m41t94_rtc_ops = {
 
 static struct spi_driver m41t94_driver;
 
-static int m41t94_probe(struct spi_device *spi)
+static int __devinit m41t94_probe(struct spi_device *spi)
 {
         struct rtc_device *rtc;
         int res;
@@ -134,7 +134,7 @@ static int m41t94_probe(struct spi_device *spi)
         return 0;
 }
 
-static int m41t94_remove(struct spi_device *spi)
+static int __devexit m41t94_remove(struct spi_device *spi)
 {
         struct rtc_device *rtc = spi_get_drvdata(spi);
 
@@ -147,13 +147,26 @@ static int m41t94_remove(struct spi_device *spi)
 static struct spi_driver m41t94_driver = {
         .driver = {
                 .name   = "rtc-m41t94",
+                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
         },
         .probe  = m41t94_probe,
-        .remove = m41t94_remove,
+        .remove = __devexit_p(m41t94_remove),
 };
 
-module_spi_driver(m41t94_driver);
+static __init int m41t94_init(void)
+{
+        return spi_register_driver(&m41t94_driver);
+}
+
+module_init(m41t94_init);
+
+static __exit void m41t94_exit(void)
+{
+        spi_unregister_driver(&m41t94_driver);
+}
+
+module_exit(m41t94_exit);
 
 MODULE_AUTHOR("Kim B. Heino <Kim.Heino@bluegiga.com>");
 MODULE_DESCRIPTION("Driver for ST M41T94 SPI RTC");
diff --git a/drivers/rtc/rtc-m48t35.c b/drivers/rtc/rtc-m48t35.c
index 31c9190a1fc..8e2a24e33ed 100644
--- a/drivers/rtc/rtc-m48t35.c
+++ b/drivers/rtc/rtc-m48t35.c
@@ -141,7 +141,7 @@ static const struct rtc_class_ops m48t35_ops = {
         .set_time       = m48t35_set_time,
 };
 
-static int m48t35_probe(struct platform_device *pdev)
+static int __devinit m48t35_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct m48t35_priv *priv;
@@ -194,7 +194,7 @@ out:
         return ret;
 }
 
-static int m48t35_remove(struct platform_device *pdev)
+static int __devexit m48t35_remove(struct platform_device *pdev)
 {
         struct m48t35_priv *priv = platform_get_drvdata(pdev);
 
@@ -213,13 +213,24 @@ static struct platform_driver m48t35_platform_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = m48t35_probe,
-        .remove         = m48t35_remove,
+        .remove         = __devexit_p(m48t35_remove),
 };
 
-module_platform_driver(m48t35_platform_driver);
+static int __init m48t35_init(void)
+{
+        return platform_driver_register(&m48t35_platform_driver);
+}
+
+static void __exit m48t35_exit(void)
+{
+        platform_driver_unregister(&m48t35_platform_driver);
+}
 
 MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
 MODULE_DESCRIPTION("M48T35 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 MODULE_ALIAS("platform:rtc-m48t35");
+
+module_init(m48t35_init);
+module_exit(m48t35_exit);
diff --git a/drivers/rtc/rtc-m48t59.c b/drivers/rtc/rtc-m48t59.c
index 130f29af386..28365388fb6 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -383,7 +383,7 @@ static struct bin_attribute m48t59_nvram_attr = {
         .write = m48t59_nvram_write,
 };
 
-static int m48t59_rtc_probe(struct platform_device *pdev)
+static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
 {
         struct m48t59_plat_data *pdata = pdev->dev.platform_data;
         struct m48t59_private *m48t59 = NULL;
@@ -501,7 +501,7 @@ out:
         return ret;
 }
 
-static int m48t59_rtc_remove(struct platform_device *pdev)
+static int __devexit m48t59_rtc_remove(struct platform_device *pdev)
 {
         struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
         struct m48t59_plat_data *pdata = pdev->dev.platform_data;
@@ -527,10 +527,21 @@ static struct platform_driver m48t59_rtc_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = m48t59_rtc_probe,
-        .remove         = m48t59_rtc_remove,
+        .remove         = __devexit_p(m48t59_rtc_remove),
 };
 
-module_platform_driver(m48t59_rtc_driver);
+static int __init m48t59_rtc_init(void)
+{
+        return platform_driver_register(&m48t59_rtc_driver);
+}
+
+static void __exit m48t59_rtc_exit(void)
+{
+        platform_driver_unregister(&m48t59_rtc_driver);
+}
+
+module_init(m48t59_rtc_init);
+module_exit(m48t59_rtc_exit);
 
 MODULE_AUTHOR("Mark Zhan <rongkai.zhan@windriver.com>");
 MODULE_DESCRIPTION("M48T59/M48T02/M48T08 RTC driver");
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
index 2ffbcacd243..f981287d582 100644
--- a/drivers/rtc/rtc-m48t86.c
+++ b/drivers/rtc/rtc-m48t86.c
@@ -144,7 +144,7 @@ static const struct rtc_class_ops m48t86_rtc_ops = {
         .proc           = m48t86_rtc_proc,
 };
 
-static int m48t86_rtc_probe(struct platform_device *dev)
+static int __devinit m48t86_rtc_probe(struct platform_device *dev)
 {
         unsigned char reg;
         struct m48t86_ops *ops = dev->dev.platform_data;
@@ -164,7 +164,7 @@ static int m48t86_rtc_probe(struct platform_device *dev)
         return 0;
 }
 
-static int m48t86_rtc_remove(struct platform_device *dev)
+static int __devexit m48t86_rtc_remove(struct platform_device *dev)
 {
         struct rtc_device *rtc = platform_get_drvdata(dev);
 
@@ -182,13 +182,24 @@ static struct platform_driver m48t86_rtc_platform_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = m48t86_rtc_probe,
-        .remove         = m48t86_rtc_remove,
+        .remove         = __devexit_p(m48t86_rtc_remove),
 };
 
-module_platform_driver(m48t86_rtc_platform_driver);
+static int __init m48t86_rtc_init(void)
+{
+        return platform_driver_register(&m48t86_rtc_platform_driver);
+}
+
+static void __exit m48t86_rtc_exit(void)
+{
+        platform_driver_unregister(&m48t86_rtc_platform_driver);
+}
 
 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 MODULE_DESCRIPTION("M48T86 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 MODULE_ALIAS("platform:rtc-m48t86");
+
+module_init(m48t86_rtc_init);
+module_exit(m48t86_rtc_exit);
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index a00e33204b9..486142c2637 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -261,9 +261,20 @@ static struct i2c_driver max6900_driver = {
         .id_table = max6900_id,
 };
 
-module_i2c_driver(max6900_driver);
+static int __init max6900_init(void)
+{
+        return i2c_add_driver(&max6900_driver);
+}
+
+static void __exit max6900_exit(void)
+{
+        i2c_del_driver(&max6900_driver);
+}
 
 MODULE_DESCRIPTION("Maxim MAX6900 RTC driver");
 MODULE_AUTHOR("Dale Farnsworth <dale@farnsworth.org>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+
+module_init(max6900_init);
+module_exit(max6900_exit);
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index 7d0bf698b79..0ec3f588a25 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -120,7 +120,7 @@ static const struct rtc_class_ops max6902_rtc_ops = {
         .set_time       = max6902_set_time,
 };
 
-static int max6902_probe(struct spi_device *spi)
+static int __devinit max6902_probe(struct spi_device *spi)
 {
         struct rtc_device *rtc;
         unsigned char tmp;
@@ -143,7 +143,7 @@ static int max6902_probe(struct spi_device *spi)
         return 0;
 }
 
-static int max6902_remove(struct spi_device *spi)
+static int __devexit max6902_remove(struct spi_device *spi)
 {
         struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
 
@@ -154,13 +154,24 @@ static int max6902_remove(struct spi_device *spi)
 static struct spi_driver max6902_driver = {
         .driver = {
                 .name   = "rtc-max6902",
+                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
         },
         .probe  = max6902_probe,
-        .remove = max6902_remove,
+        .remove = __devexit_p(max6902_remove),
 };
 
-module_spi_driver(max6902_driver);
+static __init int max6902_init(void)
+{
+        return spi_register_driver(&max6902_driver);
+}
+module_init(max6902_init);
+
+static __exit void max6902_exit(void)
+{
+        spi_unregister_driver(&max6902_driver);
+}
+module_exit(max6902_exit);
 
 MODULE_DESCRIPTION ("max6902 spi RTC driver");
 MODULE_AUTHOR ("Raphael Assenat");
diff --git a/drivers/rtc/rtc-max8907.c b/drivers/rtc/rtc-max8907.c
deleted file mode 100644
index 1d049da16c8..00000000000
--- a/drivers/rtc/rtc-max8907.c
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
- * RTC driver for Maxim MAX8907
- *
- * Copyright (c) 2011-2012, NVIDIA Corporation.
- *
- * Based on drivers/rtc/rtc-max8925.c,
- * Copyright (C) 2009-2010 Marvell International Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/bcd.h>
-#include <linux/i2c.h>
-#include <linux/mfd/max8907.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/regmap.h>
-#include <linux/rtc.h>
-#include <linux/slab.h>
-
-enum {
-        RTC_SEC = 0,
-        RTC_MIN,
-        RTC_HOUR,
-        RTC_WEEKDAY,
-        RTC_DATE,
-        RTC_MONTH,
-        RTC_YEAR1,
-        RTC_YEAR2,
-};
-
-#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 max8907_rtc {
-        struct max8907          *max8907;
-        struct regmap           *regmap;
-        struct rtc_device       *rtc_dev;
-        int                     irq;
-};
-
-static irqreturn_t max8907_irq_handler(int irq, void *data)
-{
-        struct max8907_rtc *rtc = data;
-
-        regmap_update_bits(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0x7f, 0);
-
-        rtc_update_irq(rtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
-
-        return IRQ_HANDLED;
-}
-
-static void regs_to_tm(u8 *regs, struct rtc_time *tm)
-{
-        tm->tm_year = bcd2bin(regs[RTC_YEAR2]) * 100 +
-                bcd2bin(regs[RTC_YEAR1]) - 1900;
-        tm->tm_mon = bcd2bin(regs[RTC_MONTH] & 0x1f) - 1;
-        tm->tm_mday = bcd2bin(regs[RTC_DATE] & 0x3f);
-        tm->tm_wday = (regs[RTC_WEEKDAY] & 0x07) - 1;
-        if (regs[RTC_HOUR] & HOUR_12) {
-                tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x01f);
-                if (tm->tm_hour == 12)
-                        tm->tm_hour = 0;
-                if (regs[RTC_HOUR] & HOUR_AM_PM)
-                        tm->tm_hour += 12;
-        } else {
-                tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x03f);
-        }
-        tm->tm_min = bcd2bin(regs[RTC_MIN] & 0x7f);
-        tm->tm_sec = bcd2bin(regs[RTC_SEC] & 0x7f);
-}
-
-static void tm_to_regs(struct rtc_time *tm, u8 *regs)
-{
-        u8 high, low;
-
-        high = (tm->tm_year + 1900) / 100;
-        low = tm->tm_year % 100;
-        regs[RTC_YEAR2] = bin2bcd(high);
-        regs[RTC_YEAR1] = bin2bcd(low);
-        regs[RTC_MONTH] = bin2bcd(tm->tm_mon + 1);
-        regs[RTC_DATE] = bin2bcd(tm->tm_mday);
-        regs[RTC_WEEKDAY] = tm->tm_wday + 1;
-        regs[RTC_HOUR] = bin2bcd(tm->tm_hour);
-        regs[RTC_MIN] = bin2bcd(tm->tm_min);
-        regs[RTC_SEC] = bin2bcd(tm->tm_sec);
-}
-
-static int max8907_rtc_read_time(struct device *dev, struct rtc_time *tm)
-{
-        struct max8907_rtc *rtc = dev_get_drvdata(dev);
-        u8 regs[TIME_NUM];
-        int ret;
-
-        ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
-                               TIME_NUM);
-        if (ret < 0)
-                return ret;
-
-        regs_to_tm(regs, tm);
-
-        return 0;
-}
-
-static int max8907_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        struct max8907_rtc *rtc = dev_get_drvdata(dev);
-        u8 regs[TIME_NUM];
-
-        tm_to_regs(tm, regs);
-
-        return regmap_bulk_write(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
-                                 TIME_NUM);
-}
-
-static int max8907_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        struct max8907_rtc *rtc = dev_get_drvdata(dev);
-        u8 regs[TIME_NUM];
-        unsigned int val;
-        int ret;
-
-        ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
-                               TIME_NUM);
-        if (ret < 0)
-                return ret;
-
-        regs_to_tm(regs, &alrm->time);
-
-        ret = regmap_read(rtc->regmap, MAX8907_REG_ALARM0_CNTL, &val);
-        if (ret < 0)
-                return ret;
-
-        alrm->enabled = !!(val & 0x7f);
-
-        return 0;
-}
-
-static int max8907_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        struct max8907_rtc *rtc = dev_get_drvdata(dev);
-        u8 regs[TIME_NUM];
-        int ret;
-
-        tm_to_regs(&alrm->time, regs);
-
-        /* Disable alarm while we update the target time */
-        ret = regmap_update_bits(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0x7f, 0);
-        if (ret < 0)
-                return ret;
-
-        ret = regmap_bulk_write(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
-                                TIME_NUM);
-        if (ret < 0)
-                return ret;
-
-        if (alrm->enabled)
-                ret = regmap_update_bits(rtc->regmap, MAX8907_REG_ALARM0_CNTL,
-                                         0x7f, 0x7f);
-
-        return ret;
-}
-
-static const struct rtc_class_ops max8907_rtc_ops = {
-        .read_time      = max8907_rtc_read_time,
-        .set_time       = max8907_rtc_set_time,
-        .read_alarm     = max8907_rtc_read_alarm,
-        .set_alarm      = max8907_rtc_set_alarm,
-};
-
-static int max8907_rtc_probe(struct platform_device *pdev)
-{
-        struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
-        struct max8907_rtc *rtc;
-        int ret;
-
-        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
-        if (!rtc)
-                return -ENOMEM;
-        platform_set_drvdata(pdev, rtc);
-
-        rtc->max8907 = max8907;
-        rtc->regmap = max8907->regmap_rtc;
-
-        rtc->rtc_dev = rtc_device_register("max8907-rtc", &pdev->dev,
-                                        &max8907_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
-                return ret;
-        }
-
-        rtc->irq = regmap_irq_get_virq(max8907->irqc_rtc,
-                                       MAX8907_IRQ_RTC_ALARM0);
-        if (rtc->irq < 0) {
-                ret = rtc->irq;
-                goto err_unregister;
-        }
-
-        ret = request_threaded_irq(rtc->irq, NULL, max8907_irq_handler,
-                                   IRQF_ONESHOT, "max8907-alarm0", rtc);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "Failed to request IRQ%d: %d\n",
-                        rtc->irq, ret);
-                goto err_unregister;
-        }
-
-        return 0;
-
-err_unregister:
-        rtc_device_unregister(rtc->rtc_dev);
-        return ret;
-}
-
-static int max8907_rtc_remove(struct platform_device *pdev)
-{
-        struct max8907_rtc *rtc = platform_get_drvdata(pdev);
-
-        free_irq(rtc->irq, rtc);
-        rtc_device_unregister(rtc->rtc_dev);
-
-        return 0;
-}
-
-static struct platform_driver max8907_rtc_driver = {
-        .driver = {
-                .name = "max8907-rtc",
-                .owner = THIS_MODULE,
-        },
-        .probe = max8907_rtc_probe,
-        .remove = max8907_rtc_remove,
-};
-module_platform_driver(max8907_rtc_driver);
-
-MODULE_DESCRIPTION("Maxim MAX8907 RTC driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-max8925.c b/drivers/rtc/rtc-max8925.c
index a0c8265646d..3bc046f427e 100644
--- a/drivers/rtc/rtc-max8925.c
+++ b/drivers/rtc/rtc-max8925.c
@@ -69,7 +69,6 @@ struct max8925_rtc_info {
         struct max8925_chip     *chip;
         struct i2c_client       *rtc;
         struct device           *dev;
-        int                     irq;
 };
 
 static irqreturn_t rtc_update_handler(int irq, void *data)
@@ -194,17 +193,10 @@ static int max8925_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         ret = max8925_reg_read(info->rtc, MAX8925_RTC_IRQ_MASK);
         if (ret < 0)
                 goto out;
-        if (ret & ALARM0_IRQ) {
+        if ((ret & ALARM0_IRQ) == 0)
+                alrm->enabled = 1;
+        else
                 alrm->enabled = 0;
-        } else {
-                ret = max8925_reg_read(info->rtc, MAX8925_ALARM0_CNTL);
-                if (ret < 0)
-                        goto out;
-                if (!ret)
-                        alrm->enabled = 0;
-                else
-                        alrm->enabled = 1;
-        }
         ret = max8925_reg_read(info->rtc, MAX8925_RTC_STATUS);
         if (ret < 0)
                 goto out;
@@ -212,7 +204,6 @@ static int max8925_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
                 alrm->pending = 1;
         else
                 alrm->pending = 0;
-        return 0;
 out:
         return ret;
 }
@@ -229,11 +220,8 @@ static int max8925_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         ret = max8925_bulk_write(info->rtc, MAX8925_ALARM0_SEC, TIME_NUM, buf);
         if (ret < 0)
                 goto out;
-        if (alrm->enabled)
-                /* only enable alarm on year/month/day/hour/min/sec */
-                ret = max8925_reg_write(info->rtc, MAX8925_ALARM0_CNTL, 0x77);
-        else
-                ret = max8925_reg_write(info->rtc, MAX8925_ALARM0_CNTL, 0x0);
+        /* 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:
@@ -247,11 +235,11 @@ static const struct rtc_class_ops max8925_rtc_ops = {
         .set_alarm      = max8925_rtc_set_alarm,
 };
 
-static int max8925_rtc_probe(struct platform_device *pdev)
+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 ret;
+        int irq, ret;
 
         info = kzalloc(sizeof(struct max8925_rtc_info), GFP_KERNEL);
         if (!info)
@@ -259,13 +247,13 @@ static int max8925_rtc_probe(struct platform_device *pdev)
         info->chip = chip;
         info->rtc = chip->rtc;
         info->dev = &pdev->dev;
-        info->irq = platform_get_irq(pdev, 0);
+        irq = chip->irq_base + MAX8925_IRQ_RTC_ALARM0;
 
-        ret = request_threaded_irq(info->irq, NULL, rtc_update_handler,
+        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",
-                        info->irq, ret);
+                        irq, ret);
                 goto out_irq;
         }
 
@@ -273,8 +261,6 @@ static int max8925_rtc_probe(struct platform_device *pdev)
         /* XXX - isn't this redundant? */
         platform_set_drvdata(pdev, info);
 
-        device_init_wakeup(&pdev->dev, 1);
-
         info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
                                         &max8925_rtc_ops, THIS_MODULE);
         ret = PTR_ERR(info->rtc_dev);
@@ -286,58 +272,44 @@ static int max8925_rtc_probe(struct platform_device *pdev)
         return 0;
 out_rtc:
         platform_set_drvdata(pdev, NULL);
-        free_irq(info->irq, info);
+        free_irq(chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
 out_irq:
         kfree(info);
         return ret;
 }
 
-static int max8925_rtc_remove(struct platform_device *pdev)
+static int __devexit max8925_rtc_remove(struct platform_device *pdev)
 {
         struct max8925_rtc_info *info = platform_get_drvdata(pdev);
 
         if (info) {
-                free_irq(info->irq, info);
+                free_irq(info->chip->irq_base + MAX8925_IRQ_RTC_ALARM0, info);
                 rtc_device_unregister(info->rtc_dev);
                 kfree(info);
         }
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int max8925_rtc_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
-
-        if (device_may_wakeup(dev))
-                chip->wakeup_flag |= 1 << MAX8925_IRQ_RTC_ALARM0;
-        return 0;
-}
-static int max8925_rtc_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
-
-        if (device_may_wakeup(dev))
-                chip->wakeup_flag &= ~(1 << MAX8925_IRQ_RTC_ALARM0);
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(max8925_rtc_pm_ops, max8925_rtc_suspend, max8925_rtc_resume);
-
 static struct platform_driver max8925_rtc_driver = {
         .driver         = {
                 .name   = "max8925-rtc",
                 .owner  = THIS_MODULE,
-                .pm     = &max8925_rtc_pm_ops,
         },
         .probe          = max8925_rtc_probe,
-        .remove         = max8925_rtc_remove,
+        .remove         = __devexit_p(max8925_rtc_remove),
 };
 
-module_platform_driver(max8925_rtc_driver);
+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>");
diff --git a/drivers/rtc/rtc-max8998.c b/drivers/rtc/rtc-max8998.c
index 8f234a075e8..2e48aa60427 100644
--- a/drivers/rtc/rtc-max8998.c
+++ b/drivers/rtc/rtc-max8998.c
@@ -249,7 +249,7 @@ static const struct rtc_class_ops max8998_rtc_ops = {
         .alarm_irq_enable = max8998_rtc_alarm_irq_enable,
 };
 
-static int max8998_rtc_probe(struct platform_device *pdev)
+static int __devinit max8998_rtc_probe(struct platform_device *pdev)
 {
         struct max8998_dev *max8998 = dev_get_drvdata(pdev->dev.parent);
         struct max8998_platform_data *pdata = dev_get_platdata(max8998->dev);
@@ -298,7 +298,7 @@ out_rtc:
         return ret;
 }
 
-static int max8998_rtc_remove(struct platform_device *pdev)
+static int __devexit max8998_rtc_remove(struct platform_device *pdev)
 {
         struct max8998_rtc_info *info = platform_get_drvdata(pdev);
 
@@ -323,11 +323,21 @@ static struct platform_driver max8998_rtc_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = max8998_rtc_probe,
-        .remove         = max8998_rtc_remove,
+        .remove         = __devexit_p(max8998_rtc_remove),
         .id_table       = max8998_rtc_id,
 };
 
-module_platform_driver(max8998_rtc_driver);
+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>");
diff --git a/drivers/rtc/rtc-mc13xxx.c b/drivers/rtc/rtc-mc13xxx.c
index 2643d887492..a1a278bc340 100644
--- a/drivers/rtc/rtc-mc13xxx.c
+++ b/drivers/rtc/rtc-mc13xxx.c
@@ -309,7 +309,7 @@ static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
         return IRQ_HANDLED;
 }
 
-static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
+static int __devinit mc13xxx_rtc_probe(struct platform_device *pdev)
 {
         int ret;
         struct mc13xxx_rtc *priv;
@@ -378,7 +378,7 @@ err_reset_irq_request:
         return ret;
 }
 
-static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
+static int __devexit mc13xxx_rtc_remove(struct platform_device *pdev)
 {
         struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
 
@@ -399,21 +399,18 @@ static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
-static const struct platform_device_id mc13xxx_rtc_idtable[] = {
+const struct platform_device_id mc13xxx_rtc_idtable[] = {
         {
                 .name = "mc13783-rtc",
         }, {
                 .name = "mc13892-rtc",
-        }, {
-                .name = "mc34708-rtc",
         },
-        { /* sentinel */ }
+        { }
 };
-MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);
 
 static struct platform_driver mc13xxx_rtc_driver = {
         .id_table = mc13xxx_rtc_idtable,
-        .remove = __exit_p(mc13xxx_rtc_remove),
+        .remove = __devexit_p(mc13xxx_rtc_remove),
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
@@ -435,3 +432,4 @@ module_exit(mc13xxx_rtc_exit);
 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
 MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
 MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/rtc/rtc-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
index bec10be96f8..da60915818b 100644
--- a/drivers/rtc/rtc-mpc5121.c
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -306,7 +306,7 @@ static const struct rtc_class_ops mpc5200_rtc_ops = {
         .alarm_irq_enable = mpc5121_rtc_alarm_irq_enable,
 };
 
-static int mpc5121_rtc_probe(struct platform_device *op)
+static int __devinit mpc5121_rtc_probe(struct platform_device *op)
 {
         struct mpc5121_rtc_data *rtc;
         int err = 0;
@@ -327,7 +327,7 @@ static int mpc5121_rtc_probe(struct platform_device *op)
         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, 0,
+        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",
@@ -337,7 +337,7 @@ static int mpc5121_rtc_probe(struct platform_device *op)
 
         rtc->irq_periodic = irq_of_parse_and_map(op->dev.of_node, 0);
         err = request_irq(rtc->irq_periodic, mpc5121_rtc_handler_upd,
-                                0, "mpc5121-rtc_upd", &op->dev);
+                                IRQF_DISABLED, "mpc5121-rtc_upd", &op->dev);
         if (err) {
                 dev_err(&op->dev, "%s: could not request irq: %i\n",
                                                 __func__, rtc->irq_periodic);
@@ -364,7 +364,6 @@ static int mpc5121_rtc_probe(struct platform_device *op)
                 err = PTR_ERR(rtc->rtc);
                 goto out_free_irq;
         }
-        rtc->rtc->uie_unsupported = 1;
 
         return 0;
 
@@ -382,7 +381,7 @@ out_free:
         return err;
 }
 
-static int mpc5121_rtc_remove(struct platform_device *op)
+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;
@@ -403,7 +402,7 @@ static int mpc5121_rtc_remove(struct platform_device *op)
         return 0;
 }
 
-static struct of_device_id mpc5121_rtc_match[] = {
+static struct of_device_id mpc5121_rtc_match[] __devinitdata = {
         { .compatible = "fsl,mpc5121-rtc", },
         { .compatible = "fsl,mpc5200-rtc", },
         {},
@@ -416,10 +415,20 @@ static struct platform_driver mpc5121_rtc_driver = {
                 .of_match_table = mpc5121_rtc_match,
         },
         .probe = mpc5121_rtc_probe,
-        .remove = mpc5121_rtc_remove,
+        .remove = __devexit_p(mpc5121_rtc_remove),
 };
 
-module_platform_driver(mpc5121_rtc_driver);
+static int __init mpc5121_rtc_init(void)
+{
+        return platform_driver_register(&mpc5121_rtc_driver);
+}
+module_init(mpc5121_rtc_init);
+
+static void __exit mpc5121_rtc_exit(void)
+{
+        platform_driver_unregister(&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
index 578baf9d972..d33544802a2 100644
--- a/drivers/rtc/rtc-mrst.c
+++ b/drivers/rtc/rtc-mrst.c
@@ -76,15 +76,12 @@ static inline unsigned char vrtc_is_updating(void)
 /*
  * 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 1972 (1970 is UNIX time start point) as the base,
+ * 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 1972 will
+ * 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. Then why not use 1960 as the offset? If we use
- * 1960, for a device's first use, its YEAR register is 0 and the system
- * year will be parsed as 1960 which is not a valid UNIX time and will
- * cause many applications to fail mysteriously.
+ * physical rtc devices.
  */
 static int mrst_read_time(struct device *dev, struct rtc_time *time)
 {
@@ -102,10 +99,10 @@ static int mrst_read_time(struct device *dev, struct rtc_time *time)
         time->tm_year = vrtc_cmos_read(RTC_YEAR);
         spin_unlock_irqrestore(&rtc_lock, flags);
 
-        /* Adjust for the 1972/1900 */
-        time->tm_year += 72;
+        /* Adjust for the 1960/1900 */
+        time->tm_year += 60;
         time->tm_mon--;
-        return rtc_valid_tm(time);
+        return RTC_24H;
 }
 
 static int mrst_set_time(struct device *dev, struct rtc_time *time)
@@ -122,9 +119,9 @@ static int mrst_set_time(struct device *dev, struct rtc_time *time)
         min = time->tm_min;
         sec = time->tm_sec;
 
-        if (yrs < 72 || yrs > 138)
+        if (yrs < 70 || yrs > 138)
                 return -EINVAL;
-        yrs -= 72;
+        yrs -= 60;
 
         spin_lock_irqsave(&rtc_lock, flags);
 
@@ -322,8 +319,8 @@ static irqreturn_t mrst_rtc_irq(int irq, void *p)
         return IRQ_NONE;
 }
 
-static int vrtc_mrst_do_probe(struct device *dev, struct resource *iomem,
-                              int rtc_irq)
+static int __devinit
+vrtc_mrst_do_probe(struct device *dev, struct resource *iomem, int rtc_irq)
 {
         int retval = 0;
         unsigned char rtc_control;
@@ -366,7 +363,7 @@ static int vrtc_mrst_do_probe(struct device *dev, struct resource *iomem,
 
         if (rtc_irq) {
                 retval = request_irq(rtc_irq, mrst_rtc_irq,
-                                0, dev_name(&mrst_rtc.rtc->dev),
+                                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",
@@ -394,7 +391,7 @@ static void rtc_mrst_do_shutdown(void)
         spin_unlock_irq(&rtc_lock);
 }
 
-static void rtc_mrst_do_remove(struct device *dev)
+static void __devexit rtc_mrst_do_remove(struct device *dev)
 {
         struct mrst_rtc *mrst = dev_get_drvdata(dev);
         struct resource *iomem;
@@ -503,14 +500,14 @@ static inline int mrst_poweroff(struct device *dev)
 
 #endif
 
-static int vrtc_mrst_platform_probe(struct platform_device *pdev)
+static int __devinit vrtc_mrst_platform_probe(struct platform_device *pdev)
 {
         return vrtc_mrst_do_probe(&pdev->dev,
                         platform_get_resource(pdev, IORESOURCE_MEM, 0),
                         platform_get_irq(pdev, 0));
 }
 
-static int vrtc_mrst_platform_remove(struct platform_device *pdev)
+static int __devexit vrtc_mrst_platform_remove(struct platform_device *pdev)
 {
         rtc_mrst_do_remove(&pdev->dev);
         return 0;
@@ -528,7 +525,7 @@ MODULE_ALIAS("platform:vrtc_mrst");
 
 static struct platform_driver vrtc_mrst_platform_driver = {
         .probe          = vrtc_mrst_platform_probe,
-        .remove         = vrtc_mrst_platform_remove,
+        .remove         = __devexit_p(vrtc_mrst_platform_remove),
         .shutdown       = vrtc_mrst_platform_shutdown,
         .driver = {
                 .name           = (char *) driver_name,
@@ -537,7 +534,18 @@ static struct platform_driver vrtc_mrst_platform_driver = {
         }
 };
 
-module_platform_driver(vrtc_mrst_platform_driver);
+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");
diff --git a/drivers/rtc/rtc-mv.c b/drivers/rtc/rtc-mv.c
index 57233c88599..60627a76451 100644
--- a/drivers/rtc/rtc-mv.c
+++ b/drivers/rtc/rtc-mv.c
@@ -12,10 +12,8 @@
 #include <linux/bcd.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
-#include <linux/of.h>
 #include <linux/delay.h>
 #include <linux/gfp.h>
-#include <linux/module.h>
 
 
 #define RTC_TIME_REG_OFFS       0
@@ -215,7 +213,7 @@ static const struct rtc_class_ops mv_rtc_alarm_ops = {
         .alarm_irq_enable = mv_rtc_alarm_irq_enable,
 };
 
-static int mv_rtc_probe(struct platform_device *pdev)
+static int __devinit mv_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct rtc_plat_data *pdata;
@@ -274,7 +272,7 @@ static int mv_rtc_probe(struct platform_device *pdev)
         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_SHARED,
+                                     IRQF_DISABLED | IRQF_SHARED,
                                      pdev->name, pdata) < 0) {
                         dev_warn(&pdev->dev, "interrupt not available.\n");
                         pdata->irq = -1;
@@ -295,19 +293,11 @@ static int __exit mv_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_OF
-static struct of_device_id rtc_mv_of_match_table[] = {
-        { .compatible = "marvell,orion-rtc", },
-        {}
-};
-#endif
-
 static struct platform_driver mv_rtc_driver = {
         .remove         = __exit_p(mv_rtc_remove),
         .driver         = {
                 .name   = "rtc-mv",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(rtc_mv_of_match_table),
         },
 };
 
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 1c3ef728956..39e41fbdf08 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -17,6 +17,8 @@
 #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)
@@ -70,37 +72,13 @@ static const u32 PIE_BIT_DEF[MAX_PIE_NUM][2] = {
 #define RTC_TEST2       0x2C    /*  32bit rtc test reg 2 */
 #define RTC_TEST3       0x30    /*  32bit rtc test reg 3 */
 
-enum imx_rtc_type {
-        IMX1_RTC,
-        IMX21_RTC,
-};
-
 struct rtc_plat_data {
         struct rtc_device *rtc;
         void __iomem *ioaddr;
         int irq;
         struct clk *clk;
         struct rtc_time g_rtc_alarm;
-        enum imx_rtc_type devtype;
-};
-
-static struct platform_device_id imx_rtc_devtype[] = {
-        {
-                .name = "imx1-rtc",
-                .driver_data = IMX1_RTC,
-        }, {
-                .name = "imx21-rtc",
-                .driver_data = IMX21_RTC,
-        }, {
-                /* sentinel */
-        }
 };
-MODULE_DEVICE_TABLE(platform, imx_rtc_devtype);
-
-static inline int is_imx1_rtc(struct rtc_plat_data *data)
-{
-        return data->devtype == IMX1_RTC;
-}
 
 /*
  * This function is used to obtain the RTC time or the alarm value in
@@ -177,6 +155,7 @@ 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;
@@ -189,33 +168,21 @@ static int rtc_update_alarm(struct device *dev, struct rtc_time *alrm)
         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 0;
-}
-
-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);
+        return ret;
 }
 
 /* This function is the RTC interrupt service routine. */
@@ -224,21 +191,21 @@ 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;
-        unsigned long flags;
         u32 status;
         u32 events = 0;
 
-        spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
+        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) {
+        if (status & RTC_ALM_BIT)
                 events |= (RTC_AF | RTC_IRQF);
-                /* RTC alarm should be one-shot */
-                mxc_rtc_irq_enable(&pdev->dev, RTC_ALM_BIT, 0);
-        }
 
         if (status & RTC_1HZ_BIT)
                 events |= (RTC_UF | RTC_IRQF);
@@ -246,8 +213,11 @@ static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
         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_irqrestore(&pdata->rtc->irq_lock, flags);
+        spin_unlock_irq(&pdata->rtc->irq_lock);
 
         return IRQ_HANDLED;
 }
@@ -272,6 +242,26 @@ static void mxc_rtc_release(struct device *dev)
         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);
@@ -300,20 +290,6 @@ static int mxc_rtc_read_time(struct device *dev, struct rtc_time *tm)
  */
 static int mxc_rtc_set_mmss(struct device *dev, unsigned long time)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-
-        /*
-         * TTC_DAYR register is 9-bit in MX1 SoC, save time and day of year only
-         */
-        if (is_imx1_rtc(pdata)) {
-                struct rtc_time tm;
-
-                rtc_time_to_tm(time, &tm);
-                tm.tm_year = 70;
-                rtc_tm_to_time(&tm, &time);
-        }
-
         /* Avoid roll-over from reading the different registers */
         do {
                 set_alarm_or_time(dev, MXC_RTC_TIME, time);
@@ -348,7 +324,21 @@ static int mxc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         int ret;
 
-        ret = rtc_update_alarm(dev, &alrm->time);
+        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;
 
@@ -368,7 +358,7 @@ static struct rtc_class_ops mxc_rtc_ops = {
         .alarm_irq_enable       = mxc_rtc_alarm_irq_enable,
 };
 
-static int mxc_rtc_probe(struct platform_device *pdev)
+static int __init mxc_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct rtc_device *rtc;
@@ -385,8 +375,6 @@ static int mxc_rtc_probe(struct platform_device *pdev)
         if (!pdata)
                 return -ENOMEM;
 
-        pdata->devtype = pdev->id_entry->driver_data;
-
         if (!devm_request_mem_region(&pdev->dev, res->start,
                                      resource_size(res), pdev->name))
                 return -EBUSY;
@@ -394,14 +382,14 @@ static int mxc_rtc_probe(struct platform_device *pdev)
         pdata->ioaddr = devm_ioremap(&pdev->dev, res->start,
                                      resource_size(res));
 
-        pdata->clk = devm_clk_get(&pdev->dev, NULL);
+        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_prepare_enable(pdata->clk);
+        clk_enable(pdata->clk);
         rate = clk_get_rate(pdata->clk);
 
         if (rate == 32768)
@@ -436,9 +424,6 @@ static int mxc_rtc_probe(struct platform_device *pdev)
                 pdata->irq = -1;
         }
 
-        if (pdata->irq >=0)
-                device_init_wakeup(&pdev->dev, 1);
-
         rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
                                   THIS_MODULE);
         if (IS_ERR(rtc)) {
@@ -453,66 +438,47 @@ static int mxc_rtc_probe(struct platform_device *pdev)
 exit_clr_drvdata:
         platform_set_drvdata(pdev, NULL);
 exit_put_clk:
-        clk_disable_unprepare(pdata->clk);
+        clk_disable(pdata->clk);
+        clk_put(pdata->clk);
 
 exit_free_pdata:
 
         return ret;
 }
 
-static int mxc_rtc_remove(struct platform_device *pdev)
+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_unprepare(pdata->clk);
+        clk_disable(pdata->clk);
+        clk_put(pdata->clk);
         platform_set_drvdata(pdev, NULL);
 
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int mxc_rtc_suspend(struct device *dev)
-{
-        struct rtc_plat_data *pdata = dev_get_drvdata(dev);
-
-        if (device_may_wakeup(dev))
-                enable_irq_wake(pdata->irq);
-
-        return 0;
-}
-
-static int mxc_rtc_resume(struct device *dev)
-{
-        struct rtc_plat_data *pdata = dev_get_drvdata(dev);
-
-        if (device_may_wakeup(dev))
-                disable_irq_wake(pdata->irq);
-
-        return 0;
-}
-
-static struct dev_pm_ops mxc_rtc_pm_ops = {
-        .suspend        = mxc_rtc_suspend,
-        .resume         = mxc_rtc_resume,
-};
-#endif
-
 static struct platform_driver mxc_rtc_driver = {
         .driver = {
                    .name        = "mxc_rtc",
-#ifdef CONFIG_PM
-                   .pm          = &mxc_rtc_pm_ops,
-#endif
                    .owner       = THIS_MODULE,
         },
-        .id_table = imx_rtc_devtype,
-        .probe = mxc_rtc_probe,
-        .remove = mxc_rtc_remove,
+        .remove         = __exit_p(mxc_rtc_remove),
 };
 
-module_platform_driver(mxc_rtc_driver)
+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");
diff --git a/drivers/rtc/rtc-nuc900.c b/drivers/rtc/rtc-nuc900.c
index a63680850fe..781068d62f2 100644
--- a/drivers/rtc/rtc-nuc900.c
+++ b/drivers/rtc/rtc-nuc900.c
@@ -222,7 +222,7 @@ static struct rtc_class_ops nuc900_rtc_ops = {
         .alarm_irq_enable = nuc900_alarm_irq_enable,
 };
 
-static int nuc900_rtc_probe(struct platform_device *pdev)
+static int __devinit nuc900_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct nuc900_rtc *nuc900_rtc;
@@ -269,7 +269,7 @@ static int nuc900_rtc_probe(struct platform_device *pdev)
 
         nuc900_rtc->irq_num = platform_get_irq(pdev, 0);
         if (request_irq(nuc900_rtc->irq_num, nuc900_rtc_interrupt,
-                                0, "nuc900rtc", nuc900_rtc)) {
+                                IRQF_DISABLED, "nuc900rtc", nuc900_rtc)) {
                 dev_err(&pdev->dev, "NUC900 RTC request irq failed\n");
                 err = -EBUSY;
                 goto fail4;
@@ -284,7 +284,7 @@ fail1:	kfree(nuc900_rtc);
         return err;
 }
 
-static int nuc900_rtc_remove(struct platform_device *pdev)
+static int __devexit nuc900_rtc_remove(struct platform_device *pdev)
 {
         struct nuc900_rtc *nuc900_rtc = platform_get_drvdata(pdev);
         struct resource *res;
@@ -304,7 +304,7 @@ static int nuc900_rtc_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver nuc900_rtc_driver = {
-        .remove         = nuc900_rtc_remove,
+        .remove         = __devexit_p(nuc900_rtc_remove),
         .driver         = {
                 .name   = "nuc900-rtc",
                 .owner  = THIS_MODULE,
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 600971407aa..7789002bdd5 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -20,9 +20,6 @@
 #include <linux/rtc.h>
 #include <linux/bcd.h>
 #include <linux/platform_device.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include <linux/pm_runtime.h>
 
 #include <asm/io.h>
 
@@ -41,8 +38,6 @@
  * the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.
  */
 
-#define DRIVER_NAME                     "omap_rtc"
-
 #define OMAP_RTC_BASE                   0xfffb4800
 
 /* RTC registers */
@@ -69,9 +64,6 @@
 #define OMAP_RTC_COMP_MSB_REG           0x50
 #define OMAP_RTC_OSC_REG                0x54
 
-#define OMAP_RTC_KICK0_REG              0x6c
-#define OMAP_RTC_KICK1_REG              0x70
-
 /* OMAP_RTC_CTRL_REG bit fields: */
 #define OMAP_RTC_CTRL_SPLIT             (1<<7)
 #define OMAP_RTC_CTRL_DISABLE           (1<<6)
@@ -96,18 +88,10 @@
 #define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
 #define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
 
-/* OMAP_RTC_KICKER values */
-#define KICK0_VALUE                     0x83e70b13
-#define KICK1_VALUE                     0x95a4f1e0
-
-#define OMAP_RTC_HAS_KICKER             0x1
-
 static void __iomem     *rtc_base;
 
-#define rtc_read(addr)          readb(rtc_base + (addr))
-#define rtc_write(val, addr)    writeb(val, rtc_base + (addr))
-
-#define rtc_writel(val, addr)   writel(val, 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),
@@ -301,38 +285,11 @@ static struct rtc_class_ops omap_rtc_ops = {
 static int omap_rtc_alarm;
 static int omap_rtc_timer;
 
-#define OMAP_RTC_DATA_DA830_IDX 1
-
-static struct platform_device_id omap_rtc_devtype[] = {
-        {
-                .name   = DRIVER_NAME,
-        }, {
-                .name   = "da830-rtc",
-                .driver_data = OMAP_RTC_HAS_KICKER,
-        },
-        {},
-};
-MODULE_DEVICE_TABLE(platform, omap_rtc_devtype);
-
-static const struct of_device_id omap_rtc_of_match[] = {
-        {       .compatible     = "ti,da830-rtc",
-                .data           = &omap_rtc_devtype[OMAP_RTC_DATA_DA830_IDX],
-        },
-        {},
-};
-MODULE_DEVICE_TABLE(of, omap_rtc_of_match);
-
 static int __init omap_rtc_probe(struct platform_device *pdev)
 {
         struct resource         *res, *mem;
         struct rtc_device       *rtc;
         u8                      reg, new_ctrl;
-        const struct platform_device_id *id_entry;
-        const struct of_device_id *of_id;
-
-        of_id = of_match_device(omap_rtc_of_match, &pdev->dev);
-        if (of_id)
-                pdev->id_entry = of_id->data;
 
         omap_rtc_timer = platform_get_irq(pdev, 0);
         if (omap_rtc_timer <= 0) {
@@ -365,16 +322,6 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                 goto fail;
         }
 
-        /* Enable the clock/module so that we can access the registers */
-        pm_runtime_enable(&pdev->dev);
-        pm_runtime_get_sync(&pdev->dev);
-
-        id_entry = platform_get_device_id(pdev);
-        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER)) {
-                rtc_writel(KICK0_VALUE, OMAP_RTC_KICK0_REG);
-                rtc_writel(KICK1_VALUE, OMAP_RTC_KICK1_REG);
-        }
-
         rtc = rtc_device_register(pdev->name, &pdev->dev,
                         &omap_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
@@ -401,14 +348,14 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                 rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
 
         /* handle periodic and alarm irqs */
-        if (request_irq(omap_rtc_timer, rtc_irq, 0,
+        if (request_irq(omap_rtc_timer, rtc_irq, IRQF_DISABLED,
                         dev_name(&rtc->dev), rtc)) {
                 pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
                         pdev->name, omap_rtc_timer);
                 goto fail1;
         }
         if ((omap_rtc_timer != omap_rtc_alarm) &&
-                (request_irq(omap_rtc_alarm, rtc_irq, 0,
+                (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);
@@ -451,10 +398,6 @@ fail2:
 fail1:
         rtc_device_unregister(rtc);
 fail0:
-        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
-                rtc_writel(0, OMAP_RTC_KICK0_REG);
-        pm_runtime_put_sync(&pdev->dev);
-        pm_runtime_disable(&pdev->dev);
         iounmap(rtc_base);
 fail:
         release_mem_region(mem->start, resource_size(mem));
@@ -465,8 +408,6 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device       *rtc = platform_get_drvdata(pdev);
         struct resource         *mem = dev_get_drvdata(&rtc->dev);
-        const struct platform_device_id *id_entry =
-                                platform_get_device_id(pdev);
 
         device_init_wakeup(&pdev->dev, 0);
 
@@ -479,13 +420,6 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
                 free_irq(omap_rtc_alarm, rtc);
 
         rtc_device_unregister(rtc);
-        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
-                rtc_writel(0, OMAP_RTC_KICK0_REG);
-
-        /* Disable the clock/module */
-        pm_runtime_put_sync(&pdev->dev);
-        pm_runtime_disable(&pdev->dev);
-
         iounmap(rtc_base);
         release_mem_region(mem->start, resource_size(mem));
         return 0;
@@ -508,17 +442,11 @@ static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
         else
                 rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 
-        /* Disable the clock/module */
-        pm_runtime_put_sync(&pdev->dev);
-
         return 0;
 }
 
 static int omap_rtc_resume(struct platform_device *pdev)
 {
-        /* Enable the clock/module so that we can access the registers */
-        pm_runtime_get_sync(&pdev->dev);
-
         if (device_may_wakeup(&pdev->dev))
                 disable_irq_wake(omap_rtc_alarm);
         else
@@ -543,11 +471,9 @@ static struct platform_driver omap_rtc_driver = {
         .resume         = omap_rtc_resume,
         .shutdown       = omap_rtc_shutdown,
         .driver         = {
-                .name   = DRIVER_NAME,
+                .name   = "omap_rtc",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(omap_rtc_of_match),
         },
-        .id_table       = omap_rtc_devtype,
 };
 
 static int __init rtc_init(void)
diff --git a/drivers/rtc/rtc-pcap.c b/drivers/rtc/rtc-pcap.c
index e0019cd0bf7..cd4f198cc2e 100644
--- a/drivers/rtc/rtc-pcap.c
+++ b/drivers/rtc/rtc-pcap.c
@@ -139,7 +139,7 @@ static const struct rtc_class_ops pcap_rtc_ops = {
         .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
 };
 
-static int pcap_rtc_probe(struct platform_device *pdev)
+static int __devinit pcap_rtc_probe(struct platform_device *pdev)
 {
         struct pcap_rtc *pcap_rtc;
         int timer_irq, alarm_irq;
@@ -183,7 +183,7 @@ fail_rtc:
         return err;
 }
 
-static int pcap_rtc_remove(struct platform_device *pdev)
+static int __devexit pcap_rtc_remove(struct platform_device *pdev)
 {
         struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
 
@@ -196,7 +196,7 @@ static int pcap_rtc_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver pcap_rtc_driver = {
-        .remove = pcap_rtc_remove,
+        .remove = __devexit_p(pcap_rtc_remove),
         .driver = {
                 .name  = "pcap-rtc",
                 .owner = THIS_MODULE,
diff --git a/drivers/rtc/rtc-pcf2123.c b/drivers/rtc/rtc-pcf2123.c
index 02b742afa76..71bab0ef544 100644
--- a/drivers/rtc/rtc-pcf2123.c
+++ b/drivers/rtc/rtc-pcf2123.c
@@ -42,8 +42,6 @@
 #include <linux/slab.h>
 #include <linux/rtc.h>
 #include <linux/spi/spi.h>
-#include <linux/module.h>
-#include <linux/sysfs.h>
 
 #define DRV_VERSION "0.6"
 
@@ -219,7 +217,7 @@ static const struct rtc_class_ops pcf2123_rtc_ops = {
         .set_time       = pcf2123_rtc_set_time,
 };
 
-static int pcf2123_probe(struct spi_device *spi)
+static int __devinit pcf2123_probe(struct spi_device *spi)
 {
         struct rtc_device *rtc;
         struct pcf2123_plat_data *pdata;
@@ -293,7 +291,6 @@ static int pcf2123_probe(struct spi_device *spi)
         pdata->rtc = rtc;
 
         for (i = 0; i < 16; i++) {
-                sysfs_attr_init(&pdata->regs[i].attr.attr);
                 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;
@@ -319,7 +316,7 @@ kfree_exit:
         return ret;
 }
 
-static int pcf2123_remove(struct spi_device *spi)
+static int __devexit pcf2123_remove(struct spi_device *spi)
 {
         struct pcf2123_plat_data *pdata = spi->dev.platform_data;
         int i;
@@ -342,15 +339,27 @@ static int pcf2123_remove(struct spi_device *spi)
 static struct spi_driver pcf2123_driver = {
         .driver = {
                         .name   = "rtc-pcf2123",
+                        .bus    = &spi_bus_type,
                         .owner  = THIS_MODULE,
         },
         .probe  = pcf2123_probe,
-        .remove = pcf2123_remove,
+        .remove = __devexit_p(pcf2123_remove),
 };
 
-module_spi_driver(pcf2123_driver);
+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 e9f3135d305..0c423892923 100644
--- a/drivers/rtc/rtc-pcf50633.c
+++ b/drivers/rtc/rtc-pcf50633.c
@@ -248,7 +248,7 @@ static void pcf50633_rtc_irq(int irq, void *data)
         rtc->alarm_pending = 1;
 }
 
-static int pcf50633_rtc_probe(struct platform_device *pdev)
+static int __devinit pcf50633_rtc_probe(struct platform_device *pdev)
 {
         struct pcf50633_rtc *rtc;
 
@@ -272,7 +272,7 @@ static int pcf50633_rtc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int pcf50633_rtc_remove(struct platform_device *pdev)
+static int __devexit pcf50633_rtc_remove(struct platform_device *pdev)
 {
         struct pcf50633_rtc *rtc;
 
@@ -291,10 +291,20 @@ static struct platform_driver pcf50633_rtc_driver = {
                 .name = "pcf50633-rtc",
         },
         .probe = pcf50633_rtc_probe,
-        .remove = pcf50633_rtc_remove,
+        .remove = __devexit_p(pcf50633_rtc_remove),
 };
 
-module_platform_driver(pcf50633_rtc_driver);
+static int __init pcf50633_rtc_init(void)
+{
+        return platform_driver_register(&pcf50633_rtc_driver);
+}
+module_init(pcf50633_rtc_init);
+
+static void __exit pcf50633_rtc_exit(void)
+{
+        platform_driver_unregister(&pcf50633_rtc_driver);
+}
+module_exit(pcf50633_rtc_exit);
 
 MODULE_DESCRIPTION("PCF50633 RTC driver");
 MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
diff --git a/drivers/rtc/rtc-pcf8523.c b/drivers/rtc/rtc-pcf8523.c
deleted file mode 100644
index be05a645f99..00000000000
--- a/drivers/rtc/rtc-pcf8523.c
+++ /dev/null
@@ -1,326 +0,0 @@
-/*
- * Copyright (C) 2012 Avionic Design GmbH
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/bcd.h>
-#include <linux/i2c.h>
-#include <linux/module.h>
-#include <linux/rtc.h>
-#include <linux/of.h>
-
-#define DRIVER_NAME "rtc-pcf8523"
-
-#define REG_CONTROL1 0x00
-#define REG_CONTROL1_CAP_SEL (1 << 7)
-#define REG_CONTROL1_STOP    (1 << 5)
-
-#define REG_CONTROL3 0x02
-#define REG_CONTROL3_PM_BLD (1 << 7) /* battery low detection disabled */
-#define REG_CONTROL3_PM_VDD (1 << 6) /* switch-over disabled */
-#define REG_CONTROL3_PM_DSM (1 << 5) /* direct switching mode */
-#define REG_CONTROL3_PM_MASK 0xe0
-
-#define REG_SECONDS  0x03
-#define REG_SECONDS_OS (1 << 7)
-
-#define REG_MINUTES  0x04
-#define REG_HOURS    0x05
-#define REG_DAYS     0x06
-#define REG_WEEKDAYS 0x07
-#define REG_MONTHS   0x08
-#define REG_YEARS    0x09
-
-struct pcf8523 {
-        struct rtc_device *rtc;
-};
-
-static int pcf8523_read(struct i2c_client *client, u8 reg, u8 *valuep)
-{
-        struct i2c_msg msgs[2];
-        u8 value = 0;
-        int err;
-
-        msgs[0].addr = client->addr;
-        msgs[0].flags = 0;
-        msgs[0].len = sizeof(reg);
-        msgs[0].buf = &reg;
-
-        msgs[1].addr = client->addr;
-        msgs[1].flags = I2C_M_RD;
-        msgs[1].len = sizeof(value);
-        msgs[1].buf = &value;
-
-        err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-        if (err < 0)
-                return err;
-
-        *valuep = value;
-
-        return 0;
-}
-
-static int pcf8523_write(struct i2c_client *client, u8 reg, u8 value)
-{
-        u8 buffer[2] = { reg, value };
-        struct i2c_msg msg;
-        int err;
-
-        msg.addr = client->addr;
-        msg.flags = 0;
-        msg.len = sizeof(buffer);
-        msg.buf = buffer;
-
-        err = i2c_transfer(client->adapter, &msg, 1);
-        if (err < 0)
-                return err;
-
-        return 0;
-}
-
-static int pcf8523_select_capacitance(struct i2c_client *client, bool high)
-{
-        u8 value;
-        int err;
-
-        err = pcf8523_read(client, REG_CONTROL1, &value);
-        if (err < 0)
-                return err;
-
-        if (!high)
-                value &= ~REG_CONTROL1_CAP_SEL;
-        else
-                value |= REG_CONTROL1_CAP_SEL;
-
-        err = pcf8523_write(client, REG_CONTROL1, value);
-        if (err < 0)
-                return err;
-
-        return err;
-}
-
-static int pcf8523_set_pm(struct i2c_client *client, u8 pm)
-{
-        u8 value;
-        int err;
-
-        err = pcf8523_read(client, REG_CONTROL3, &value);
-        if (err < 0)
-                return err;
-
-        value = (value & ~REG_CONTROL3_PM_MASK) | pm;
-
-        err = pcf8523_write(client, REG_CONTROL3, value);
-        if (err < 0)
-                return err;
-
-        return 0;
-}
-
-static int pcf8523_stop_rtc(struct i2c_client *client)
-{
-        u8 value;
-        int err;
-
-        err = pcf8523_read(client, REG_CONTROL1, &value);
-        if (err < 0)
-                return err;
-
-        value |= REG_CONTROL1_STOP;
-
-        err = pcf8523_write(client, REG_CONTROL1, value);
-        if (err < 0)
-                return err;
-
-        return 0;
-}
-
-static int pcf8523_start_rtc(struct i2c_client *client)
-{
-        u8 value;
-        int err;
-
-        err = pcf8523_read(client, REG_CONTROL1, &value);
-        if (err < 0)
-                return err;
-
-        value &= ~REG_CONTROL1_STOP;
-
-        err = pcf8523_write(client, REG_CONTROL1, value);
-        if (err < 0)
-                return err;
-
-        return 0;
-}
-
-static int pcf8523_rtc_read_time(struct device *dev, struct rtc_time *tm)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        u8 start = REG_SECONDS, regs[7];
-        struct i2c_msg msgs[2];
-        int err;
-
-        msgs[0].addr = client->addr;
-        msgs[0].flags = 0;
-        msgs[0].len = 1;
-        msgs[0].buf = &start;
-
-        msgs[1].addr = client->addr;
-        msgs[1].flags = I2C_M_RD;
-        msgs[1].len = sizeof(regs);
-        msgs[1].buf = regs;
-
-        err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-        if (err < 0)
-                return err;
-
-        if (regs[0] & REG_SECONDS_OS) {
-                /*
-                 * If the oscillator was stopped, try to clear the flag. Upon
-                 * power-up the flag is always set, but if we cannot clear it
-                 * the oscillator isn't running properly for some reason. The
-                 * sensible thing therefore is to return an error, signalling
-                 * that the clock cannot be assumed to be correct.
-                 */
-
-                regs[0] &= ~REG_SECONDS_OS;
-
-                err = pcf8523_write(client, REG_SECONDS, regs[0]);
-                if (err < 0)
-                        return err;
-
-                err = pcf8523_read(client, REG_SECONDS, &regs[0]);
-                if (err < 0)
-                        return err;
-
-                if (regs[0] & REG_SECONDS_OS)
-                        return -EAGAIN;
-        }
-
-        tm->tm_sec = bcd2bin(regs[0] & 0x7f);
-        tm->tm_min = bcd2bin(regs[1] & 0x7f);
-        tm->tm_hour = bcd2bin(regs[2] & 0x3f);
-        tm->tm_mday = bcd2bin(regs[3] & 0x3f);
-        tm->tm_wday = regs[4] & 0x7;
-        tm->tm_mon = bcd2bin(regs[5] & 0x1f);
-        tm->tm_year = bcd2bin(regs[6]) + 100;
-
-        return rtc_valid_tm(tm);
-}
-
-static int pcf8523_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct i2c_msg msg;
-        u8 regs[8];
-        int err;
-
-        err = pcf8523_stop_rtc(client);
-        if (err < 0)
-                return err;
-
-        regs[0] = REG_SECONDS;
-        regs[1] = bin2bcd(tm->tm_sec);
-        regs[2] = bin2bcd(tm->tm_min);
-        regs[3] = bin2bcd(tm->tm_hour);
-        regs[4] = bin2bcd(tm->tm_mday);
-        regs[5] = tm->tm_wday;
-        regs[6] = bin2bcd(tm->tm_mon);
-        regs[7] = bin2bcd(tm->tm_year - 100);
-
-        msg.addr = client->addr;
-        msg.flags = 0;
-        msg.len = sizeof(regs);
-        msg.buf = regs;
-
-        err = i2c_transfer(client->adapter, &msg, 1);
-        if (err < 0) {
-                /*
-                 * If the time cannot be set, restart the RTC anyway. Note
-                 * that errors are ignored if the RTC cannot be started so
-                 * that we have a chance to propagate the original error.
-                 */
-                pcf8523_start_rtc(client);
-                return err;
-        }
-
-        return pcf8523_start_rtc(client);
-}
-
-static const struct rtc_class_ops pcf8523_rtc_ops = {
-        .read_time = pcf8523_rtc_read_time,
-        .set_time = pcf8523_rtc_set_time,
-};
-
-static int pcf8523_probe(struct i2c_client *client,
-                         const struct i2c_device_id *id)
-{
-        struct pcf8523 *pcf;
-        int err;
-
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
-                return -ENODEV;
-
-        pcf = devm_kzalloc(&client->dev, sizeof(*pcf), GFP_KERNEL);
-        if (!pcf)
-                return -ENOMEM;
-
-        err = pcf8523_select_capacitance(client, true);
-        if (err < 0)
-                return err;
-
-        err = pcf8523_set_pm(client, 0);
-        if (err < 0)
-                return err;
-
-        pcf->rtc = rtc_device_register(DRIVER_NAME, &client->dev,
-                                       &pcf8523_rtc_ops, THIS_MODULE);
-        if (IS_ERR(pcf->rtc))
-                return PTR_ERR(pcf->rtc);
-
-        i2c_set_clientdata(client, pcf);
-
-        return 0;
-}
-
-static int pcf8523_remove(struct i2c_client *client)
-{
-        struct pcf8523 *pcf = i2c_get_clientdata(client);
-
-        rtc_device_unregister(pcf->rtc);
-
-        return 0;
-}
-
-static const struct i2c_device_id pcf8523_id[] = {
-        { "pcf8523", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, pcf8523_id);
-
-#ifdef CONFIG_OF
-static const struct of_device_id pcf8523_of_match[] = {
-        { .compatible = "nxp,pcf8523" },
-        { }
-};
-MODULE_DEVICE_TABLE(of, pcf8523_of_match);
-#endif
-
-static struct i2c_driver pcf8523_driver = {
-        .driver = {
-                .name = DRIVER_NAME,
-                .owner = THIS_MODULE,
-                .of_match_table = of_match_ptr(pcf8523_of_match),
-        },
-        .probe = pcf8523_probe,
-        .remove = pcf8523_remove,
-        .id_table = pcf8523_id,
-};
-module_i2c_driver(pcf8523_driver);
-
-MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
-MODULE_DESCRIPTION("NXP PCF8523 RTC driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index 7098ee89bd2..b42c0c67926 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -18,8 +18,6 @@
 #include <linux/bcd.h>
 #include <linux/rtc.h>
 #include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/of.h>
 
 #define DRV_VERSION "0.4.3"
 
@@ -65,7 +63,6 @@ struct pcf8563 {
          * 1970...2069.
          */
         int c_polarity; /* 0: MO_C=1 means 19xx, otherwise MO_C=1 means 20xx */
-        int voltage_low; /* incicates if a low_voltage was detected */
 };
 
 /*
@@ -78,17 +75,8 @@ static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         unsigned char buf[13] = { PCF8563_REG_ST1 };
 
         struct i2c_msg msgs[] = {
-                {/* setup read ptr */
-                        .addr = client->addr,
-                        .len = 1,
-                        .buf = buf
-                },
-                {/* read status + date */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 13,
-                        .buf = buf
-                },
+                { client->addr, 0, 1, buf },    /* setup read ptr */
+                { client->addr, I2C_M_RD, 13, buf },    /* read status + date */
         };
 
         /* read registers */
@@ -97,11 +85,9 @@ static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
                 return -EIO;
         }
 
-        if (buf[PCF8563_REG_SC] & PCF8563_SC_LV) {
-                pcf8563->voltage_low = 1;
+        if (buf[PCF8563_REG_SC] & PCF8563_SC_LV)
                 dev_info(&client->dev,
                         "low voltage detected, date/time is not reliable.\n");
-        }
 
         dev_dbg(&client->dev,
                 "%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
@@ -186,44 +172,6 @@ static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm)
         return 0;
 }
 
-#ifdef CONFIG_RTC_INTF_DEV
-static int pcf8563_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
-{
-        struct pcf8563 *pcf8563 = i2c_get_clientdata(to_i2c_client(dev));
-        struct rtc_time tm;
-
-        switch (cmd) {
-        case RTC_VL_READ:
-                if (pcf8563->voltage_low)
-                        dev_info(dev, "low voltage detected, date/time is not reliable.\n");
-
-                if (copy_to_user((void __user *)arg, &pcf8563->voltage_low,
-                                        sizeof(int)))
-                        return -EFAULT;
-                return 0;
-        case RTC_VL_CLR:
-                /*
-                 * Clear the VL bit in the seconds register in case
-                 * the time has not been set already (which would
-                 * have cleared it). This does not really matter
-                 * because of the cached voltage_low value but do it
-                 * anyway for consistency.
-                 */
-                if (pcf8563_get_datetime(to_i2c_client(dev), &tm))
-                        pcf8563_set_datetime(to_i2c_client(dev), &tm);
-
-                /* Clear the cached value. */
-                pcf8563->voltage_low = 0;
-
-                return 0;
-        default:
-                return -ENOIOCTLCMD;
-        }
-}
-#else
-#define pcf8563_rtc_ioctl NULL
-#endif
-
 static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         return pcf8563_get_datetime(to_i2c_client(dev), tm);
@@ -235,7 +183,6 @@ static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm)
 }
 
 static const struct rtc_class_ops pcf8563_rtc_ops = {
-        .ioctl          = pcf8563_rtc_ioctl,
         .read_time      = pcf8563_rtc_read_time,
         .set_time       = pcf8563_rtc_set_time,
 };
@@ -295,28 +242,29 @@ static const struct i2c_device_id pcf8563_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, pcf8563_id);
 
-#ifdef CONFIG_OF
-static const struct of_device_id pcf8563_of_match[] = {
-        { .compatible = "nxp,pcf8563" },
-        {}
-};
-MODULE_DEVICE_TABLE(of, pcf8563_of_match);
-#endif
-
 static struct i2c_driver pcf8563_driver = {
         .driver         = {
                 .name   = "rtc-pcf8563",
-                .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(pcf8563_of_match),
         },
         .probe          = pcf8563_probe,
         .remove         = pcf8563_remove,
         .id_table       = pcf8563_id,
 };
 
-module_i2c_driver(pcf8563_driver);
+static int __init pcf8563_init(void)
+{
+        return i2c_add_driver(&pcf8563_driver);
+}
+
+static void __exit pcf8563_exit(void)
+{
+        i2c_del_driver(&pcf8563_driver);
+}
 
 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 MODULE_DESCRIPTION("Philips PCF8563/Epson RTC8564 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+
+module_init(pcf8563_init);
+module_exit(pcf8563_exit);
diff --git a/drivers/rtc/rtc-pcf8583.c b/drivers/rtc/rtc-pcf8583.c
index 3415b8f1855..2d201afead3 100644
--- a/drivers/rtc/rtc-pcf8583.c
+++ b/drivers/rtc/rtc-pcf8583.c
@@ -294,7 +294,7 @@ exit_kfree:
         return err;
 }
 
-static int pcf8583_remove(struct i2c_client *client)
+static int __devexit pcf8583_remove(struct i2c_client *client)
 {
         struct pcf8583 *pcf8583 = i2c_get_clientdata(client);
 
@@ -316,11 +316,22 @@ static struct i2c_driver pcf8583_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = pcf8583_probe,
-        .remove         = pcf8583_remove,
+        .remove         = __devexit_p(pcf8583_remove),
         .id_table       = pcf8583_id,
 };
 
-module_i2c_driver(pcf8583_driver);
+static __init int pcf8583_init(void)
+{
+        return i2c_add_driver(&pcf8583_driver);
+}
+
+static __exit void pcf8583_exit(void)
+{
+        i2c_del_driver(&pcf8583_driver);
+}
+
+module_init(pcf8583_init);
+module_exit(pcf8583_exit);
 
 MODULE_AUTHOR("Russell King");
 MODULE_DESCRIPTION("PCF8583 I2C RTC driver");
diff --git a/drivers/rtc/rtc-pl030.c b/drivers/rtc/rtc-pl030.c
index 22bacdbf913..1d28d4451da 100644
--- a/drivers/rtc/rtc-pl030.c
+++ b/drivers/rtc/rtc-pl030.c
@@ -123,7 +123,7 @@ static int pl030_probe(struct amba_device *dev, const struct amba_id *id)
 
         amba_set_drvdata(dev, rtc);
 
-        ret = request_irq(dev->irq[0], pl030_interrupt, 0,
+        ret = request_irq(dev->irq[0], pl030_interrupt, IRQF_DISABLED,
                           "rtc-pl030", rtc);
         if (ret)
                 goto err_irq;
@@ -174,8 +174,6 @@ static struct amba_id pl030_ids[] = {
         { 0, 0 },
 };
 
-MODULE_DEVICE_TABLE(amba, pl030_ids);
-
 static struct amba_driver pl030_driver = {
         .drv            = {
                 .name   = "rtc-pl030",
@@ -185,7 +183,18 @@ static struct amba_driver pl030_driver = {
         .id_table       = pl030_ids,
 };
 
-module_amba_driver(pl030_driver);
+static int __init pl030_init(void)
+{
+        return amba_driver_register(&pl030_driver);
+}
+
+static void __exit pl030_exit(void)
+{
+        amba_driver_unregister(&pl030_driver);
+}
+
+module_init(pl030_init);
+module_exit(pl030_exit);
 
 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
 MODULE_DESCRIPTION("ARM AMBA PL030 RTC Driver");
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index 08378e3cc21..ff1b84bd9bb 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -68,26 +68,11 @@
 
 #define RTC_TIMER_FREQ 32768
 
-/**
- * struct pl031_vendor_data - per-vendor variations
- * @ops: the vendor-specific operations used on this silicon version
- * @clockwatch: if this is an ST Microelectronics silicon version with a
- *      clockwatch function
- * @st_weekday: if this is an ST Microelectronics silicon version that need
- *      the weekday fix
- * @irqflags: special IRQ flags per variant
- */
-struct pl031_vendor_data {
-        struct rtc_class_ops ops;
-        bool clockwatch;
-        bool st_weekday;
-        unsigned long irqflags;
-};
-
 struct pl031_local {
-        struct pl031_vendor_data *vendor;
         struct rtc_device *rtc;
         void __iomem *base;
+        u8 hw_designer;
+        u8 hw_revision:4;
 };
 
 static int pl031_alarm_irq_enable(struct device *dev,
@@ -235,9 +220,17 @@ static irqreturn_t pl031_interrupt(int irq, void *dev_id)
         unsigned long events = 0;
 
         rtcmis = readl(ldata->base + RTC_MIS);
-        if (rtcmis & RTC_BIT_AI) {
-                writel(RTC_BIT_AI, ldata->base + RTC_ICR);
-                events |= (RTC_AF | RTC_IRQF);
+        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;
@@ -318,9 +311,7 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
 {
         int ret;
         struct pl031_local *ldata;
-        struct pl031_vendor_data *vendor = id->data;
-        struct rtc_class_ops *ops = &vendor->ops;
-        unsigned long time;
+        struct rtc_class_ops *ops = id->data;
 
         ret = amba_request_regions(adev, NULL);
         if (ret)
@@ -331,7 +322,6 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
                 ret = -ENOMEM;
                 goto out;
         }
-        ldata->vendor = vendor;
 
         ldata->base = ioremap(adev->res.start, resource_size(&adev->res));
 
@@ -342,31 +332,18 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
 
         amba_set_drvdata(adev, ldata);
 
-        dev_dbg(&adev->dev, "designer ID = 0x%02x\n", amba_manf(adev));
-        dev_dbg(&adev->dev, "revision = 0x%01x\n", amba_rev(adev));
+        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 (vendor->clockwatch)
+        if ((ldata->hw_designer == AMBA_VENDOR_ST) &&
+            (ldata->hw_revision > 1))
                 writel(readl(ldata->base + RTC_CR) | RTC_CR_CWEN,
                        ldata->base + RTC_CR);
 
-        /*
-         * On ST PL031 variants, the RTC reset value does not provide correct
-         * weekday for 2000-01-01. Correct the erroneous sunday to saturday.
-         */
-        if (vendor->st_weekday) {
-                if (readl(ldata->base + RTC_YDR) == 0x2000) {
-                        time = readl(ldata->base + RTC_DR);
-                        if ((time &
-                             (RTC_MON_MASK | RTC_MDAY_MASK | RTC_WDAY_MASK))
-                            == 0x02120000) {
-                                time = time | (0x7 << RTC_WDAY_SHIFT);
-                                writel(0x2000, ldata->base + RTC_YLR);
-                                writel(time, ldata->base + RTC_LR);
-                        }
-                }
-        }
-
         ldata->rtc = rtc_device_register("pl031", &adev->dev, ops,
                                         THIS_MODULE);
         if (IS_ERR(ldata->rtc)) {
@@ -375,7 +352,7 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
         }
 
         if (request_irq(adev->irq[0], pl031_interrupt,
-                        vendor->irqflags, "rtc-pl031", ldata)) {
+                        IRQF_DISABLED, "rtc-pl031", ldata)) {
                 ret = -EIO;
                 goto out_no_irq;
         }
@@ -397,71 +374,52 @@ err_req:
 }
 
 /* Operations for the original ARM version */
-static struct pl031_vendor_data 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,
-        },
-        .irqflags = IRQF_NO_SUSPEND,
+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 pl031_vendor_data 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,
-        },
-        .clockwatch = true,
-        .st_weekday = true,
-        .irqflags = IRQF_NO_SUSPEND,
+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,
 };
 
 /* And the second ST derivative */
-static struct pl031_vendor_data 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,
-        },
-        .clockwatch = true,
-        .st_weekday = true,
-        /*
-         * This variant shares the IRQ with another block and must not
-         * suspend that IRQ line.
-         */
-        .irqflags = IRQF_SHARED | IRQF_NO_SUSPEND,
+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,
 };
 
 static struct amba_id pl031_ids[] = {
         {
                 .id = 0x00041031,
                 .mask = 0x000fffff,
-                .data = &arm_pl031,
+                .data = &arm_pl031_ops,
         },
         /* ST Micro variants */
         {
                 .id = 0x00180031,
                 .mask = 0x00ffffff,
-                .data = &stv1_pl031,
+                .data = &stv1_pl031_ops,
         },
         {
                 .id = 0x00280031,
                 .mask = 0x00ffffff,
-                .data = &stv2_pl031,
+                .data = &stv2_pl031_ops,
         },
         {0, 0},
 };
 
-MODULE_DEVICE_TABLE(amba, pl031_ids);
-
 static struct amba_driver pl031_driver = {
         .drv = {
                 .name = "rtc-pl031",
@@ -471,7 +429,18 @@ static struct amba_driver pl031_driver = {
         .remove = pl031_remove,
 };
 
-module_amba_driver(pl031_driver);
+static int __init pl031_init(void)
+{
+        return amba_driver_register(&pl031_driver);
+}
+
+static void __exit pl031_exit(void)
+{
+        amba_driver_unregister(&pl031_driver);
+}
+
+module_init(pl031_init);
+module_exit(pl031_exit);
 
 MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net");
 MODULE_DESCRIPTION("ARM AMBA PL031 RTC Driver");
diff --git a/drivers/rtc/rtc-pm8xxx.c b/drivers/rtc/rtc-pm8xxx.c
index f1a6557261f..d420e9d877e 100644
--- a/drivers/rtc/rtc-pm8xxx.c
+++ b/drivers/rtc/rtc-pm8xxx.c
@@ -382,7 +382,7 @@ rtc_alarm_handled:
         return IRQ_HANDLED;
 }
 
-static int pm8xxx_rtc_probe(struct platform_device *pdev)
+static int __devinit pm8xxx_rtc_probe(struct platform_device *pdev)
 {
         int rc;
         u8 ctrl_reg;
@@ -485,7 +485,7 @@ fail_rtc_enable:
         return rc;
 }
 
-static int pm8xxx_rtc_remove(struct platform_device *pdev)
+static int __devexit pm8xxx_rtc_remove(struct platform_device *pdev)
 {
         struct pm8xxx_rtc *rtc_dd = platform_get_drvdata(pdev);
 
@@ -520,11 +520,11 @@ static int pm8xxx_rtc_suspend(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(pm8xxx_rtc_pm_ops, pm8xxx_rtc_suspend, pm8xxx_rtc_resume);
+SIMPLE_DEV_PM_OPS(pm8xxx_rtc_pm_ops, pm8xxx_rtc_suspend, pm8xxx_rtc_resume);
 
 static struct platform_driver pm8xxx_rtc_driver = {
         .probe          = pm8xxx_rtc_probe,
-        .remove         = pm8xxx_rtc_remove,
+        .remove         = __devexit_p(pm8xxx_rtc_remove),
         .driver = {
                 .name   = PM8XXX_RTC_DEV_NAME,
                 .owner  = THIS_MODULE,
@@ -532,7 +532,17 @@ static struct platform_driver pm8xxx_rtc_driver = {
         },
 };
 
-module_platform_driver(pm8xxx_rtc_driver);
+static int __init pm8xxx_rtc_init(void)
+{
+        return platform_driver_register(&pm8xxx_rtc_driver);
+}
+module_init(pm8xxx_rtc_init);
+
+static void __exit pm8xxx_rtc_exit(void)
+{
+        platform_driver_unregister(&pm8xxx_rtc_driver);
+}
+module_exit(pm8xxx_rtc_exit);
 
 MODULE_ALIAS("platform:rtc-pm8xxx");
 MODULE_DESCRIPTION("PMIC8xxx RTC driver");
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
index e96236ac2e7..0a59fda5c09 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -18,26 +18,6 @@
 
 #include "rtc-core.h"
 
-#define NAME_SIZE       10
-
-#if defined(CONFIG_RTC_HCTOSYS_DEVICE)
-static bool is_rtc_hctosys(struct rtc_device *rtc)
-{
-        int size;
-        char name[NAME_SIZE];
-
-        size = scnprintf(name, NAME_SIZE, "rtc%d", rtc->id);
-        if (size > NAME_SIZE)
-                return false;
-
-        return !strncmp(name, CONFIG_RTC_HCTOSYS_DEVICE, NAME_SIZE);
-}
-#else
-static bool is_rtc_hctosys(struct rtc_device *rtc)
-{
-        return (rtc->id == 0);
-}
-#endif
 
 static int rtc_proc_show(struct seq_file *seq, void *offset)
 {
@@ -137,12 +117,12 @@ static const struct file_operations rtc_proc_fops = {
 
 void rtc_proc_add_device(struct rtc_device *rtc)
 {
-        if (is_rtc_hctosys(rtc))
+        if (rtc->id == 0)
                 proc_create_data("driver/rtc", 0, NULL, &rtc_proc_fops, rtc);
 }
 
 void rtc_proc_del_device(struct rtc_device *rtc)
 {
-        if (is_rtc_hctosys(rtc))
+        if (rtc->id == 0)
                 remove_proc_entry("driver/rtc", NULL);
 }
diff --git a/drivers/rtc/rtc-puv3.c b/drivers/rtc/rtc-puv3.c
index 0407e13d4de..b3eba3cddd4 100644
--- a/drivers/rtc/rtc-puv3.c
+++ b/drivers/rtc/rtc-puv3.c
@@ -164,7 +164,7 @@ static int puv3_rtc_open(struct device *dev)
         int ret;
 
         ret = request_irq(puv3_rtc_alarmno, puv3_rtc_alarmirq,
-                        0, "pkunity-rtc alarm", rtc_dev);
+                          IRQF_DISABLED,  "pkunity-rtc alarm", rtc_dev);
 
         if (ret) {
                 dev_err(dev, "IRQ%d error %d\n", puv3_rtc_alarmno, ret);
@@ -172,7 +172,7 @@ static int puv3_rtc_open(struct device *dev)
         }
 
         ret = request_irq(puv3_rtc_tickno, puv3_rtc_tickirq,
-                        0, "pkunity-rtc tick", rtc_dev);
+                          IRQF_DISABLED,  "pkunity-rtc tick", rtc_dev);
 
         if (ret) {
                 dev_err(dev, "IRQ%d error %d\n", puv3_rtc_tickno, ret);
@@ -326,9 +326,9 @@ static int puv3_rtc_resume(struct platform_device *pdev)
 #define puv3_rtc_resume  NULL
 #endif
 
-static struct platform_driver puv3_rtc_driver = {
+static struct platform_driver puv3_rtcdrv = {
         .probe          = puv3_rtc_probe,
-        .remove         = puv3_rtc_remove,
+        .remove         = __devexit_p(puv3_rtc_remove),
         .suspend        = puv3_rtc_suspend,
         .resume         = puv3_rtc_resume,
         .driver         = {
@@ -337,7 +337,21 @@ static struct platform_driver puv3_rtc_driver = {
         }
 };
 
-module_platform_driver(puv3_rtc_driver);
+static char __initdata banner[] = "PKUnity-v3 RTC, (c) 2009 PKUnity Co.\n";
+
+static int __init puv3_rtc_init(void)
+{
+        printk(banner);
+        return platform_driver_register(&puv3_rtcdrv);
+}
+
+static void __exit puv3_rtc_exit(void)
+{
+        platform_driver_unregister(&puv3_rtcdrv);
+}
+
+module_init(puv3_rtc_init);
+module_exit(puv3_rtc_exit);
 
 MODULE_DESCRIPTION("RTC Driver for the PKUnity v3 chip");
 MODULE_AUTHOR("Hu Dongliang");
diff --git a/drivers/rtc/rtc-pxa.c b/drivers/rtc/rtc-pxa.c
index f771b2ee4b1..fc9f4991574 100644
--- a/drivers/rtc/rtc-pxa.c
+++ b/drivers/rtc/rtc-pxa.c
@@ -27,8 +27,6 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
 
 #include <mach/hardware.h>
 
@@ -176,14 +174,14 @@ static int pxa_rtc_open(struct device *dev)
         struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev);
         int ret;
 
-        ret = request_irq(pxa_rtc->irq_1Hz, pxa_rtc_irq, 0,
+        ret = request_irq(pxa_rtc->irq_1Hz, pxa_rtc_irq, IRQF_DISABLED,
                           "rtc 1Hz", dev);
         if (ret < 0) {
                 dev_err(dev, "can't get irq %i, err %d\n", pxa_rtc->irq_1Hz,
                         ret);
                 goto err_irq_1Hz;
         }
-        ret = request_irq(pxa_rtc->irq_Alrm, pxa_rtc_irq, 0,
+        ret = request_irq(pxa_rtc->irq_Alrm, pxa_rtc_irq, IRQF_DISABLED,
                           "rtc Alrm", dev);
         if (ret < 0) {
                 dev_err(dev, "can't get irq %i, err %d\n", pxa_rtc->irq_Alrm,
@@ -398,14 +396,6 @@ static int __exit pxa_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_OF
-static struct of_device_id pxa_rtc_dt_ids[] = {
-        { .compatible = "marvell,pxa-rtc" },
-        {}
-};
-MODULE_DEVICE_TABLE(of, pxa_rtc_dt_ids);
-#endif
-
 #ifdef CONFIG_PM
 static int pxa_rtc_suspend(struct device *dev)
 {
@@ -435,7 +425,6 @@ static struct platform_driver pxa_rtc_driver = {
         .remove         = __exit_p(pxa_rtc_remove),
         .driver         = {
                 .name   = "pxa-rtc",
-                .of_match_table = of_match_ptr(pxa_rtc_dt_ids),
 #ifdef CONFIG_PM
                 .pm     = &pxa_rtc_pm_ops,
 #endif
diff --git a/drivers/rtc/rtc-r9701.c b/drivers/rtc/rtc-r9701.c
index 7726f4a4f2d..9beba49c3c5 100644
--- a/drivers/rtc/rtc-r9701.c
+++ b/drivers/rtc/rtc-r9701.c
@@ -119,41 +119,12 @@ static const struct rtc_class_ops r9701_rtc_ops = {
         .set_time       = r9701_set_datetime,
 };
 
-static int r9701_probe(struct spi_device *spi)
+static int __devinit r9701_probe(struct spi_device *spi)
 {
         struct rtc_device *rtc;
-        struct rtc_time dt;
         unsigned char tmp;
         int res;
 
-        tmp = R100CNT;
-        res = read_regs(&spi->dev, &tmp, 1);
-        if (res || tmp != 0x20) {
-                dev_err(&spi->dev, "cannot read RTC register\n");
-                return -ENODEV;
-        }
-
-        /*
-         * The device seems to be present. Now check if the registers
-         * contain invalid values. If so, try to write a default date:
-         * 2000/1/1 00:00:00
-         */
-        if (r9701_get_datetime(&spi->dev, &dt)) {
-                dev_info(&spi->dev, "trying to repair invalid date/time\n");
-                dt.tm_sec  = 0;
-                dt.tm_min  = 0;
-                dt.tm_hour = 0;
-                dt.tm_mday = 1;
-                dt.tm_mon  = 0;
-                dt.tm_year = 100;
-
-                if (r9701_set_datetime(&spi->dev, &dt) ||
-                                r9701_get_datetime(&spi->dev, &dt)) {
-                        dev_err(&spi->dev, "cannot repair RTC register\n");
-                        return -ENODEV;
-                }
-        }
-
         rtc = rtc_device_register("r9701",
                                 &spi->dev, &r9701_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc))
@@ -161,10 +132,17 @@ static int r9701_probe(struct spi_device *spi)
 
         dev_set_drvdata(&spi->dev, rtc);
 
+        tmp = R100CNT;
+        res = read_regs(&spi->dev, &tmp, 1);
+        if (res || tmp != 0x20) {
+                rtc_device_unregister(rtc);
+                return res;
+        }
+
         return 0;
 }
 
-static int r9701_remove(struct spi_device *spi)
+static int __devexit r9701_remove(struct spi_device *spi)
 {
         struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
 
@@ -178,10 +156,20 @@ static struct spi_driver r9701_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe  = r9701_probe,
-        .remove = r9701_remove,
+        .remove = __devexit_p(r9701_remove),
 };
 
-module_spi_driver(r9701_driver);
+static __init int r9701_init(void)
+{
+        return spi_register_driver(&r9701_driver);
+}
+module_init(r9701_init);
+
+static __exit void r9701_exit(void)
+{
+        spi_unregister_driver(&r9701_driver);
+}
+module_exit(r9701_exit);
 
 MODULE_DESCRIPTION("r9701 spi RTC driver");
 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
diff --git a/drivers/rtc/rtc-rc5t583.c b/drivers/rtc/rtc-rc5t583.c
deleted file mode 100644
index eb3194d664a..00000000000
--- a/drivers/rtc/rtc-rc5t583.c
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * rtc-rc5t583.c -- RICOH RC5T583 Real Time Clock
- *
- * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
- * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>. */
-
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/rtc.h>
-#include <linux/bcd.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/mfd/rc5t583.h>
-
-struct rc5t583_rtc {
-        struct rtc_device       *rtc;
-        /* To store the list of enabled interrupts, during system suspend */
-        u32 irqen;
-};
-
-/* Total number of RTC registers needed to set time*/
-#define NUM_TIME_REGS   (RC5T583_RTC_YEAR - RC5T583_RTC_SEC + 1)
-
-/* Total number of RTC registers needed to set Y-Alarm*/
-#define NUM_YAL_REGS    (RC5T583_RTC_AY_YEAR - RC5T583_RTC_AY_MIN + 1)
-
-/* Set Y-Alarm interrupt */
-#define SET_YAL BIT(5)
-
-/* Get Y-Alarm interrupt status*/
-#define GET_YAL_STATUS BIT(3)
-
-static int rc5t583_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        u8 val;
-
-        /* Set Y-Alarm, based on 'enabled' */
-        val = enabled ? SET_YAL : 0;
-
-        return regmap_update_bits(rc5t583->regmap, RC5T583_RTC_CTL1, SET_YAL,
-                val);
-}
-
-/*
- * Gets current rc5t583 RTC time and date parameters.
- *
- * The RTC's time/alarm representation is not what gmtime(3) requires
- * Linux to use:
- *
- *  - Months are 1..12 vs Linux 0-11
- *  - Years are 0..99 vs Linux 1900..N (we assume 21st century)
- */
-static int rc5t583_rtc_read_time(struct device *dev, struct rtc_time *tm)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        u8 rtc_data[NUM_TIME_REGS];
-        int ret;
-
-        ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data,
-                NUM_TIME_REGS);
-        if (ret < 0) {
-                dev_err(dev, "RTC read time failed with err:%d\n", ret);
-                return ret;
-        }
-
-        tm->tm_sec = bcd2bin(rtc_data[0]);
-        tm->tm_min = bcd2bin(rtc_data[1]);
-        tm->tm_hour = bcd2bin(rtc_data[2]);
-        tm->tm_wday = bcd2bin(rtc_data[3]);
-        tm->tm_mday = bcd2bin(rtc_data[4]);
-        tm->tm_mon = bcd2bin(rtc_data[5]) - 1;
-        tm->tm_year = bcd2bin(rtc_data[6]) + 100;
-
-        return ret;
-}
-
-static int rc5t583_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        unsigned char rtc_data[NUM_TIME_REGS];
-        int ret;
-
-        rtc_data[0] = bin2bcd(tm->tm_sec);
-        rtc_data[1] = bin2bcd(tm->tm_min);
-        rtc_data[2] = bin2bcd(tm->tm_hour);
-        rtc_data[3] = bin2bcd(tm->tm_wday);
-        rtc_data[4] = bin2bcd(tm->tm_mday);
-        rtc_data[5] = bin2bcd(tm->tm_mon + 1);
-        rtc_data[6] = bin2bcd(tm->tm_year - 100);
-
-        ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data,
-                NUM_TIME_REGS);
-        if (ret < 0) {
-                dev_err(dev, "RTC set time failed with error %d\n", ret);
-                return ret;
-        }
-
-        return ret;
-}
-
-static int rc5t583_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        unsigned char alarm_data[NUM_YAL_REGS];
-        u32 interrupt_enable;
-        int ret;
-
-        ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data,
-                NUM_YAL_REGS);
-        if (ret < 0) {
-                dev_err(dev, "rtc_read_alarm error %d\n", ret);
-                return ret;
-        }
-
-        alm->time.tm_min = bcd2bin(alarm_data[0]);
-        alm->time.tm_hour = bcd2bin(alarm_data[1]);
-        alm->time.tm_mday = bcd2bin(alarm_data[2]);
-        alm->time.tm_mon = bcd2bin(alarm_data[3]) - 1;
-        alm->time.tm_year = bcd2bin(alarm_data[4]) + 100;
-
-        ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, &interrupt_enable);
-        if (ret < 0)
-                return ret;
-
-        /* check if YALE is set */
-        if (interrupt_enable & SET_YAL)
-                alm->enabled = 1;
-
-        return ret;
-}
-
-static int rc5t583_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        unsigned char alarm_data[NUM_YAL_REGS];
-        int ret;
-
-        ret = rc5t583_rtc_alarm_irq_enable(dev, 0);
-        if (ret)
-                return ret;
-
-        alarm_data[0] = bin2bcd(alm->time.tm_min);
-        alarm_data[1] = bin2bcd(alm->time.tm_hour);
-        alarm_data[2] = bin2bcd(alm->time.tm_mday);
-        alarm_data[3] = bin2bcd(alm->time.tm_mon + 1);
-        alarm_data[4] = bin2bcd(alm->time.tm_year - 100);
-
-        ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data,
-                NUM_YAL_REGS);
-        if (ret) {
-                dev_err(dev, "rtc_set_alarm error %d\n", ret);
-                return ret;
-        }
-
-        if (alm->enabled)
-                ret = rc5t583_rtc_alarm_irq_enable(dev, 1);
-
-        return ret;
-}
-
-static irqreturn_t rc5t583_rtc_interrupt(int irq, void *rtc)
-{
-        struct device *dev = rtc;
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
-        unsigned long events = 0;
-        int ret;
-        u32 rtc_reg;
-
-        ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL2, &rtc_reg);
-        if (ret < 0)
-                return IRQ_NONE;
-
-        if (rtc_reg & GET_YAL_STATUS) {
-                events = RTC_IRQF | RTC_AF;
-                /* clear pending Y-alarm interrupt bit */
-                rtc_reg &= ~GET_YAL_STATUS;
-        }
-
-        ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, rtc_reg);
-        if (ret)
-                return IRQ_NONE;
-
-        /* Notify RTC core on event */
-        rtc_update_irq(rc5t583_rtc->rtc, 1, events);
-
-        return IRQ_HANDLED;
-}
-
-static const struct rtc_class_ops rc5t583_rtc_ops = {
-        .read_time      = rc5t583_rtc_read_time,
-        .set_time       = rc5t583_rtc_set_time,
-        .read_alarm     = rc5t583_rtc_read_alarm,
-        .set_alarm      = rc5t583_rtc_set_alarm,
-        .alarm_irq_enable = rc5t583_rtc_alarm_irq_enable,
-};
-
-static int rc5t583_rtc_probe(struct platform_device *pdev)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent);
-        struct rc5t583_rtc *ricoh_rtc;
-        struct rc5t583_platform_data *pmic_plat_data;
-        int ret;
-        int irq;
-
-        ricoh_rtc = devm_kzalloc(&pdev->dev, sizeof(struct rc5t583_rtc),
-                        GFP_KERNEL);
-        if (!ricoh_rtc)
-                return -ENOMEM;
-
-        platform_set_drvdata(pdev, ricoh_rtc);
-
-        /* Clear pending interrupts */
-        ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, 0);
-        if (ret < 0)
-                return ret;
-
-        /* clear RTC Adjust register */
-        ret = regmap_write(rc5t583->regmap, RC5T583_RTC_ADJ, 0);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "unable to program rtc_adjust reg\n");
-                return -EBUSY;
-        }
-
-        pmic_plat_data = dev_get_platdata(rc5t583->dev);
-        irq = pmic_plat_data->irq_base;
-        if (irq <= 0) {
-                dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
-                        irq);
-                return ret;
-        }
-
-        irq += RC5T583_IRQ_YALE;
-        ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
-                rc5t583_rtc_interrupt, IRQF_TRIGGER_LOW,
-                "rtc-rc5t583", &pdev->dev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "IRQ is not free.\n");
-                return ret;
-        }
-        device_init_wakeup(&pdev->dev, 1);
-
-        ricoh_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
-                &rc5t583_rtc_ops, THIS_MODULE);
-        if (IS_ERR(ricoh_rtc->rtc)) {
-                ret = PTR_ERR(ricoh_rtc->rtc);
-                dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
-                return ret;
-        }
-
-        return 0;
-}
-
-/*
- * Disable rc5t583 RTC interrupts.
- * Sets status flag to free.
- */
-static int rc5t583_rtc_remove(struct platform_device *pdev)
-{
-        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(&pdev->dev);
-
-        rc5t583_rtc_alarm_irq_enable(&rc5t583_rtc->rtc->dev, 0);
-
-        rtc_device_unregister(rc5t583_rtc->rtc);
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-
-static int rc5t583_rtc_suspend(struct device *dev)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
-        int ret;
-
-        /* Store current list of enabled interrupts*/
-        ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1,
-                &rc5t583_rtc->irqen);
-        return ret;
-}
-
-static int rc5t583_rtc_resume(struct device *dev)
-{
-        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
-        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
-
-        /* Restore list of enabled interrupts before suspend */
-        return regmap_write(rc5t583->regmap, RC5T583_RTC_CTL1,
-                rc5t583_rtc->irqen);
-}
-
-static const struct dev_pm_ops rc5t583_rtc_pm_ops = {
-        .suspend        = rc5t583_rtc_suspend,
-        .resume         = rc5t583_rtc_resume,
-};
-
-#define DEV_PM_OPS     (&rc5t583_rtc_pm_ops)
-#else
-#define DEV_PM_OPS     NULL
-#endif
-
-static struct platform_driver rc5t583_rtc_driver = {
-        .probe          = rc5t583_rtc_probe,
-        .remove         = rc5t583_rtc_remove,
-        .driver         = {
-                .owner  = THIS_MODULE,
-                .name   = "rtc-rc5t583",
-                .pm     = DEV_PM_OPS,
-        },
-};
-
-module_platform_driver(rc5t583_rtc_driver);
-MODULE_ALIAS("platform:rtc-rc5t583");
-MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-rs5c313.c b/drivers/rtc/rtc-rs5c313.c
index d1aee793ecc..e3ff179b99c 100644
--- a/drivers/rtc/rtc-rs5c313.c
+++ b/drivers/rtc/rtc-rs5c313.c
@@ -377,7 +377,7 @@ static int rs5c313_rtc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int rs5c313_rtc_remove(struct platform_device *pdev)
+static int __devexit rs5c313_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device *rtc = platform_get_drvdata( pdev );
 
@@ -392,7 +392,7 @@ static struct platform_driver rs5c313_rtc_platform_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe  = rs5c313_rtc_probe,
-        .remove = rs5c313_rtc_remove,
+        .remove = __devexit_p( rs5c313_rtc_remove ),
 };
 
 static int __init rs5c313_rtc_init(void)
diff --git a/drivers/rtc/rtc-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
index 72ef10be866..368d0e63cf8 100644
--- a/drivers/rtc/rtc-rs5c348.c
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -23,7 +23,6 @@
 #include <linux/rtc.h>
 #include <linux/workqueue.h>
 #include <linux/spi/spi.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.2"
 
@@ -122,12 +121,9 @@ rs5c348_rtc_read_time(struct device *dev, struct rtc_time *tm)
         tm->tm_min = bcd2bin(rxbuf[RS5C348_REG_MINS] & RS5C348_MINS_MASK);
         tm->tm_hour = bcd2bin(rxbuf[RS5C348_REG_HOURS] & RS5C348_HOURS_MASK);
         if (!pdata->rtc_24h) {
-                if (rxbuf[RS5C348_REG_HOURS] & RS5C348_BIT_PM) {
-                        tm->tm_hour -= 20;
-                        tm->tm_hour %= 12;
+                tm->tm_hour %= 12;
+                if (rxbuf[RS5C348_REG_HOURS] & RS5C348_BIT_PM)
                         tm->tm_hour += 12;
-                } else
-                        tm->tm_hour %= 12;
         }
         tm->tm_wday = bcd2bin(rxbuf[RS5C348_REG_WDAY] & RS5C348_WDAY_MASK);
         tm->tm_mday = bcd2bin(rxbuf[RS5C348_REG_DAY] & RS5C348_DAY_MASK);
@@ -152,7 +148,7 @@ static const struct rtc_class_ops rs5c348_rtc_ops = {
 
 static struct spi_driver rs5c348_driver;
 
-static int rs5c348_probe(struct spi_device *spi)
+static int __devinit rs5c348_probe(struct spi_device *spi)
 {
         int ret;
         struct rtc_device *rtc;
@@ -218,7 +214,7 @@ static int rs5c348_probe(struct spi_device *spi)
         return ret;
 }
 
-static int rs5c348_remove(struct spi_device *spi)
+static int __devexit rs5c348_remove(struct spi_device *spi)
 {
         struct rs5c348_plat_data *pdata = spi->dev.platform_data;
         struct rtc_device *rtc = pdata->rtc;
@@ -232,13 +228,25 @@ static int rs5c348_remove(struct spi_device *spi)
 static struct spi_driver rs5c348_driver = {
         .driver = {
                 .name   = "rtc-rs5c348",
+                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
         },
         .probe  = rs5c348_probe,
-        .remove = rs5c348_remove,
+        .remove = __devexit_p(rs5c348_remove),
 };
 
-module_spi_driver(rs5c348_driver);
+static __init int rs5c348_init(void)
+{
+        return spi_register_driver(&rs5c348_driver);
+}
+
+static __exit void rs5c348_exit(void)
+{
+        spi_unregister_driver(&rs5c348_driver);
+}
+
+module_init(rs5c348_init);
+module_exit(rs5c348_exit);
 
 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
 MODULE_DESCRIPTION("Ricoh RS5C348 RTC driver");
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index 76f565ae384..85c1b848dd7 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -14,7 +14,6 @@
 #include <linux/rtc.h>
 #include <linux/bcd.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.6"
 
@@ -104,12 +103,7 @@ static int rs5c_get_regs(struct rs5c372 *rs5c)
 {
         struct i2c_client       *client = rs5c->client;
         struct i2c_msg          msgs[] = {
-                {
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = sizeof(rs5c->buf),
-                        .buf = rs5c->buf
-                },
+                { client->addr, I2C_M_RD, sizeof rs5c->buf, rs5c->buf },
         };
 
         /* This implements the third reading method from the datasheet, using
@@ -694,7 +688,18 @@ static struct i2c_driver rs5c372_driver = {
         .id_table       = rs5c372_id,
 };
 
-module_i2c_driver(rs5c372_driver);
+static __init int rs5c372_init(void)
+{
+        return i2c_add_driver(&rs5c372_driver);
+}
+
+static __exit void rs5c372_exit(void)
+{
+        i2c_del_driver(&rs5c372_driver);
+}
+
+module_init(rs5c372_init);
+module_exit(rs5c372_exit);
 
 MODULE_AUTHOR(
                 "Pavel Mironchik <pmironchik@optifacio.net>, "
diff --git a/drivers/rtc/rtc-rv3029c2.c b/drivers/rtc/rtc-rv3029c2.c
index f8ee8ad7825..ea09ff211dc 100644
--- a/drivers/rtc/rtc-rv3029c2.c
+++ b/drivers/rtc/rtc-rv3029c2.c
@@ -385,8 +385,8 @@ static struct i2c_device_id rv3029c2_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, rv3029c2_id);
 
-static int rv3029c2_probe(struct i2c_client *client,
-                          const struct i2c_device_id *id)
+static int __devinit
+rv3029c2_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
         struct rtc_device *rtc;
         int rc = 0;
@@ -418,7 +418,7 @@ exit_unregister:
         return rc;
 }
 
-static int rv3029c2_remove(struct i2c_client *client)
+static int __devexit rv3029c2_remove(struct i2c_client *client)
 {
         struct rtc_device *rtc = i2c_get_clientdata(client);
 
@@ -432,11 +432,22 @@ static struct i2c_driver rv3029c2_driver = {
                 .name = "rtc-rv3029c2",
         },
         .probe = rv3029c2_probe,
-        .remove = rv3029c2_remove,
+        .remove = __devexit_p(rv3029c2_remove),
         .id_table = rv3029c2_id,
 };
 
-module_i2c_driver(rv3029c2_driver);
+static int __init rv3029c2_init(void)
+{
+        return i2c_add_driver(&rv3029c2_driver);
+}
+
+static void __exit rv3029c2_exit(void)
+{
+        i2c_del_driver(&rv3029c2_driver);
+}
+
+module_init(rv3029c2_init);
+module_exit(rv3029c2_exit);
 
 MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
 MODULE_DESCRIPTION("Micro Crystal RV3029C2 RTC driver");
diff --git a/drivers/rtc/rtc-rx8025.c b/drivers/rtc/rtc-rx8025.c
index 0722d36b9c9..fde172fb2ab 100644
--- a/drivers/rtc/rtc-rx8025.c
+++ b/drivers/rtc/rtc-rx8025.c
@@ -534,8 +534,8 @@ static void rx8025_sysfs_unregister(struct device *dev)
         device_remove_file(dev, &dev_attr_clock_adjust_ppb);
 }
 
-static int rx8025_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id)
+static int __devinit rx8025_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
 {
         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
         struct rx8025_data *rx8025;
@@ -614,7 +614,7 @@ errout:
         return err;
 }
 
-static int rx8025_remove(struct i2c_client *client)
+static int __devexit rx8025_remove(struct i2c_client *client)
 {
         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
         struct mutex *lock = &rx8025->rtc->ops_lock;
@@ -640,12 +640,23 @@ static struct i2c_driver rx8025_driver = {
                 .owner = THIS_MODULE,
         },
         .probe          = rx8025_probe,
-        .remove         = rx8025_remove,
+        .remove         = __devexit_p(rx8025_remove),
         .id_table       = rx8025_id,
 };
 
-module_i2c_driver(rx8025_driver);
+static int __init rx8025_init(void)
+{
+        return i2c_add_driver(&rx8025_driver);
+}
+
+static void __exit rx8025_exit(void)
+{
+        i2c_del_driver(&rx8025_driver);
+}
 
 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
 MODULE_LICENSE("GPL");
+
+module_init(rx8025_init);
+module_exit(rx8025_exit);
diff --git a/drivers/rtc/rtc-rx8581.c b/drivers/rtc/rtc-rx8581.c
index b0c272658fa..600b890a3c1 100644
--- a/drivers/rtc/rtc-rx8581.c
+++ b/drivers/rtc/rtc-rx8581.c
@@ -228,8 +228,8 @@ static const struct rtc_class_ops rx8581_rtc_ops = {
         .set_time       = rx8581_rtc_set_time,
 };
 
-static int rx8581_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id)
+static int __devinit rx8581_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
 {
         struct rtc_device *rtc;
 
@@ -251,7 +251,7 @@ static int rx8581_probe(struct i2c_client *client,
         return 0;
 }
 
-static int rx8581_remove(struct i2c_client *client)
+static int __devexit rx8581_remove(struct i2c_client *client)
 {
         struct rtc_device *rtc = i2c_get_clientdata(client);
 
@@ -272,13 +272,24 @@ static struct i2c_driver rx8581_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = rx8581_probe,
-        .remove         = rx8581_remove,
+        .remove         = __devexit_p(rx8581_remove),
         .id_table       = rx8581_id,
 };
 
-module_i2c_driver(rx8581_driver);
+static int __init rx8581_init(void)
+{
+        return i2c_add_driver(&rx8581_driver);
+}
+
+static void __exit rx8581_exit(void)
+{
+        i2c_del_driver(&rx8581_driver);
+}
 
 MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com>");
 MODULE_DESCRIPTION("Epson RX-8581 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+
+module_init(rx8581_init);
+module_exit(rx8581_exit);
diff --git a/drivers/rtc/rtc-s35390a.c b/drivers/rtc/rtc-s35390a.c
index 8a092325188..f789e002c9b 100644
--- a/drivers/rtc/rtc-s35390a.c
+++ b/drivers/rtc/rtc-s35390a.c
@@ -19,8 +19,6 @@
 #define S35390A_CMD_STATUS1     0
 #define S35390A_CMD_STATUS2     1
 #define S35390A_CMD_TIME1       2
-#define S35390A_CMD_TIME2       3
-#define S35390A_CMD_INT2_REG1   5
 
 #define S35390A_BYTE_YEAR       0
 #define S35390A_BYTE_MONTH      1
@@ -30,23 +28,12 @@
 #define S35390A_BYTE_MINS       5
 #define S35390A_BYTE_SECS       6
 
-#define S35390A_ALRM_BYTE_WDAY  0
-#define S35390A_ALRM_BYTE_HOURS 1
-#define S35390A_ALRM_BYTE_MINS  2
-
 #define S35390A_FLAG_POC        0x01
 #define S35390A_FLAG_BLD        0x02
 #define S35390A_FLAG_24H        0x40
 #define S35390A_FLAG_RESET      0x80
 #define S35390A_FLAG_TEST       0x01
 
-#define S35390A_INT2_MODE_MASK          0xF0
-
-#define S35390A_INT2_MODE_NOINTR        0x00
-#define S35390A_INT2_MODE_FREQ          0x10
-#define S35390A_INT2_MODE_ALARM         0x40
-#define S35390A_INT2_MODE_PMIN_EDG      0x20
-
 static const struct i2c_device_id s35390a_id[] = {
         { "s35390a", 0 },
         { }
@@ -63,11 +50,7 @@ static int s35390a_set_reg(struct s35390a *s35390a, int reg, char *buf, int len)
 {
         struct i2c_client *client = s35390a->client[reg];
         struct i2c_msg msg[] = {
-                {
-                        .addr = client->addr,
-                        .len = len,
-                        .buf = buf
-                },
+                { client->addr, 0, len, buf },
         };
 
         if ((i2c_transfer(client->adapter, msg, 1)) != 1)
@@ -80,12 +63,7 @@ static int s35390a_get_reg(struct s35390a *s35390a, int reg, char *buf, int len)
 {
         struct i2c_client *client = s35390a->client[reg];
         struct i2c_msg msg[] = {
-                {
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = len,
-                        .buf = buf
-                },
+                { client->addr, I2C_M_RD, len, buf },
         };
 
         if ((i2c_transfer(client->adapter, msg, 1)) != 1)
@@ -206,104 +184,6 @@ static int s35390a_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         return rtc_valid_tm(tm);
 }
 
-static int s35390a_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alm)
-{
-        struct s35390a *s35390a = i2c_get_clientdata(client);
-        char buf[3], sts = 0;
-        int err, i;
-
-        dev_dbg(&client->dev, "%s: alm is secs=%d, mins=%d, hours=%d mday=%d, "\
-                "mon=%d, year=%d, wday=%d\n", __func__, alm->time.tm_sec,
-                alm->time.tm_min, alm->time.tm_hour, alm->time.tm_mday,
-                alm->time.tm_mon, alm->time.tm_year, alm->time.tm_wday);
-
-        /* disable interrupt */
-        err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
-        if (err < 0)
-                return err;
-
-        /* clear pending interrupt, if any */
-        err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &sts, sizeof(sts));
-        if (err < 0)
-                return err;
-
-        if (alm->enabled)
-                sts = S35390A_INT2_MODE_ALARM;
-        else
-                sts = S35390A_INT2_MODE_NOINTR;
-
-        /* This chip expects the bits of each byte to be in reverse order */
-        sts = bitrev8(sts);
-
-        /* set interupt mode*/
-        err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
-        if (err < 0)
-                return err;
-
-        if (alm->time.tm_wday != -1)
-                buf[S35390A_ALRM_BYTE_WDAY] = bin2bcd(alm->time.tm_wday) | 0x80;
-
-        buf[S35390A_ALRM_BYTE_HOURS] = s35390a_hr2reg(s35390a,
-                        alm->time.tm_hour) | 0x80;
-        buf[S35390A_ALRM_BYTE_MINS] = bin2bcd(alm->time.tm_min) | 0x80;
-
-        if (alm->time.tm_hour >= 12)
-                buf[S35390A_ALRM_BYTE_HOURS] |= 0x40;
-
-        for (i = 0; i < 3; ++i)
-                buf[i] = bitrev8(buf[i]);
-
-        err = s35390a_set_reg(s35390a, S35390A_CMD_INT2_REG1, buf,
-                                                                sizeof(buf));
-
-        return err;
-}
-
-static int s35390a_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alm)
-{
-        struct s35390a *s35390a = i2c_get_clientdata(client);
-        char buf[3], sts;
-        int i, err;
-
-        err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
-        if (err < 0)
-                return err;
-
-        if (bitrev8(sts) != S35390A_INT2_MODE_ALARM)
-                return -EINVAL;
-
-        err = s35390a_get_reg(s35390a, S35390A_CMD_INT2_REG1, buf, sizeof(buf));
-        if (err < 0)
-                return err;
-
-        /* This chip returns the bits of each byte in reverse order */
-        for (i = 0; i < 3; ++i) {
-                buf[i] = bitrev8(buf[i]);
-                buf[i] &= ~0x80;
-        }
-
-        alm->time.tm_wday = bcd2bin(buf[S35390A_ALRM_BYTE_WDAY]);
-        alm->time.tm_hour = s35390a_reg2hr(s35390a,
-                                                buf[S35390A_ALRM_BYTE_HOURS]);
-        alm->time.tm_min = bcd2bin(buf[S35390A_ALRM_BYTE_MINS]);
-
-        dev_dbg(&client->dev, "%s: alm is mins=%d, hours=%d, wday=%d\n",
-                        __func__, alm->time.tm_min, alm->time.tm_hour,
-                        alm->time.tm_wday);
-
-        return 0;
-}
-
-static int s35390a_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
-{
-        return s35390a_read_alarm(to_i2c_client(dev), alm);
-}
-
-static int s35390a_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
-{
-        return s35390a_set_alarm(to_i2c_client(dev), alm);
-}
-
 static int s35390a_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         return s35390a_get_datetime(to_i2c_client(dev), tm);
@@ -317,9 +197,6 @@ static int s35390a_rtc_set_time(struct device *dev, struct rtc_time *tm)
 static const struct rtc_class_ops s35390a_rtc_ops = {
         .read_time      = s35390a_rtc_read_time,
         .set_time       = s35390a_rtc_set_time,
-        .set_alarm      = s35390a_rtc_set_alarm,
-        .read_alarm     = s35390a_rtc_read_alarm,
-
 };
 
 static struct i2c_driver s35390a_driver;
@@ -384,8 +261,6 @@ static int s35390a_probe(struct i2c_client *client,
         if (s35390a_get_datetime(client, &tm) < 0)
                 dev_warn(&client->dev, "clock needs to be set\n");
 
-        device_set_wakeup_capable(&client->dev, 1);
-
         s35390a->rtc = rtc_device_register(s35390a_driver.driver.name,
                                 &client->dev, &s35390a_rtc_ops, THIS_MODULE);
 
@@ -429,8 +304,19 @@ static struct i2c_driver s35390a_driver = {
         .id_table       = s35390a_id,
 };
 
-module_i2c_driver(s35390a_driver);
+static int __init s35390a_rtc_init(void)
+{
+        return i2c_add_driver(&s35390a_driver);
+}
+
+static void __exit s35390a_rtc_exit(void)
+{
+        i2c_del_driver(&s35390a_driver);
+}
 
 MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>");
 MODULE_DESCRIPTION("S35390A RTC driver");
 MODULE_LICENSE("GPL");
+
+module_init(s35390a_rtc_init);
+module_exit(s35390a_rtc_exit);
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index 404651464d4..5b979d9cc33 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -25,28 +25,23 @@
 #include <linux/clk.h>
 #include <linux/log2.h>
 #include <linux/slab.h>
-#include <linux/of.h>
-#include <linux/uaccess.h>
-#include <linux/io.h>
 
 #include <mach/hardware.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
 #include <asm/irq.h>
 #include <plat/regs-rtc.h>
 
 enum s3c_cpu_type {
         TYPE_S3C2410,
-        TYPE_S3C2416,
-        TYPE_S3C2443,
         TYPE_S3C64XX,
 };
 
-struct s3c_rtc_drv_data {
-        int cpu_type;
-};
-
 /* 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;
@@ -136,7 +131,6 @@ static int s3c_rtc_setfreq(struct device *dev, int freq)
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
         unsigned int tmp = 0;
-        int val;
 
         if (!is_power_of_2(freq))
                 return -EINVAL;
@@ -144,22 +138,12 @@ static int s3c_rtc_setfreq(struct device *dev, int freq)
         clk_enable(rtc_clk);
         spin_lock_irq(&s3c_rtc_pie_lock);
 
-        if (s3c_rtc_cpu_type != TYPE_S3C64XX) {
+        if (s3c_rtc_cpu_type == TYPE_S3C2410) {
                 tmp = readb(s3c_rtc_base + S3C2410_TICNT);
                 tmp &= S3C2410_TICNT_ENABLE;
         }
 
-        val = (rtc_dev->max_user_freq / freq) - 1;
-
-        if (s3c_rtc_cpu_type == TYPE_S3C2416 || s3c_rtc_cpu_type == TYPE_S3C2443) {
-                tmp |= S3C2443_TICNT_PART(val);
-                writel(S3C2443_TICNT1_PART(val), s3c_rtc_base + S3C2443_TICNT1);
-
-                if (s3c_rtc_cpu_type == TYPE_S3C2416)
-                        writel(S3C2416_TICNT2_PART(val), s3c_rtc_base + S3C2416_TICNT2);
-        } else {
-                tmp |= val;
-        }
+        tmp |= (rtc_dev->max_user_freq / freq)-1;
 
         writel(tmp, s3c_rtc_base + S3C2410_TICNT);
         spin_unlock_irq(&s3c_rtc_pie_lock);
@@ -184,7 +168,7 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
         rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR);
         rtc_tm->tm_sec  = readb(base + S3C2410_RTCSEC);
 
-        /* the only way to work out whether the system was mid-update
+        /* the only way to work out wether the system was mid-update
          * when we read it is to check the second counter, and if it
          * is zero, then we re-try the entire read
          */
@@ -386,7 +370,7 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
                 tmp &= ~S3C2410_RTCCON_RTCEN;
                 writew(tmp, base + S3C2410_RTCCON);
 
-                if (s3c_rtc_cpu_type != TYPE_S3C64XX) {
+                if (s3c_rtc_cpu_type == TYPE_S3C2410) {
                         tmp = readb(base + S3C2410_TICNT);
                         tmp &= ~S3C2410_TICNT_ENABLE;
                         writeb(tmp, base + S3C2410_TICNT);
@@ -421,43 +405,34 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
         clk_disable(rtc_clk);
 }
 
-static int s3c_rtc_remove(struct platform_device *dev)
+static int __devexit s3c_rtc_remove(struct platform_device *dev)
 {
         struct rtc_device *rtc = platform_get_drvdata(dev);
 
+        free_irq(s3c_rtc_alarmno, rtc);
+        free_irq(s3c_rtc_tickno, rtc);
+
         platform_set_drvdata(dev, NULL);
         rtc_device_unregister(rtc);
 
         s3c_rtc_setaie(&dev->dev, 0);
 
+        clk_put(rtc_clk);
         rtc_clk = NULL;
 
-        return 0;
-}
-
-static const struct of_device_id s3c_rtc_dt_match[];
+        iounmap(s3c_rtc_base);
+        release_resource(s3c_rtc_mem);
+        kfree(s3c_rtc_mem);
 
-static inline int s3c_rtc_get_driver_data(struct platform_device *pdev)
-{
-#ifdef CONFIG_OF
-        struct s3c_rtc_drv_data *data;
-        if (pdev->dev.of_node) {
-                const struct of_device_id *match;
-                match = of_match_node(s3c_rtc_dt_match, pdev->dev.of_node);
-                data = (struct s3c_rtc_drv_data *) match->data;
-                return data->cpu_type;
-        }
-#endif
-        return platform_get_device_id(pdev)->driver_data;
+        return 0;
 }
 
-static int s3c_rtc_probe(struct platform_device *pdev)
+static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         struct rtc_time rtc_tm;
         struct resource *res;
         int ret;
-        int tmp;
 
         pr_debug("%s: probe=%p\n", __func__, pdev);
 
@@ -466,13 +441,13 @@ static int s3c_rtc_probe(struct platform_device *pdev)
         s3c_rtc_tickno = platform_get_irq(pdev, 1);
         if (s3c_rtc_tickno < 0) {
                 dev_err(&pdev->dev, "no irq for rtc tick\n");
-                return s3c_rtc_tickno;
+                return -ENOENT;
         }
 
         s3c_rtc_alarmno = platform_get_irq(pdev, 0);
         if (s3c_rtc_alarmno < 0) {
                 dev_err(&pdev->dev, "no irq for alarm\n");
-                return s3c_rtc_alarmno;
+                return -ENOENT;
         }
 
         pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n",
@@ -486,18 +461,28 @@ static int s3c_rtc_probe(struct platform_device *pdev)
                 return -ENOENT;
         }
 
-        s3c_rtc_base = devm_request_and_ioremap(&pdev->dev, res);
+        s3c_rtc_mem = request_mem_region(res->start, resource_size(res),
+                                         pdev->name);
+
+        if (s3c_rtc_mem == NULL) {
+                dev_err(&pdev->dev, "failed to reserve memory region\n");
+                ret = -ENOENT;
+                goto err_nores;
+        }
+
+        s3c_rtc_base = ioremap(res->start, resource_size(res));
         if (s3c_rtc_base == NULL) {
-                dev_err(&pdev->dev, "failed to ioremap memory region\n");
-                return -EINVAL;
+                dev_err(&pdev->dev, "failed ioremap()\n");
+                ret = -EINVAL;
+                goto err_nomap;
         }
 
-        rtc_clk = devm_clk_get(&pdev->dev, "rtc");
+        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;
-                return ret;
+                goto err_clk;
         }
 
         clk_enable(rtc_clk);
@@ -522,7 +507,7 @@ static int s3c_rtc_probe(struct platform_device *pdev)
                 goto err_nortc;
         }
 
-        s3c_rtc_cpu_type = s3c_rtc_get_driver_data(pdev);
+        s3c_rtc_cpu_type = platform_get_device_id(pdev)->driver_data;
 
         /* Check RTC Time */
 
@@ -541,39 +526,37 @@ static int s3c_rtc_probe(struct platform_device *pdev)
                 dev_warn(&pdev->dev, "warning: invalid RTC value so initializing it\n");
         }
 
-        if (s3c_rtc_cpu_type != TYPE_S3C2410)
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX)
                 rtc->max_user_freq = 32768;
         else
                 rtc->max_user_freq = 128;
 
-        if (s3c_rtc_cpu_type == TYPE_S3C2416 || s3c_rtc_cpu_type == TYPE_S3C2443) {
-                tmp = readw(s3c_rtc_base + S3C2410_RTCCON);
-                tmp |= S3C2443_RTCCON_TICSEL;
-                writew(tmp, s3c_rtc_base + S3C2410_RTCCON);
-        }
-
         platform_set_drvdata(pdev, rtc);
 
         s3c_rtc_setfreq(&pdev->dev, 1);
 
-        ret = devm_request_irq(&pdev->dev, s3c_rtc_alarmno, s3c_rtc_alarmirq,
-                          0,  "s3c2410-rtc alarm", rtc);
+        ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
+                          IRQF_DISABLED,  "s3c2410-rtc alarm", rtc);
         if (ret) {
                 dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
                 goto err_alarm_irq;
         }
 
-        ret = devm_request_irq(&pdev->dev, s3c_rtc_tickno, s3c_rtc_tickirq,
-                          0,  "s3c2410-rtc tick", rtc);
+        ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
+                          IRQF_DISABLED,  "s3c2410-rtc tick", rtc);
         if (ret) {
                 dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
-                goto err_alarm_irq;
+                free_irq(s3c_rtc_alarmno, rtc);
+                goto err_tick_irq;
         }
 
         clk_disable(rtc_clk);
 
         return 0;
 
+ err_tick_irq:
+        free_irq(s3c_rtc_alarmno, rtc);
+
  err_alarm_irq:
         platform_set_drvdata(pdev, NULL);
         rtc_device_unregister(rtc);
@@ -581,7 +564,15 @@ static int s3c_rtc_probe(struct platform_device *pdev)
  err_nortc:
         s3c_rtc_enable(pdev, 0);
         clk_disable(rtc_clk);
+        clk_put(rtc_clk);
 
+ err_clk:
+        iounmap(s3c_rtc_base);
+
+ err_nomap:
+        release_resource(s3c_rtc_mem);
+
+ err_nores:
         return ret;
 }
 
@@ -638,44 +629,11 @@ static int s3c_rtc_resume(struct platform_device *pdev)
 #define s3c_rtc_resume  NULL
 #endif
 
-#ifdef CONFIG_OF
-static struct s3c_rtc_drv_data s3c_rtc_drv_data_array[] = {
-        [TYPE_S3C2410] = { TYPE_S3C2410 },
-        [TYPE_S3C2416] = { TYPE_S3C2416 },
-        [TYPE_S3C2443] = { TYPE_S3C2443 },
-        [TYPE_S3C64XX] = { TYPE_S3C64XX },
-};
-
-static const struct of_device_id s3c_rtc_dt_match[] = {
-        {
-                .compatible = "samsung,s3c2410-rtc",
-                .data = &s3c_rtc_drv_data_array[TYPE_S3C2410],
-        }, {
-                .compatible = "samsung,s3c2416-rtc",
-                .data = &s3c_rtc_drv_data_array[TYPE_S3C2416],
-        }, {
-                .compatible = "samsung,s3c2443-rtc",
-                .data = &s3c_rtc_drv_data_array[TYPE_S3C2443],
-        }, {
-                .compatible = "samsung,s3c6410-rtc",
-                .data = &s3c_rtc_drv_data_array[TYPE_S3C64XX],
-        },
-        {},
-};
-MODULE_DEVICE_TABLE(of, s3c_rtc_dt_match);
-#endif
-
 static struct platform_device_id s3c_rtc_driver_ids[] = {
         {
                 .name           = "s3c2410-rtc",
                 .driver_data    = TYPE_S3C2410,
         }, {
-                .name           = "s3c2416-rtc",
-                .driver_data    = TYPE_S3C2416,
-        }, {
-                .name           = "s3c2443-rtc",
-                .driver_data    = TYPE_S3C2443,
-        }, {
                 .name           = "s3c64xx-rtc",
                 .driver_data    = TYPE_S3C64XX,
         },
@@ -686,18 +644,31 @@ MODULE_DEVICE_TABLE(platform, s3c_rtc_driver_ids);
 
 static struct platform_driver s3c_rtc_driver = {
         .probe          = s3c_rtc_probe,
-        .remove         = s3c_rtc_remove,
+        .remove         = __devexit_p(s3c_rtc_remove),
         .suspend        = s3c_rtc_suspend,
         .resume         = s3c_rtc_resume,
         .id_table       = s3c_rtc_driver_ids,
         .driver         = {
                 .name   = "s3c-rtc",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(s3c_rtc_dt_match),
         },
 };
 
-module_platform_driver(s3c_rtc_driver);
+static char __initdata banner[] = "S3C24XX RTC, (c) 2004,2006 Simtec Electronics\n";
+
+static int __init s3c_rtc_init(void)
+{
+        printk(banner);
+        return platform_driver_register(&s3c_rtc_driver);
+}
+
+static void __exit s3c_rtc_exit(void)
+{
+        platform_driver_unregister(&s3c_rtc_driver);
+}
+
+module_init(s3c_rtc_init);
+module_exit(s3c_rtc_exit);
 
 MODULE_DESCRIPTION("Samsung S3C RTC Driver");
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 50a5c4adee4..0b40bb88a88 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -23,45 +23,95 @@
 
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/clk.h>
 #include <linux/rtc.h>
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/interrupt.h>
-#include <linux/slab.h>
 #include <linux/string.h>
-#include <linux/of.h>
 #include <linux/pm.h>
 #include <linux/bitops.h>
-#include <linux/io.h>
 
 #include <mach/hardware.h>
-#include <mach/irqs.h>
+#include <asm/irq.h>
 
-#if defined(CONFIG_ARCH_PXA) || defined(CONFIG_ARCH_MMP)
+#ifdef CONFIG_ARCH_PXA
 #include <mach/regs-rtc.h>
+#include <mach/regs-ost.h>
 #endif
 
 #define RTC_DEF_DIVIDER         (32768 - 1)
 #define RTC_DEF_TRIM            0
-#define RTC_FREQ                1024
-
-struct sa1100_rtc {
-        spinlock_t              lock;
-        int                     irq_1hz;
-        int                     irq_alarm;
-        struct rtc_device       *rtc;
-        struct clk              *clk;
-};
+
+static const unsigned long RTC_FREQ = 1024;
+static struct rtc_time rtc_alarm;
+static DEFINE_SPINLOCK(sa1100_rtc_lock);
+
+static inline int rtc_periodic_alarm(struct rtc_time *tm)
+{
+        return  (tm->tm_year == -1) ||
+                ((unsigned)tm->tm_mon >= 12) ||
+                ((unsigned)(tm->tm_mday - 1) >= 31) ||
+                ((unsigned)tm->tm_hour > 23) ||
+                ((unsigned)tm->tm_min > 59) ||
+                ((unsigned)tm->tm_sec > 59);
+}
+
+/*
+ * Calculate the next alarm time given the requested alarm time mask
+ * and the current time.
+ */
+static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now,
+        struct rtc_time *alrm)
+{
+        unsigned long next_time;
+        unsigned long now_time;
+
+        next->tm_year = now->tm_year;
+        next->tm_mon = now->tm_mon;
+        next->tm_mday = now->tm_mday;
+        next->tm_hour = alrm->tm_hour;
+        next->tm_min = alrm->tm_min;
+        next->tm_sec = alrm->tm_sec;
+
+        rtc_tm_to_time(now, &now_time);
+        rtc_tm_to_time(next, &next_time);
+
+        if (next_time < now_time) {
+                /* Advance one day */
+                next_time += 60 * 60 * 24;
+                rtc_time_to_tm(next_time, next);
+        }
+}
+
+static int rtc_update_alarm(struct rtc_time *alrm)
+{
+        struct rtc_time alarm_tm, now_tm;
+        unsigned long now, time;
+        int ret;
+
+        do {
+                now = RCNR;
+                rtc_time_to_tm(now, &now_tm);
+                rtc_next_alarm_time(&alarm_tm, &now_tm, alrm);
+                ret = rtc_tm_to_time(&alarm_tm, &time);
+                if (ret != 0)
+                        break;
+
+                RTSR = RTSR & (RTSR_HZE|RTSR_ALE|RTSR_AL);
+                RTAR = time;
+        } while (now != RCNR);
+
+        return ret;
+}
 
 static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id)
 {
-        struct sa1100_rtc *info = dev_get_drvdata(dev_id);
-        struct rtc_device *rtc = info->rtc;
+        struct platform_device *pdev = to_platform_device(dev_id);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
         unsigned int rtsr;
         unsigned long events = 0;
 
-        spin_lock(&info->lock);
+        spin_lock(&sa1100_rtc_lock);
 
         rtsr = RTSR;
         /* clear interrupt sources */
@@ -97,28 +147,30 @@ static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id)
 
         rtc_update_irq(rtc, 1, events);
 
-        spin_unlock(&info->lock);
+        if (rtsr & RTSR_AL && rtc_periodic_alarm(&rtc_alarm))
+                rtc_update_alarm(&rtc_alarm);
+
+        spin_unlock(&sa1100_rtc_lock);
 
         return IRQ_HANDLED;
 }
 
 static int sa1100_rtc_open(struct device *dev)
 {
-        struct sa1100_rtc *info = dev_get_drvdata(dev);
-        struct rtc_device *rtc = info->rtc;
         int ret;
+        struct platform_device *plat_dev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
 
-        ret = clk_prepare_enable(info->clk);
-        if (ret)
-                goto fail_clk;
-        ret = request_irq(info->irq_1hz, sa1100_rtc_interrupt, 0, "rtc 1Hz", dev);
+        ret = request_irq(IRQ_RTC1Hz, sa1100_rtc_interrupt, IRQF_DISABLED,
+                "rtc 1Hz", dev);
         if (ret) {
-                dev_err(dev, "IRQ %d already in use.\n", info->irq_1hz);
+                dev_err(dev, "IRQ %d already in use.\n", IRQ_RTC1Hz);
                 goto fail_ui;
         }
-        ret = request_irq(info->irq_alarm, sa1100_rtc_interrupt, 0, "rtc Alrm", dev);
+        ret = request_irq(IRQ_RTCAlrm, sa1100_rtc_interrupt, IRQF_DISABLED,
+                "rtc Alrm", dev);
         if (ret) {
-                dev_err(dev, "IRQ %d already in use.\n", info->irq_alarm);
+                dev_err(dev, "IRQ %d already in use.\n", IRQ_RTCAlrm);
                 goto fail_ai;
         }
         rtc->max_user_freq = RTC_FREQ;
@@ -127,36 +179,31 @@ static int sa1100_rtc_open(struct device *dev)
         return 0;
 
  fail_ai:
-        free_irq(info->irq_1hz, dev);
+        free_irq(IRQ_RTC1Hz, dev);
  fail_ui:
-        clk_disable_unprepare(info->clk);
- fail_clk:
         return ret;
 }
 
 static void sa1100_rtc_release(struct device *dev)
 {
-        struct sa1100_rtc *info = dev_get_drvdata(dev);
-
-        spin_lock_irq(&info->lock);
+        spin_lock_irq(&sa1100_rtc_lock);
         RTSR = 0;
-        spin_unlock_irq(&info->lock);
+        OIER &= ~OIER_E1;
+        OSSR = OSSR_M1;
+        spin_unlock_irq(&sa1100_rtc_lock);
 
-        free_irq(info->irq_alarm, dev);
-        free_irq(info->irq_1hz, dev);
-        clk_disable_unprepare(info->clk);
+        free_irq(IRQ_RTCAlrm, dev);
+        free_irq(IRQ_RTC1Hz, dev);
 }
 
 static int sa1100_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
-        struct sa1100_rtc *info = dev_get_drvdata(dev);
-
-        spin_lock_irq(&info->lock);
+        spin_lock_irq(&sa1100_rtc_lock);
         if (enabled)
                 RTSR |= RTSR_ALE;
         else
                 RTSR &= ~RTSR_ALE;
-        spin_unlock_irq(&info->lock);
+        spin_unlock_irq(&sa1100_rtc_lock);
         return 0;
 }
 
@@ -181,6 +228,7 @@ static int sa1100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
         u32     rtsr;
 
+        memcpy(&alrm->time, &rtc_alarm, sizeof(struct rtc_time));
         rtsr = RTSR;
         alrm->enabled = (rtsr & RTSR_ALE) ? 1 : 0;
         alrm->pending = (rtsr & RTSR_AL) ? 1 : 0;
@@ -189,22 +237,17 @@ static int sa1100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 
 static int sa1100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
-        struct sa1100_rtc *info = dev_get_drvdata(dev);
-        unsigned long time;
         int ret;
 
-        spin_lock_irq(&info->lock);
-        ret = rtc_tm_to_time(&alrm->time, &time);
-        if (ret != 0)
-                goto out;
-        RTSR = RTSR & (RTSR_HZE|RTSR_ALE|RTSR_AL);
-        RTAR = time;
-        if (alrm->enabled)
-                RTSR |= RTSR_ALE;
-        else
-                RTSR &= ~RTSR_ALE;
-out:
-        spin_unlock_irq(&info->lock);
+        spin_lock_irq(&sa1100_rtc_lock);
+        ret = rtc_update_alarm(&alrm->time);
+        if (ret == 0) {
+                if (alrm->enabled)
+                        RTSR |= RTSR_ALE;
+                else
+                        RTSR &= ~RTSR_ALE;
+        }
+        spin_unlock_irq(&sa1100_rtc_lock);
 
         return ret;
 }
@@ -231,27 +274,6 @@ static const struct rtc_class_ops sa1100_rtc_ops = {
 static int sa1100_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
-        struct sa1100_rtc *info;
-        int irq_1hz, irq_alarm, ret = 0;
-
-        irq_1hz = platform_get_irq_byname(pdev, "rtc 1Hz");
-        irq_alarm = platform_get_irq_byname(pdev, "rtc alarm");
-        if (irq_1hz < 0 || irq_alarm < 0)
-                return -ENODEV;
-
-        info = kzalloc(sizeof(struct sa1100_rtc), GFP_KERNEL);
-        if (!info)
-                return -ENOMEM;
-        info->clk = clk_get(&pdev->dev, NULL);
-        if (IS_ERR(info->clk)) {
-                dev_err(&pdev->dev, "failed to find rtc clock source\n");
-                ret = PTR_ERR(info->clk);
-                goto err_clk;
-        }
-        info->irq_1hz = irq_1hz;
-        info->irq_alarm = irq_alarm;
-        spin_lock_init(&info->lock);
-        platform_set_drvdata(pdev, info);
 
         /*
          * According to the manual we should be able to let RTTR be zero
@@ -273,11 +295,10 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
         rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops,
                 THIS_MODULE);
 
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                goto err_dev;
-        }
-        info->rtc = rtc;
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        platform_set_drvdata(pdev, rtc);
 
         /* Fix for a nasty initialization problem the in SA11xx RTSR register.
          * See also the comments in sa1100_rtc_interrupt().
@@ -304,24 +325,14 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
         RTSR = RTSR_AL | RTSR_HZ;
 
         return 0;
-err_dev:
-        platform_set_drvdata(pdev, NULL);
-        clk_put(info->clk);
-err_clk:
-        kfree(info);
-        return ret;
 }
 
 static int sa1100_rtc_remove(struct platform_device *pdev)
 {
-        struct sa1100_rtc *info = platform_get_drvdata(pdev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
 
-        if (info) {
-                rtc_device_unregister(info->rtc);
-                clk_put(info->clk);
-                platform_set_drvdata(pdev, NULL);
-                kfree(info);
-        }
+        if (rtc)
+                rtc_device_unregister(rtc);
 
         return 0;
 }
@@ -329,17 +340,15 @@ static int sa1100_rtc_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int sa1100_rtc_suspend(struct device *dev)
 {
-        struct sa1100_rtc *info = dev_get_drvdata(dev);
         if (device_may_wakeup(dev))
-                enable_irq_wake(info->irq_alarm);
+                enable_irq_wake(IRQ_RTCAlrm);
         return 0;
 }
 
 static int sa1100_rtc_resume(struct device *dev)
 {
-        struct sa1100_rtc *info = dev_get_drvdata(dev);
         if (device_may_wakeup(dev))
-                disable_irq_wake(info->irq_alarm);
+                disable_irq_wake(IRQ_RTCAlrm);
         return 0;
 }
 
@@ -349,13 +358,6 @@ static const struct dev_pm_ops sa1100_rtc_pm_ops = {
 };
 #endif
 
-static struct of_device_id sa1100_rtc_dt_ids[] = {
-        { .compatible = "mrvl,sa1100-rtc", },
-        { .compatible = "mrvl,mmp-rtc", },
-        {}
-};
-MODULE_DEVICE_TABLE(of, sa1100_rtc_dt_ids);
-
 static struct platform_driver sa1100_rtc_driver = {
         .probe          = sa1100_rtc_probe,
         .remove         = sa1100_rtc_remove,
@@ -364,11 +366,21 @@ static struct platform_driver sa1100_rtc_driver = {
 #ifdef CONFIG_PM
                 .pm     = &sa1100_rtc_pm_ops,
 #endif
-                .of_match_table = sa1100_rtc_dt_ids,
         },
 };
 
-module_platform_driver(sa1100_rtc_driver);
+static int __init sa1100_rtc_init(void)
+{
+        return platform_driver_register(&sa1100_rtc_driver);
+}
+
+static void __exit sa1100_rtc_exit(void)
+{
+        platform_driver_unregister(&sa1100_rtc_driver);
+}
+
+module_init(sa1100_rtc_init);
+module_exit(sa1100_rtc_exit);
 
 MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
 MODULE_DESCRIPTION("SA11x0/PXA2xx Realtime Clock Driver (RTC)");
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index e55a7635ae5..6ac55fd4841 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -666,7 +666,7 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
         if (rtc->carry_irq <= 0) {
                 /* register shared periodic/carry/alarm irq */
                 ret = request_irq(rtc->periodic_irq, sh_rtc_shared,
-                                  0, "sh-rtc", rtc);
+                                  IRQF_DISABLED, "sh-rtc", rtc);
                 if (unlikely(ret)) {
                         dev_err(&pdev->dev,
                                 "request IRQ failed with %d, IRQ %d\n", ret,
@@ -676,7 +676,7 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
         } else {
                 /* register periodic/carry/alarm irqs */
                 ret = request_irq(rtc->periodic_irq, sh_rtc_periodic,
-                                  0, "sh-rtc period", rtc);
+                                  IRQF_DISABLED, "sh-rtc period", rtc);
                 if (unlikely(ret)) {
                         dev_err(&pdev->dev,
                                 "request period IRQ failed with %d, IRQ %d\n",
@@ -685,7 +685,7 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
                 }
 
                 ret = request_irq(rtc->carry_irq, sh_rtc_interrupt,
-                                  0, "sh-rtc carry", rtc);
+                                  IRQF_DISABLED, "sh-rtc carry", rtc);
                 if (unlikely(ret)) {
                         dev_err(&pdev->dev,
                                 "request carry IRQ failed with %d, IRQ %d\n",
@@ -695,7 +695,7 @@ static int __init sh_rtc_probe(struct platform_device *pdev)
                 }
 
                 ret = request_irq(rtc->alarm_irq, sh_rtc_alarm,
-                                  0, "sh-rtc alarm", rtc);
+                                  IRQF_DISABLED, "sh-rtc alarm", rtc);
                 if (unlikely(ret)) {
                         dev_err(&pdev->dev,
                                 "request alarm IRQ failed with %d, IRQ %d\n",
diff --git a/drivers/rtc/rtc-snvs.c b/drivers/rtc/rtc-snvs.c
deleted file mode 100644
index d5ec7854a65..00000000000
--- a/drivers/rtc/rtc-snvs.c
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
- * Copyright (C) 2011-2012 Freescale Semiconductor, Inc.
- *
- * 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/init.h>
-#include <linux/io.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include <linux/platform_device.h>
-#include <linux/rtc.h>
-
-/* These register offsets are relative to LP (Low Power) range */
-#define SNVS_LPCR               0x04
-#define SNVS_LPSR               0x18
-#define SNVS_LPSRTCMR           0x1c
-#define SNVS_LPSRTCLR           0x20
-#define SNVS_LPTAR              0x24
-#define SNVS_LPPGDR             0x30
-
-#define SNVS_LPCR_SRTC_ENV      (1 << 0)
-#define SNVS_LPCR_LPTA_EN       (1 << 1)
-#define SNVS_LPCR_LPWUI_EN      (1 << 3)
-#define SNVS_LPSR_LPTA          (1 << 0)
-
-#define SNVS_LPPGDR_INIT        0x41736166
-#define CNTR_TO_SECS_SH         15
-
-struct snvs_rtc_data {
-        struct rtc_device *rtc;
-        void __iomem *ioaddr;
-        int irq;
-        spinlock_t lock;
-};
-
-static u32 rtc_read_lp_counter(void __iomem *ioaddr)
-{
-        u64 read1, read2;
-
-        do {
-                read1 = readl(ioaddr + SNVS_LPSRTCMR);
-                read1 <<= 32;
-                read1 |= readl(ioaddr + SNVS_LPSRTCLR);
-
-                read2 = readl(ioaddr + SNVS_LPSRTCMR);
-                read2 <<= 32;
-                read2 |= readl(ioaddr + SNVS_LPSRTCLR);
-        } while (read1 != read2);
-
-        /* Convert 47-bit counter to 32-bit raw second count */
-        return (u32) (read1 >> CNTR_TO_SECS_SH);
-}
-
-static void rtc_write_sync_lp(void __iomem *ioaddr)
-{
-        u32 count1, count2, count3;
-        int i;
-
-        /* Wait for 3 CKIL cycles */
-        for (i = 0; i < 3; i++) {
-                do {
-                        count1 = readl(ioaddr + SNVS_LPSRTCLR);
-                        count2 = readl(ioaddr + SNVS_LPSRTCLR);
-                } while (count1 != count2);
-
-                /* Now wait until counter value changes */
-                do {
-                        do {
-                                count2 = readl(ioaddr + SNVS_LPSRTCLR);
-                                count3 = readl(ioaddr + SNVS_LPSRTCLR);
-                        } while (count2 != count3);
-                } while (count3 == count1);
-        }
-}
-
-static int snvs_rtc_enable(struct snvs_rtc_data *data, bool enable)
-{
-        unsigned long flags;
-        int timeout = 1000;
-        u32 lpcr;
-
-        spin_lock_irqsave(&data->lock, flags);
-
-        lpcr = readl(data->ioaddr + SNVS_LPCR);
-        if (enable)
-                lpcr |= SNVS_LPCR_SRTC_ENV;
-        else
-                lpcr &= ~SNVS_LPCR_SRTC_ENV;
-        writel(lpcr, data->ioaddr + SNVS_LPCR);
-
-        spin_unlock_irqrestore(&data->lock, flags);
-
-        while (--timeout) {
-                lpcr = readl(data->ioaddr + SNVS_LPCR);
-
-                if (enable) {
-                        if (lpcr & SNVS_LPCR_SRTC_ENV)
-                                break;
-                } else {
-                        if (!(lpcr & SNVS_LPCR_SRTC_ENV))
-                                break;
-                }
-        }
-
-        if (!timeout)
-                return -ETIMEDOUT;
-
-        return 0;
-}
-
-static int snvs_rtc_read_time(struct device *dev, struct rtc_time *tm)
-{
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-        unsigned long time = rtc_read_lp_counter(data->ioaddr);
-
-        rtc_time_to_tm(time, tm);
-
-        return 0;
-}
-
-static int snvs_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-        unsigned long time;
-
-        rtc_tm_to_time(tm, &time);
-
-        /* Disable RTC first */
-        snvs_rtc_enable(data, false);
-
-        /* Write 32-bit time to 47-bit timer, leaving 15 LSBs blank */
-        writel(time << CNTR_TO_SECS_SH, data->ioaddr + SNVS_LPSRTCLR);
-        writel(time >> (32 - CNTR_TO_SECS_SH), data->ioaddr + SNVS_LPSRTCMR);
-
-        /* Enable RTC again */
-        snvs_rtc_enable(data, true);
-
-        return 0;
-}
-
-static int snvs_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-        u32 lptar, lpsr;
-
-        lptar = readl(data->ioaddr + SNVS_LPTAR);
-        rtc_time_to_tm(lptar, &alrm->time);
-
-        lpsr = readl(data->ioaddr + SNVS_LPSR);
-        alrm->pending = (lpsr & SNVS_LPSR_LPTA) ? 1 : 0;
-
-        return 0;
-}
-
-static int snvs_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
-{
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-        u32 lpcr;
-        unsigned long flags;
-
-        spin_lock_irqsave(&data->lock, flags);
-
-        lpcr = readl(data->ioaddr + SNVS_LPCR);
-        if (enable)
-                lpcr |= (SNVS_LPCR_LPTA_EN | SNVS_LPCR_LPWUI_EN);
-        else
-                lpcr &= ~(SNVS_LPCR_LPTA_EN | SNVS_LPCR_LPWUI_EN);
-        writel(lpcr, data->ioaddr + SNVS_LPCR);
-
-        spin_unlock_irqrestore(&data->lock, flags);
-
-        rtc_write_sync_lp(data->ioaddr);
-
-        return 0;
-}
-
-static int snvs_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
-{
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-        struct rtc_time *alrm_tm = &alrm->time;
-        unsigned long time;
-        unsigned long flags;
-        u32 lpcr;
-
-        rtc_tm_to_time(alrm_tm, &time);
-
-        spin_lock_irqsave(&data->lock, flags);
-
-        /* Have to clear LPTA_EN before programming new alarm time in LPTAR */
-        lpcr = readl(data->ioaddr + SNVS_LPCR);
-        lpcr &= ~SNVS_LPCR_LPTA_EN;
-        writel(lpcr, data->ioaddr + SNVS_LPCR);
-
-        spin_unlock_irqrestore(&data->lock, flags);
-
-        writel(time, data->ioaddr + SNVS_LPTAR);
-
-        /* Clear alarm interrupt status bit */
-        writel(SNVS_LPSR_LPTA, data->ioaddr + SNVS_LPSR);
-
-        return snvs_rtc_alarm_irq_enable(dev, alrm->enabled);
-}
-
-static const struct rtc_class_ops snvs_rtc_ops = {
-        .read_time = snvs_rtc_read_time,
-        .set_time = snvs_rtc_set_time,
-        .read_alarm = snvs_rtc_read_alarm,
-        .set_alarm = snvs_rtc_set_alarm,
-        .alarm_irq_enable = snvs_rtc_alarm_irq_enable,
-};
-
-static irqreturn_t snvs_rtc_irq_handler(int irq, void *dev_id)
-{
-        struct device *dev = dev_id;
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-        u32 lpsr;
-        u32 events = 0;
-
-        lpsr = readl(data->ioaddr + SNVS_LPSR);
-
-        if (lpsr & SNVS_LPSR_LPTA) {
-                events |= (RTC_AF | RTC_IRQF);
-
-                /* RTC alarm should be one-shot */
-                snvs_rtc_alarm_irq_enable(dev, 0);
-
-                rtc_update_irq(data->rtc, 1, events);
-        }
-
-        /* clear interrupt status */
-        writel(lpsr, data->ioaddr + SNVS_LPSR);
-
-        return events ? IRQ_HANDLED : IRQ_NONE;
-}
-
-static int snvs_rtc_probe(struct platform_device *pdev)
-{
-        struct snvs_rtc_data *data;
-        struct resource *res;
-        int ret;
-
-        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        data->ioaddr = devm_request_and_ioremap(&pdev->dev, res);
-        if (!data->ioaddr)
-                return -EADDRNOTAVAIL;
-
-        data->irq = platform_get_irq(pdev, 0);
-        if (data->irq < 0)
-                return data->irq;
-
-        platform_set_drvdata(pdev, data);
-
-        spin_lock_init(&data->lock);
-
-        /* Initialize glitch detect */
-        writel(SNVS_LPPGDR_INIT, data->ioaddr + SNVS_LPPGDR);
-
-        /* Clear interrupt status */
-        writel(0xffffffff, data->ioaddr + SNVS_LPSR);
-
-        /* Enable RTC */
-        snvs_rtc_enable(data, true);
-
-        device_init_wakeup(&pdev->dev, true);
-
-        ret = devm_request_irq(&pdev->dev, data->irq, snvs_rtc_irq_handler,
-                               IRQF_SHARED, "rtc alarm", &pdev->dev);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to request irq %d: %d\n",
-                        data->irq, ret);
-                return ret;
-        }
-
-        data->rtc = rtc_device_register(pdev->name, &pdev->dev,
-                                        &snvs_rtc_ops, THIS_MODULE);
-        if (IS_ERR(data->rtc)) {
-                ret = PTR_ERR(data->rtc);
-                dev_err(&pdev->dev, "failed to register rtc: %d\n", ret);
-                return ret;
-        }
-
-        return 0;
-}
-
-static int snvs_rtc_remove(struct platform_device *pdev)
-{
-        struct snvs_rtc_data *data = platform_get_drvdata(pdev);
-
-        rtc_device_unregister(data->rtc);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int snvs_rtc_suspend(struct device *dev)
-{
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-
-        if (device_may_wakeup(dev))
-                enable_irq_wake(data->irq);
-
-        return 0;
-}
-
-static int snvs_rtc_resume(struct device *dev)
-{
-        struct snvs_rtc_data *data = dev_get_drvdata(dev);
-
-        if (device_may_wakeup(dev))
-                disable_irq_wake(data->irq);
-
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(snvs_rtc_pm_ops, snvs_rtc_suspend, snvs_rtc_resume);
-
-static const struct of_device_id snvs_dt_ids[] = {
-        { .compatible = "fsl,sec-v4.0-mon-rtc-lp", },
-        { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, snvs_dt_ids);
-
-static struct platform_driver snvs_rtc_driver = {
-        .driver = {
-                .name   = "snvs_rtc",
-                .owner  = THIS_MODULE,
-                .pm     = &snvs_rtc_pm_ops,
-                .of_match_table = snvs_dt_ids,
-        },
-        .probe          = snvs_rtc_probe,
-        .remove         = snvs_rtc_remove,
-};
-module_platform_driver(snvs_rtc_driver);
-
-MODULE_AUTHOR("Freescale Semiconductor, Inc.");
-MODULE_DESCRIPTION("Freescale SNVS RTC Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
index c2121b5a01f..893bac2bb21 100644
--- a/drivers/rtc/rtc-spear.c
+++ b/drivers/rtc/rtc-spear.c
@@ -16,7 +16,6 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/module.h>
-#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/slab.h>
@@ -78,11 +77,9 @@
 #define STATUS_FAIL             (LOST_WR_TIME | LOST_WR_DATE)
 
 struct spear_rtc_config {
-        struct rtc_device *rtc;
         struct clk *clk;
         spinlock_t lock;
         void __iomem *ioaddr;
-        unsigned int irq_wake;
 };
 
 static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config)
@@ -152,7 +149,8 @@ static void rtc_wait_not_busy(struct spear_rtc_config *config)
 
 static irqreturn_t spear_rtc_irq(int irq, void *dev_id)
 {
-        struct spear_rtc_config *config = dev_id;
+        struct rtc_device *rtc = (struct rtc_device *)dev_id;
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
         unsigned long flags, events = 0;
         unsigned int irq_data;
 
@@ -163,7 +161,7 @@ static irqreturn_t spear_rtc_irq(int irq, void *dev_id)
         if ((irq_data & RTC_INT_MASK)) {
                 spear_rtc_clear_interrupt(config);
                 events = RTC_IRQF | RTC_AF;
-                rtc_update_irq(config->rtc, 1, events);
+                rtc_update_irq(rtc, 1, events);
                 return IRQ_HANDLED;
         } else
                 return IRQ_NONE;
@@ -205,7 +203,9 @@ static void bcd2tm(struct rtc_time *tm)
  */
 static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        struct spear_rtc_config *config = dev_get_drvdata(dev);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
         unsigned int time, date;
 
         /* we don't report wday/yday/isdst ... */
@@ -234,8 +234,10 @@ static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm)
  */
 static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
-        struct spear_rtc_config *config = dev_get_drvdata(dev);
-        unsigned int time, date;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        unsigned int time, date, err = 0;
 
         if (tm2bcd(tm) < 0)
                 return -EINVAL;
@@ -247,8 +249,11 @@ static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
                 (tm->tm_year << YEAR_SHIFT);
         writel(time, config->ioaddr + TIME_REG);
         writel(date, config->ioaddr + DATE_REG);
+        err = is_write_complete(config);
+        if (err < 0)
+                return err;
 
-        return is_write_complete(config);
+        return 0;
 }
 
 /*
@@ -261,7 +266,9 @@ static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
  */
 static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
-        struct spear_rtc_config *config = dev_get_drvdata(dev);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
         unsigned int time, date;
 
         rtc_wait_not_busy(config);
@@ -291,9 +298,10 @@ static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
  */
 static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
-        struct spear_rtc_config *config = dev_get_drvdata(dev);
-        unsigned int time, date;
-        int err;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        unsigned int time, date, err = 0;
 
         if (tm2bcd(&alm->time) < 0)
                 return -EINVAL;
@@ -318,44 +326,19 @@ static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 
         return 0;
 }
-
-static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct spear_rtc_config *config = dev_get_drvdata(dev);
-        int ret = 0;
-
-        spear_rtc_clear_interrupt(config);
-
-        switch (enabled) {
-        case 0:
-                /* alarm off */
-                spear_rtc_disable_interrupt(config);
-                break;
-        case 1:
-                /* alarm on */
-                spear_rtc_enable_interrupt(config);
-                break;
-        default:
-                ret = -EINVAL;
-                break;
-        }
-
-        return ret;
-}
-
 static struct rtc_class_ops spear_rtc_ops = {
         .read_time = spear_rtc_read_time,
         .set_time = spear_rtc_set_time,
         .read_alarm = spear_rtc_read_alarm,
         .set_alarm = spear_rtc_set_alarm,
-        .alarm_irq_enable = spear_alarm_irq_enable,
 };
 
-static int spear_rtc_probe(struct platform_device *pdev)
+static int __devinit spear_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
+        struct rtc_device *rtc;
         struct spear_rtc_config *config;
-        int status = 0;
+        unsigned int status = 0;
         int irq;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -363,76 +346,110 @@ static int spear_rtc_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "no resource defined\n");
                 return -EBUSY;
         }
+        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
+                dev_err(&pdev->dev, "rtc region already claimed\n");
+                return -EBUSY;
+        }
 
-        config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
+        config = kzalloc(sizeof(*config), GFP_KERNEL);
         if (!config) {
                 dev_err(&pdev->dev, "out of memory\n");
-                return -ENOMEM;
+                status = -ENOMEM;
+                goto err_release_region;
         }
 
-        /* alarm irqs */
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                dev_err(&pdev->dev, "no update irq?\n");
-                return irq;
+        config->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(config->clk)) {
+                status = PTR_ERR(config->clk);
+                goto err_kfree;
         }
 
-        status = devm_request_irq(&pdev->dev, irq, spear_rtc_irq, 0, pdev->name,
-                        config);
-        if (status) {
-                dev_err(&pdev->dev, "Alarm interrupt IRQ%d already claimed\n",
-                                irq);
-                return status;
-        }
+        status = clk_enable(config->clk);
+        if (status < 0)
+                goto err_clk_put;
 
-        config->ioaddr = devm_request_and_ioremap(&pdev->dev, res);
+        config->ioaddr = ioremap(res->start, resource_size(res));
         if (!config->ioaddr) {
-                dev_err(&pdev->dev, "request-ioremap fail\n");
-                return -ENOMEM;
+                dev_err(&pdev->dev, "ioremap fail\n");
+                status = -ENOMEM;
+                goto err_disable_clock;
         }
 
-        config->clk = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(config->clk))
-                return PTR_ERR(config->clk);
-
-        status = clk_prepare_enable(config->clk);
-        if (status < 0)
-                return status;
-
         spin_lock_init(&config->lock);
-        platform_set_drvdata(pdev, config);
 
-        config->rtc = rtc_device_register(pdev->name, &pdev->dev,
-                        &spear_rtc_ops, THIS_MODULE);
-        if (IS_ERR(config->rtc)) {
+        rtc = rtc_device_register(pdev->name, &pdev->dev, &spear_rtc_ops,
+                        THIS_MODULE);
+        if (IS_ERR(rtc)) {
                 dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
-                                PTR_ERR(config->rtc));
-                status = PTR_ERR(config->rtc);
-                goto err_disable_clock;
+                                PTR_ERR(rtc));
+                status = PTR_ERR(rtc);
+                goto err_iounmap;
         }
 
-        config->rtc->uie_unsupported = 1;
+        platform_set_drvdata(pdev, rtc);
+        dev_set_drvdata(&rtc->dev, config);
+
+        /* alarm irqs */
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "no update irq?\n");
+                status = irq;
+                goto err_clear_platdata;
+        }
+
+        status = request_irq(irq, spear_rtc_irq, 0, pdev->name, rtc);
+        if (status) {
+                dev_err(&pdev->dev, "Alarm interrupt IRQ%d already \
+                                claimed\n", irq);
+                goto err_clear_platdata;
+        }
 
         if (!device_can_wakeup(&pdev->dev))
                 device_init_wakeup(&pdev->dev, 1);
 
         return 0;
 
-err_disable_clock:
+err_clear_platdata:
         platform_set_drvdata(pdev, NULL);
-        clk_disable_unprepare(config->clk);
+        dev_set_drvdata(&rtc->dev, NULL);
+        rtc_device_unregister(rtc);
+err_iounmap:
+        iounmap(config->ioaddr);
+err_disable_clock:
+        clk_disable(config->clk);
+err_clk_put:
+        clk_put(config->clk);
+err_kfree:
+        kfree(config);
+err_release_region:
+        release_mem_region(res->start, resource_size(res));
 
         return status;
 }
 
-static int spear_rtc_remove(struct platform_device *pdev)
+static int __devexit spear_rtc_remove(struct platform_device *pdev)
 {
-        struct spear_rtc_config *config = platform_get_drvdata(pdev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
+        int irq;
+        struct resource *res;
 
-        rtc_device_unregister(config->rtc);
+        /* leave rtc running, but disable irqs */
         spear_rtc_disable_interrupt(config);
-        clk_disable_unprepare(config->clk);
         device_init_wakeup(&pdev->dev, 0);
+        irq = platform_get_irq(pdev, 0);
+        if (irq)
+                free_irq(irq, pdev);
+        clk_disable(config->clk);
+        clk_put(config->clk);
+        iounmap(config->ioaddr);
+        kfree(config);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res)
+                release_mem_region(res->start, resource_size(res));
+        platform_set_drvdata(pdev, NULL);
+        dev_set_drvdata(&rtc->dev, NULL);
+        rtc_device_unregister(rtc);
 
         return 0;
 }
@@ -441,14 +458,14 @@ static int spear_rtc_remove(struct platform_device *pdev)
 
 static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        struct spear_rtc_config *config = platform_get_drvdata(pdev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
         int irq;
 
         irq = platform_get_irq(pdev, 0);
-        if (device_may_wakeup(&pdev->dev)) {
-                if (!enable_irq_wake(irq))
-                        config->irq_wake = 1;
-        } else {
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(irq);
+        else {
                 spear_rtc_disable_interrupt(config);
                 clk_disable(config->clk);
         }
@@ -458,17 +475,15 @@ static int spear_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 
 static int spear_rtc_resume(struct platform_device *pdev)
 {
-        struct spear_rtc_config *config = platform_get_drvdata(pdev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
         int irq;
 
         irq = platform_get_irq(pdev, 0);
 
-        if (device_may_wakeup(&pdev->dev)) {
-                if (config->irq_wake) {
-                        disable_irq_wake(irq);
-                        config->irq_wake = 0;
-                }
-        } else {
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(irq);
+        else {
                 clk_enable(config->clk);
                 spear_rtc_enable_interrupt(config);
         }
@@ -483,33 +498,35 @@ static int spear_rtc_resume(struct platform_device *pdev)
 
 static void spear_rtc_shutdown(struct platform_device *pdev)
 {
-        struct spear_rtc_config *config = platform_get_drvdata(pdev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct spear_rtc_config *config = dev_get_drvdata(&rtc->dev);
 
         spear_rtc_disable_interrupt(config);
         clk_disable(config->clk);
 }
 
-#ifdef CONFIG_OF
-static const struct of_device_id spear_rtc_id_table[] = {
-        { .compatible = "st,spear600-rtc" },
-        {}
-};
-MODULE_DEVICE_TABLE(of, spear_rtc_id_table);
-#endif
-
 static struct platform_driver spear_rtc_driver = {
         .probe = spear_rtc_probe,
-        .remove = spear_rtc_remove,
+        .remove = __devexit_p(spear_rtc_remove),
         .suspend = spear_rtc_suspend,
         .resume = spear_rtc_resume,
         .shutdown = spear_rtc_shutdown,
         .driver = {
                 .name = "rtc-spear",
-                .of_match_table = of_match_ptr(spear_rtc_id_table),
         },
 };
 
-module_platform_driver(spear_rtc_driver);
+static int __init rtc_init(void)
+{
+        return platform_driver_register(&spear_rtc_driver);
+}
+module_init(rtc_init);
+
+static void __exit rtc_exit(void)
+{
+        platform_driver_unregister(&spear_rtc_driver);
+}
+module_exit(rtc_exit);
 
 MODULE_ALIAS("platform:rtc-spear");
 MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
index 7e4a6f65cb9..3b943673cd3 100644
--- a/drivers/rtc/rtc-stk17ta8.c
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -21,7 +21,6 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "0.1"
 
@@ -285,7 +284,7 @@ static struct bin_attribute stk17ta8_nvram_attr = {
         .write = stk17ta8_nvram_write,
 };
 
-static int stk17ta8_rtc_probe(struct platform_device *pdev)
+static int __devinit stk17ta8_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         unsigned int cal;
@@ -329,7 +328,7 @@ static int stk17ta8_rtc_probe(struct platform_device *pdev)
                 writeb(0, ioaddr + RTC_INTERRUPTS);
                 if (devm_request_irq(&pdev->dev, pdata->irq,
                                 stk17ta8_rtc_interrupt,
-                                IRQF_SHARED,
+                                IRQF_DISABLED | IRQF_SHARED,
                                 pdev->name, pdev) < 0) {
                         dev_warn(&pdev->dev, "interrupt not available.\n");
                         pdata->irq = 0;
@@ -347,7 +346,7 @@ static int stk17ta8_rtc_probe(struct platform_device *pdev)
         return ret;
 }
 
-static int stk17ta8_rtc_remove(struct platform_device *pdev)
+static int __devexit stk17ta8_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
@@ -363,14 +362,25 @@ MODULE_ALIAS("platform:stk17ta8");
 
 static struct platform_driver stk17ta8_rtc_driver = {
         .probe          = stk17ta8_rtc_probe,
-        .remove         = stk17ta8_rtc_remove,
+        .remove         = __devexit_p(stk17ta8_rtc_remove),
         .driver         = {
                 .name   = "stk17ta8",
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(stk17ta8_rtc_driver);
+static __init int stk17ta8_init(void)
+{
+        return platform_driver_register(&stk17ta8_rtc_driver);
+}
+
+static __exit void stk17ta8_exit(void)
+{
+        platform_driver_unregister(&stk17ta8_rtc_driver);
+}
+
+module_init(stk17ta8_init);
+module_exit(stk17ta8_exit);
 
 MODULE_AUTHOR("Thomas Hommel <thomas.hommel@ge.com>");
 MODULE_DESCRIPTION("Simtek STK17TA8 RTC driver");
diff --git a/drivers/rtc/rtc-stmp3xxx.c b/drivers/rtc/rtc-stmp3xxx.c
index 739ef55694f..7315068daa5 100644
--- a/drivers/rtc/rtc-stmp3xxx.c
+++ b/drivers/rtc/rtc-stmp3xxx.c
@@ -25,7 +25,6 @@
 #include <linux/interrupt.h>
 #include <linux/rtc.h>
 #include <linux/slab.h>
-#include <linux/of_device.h>
 
 #include <mach/common.h>
 
@@ -266,12 +265,6 @@ static int stmp3xxx_rtc_resume(struct platform_device *dev)
 #define stmp3xxx_rtc_resume     NULL
 #endif
 
-static const struct of_device_id rtc_dt_ids[] = {
-        { .compatible = "fsl,stmp3xxx-rtc", },
-        { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, rtc_dt_ids);
-
 static struct platform_driver stmp3xxx_rtcdrv = {
         .probe          = stmp3xxx_rtc_probe,
         .remove         = stmp3xxx_rtc_remove,
@@ -280,11 +273,21 @@ static struct platform_driver stmp3xxx_rtcdrv = {
         .driver         = {
                 .name   = "stmp3xxx-rtc",
                 .owner  = THIS_MODULE,
-                .of_match_table = rtc_dt_ids,
         },
 };
 
-module_platform_driver(stmp3xxx_rtcdrv);
+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> and "
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index b70e2bb6364..380083ca572 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -102,12 +102,6 @@ rtc_sysfs_set_max_user_freq(struct device *dev, struct device_attribute *attr,
         return n;
 }
 
-/**
- * rtc_sysfs_show_hctosys - indicate if the given RTC set the system time
- *
- * Returns 1 if the system clock was set by this RTC at the last
- * boot or resume event.
- */
 static ssize_t
 rtc_sysfs_show_hctosys(struct device *dev, struct device_attribute *attr,
                 char *buf)
diff --git a/drivers/rtc/rtc-tegra.c b/drivers/rtc/rtc-tegra.c
index c84ea6659f4..773adffac27 100644
--- a/drivers/rtc/rtc-tegra.c
+++ b/drivers/rtc/rtc-tegra.c
@@ -1,7 +1,8 @@
 /*
  * An RTC driver for the NVIDIA Tegra 200 series internal RTC.
  *
- * Copyright (c) 2010, NVIDIA Corporation.
+ * Copyright (c) 2010-2011, NVIDIA Corporation.
+ * Copyright (c) 2010 Jon Mayo <jmayo@nvidia.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
@@ -303,20 +304,13 @@ static struct rtc_class_ops tegra_rtc_ops = {
         .alarm_irq_enable = tegra_rtc_alarm_irq_enable,
 };
 
-static const struct of_device_id tegra_rtc_dt_match[] = {
-        { .compatible = "nvidia,tegra20-rtc", },
-        {}
-};
-MODULE_DEVICE_TABLE(of, tegra_rtc_dt_match);
-
-static int tegra_rtc_probe(struct platform_device *pdev)
+static int __devinit tegra_rtc_probe(struct platform_device *pdev)
 {
         struct tegra_rtc_info *info;
         struct resource *res;
         int ret;
 
-        info = devm_kzalloc(&pdev->dev, sizeof(struct tegra_rtc_info),
-                GFP_KERNEL);
+        info = kzalloc(sizeof(struct tegra_rtc_info), GFP_KERNEL);
         if (!info)
                 return -ENOMEM;
 
@@ -324,18 +318,29 @@ static int tegra_rtc_probe(struct platform_device *pdev)
         if (!res) {
                 dev_err(&pdev->dev,
                         "Unable to allocate resources for device.\n");
-                return -EBUSY;
+                ret = -EBUSY;
+                goto err_free_info;
         }
 
-        info->rtc_base = devm_request_and_ioremap(&pdev->dev, res);
-        if (!info->rtc_base) {
-                dev_err(&pdev->dev, "Unable to request mem region and grab IOs for device.\n");
-                return -EBUSY;
+        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
+                dev_err(&pdev->dev,
+                        "Unable to request mem region for device.\n");
+                ret = -EBUSY;
+                goto err_free_info;
         }
 
         info->tegra_rtc_irq = platform_get_irq(pdev, 0);
-        if (info->tegra_rtc_irq <= 0)
-                return -EBUSY;
+        if (info->tegra_rtc_irq <= 0) {
+                ret = -EBUSY;
+                goto err_release_mem_region;
+        }
+
+        info->rtc_base = ioremap_nocache(res->start, resource_size(res));
+        if (!info->rtc_base) {
+                dev_err(&pdev->dev, "Unable to grab IOs for device.\n");
+                ret = -EBUSY;
+                goto err_release_mem_region;
+        }
 
         /* set context info. */
         info->pdev = pdev;
@@ -358,12 +363,11 @@ static int tegra_rtc_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev,
                         "Unable to register device (err=%d).\n",
                         ret);
-                return ret;
+                goto err_iounmap;
         }
 
-        ret = devm_request_irq(&pdev->dev, info->tegra_rtc_irq,
-                        tegra_rtc_irq_handler, IRQF_TRIGGER_HIGH,
-                        "rtc alarm", &pdev->dev);
+        ret = request_irq(info->tegra_rtc_irq, tegra_rtc_irq_handler,
+                IRQF_TRIGGER_HIGH, "rtc alarm", &pdev->dev);
         if (ret) {
                 dev_err(&pdev->dev,
                         "Unable to request interrupt for device (err=%d).\n",
@@ -373,19 +377,64 @@ static int tegra_rtc_probe(struct platform_device *pdev)
 
         dev_notice(&pdev->dev, "Tegra internal Real Time Clock\n");
 
+#ifndef CONFIG_TEGRA_SILICON_PLATFORM
+        {
+                struct rtc_time tm;
+
+                /* Get the current time from the RTC. */
+                ret = tegra_rtc_read_time(&pdev->dev, &tm);
+                if (ret) {
+                        /* Report but ignore this error. */
+                        dev_err(&pdev->dev,
+                                "Failed to get FPGA internal RTC time (err=%d)\n",
+                                ret);
+                } else if (tm.tm_year < 2010) {
+                        /* The RTC's default reset time is soooo last century. */
+                        tm.tm_year = 2010-1900;
+                        tm.tm_mon  = 0;
+                        tm.tm_mday = 1;
+                        tm.tm_hour = 0;
+                        tm.tm_min  = 0;
+                        tm.tm_sec  = 0;
+                        ret = tegra_rtc_set_time(&pdev->dev, &tm);
+                        if (ret) {
+                                /* Report but ignore this error. */
+                                dev_err(&pdev->dev,
+                                        "Failed to set FPGA internal RTC time (err=%d)\n",
+                                        ret);
+                        }
+                }
+        }
+#endif
+
         return 0;
 
 err_dev_unreg:
         rtc_device_unregister(info->rtc_dev);
+err_iounmap:
+        iounmap(info->rtc_base);
+err_release_mem_region:
+        release_mem_region(res->start, resource_size(res));
+err_free_info:
+        kfree(info);
 
         return ret;
 }
 
-static int tegra_rtc_remove(struct platform_device *pdev)
+static int __devexit tegra_rtc_remove(struct platform_device *pdev)
 {
         struct tegra_rtc_info *info = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -EBUSY;
 
+        free_irq(info->tegra_rtc_irq, &pdev->dev);
         rtc_device_unregister(info->rtc_dev);
+        iounmap(info->rtc_base);
+        release_mem_region(res->start, resource_size(res));
+        kfree(info);
 
         platform_set_drvdata(pdev, NULL);
 
@@ -441,12 +490,11 @@ static void tegra_rtc_shutdown(struct platform_device *pdev)
 
 MODULE_ALIAS("platform:tegra_rtc");
 static struct platform_driver tegra_rtc_driver = {
-        .remove         = tegra_rtc_remove,
+        .remove         = __devexit_p(tegra_rtc_remove),
         .shutdown       = tegra_rtc_shutdown,
         .driver         = {
                 .name   = "tegra_rtc",
                 .owner  = THIS_MODULE,
-                .of_match_table = tegra_rtc_dt_match,
         },
 #ifdef CONFIG_PM
         .suspend        = tegra_rtc_suspend,
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index b92e0f6383e..7e96254bd36 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -119,7 +119,7 @@ err:
         return err;
 }
 
-static int test_remove(struct platform_device *plat_dev)
+static int __devexit test_remove(struct platform_device *plat_dev)
 {
         struct rtc_device *rtc = platform_get_drvdata(plat_dev);
 
@@ -131,7 +131,7 @@ static int test_remove(struct platform_device *plat_dev)
 
 static struct platform_driver test_driver = {
         .probe  = test_probe,
-        .remove = test_remove,
+        .remove = __devexit_p(test_remove),
         .driver = {
                 .name = "rtc-test",
                 .owner = THIS_MODULE,
@@ -152,24 +152,24 @@ static int __init test_init(void)
 
         if ((test1 = platform_device_alloc("rtc-test", 1)) == NULL) {
                 err = -ENOMEM;
-                goto exit_put_test0;
+                goto exit_free_test0;
         }
 
         if ((err = platform_device_add(test0)))
-                goto exit_put_test1;
+                goto exit_free_test1;
 
         if ((err = platform_device_add(test1)))
-                goto exit_del_test0;
+                goto exit_device_unregister;
 
         return 0;
 
-exit_del_test0:
-        platform_device_del(test0);
+exit_device_unregister:
+        platform_device_unregister(test0);
 
-exit_put_test1:
+exit_free_test1:
         platform_device_put(test1);
 
-exit_put_test0:
+exit_free_test0:
         platform_device_put(test0);
 
 exit_driver_unregister:
diff --git a/drivers/rtc/rtc-tile.c b/drivers/rtc/rtc-tile.c
index 62db4841078..eb65dafee66 100644
--- a/drivers/rtc/rtc-tile.c
+++ b/drivers/rtc/rtc-tile.c
@@ -76,7 +76,7 @@ static const struct rtc_class_ops tile_rtc_ops = {
 /*
  * Device probe routine.
  */
-static int tile_rtc_probe(struct platform_device *dev)
+static int __devinit tile_rtc_probe(struct platform_device *dev)
 {
         struct rtc_device *rtc;
 
@@ -94,7 +94,7 @@ static int tile_rtc_probe(struct platform_device *dev)
 /*
  * Device cleanup routine.
  */
-static int tile_rtc_remove(struct platform_device *dev)
+static int __devexit tile_rtc_remove(struct platform_device *dev)
 {
         struct rtc_device *rtc = platform_get_drvdata(dev);
 
@@ -112,7 +112,7 @@ static struct platform_driver tile_rtc_platform_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = tile_rtc_probe,
-        .remove         = tile_rtc_remove,
+        .remove         = __devexit_p(tile_rtc_remove),
 };
 
 /*
diff --git a/drivers/rtc/rtc-tps6586x.c b/drivers/rtc/rtc-tps6586x.c
index 70f61b8e9e6..c41edabf0b2 100644
--- a/drivers/rtc/rtc-tps6586x.c
+++ b/drivers/rtc/rtc-tps6586x.c
@@ -1,23 +1,23 @@
 /*
- * rtc-tps6586x.c: RTC driver for TI PMIC TPS6586X
+ * drivers/rtc/rtc-tps6586x.c
  *
- * Copyright (c) 2012, NVIDIA Corporation.
+ * RTC driver for TI TPS6586x
  *
- * Author: Laxman Dewangan <ldewangan@nvidia.com>
+ * Copyright (c) 2010, NVIDIA Corporation.
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation version 2.
+ * 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 "as is" WITHOUT ANY WARRANTY of any kind,
- * whether express or implied; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
+ * 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
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include <linux/device.h>
@@ -25,40 +25,28 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/mfd/tps6586x.h>
-#include <linux/module.h>
 #include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
 #include <linux/rtc.h>
 #include <linux/slab.h>
 
-#define RTC_CTRL                        0xc0
-#define POR_RESET_N                     BIT(7)
-#define OSC_SRC_SEL                     BIT(6)
-#define RTC_ENABLE                      BIT(5)  /* enables alarm */
-#define RTC_BUF_ENABLE                  BIT(4)  /* 32 KHz buffer enable */
-#define PRE_BYPASS                      BIT(3)  /* 0=1KHz or 1=32KHz updates */
-#define CL_SEL_MASK                     (BIT(2)|BIT(1))
-#define CL_SEL_POS                      1
-#define RTC_ALARM1_HI                   0xc1
-#define RTC_COUNT4                      0xc6
-
-/* start a PMU RTC access by reading the register prior to the RTC_COUNT4 */
-#define RTC_COUNT4_DUMMYREAD            0xc5
-
-/*only 14-bits width in second*/
-#define ALM1_VALID_RANGE_IN_SEC         0x3FFF
-
-#define TPS6586X_RTC_CL_SEL_1_5PF       0x0
-#define TPS6586X_RTC_CL_SEL_6_5PF       0x1
-#define TPS6586X_RTC_CL_SEL_7_5PF       0x2
-#define TPS6586X_RTC_CL_SEL_12_5PF      0x3
+#define RTC_CTRL        0xc0
+#define POR_RESET_N     BIT(7)
+#define OSC_SRC_SEL     BIT(6)
+#define RTC_ENABLE      BIT(5)  /* enables alarm */
+#define RTC_BUF_ENABLE  BIT(4)  /* 32 KHz buffer enable */
+#define PRE_BYPASS      BIT(3)  /* 0=1KHz or 1=32KHz updates */
+#define CL_SEL_MASK     (BIT(2)|BIT(1))
+#define CL_SEL_POS      1
+#define RTC_ALARM1_HI   0xc1
+#define RTC_COUNT4      0xc6
+#define RTC_COUNT4_DUMMYREAD 0xc5  /* start a PMU RTC access by reading the register prior to the RTC_COUNT4 */
+#define ALM1_VALID_RANGE_IN_SEC 0x3FFF /*only 14-bits width in second*/
 
 struct tps6586x_rtc {
-        struct device           *dev;
-        struct rtc_device       *rtc;
+        unsigned long           epoch_start;
         int                     irq;
+        struct rtc_device       *rtc;
         bool                    irq_en;
-        unsigned long long      epoch_start;
 };
 
 static inline struct device *to_tps6586x_dev(struct device *dev)
@@ -73,13 +61,13 @@ static int tps6586x_rtc_read_time(struct device *dev, struct rtc_time *tm)
         unsigned long long ticks = 0;
         unsigned long seconds;
         u8 buff[6];
-        int ret;
+        int err;
         int i;
 
-        ret = tps6586x_reads(tps_dev, RTC_COUNT4_DUMMYREAD, sizeof(buff), buff);
-        if (ret < 0) {
-                dev_err(dev, "read counter failed with err %d\n", ret);
-                return ret;
+        err = tps6586x_reads(tps_dev, RTC_COUNT4_DUMMYREAD, sizeof(buff), buff);
+        if (err < 0) {
+                dev_err(dev, "failed to read counter\n");
+                return err;
         }
 
         for (i = 1; i < sizeof(buff); i++) {
@@ -88,6 +76,7 @@ static int tps6586x_rtc_read_time(struct device *dev, struct rtc_time *tm)
         }
 
         seconds = ticks >> 10;
+
         seconds += rtc->epoch_start;
         rtc_time_to_tm(seconds, tm);
         return rtc_valid_tm(tm);
@@ -100,13 +89,15 @@ static int tps6586x_rtc_set_time(struct device *dev, struct rtc_time *tm)
         unsigned long long ticks;
         unsigned long seconds;
         u8 buff[5];
-        int ret;
+        int err;
 
         rtc_tm_to_time(tm, &seconds);
-        if (seconds < rtc->epoch_start) {
+
+        if (WARN_ON(seconds < rtc->epoch_start)) {
                 dev_err(dev, "requested time unsupported\n");
                 return -EINVAL;
         }
+
         seconds -= rtc->epoch_start;
 
         ticks = (unsigned long long)seconds << 10;
@@ -116,40 +107,24 @@ static int tps6586x_rtc_set_time(struct device *dev, struct rtc_time *tm)
         buff[3] = (ticks >> 8) & 0xff;
         buff[4] = ticks & 0xff;
 
-        /* Disable RTC before changing time */
-        ret = tps6586x_clr_bits(tps_dev, RTC_CTRL, RTC_ENABLE);
-        if (ret < 0) {
+        err = tps6586x_clr_bits(tps_dev, RTC_CTRL, RTC_ENABLE);
+        if (err < 0) {
                 dev_err(dev, "failed to clear RTC_ENABLE\n");
-                return ret;
+                return err;
         }
 
-        ret = tps6586x_writes(tps_dev, RTC_COUNT4, sizeof(buff), buff);
-        if (ret < 0) {
+        err = tps6586x_writes(tps_dev, RTC_COUNT4, sizeof(buff), buff);
+        if (err < 0) {
                 dev_err(dev, "failed to program new time\n");
-                return ret;
+                return err;
         }
 
-        /* Enable RTC */
-        ret = tps6586x_set_bits(tps_dev, RTC_CTRL, RTC_ENABLE);
-        if (ret < 0) {
+        err = tps6586x_set_bits(tps_dev, RTC_CTRL, RTC_ENABLE);
+        if (err < 0) {
                 dev_err(dev, "failed to set RTC_ENABLE\n");
-                return ret;
+                return err;
         }
-        return 0;
-}
 
-static int tps6586x_rtc_alarm_irq_enable(struct device *dev,
-                         unsigned int enabled)
-{
-        struct tps6586x_rtc *rtc = dev_get_drvdata(dev);
-
-        if (enabled && !rtc->irq_en) {
-                enable_irq(rtc->irq);
-                rtc->irq_en = true;
-        } else if (!enabled && rtc->irq_en)  {
-                disable_irq(rtc->irq);
-                rtc->irq_en = false;
-        }
         return 0;
 }
 
@@ -163,28 +138,33 @@ static int tps6586x_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         unsigned long long rticks = 0;
         u8 buff[3];
         u8 rbuff[6];
-        int ret;
+        int err;
         int i;
 
+        if (rtc->irq == -1)
+                return -EIO;
+
         rtc_tm_to_time(&alrm->time, &seconds);
 
-        if (alrm->enabled && (seconds < rtc->epoch_start)) {
+        if (WARN_ON(alrm->enabled && (seconds < rtc->epoch_start))) {
                 dev_err(dev, "can't set alarm to requested time\n");
                 return -EINVAL;
         }
 
-        ret = tps6586x_rtc_alarm_irq_enable(dev, alrm->enabled);
-        if (ret < 0) {
-                dev_err(dev, "can't set alarm irq, err %d\n", ret);
-                return ret;
+        if (alrm->enabled && !rtc->irq_en) {
+                enable_irq(rtc->irq);
+                rtc->irq_en = true;
+        } else if (!alrm->enabled && rtc->irq_en) {
+                disable_irq(rtc->irq);
+                rtc->irq_en = false;
         }
 
         seconds -= rtc->epoch_start;
-        ret = tps6586x_reads(tps_dev, RTC_COUNT4_DUMMYREAD,
-                        sizeof(rbuff), rbuff);
-        if (ret < 0) {
-                dev_err(dev, "read counter failed with err %d\n", ret);
-                return ret;
+
+        err = tps6586x_reads(tps_dev, RTC_COUNT4_DUMMYREAD, sizeof(rbuff), rbuff);
+        if (err < 0) {
+                dev_err(dev, "failed to read counter\n");
+                return err;
         }
 
         for (i = 1; i < sizeof(rbuff); i++) {
@@ -197,15 +177,16 @@ static int tps6586x_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
                 seconds = rtc_current_time - 1;
 
         ticks = (unsigned long long)seconds << 10;
+
         buff[0] = (ticks >> 16) & 0xff;
         buff[1] = (ticks >> 8) & 0xff;
         buff[2] = ticks & 0xff;
 
-        ret = tps6586x_writes(tps_dev, RTC_ALARM1_HI, sizeof(buff), buff);
-        if (ret)
-                dev_err(dev, "programming alarm failed with err %d\n", ret);
+        err = tps6586x_writes(tps_dev, RTC_ALARM1_HI, sizeof(buff), buff);
+        if (err)
+                dev_err(tps_dev, "unable to program alarm\n");
 
-        return ret;
+        return err;
 }
 
 static int tps6586x_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
@@ -215,19 +196,66 @@ static int tps6586x_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         unsigned long ticks;
         unsigned long seconds;
         u8 buff[3];
-        int ret;
+        int err;
 
-        ret = tps6586x_reads(tps_dev, RTC_ALARM1_HI, sizeof(buff), buff);
-        if (ret) {
-                dev_err(dev, "read RTC_ALARM1_HI failed with err %d\n", ret);
-                return ret;
-        }
+        err = tps6586x_reads(tps_dev, RTC_ALARM1_HI, sizeof(buff), buff);
+        if (err)
+                return err;
 
         ticks = (buff[0] << 16) | (buff[1] << 8) | buff[2];
         seconds = ticks >> 10;
         seconds += rtc->epoch_start;
 
         rtc_time_to_tm(seconds, &alrm->time);
+
+        return 0;
+}
+
+static int tps6586x_rtc_alarm_irq_enable(struct device *dev,
+                                         unsigned int enabled)
+{
+        struct tps6586x_rtc *rtc = dev_get_drvdata(dev);
+        struct device *tps_dev = to_tps6586x_dev(dev);
+        u8 buff;
+        int err;
+
+        if (rtc->irq == -1)
+                return -EIO;
+
+        err = tps6586x_read(tps_dev, RTC_CTRL, &buff);
+        if (err < 0) {
+                dev_err(dev, "failed to read RTC_CTRL\n");
+                return err;
+        }
+
+        if ((enabled && (buff & RTC_ENABLE)) ||
+            (!enabled && !(buff & RTC_ENABLE)))
+                return 0;
+
+        if (enabled) {
+                err = tps6586x_set_bits(tps_dev, RTC_CTRL, RTC_ENABLE);
+                if (err < 0) {
+                        dev_err(dev, "failed to set RTC_ENABLE\n");
+                        return err;
+                }
+
+                if (!rtc->irq_en) {
+                        enable_irq(rtc->irq);
+                        rtc->irq_en = true;
+                }
+        } else {
+                err = tps6586x_clr_bits(tps_dev, RTC_CTRL, RTC_ENABLE);
+                if (err < 0) {
+                        dev_err(dev, "failed to clear RTC_ENABLE\n");
+                        return err;
+                }
+
+                if (rtc->irq_en) {
+                        disable_irq(rtc->irq);
+                        rtc->irq_en = false;
+                }
+        }
+
         return 0;
 }
 
@@ -241,116 +269,119 @@ static const struct rtc_class_ops tps6586x_rtc_ops = {
 
 static irqreturn_t tps6586x_rtc_irq(int irq, void *data)
 {
-        struct tps6586x_rtc *rtc = data;
+        struct device *dev = data;
+        struct tps6586x_rtc *rtc = dev_get_drvdata(dev);
 
         rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
         return IRQ_HANDLED;
 }
 
-static int tps6586x_rtc_probe(struct platform_device *pdev)
+static int __devinit tps6586x_rtc_probe(struct platform_device *pdev)
 {
+        struct tps6586x_rtc_platform_data *pdata = pdev->dev.platform_data;
         struct device *tps_dev = to_tps6586x_dev(&pdev->dev);
         struct tps6586x_rtc *rtc;
-        int ret;
+        int err;
+        struct tps6586x_epoch_start *epoch;
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform_data specified\n");
+                return -EINVAL;
+        }
+
+        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
 
-        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
         if (!rtc)
                 return -ENOMEM;
 
-        rtc->dev = &pdev->dev;
-        rtc->irq = platform_get_irq(pdev, 0);
+        rtc->irq = -1;
 
-        /* Set epoch start as 00:00:00:01:01:2009 */
-        rtc->epoch_start = mktime(2009, 1, 1, 0, 0, 0);
+        if (pdata->irq < 0)
+                dev_warn(&pdev->dev, "no IRQ specified, wakeup is disabled\n");
 
-        /* 1 kHz tick mode, enable tick counting */
-        ret = tps6586x_update(tps_dev, RTC_CTRL,
-                RTC_ENABLE | OSC_SRC_SEL |
-                ((TPS6586X_RTC_CL_SEL_1_5PF << CL_SEL_POS) & CL_SEL_MASK),
-                RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "unable to start counter\n");
-                return ret;
-        }
+        epoch = &pdata->start;
+        rtc->epoch_start = mktime(epoch->year, epoch->month, epoch->day,
+                                  epoch->hour, epoch->min, epoch->sec);
+
+        dev_set_drvdata(&pdev->dev, rtc);
 
-        platform_set_drvdata(pdev, rtc);
-        rtc->rtc = rtc_device_register(dev_name(&pdev->dev), &pdev->dev,
+        device_init_wakeup(&pdev->dev, 1);
+
+        rtc->rtc = rtc_device_register("tps6586x-rtc", &pdev->dev,
                                        &tps6586x_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc)) {
-                ret = PTR_ERR(rtc->rtc);
-                dev_err(&pdev->dev, "RTC device register: ret %d\n", ret);
-                goto fail_rtc_register;
-        }
 
-        ret = request_threaded_irq(rtc->irq, NULL, tps6586x_rtc_irq,
-                                IRQF_ONESHOT | IRQF_EARLY_RESUME,
-                                dev_name(&pdev->dev), rtc);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "request IRQ(%d) failed with ret %d\n",
-                                rtc->irq, ret);
-                goto fail_req_irq;
+        if (IS_ERR(rtc->rtc)) {
+                err = PTR_ERR(rtc->rtc);
+                goto fail;
         }
-        disable_irq(rtc->irq);
-        device_set_wakeup_capable(&pdev->dev, 1);
-        return 0;
-
-fail_req_irq:
-        rtc_device_unregister(rtc->rtc);
 
-fail_rtc_register:
-        tps6586x_update(tps_dev, RTC_CTRL, 0,
+        /* 1 kHz tick mode, enable tick counting */
+        err = tps6586x_update(tps_dev, RTC_CTRL,
+                RTC_ENABLE | OSC_SRC_SEL | ((pdata->cl_sel << CL_SEL_POS) &
+                                            CL_SEL_MASK),
                 RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
-        return ret;
-};
+        if (err < 0) {
+                dev_err(&pdev->dev, "unable to start counter\n");
+                goto fail;
+        }
 
-static int tps6586x_rtc_remove(struct platform_device *pdev)
-{
-        struct tps6586x_rtc *rtc = platform_get_drvdata(pdev);
-        struct device *tps_dev = to_tps6586x_dev(&pdev->dev);
+        if (pdata && (pdata->irq >= 0)) {
+                rtc->irq = pdata->irq;
+                err = request_threaded_irq(pdata->irq, NULL, tps6586x_rtc_irq,
+                                           IRQF_ONESHOT, "tps6586x-rtc",
+                                           &pdev->dev);
+                if (err) {
+                        dev_warn(&pdev->dev, "unable to request IRQ(%d)\n", rtc->irq);
+                        rtc->irq = -1;
+                } else {
+                        enable_irq_wake(rtc->irq);
+                        disable_irq(rtc->irq);
+                }
+        }
 
-        tps6586x_update(tps_dev, RTC_CTRL, 0,
-                RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
-        rtc_device_unregister(rtc->rtc);
-        free_irq(rtc->irq, rtc);
         return 0;
-}
 
-#ifdef CONFIG_PM_SLEEP
-static int tps6586x_rtc_suspend(struct device *dev)
-{
-        struct tps6586x_rtc *rtc = dev_get_drvdata(dev);
-
-        if (device_may_wakeup(dev))
-                enable_irq_wake(rtc->irq);
-        return 0;
+fail:
+        if (!IS_ERR_OR_NULL(rtc->rtc))
+                rtc_device_unregister(rtc->rtc);
+        device_init_wakeup(&pdev->dev, 0);
+        kfree(rtc);
+        return err;
 }
 
-static int tps6586x_rtc_resume(struct device *dev)
+static int __devexit tps6586x_rtc_remove(struct platform_device *pdev)
 {
-        struct tps6586x_rtc *rtc = dev_get_drvdata(dev);
+        struct tps6586x_rtc *rtc = dev_get_drvdata(&pdev->dev);
 
-        if (device_may_wakeup(dev))
-                disable_irq_wake(rtc->irq);
+        if (rtc->irq != -1)
+                free_irq(rtc->irq, rtc);
+        rtc_device_unregister(rtc->rtc);
+        kfree(rtc);
         return 0;
 }
-#endif
-
-static const struct dev_pm_ops tps6586x_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(tps6586x_rtc_suspend, tps6586x_rtc_resume)
-};
 
 static struct platform_driver tps6586x_rtc_driver = {
         .driver = {
                 .name   = "tps6586x-rtc",
                 .owner  = THIS_MODULE,
-                .pm     = &tps6586x_pm_ops,
         },
         .probe  = tps6586x_rtc_probe,
-        .remove = tps6586x_rtc_remove,
+        .remove = __devexit_p(tps6586x_rtc_remove),
 };
-module_platform_driver(tps6586x_rtc_driver);
 
-MODULE_ALIAS("platform:rtc-tps6586x");
+static int __init tps6586x_rtc_init(void)
+{
+        return platform_driver_register(&tps6586x_rtc_driver);
+}
+module_init(tps6586x_rtc_init);
+
+static void __exit tps6586x_rtc_exit(void)
+{
+        platform_driver_unregister(&tps6586x_rtc_driver);
+}
+module_exit(tps6586x_rtc_exit);
+
 MODULE_DESCRIPTION("TI TPS6586x RTC driver");
-MODULE_AUTHOR("Laxman dewangan <ldewangan@nvidia.com>");
-MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("NVIDIA Corporation");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:rtc-tps6586x");
diff --git a/drivers/rtc/rtc-tps65910.c b/drivers/rtc/rtc-tps65910.c
deleted file mode 100644
index e5fef141a0e..00000000000
--- a/drivers/rtc/rtc-tps65910.c
+++ /dev/null
@@ -1,356 +0,0 @@
-/*
- * rtc-tps65910.c -- TPS65910 Real Time Clock interface
- *
- * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
- * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
- *
- * Based on original TI driver rtc-twl.c
- *   Copyright (C) 2007 MontaVista Software, Inc
- *   Author: Alexandre Rusev <source@mvista.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/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/rtc.h>
-#include <linux/bcd.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/mfd/tps65910.h>
-
-struct tps65910_rtc {
-        struct rtc_device       *rtc;
-        /* To store the list of enabled interrupts */
-        u32 irqstat;
-};
-
-/* Total number of RTC registers needed to set time*/
-#define NUM_TIME_REGS   (TPS65910_YEARS - TPS65910_SECONDS + 1)
-
-static int tps65910_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
-{
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-        u8 val = 0;
-
-        if (enabled)
-                val = TPS65910_RTC_INTERRUPTS_IT_ALARM;
-
-        return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, val);
-}
-
-/*
- * Gets current tps65910 RTC time and date parameters.
- *
- * The RTC's time/alarm representation is not what gmtime(3) requires
- * Linux to use:
- *
- *  - Months are 1..12 vs Linux 0-11
- *  - Years are 0..99 vs Linux 1900..N (we assume 21st century)
- */
-static int tps65910_rtc_read_time(struct device *dev, struct rtc_time *tm)
-{
-        unsigned char rtc_data[NUM_TIME_REGS];
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-        int ret;
-
-        /* Copy RTC counting registers to static registers or latches */
-        ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
-                TPS65910_RTC_CTRL_GET_TIME, TPS65910_RTC_CTRL_GET_TIME);
-        if (ret < 0) {
-                dev_err(dev, "RTC CTRL reg update failed with err:%d\n", ret);
-                return ret;
-        }
-
-        ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, rtc_data,
-                NUM_TIME_REGS);
-        if (ret < 0) {
-                dev_err(dev, "reading from RTC failed with err:%d\n", ret);
-                return ret;
-        }
-
-        tm->tm_sec = bcd2bin(rtc_data[0]);
-        tm->tm_min = bcd2bin(rtc_data[1]);
-        tm->tm_hour = bcd2bin(rtc_data[2]);
-        tm->tm_mday = bcd2bin(rtc_data[3]);
-        tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
-        tm->tm_year = bcd2bin(rtc_data[5]) + 100;
-
-        return ret;
-}
-
-static int tps65910_rtc_set_time(struct device *dev, struct rtc_time *tm)
-{
-        unsigned char rtc_data[NUM_TIME_REGS];
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-        int ret;
-
-        rtc_data[0] = bin2bcd(tm->tm_sec);
-        rtc_data[1] = bin2bcd(tm->tm_min);
-        rtc_data[2] = bin2bcd(tm->tm_hour);
-        rtc_data[3] = bin2bcd(tm->tm_mday);
-        rtc_data[4] = bin2bcd(tm->tm_mon + 1);
-        rtc_data[5] = bin2bcd(tm->tm_year - 100);
-
-        /* Stop RTC while updating the RTC time registers */
-        ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
-                TPS65910_RTC_CTRL_STOP_RTC, 0);
-        if (ret < 0) {
-                dev_err(dev, "RTC stop failed with err:%d\n", ret);
-                return ret;
-        }
-
-        /* update all the time registers in one shot */
-        ret = regmap_bulk_write(tps->regmap, TPS65910_SECONDS, rtc_data,
-                NUM_TIME_REGS);
-        if (ret < 0) {
-                dev_err(dev, "rtc_set_time error %d\n", ret);
-                return ret;
-        }
-
-        /* Start back RTC */
-        ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
-                TPS65910_RTC_CTRL_STOP_RTC, 1);
-        if (ret < 0)
-                dev_err(dev, "RTC start failed with err:%d\n", ret);
-
-        return ret;
-}
-
-/*
- * Gets current tps65910 RTC alarm time.
- */
-static int tps65910_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
-{
-        unsigned char alarm_data[NUM_TIME_REGS];
-        u32 int_val;
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-        int ret;
-
-        ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, alarm_data,
-                NUM_TIME_REGS);
-        if (ret < 0) {
-                dev_err(dev, "rtc_read_alarm error %d\n", ret);
-                return ret;
-        }
-
-        alm->time.tm_sec = bcd2bin(alarm_data[0]);
-        alm->time.tm_min = bcd2bin(alarm_data[1]);
-        alm->time.tm_hour = bcd2bin(alarm_data[2]);
-        alm->time.tm_mday = bcd2bin(alarm_data[3]);
-        alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1;
-        alm->time.tm_year = bcd2bin(alarm_data[5]) + 100;
-
-        ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS, &int_val);
-        if (ret < 0)
-                return ret;
-
-        if (int_val & TPS65910_RTC_INTERRUPTS_IT_ALARM)
-                alm->enabled = 1;
-
-        return ret;
-}
-
-static int tps65910_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
-{
-        unsigned char alarm_data[NUM_TIME_REGS];
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-        int ret;
-
-        ret = tps65910_rtc_alarm_irq_enable(dev, 0);
-        if (ret)
-                return ret;
-
-        alarm_data[0] = bin2bcd(alm->time.tm_sec);
-        alarm_data[1] = bin2bcd(alm->time.tm_min);
-        alarm_data[2] = bin2bcd(alm->time.tm_hour);
-        alarm_data[3] = bin2bcd(alm->time.tm_mday);
-        alarm_data[4] = bin2bcd(alm->time.tm_mon + 1);
-        alarm_data[5] = bin2bcd(alm->time.tm_year - 100);
-
-        /* update all the alarm registers in one shot */
-        ret = regmap_bulk_write(tps->regmap, TPS65910_ALARM_SECONDS,
-                alarm_data, NUM_TIME_REGS);
-        if (ret) {
-                dev_err(dev, "rtc_set_alarm error %d\n", ret);
-                return ret;
-        }
-
-        if (alm->enabled)
-                ret = tps65910_rtc_alarm_irq_enable(dev, 1);
-
-        return ret;
-}
-
-static irqreturn_t tps65910_rtc_interrupt(int irq, void *rtc)
-{
-        struct device *dev = rtc;
-        unsigned long events = 0;
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-        struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
-        int ret;
-        u32 rtc_reg;
-
-        ret = regmap_read(tps->regmap, TPS65910_RTC_STATUS, &rtc_reg);
-        if (ret)
-                return IRQ_NONE;
-
-        if (rtc_reg & TPS65910_RTC_STATUS_ALARM)
-                events = RTC_IRQF | RTC_AF;
-
-        ret = regmap_write(tps->regmap, TPS65910_RTC_STATUS, rtc_reg);
-        if (ret)
-                return IRQ_NONE;
-
-        /* Notify RTC core on event */
-        rtc_update_irq(tps_rtc->rtc, 1, events);
-
-        return IRQ_HANDLED;
-}
-
-static const struct rtc_class_ops tps65910_rtc_ops = {
-        .read_time      = tps65910_rtc_read_time,
-        .set_time       = tps65910_rtc_set_time,
-        .read_alarm     = tps65910_rtc_read_alarm,
-        .set_alarm      = tps65910_rtc_set_alarm,
-        .alarm_irq_enable = tps65910_rtc_alarm_irq_enable,
-};
-
-static int tps65910_rtc_probe(struct platform_device *pdev)
-{
-        struct tps65910 *tps65910 = NULL;
-        struct tps65910_rtc *tps_rtc = NULL;
-        int ret;
-        int irq;
-        u32 rtc_reg;
-
-        tps65910 = dev_get_drvdata(pdev->dev.parent);
-
-        tps_rtc = devm_kzalloc(&pdev->dev, sizeof(struct tps65910_rtc),
-                        GFP_KERNEL);
-        if (!tps_rtc)
-                return -ENOMEM;
-
-        /* Clear pending interrupts */
-        ret = regmap_read(tps65910->regmap, TPS65910_RTC_STATUS, &rtc_reg);
-        if (ret < 0)
-                return ret;
-
-        ret = regmap_write(tps65910->regmap, TPS65910_RTC_STATUS, rtc_reg);
-        if (ret < 0)
-                return ret;
-
-        dev_dbg(&pdev->dev, "Enabling rtc-tps65910.\n");
-
-        /* Enable RTC digital power domain */
-        ret = regmap_update_bits(tps65910->regmap, TPS65910_DEVCTRL,
-                DEVCTRL_RTC_PWDN_MASK, 0 << DEVCTRL_RTC_PWDN_SHIFT);
-        if (ret < 0)
-                return ret;
-
-        rtc_reg = TPS65910_RTC_CTRL_STOP_RTC;
-        ret = regmap_write(tps65910->regmap, TPS65910_RTC_CTRL, rtc_reg);
-        if (ret < 0)
-                return ret;
-
-        irq  = platform_get_irq(pdev, 0);
-        if (irq <= 0) {
-                dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
-                        irq);
-                return ret;
-        }
-
-        ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
-                tps65910_rtc_interrupt, IRQF_TRIGGER_LOW,
-                dev_name(&pdev->dev), &pdev->dev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "IRQ is not free.\n");
-                return ret;
-        }
-        device_init_wakeup(&pdev->dev, 1);
-
-        tps_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
-                &tps65910_rtc_ops, THIS_MODULE);
-        if (IS_ERR(tps_rtc->rtc)) {
-                ret = PTR_ERR(tps_rtc->rtc);
-                dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
-                return ret;
-        }
-
-        platform_set_drvdata(pdev, tps_rtc);
-
-        return 0;
-}
-
-/*
- * Disable tps65910 RTC interrupts.
- * Sets status flag to free.
- */
-static int tps65910_rtc_remove(struct platform_device *pdev)
-{
-        /* leave rtc running, but disable irqs */
-        struct tps65910_rtc *tps_rtc = platform_get_drvdata(pdev);
-
-        tps65910_rtc_alarm_irq_enable(&pdev->dev, 0);
-
-        rtc_device_unregister(tps_rtc->rtc);
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-
-static int tps65910_rtc_suspend(struct device *dev)
-{
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-        u8 alarm = TPS65910_RTC_INTERRUPTS_IT_ALARM;
-        int ret;
-
-        /* Store current list of enabled interrupts*/
-        ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS,
-                &tps->rtc->irqstat);
-        if (ret < 0)
-                return ret;
-
-        /* Enable RTC ALARM interrupt only */
-        return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, alarm);
-}
-
-static int tps65910_rtc_resume(struct device *dev)
-{
-        struct tps65910 *tps = dev_get_drvdata(dev->parent);
-
-        /* Restore list of enabled interrupts before suspend */
-        return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS,
-                tps->rtc->irqstat);
-}
-
-static const struct dev_pm_ops tps65910_rtc_pm_ops = {
-        .suspend        = tps65910_rtc_suspend,
-        .resume         = tps65910_rtc_resume,
-};
-
-#define DEV_PM_OPS     (&tps65910_rtc_pm_ops)
-#else
-#define DEV_PM_OPS     NULL
-#endif
-
-static struct platform_driver tps65910_rtc_driver = {
-        .probe          = tps65910_rtc_probe,
-        .remove         = tps65910_rtc_remove,
-        .driver         = {
-                .owner  = THIS_MODULE,
-                .name   = "tps65910-rtc",
-                .pm     = DEV_PM_OPS,
-        },
-};
-
-module_platform_driver(tps65910_rtc_driver);
-MODULE_ALIAS("platform:rtc-tps65910");
-MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index ccd4ad370b3..20687d55e7a 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -112,7 +112,6 @@ static const u8 twl6030_rtc_reg_map[] = {
 #define BIT_RTC_CTRL_REG_TEST_MODE_M             0x10
 #define BIT_RTC_CTRL_REG_SET_32_COUNTER_M        0x20
 #define BIT_RTC_CTRL_REG_GET_TIME_M              0x40
-#define BIT_RTC_CTRL_REG_RTC_V_OPT               0x80
 
 /* RTC_STATUS_REG bitfields */
 #define BIT_RTC_STATUS_REG_RUN_M                 0x02
@@ -177,10 +176,6 @@ static int set_rtc_irq_bit(unsigned char bit)
         unsigned char val;
         int ret;
 
-        /* if the bit is set, return from here */
-        if (rtc_irq_bits & bit)
-                return 0;
-
         val = rtc_irq_bits | bit;
         val &= ~BIT_RTC_INTERRUPTS_REG_EVERY_M;
         ret = twl_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
@@ -198,10 +193,6 @@ static int mask_rtc_irq_bit(unsigned char bit)
         unsigned char val;
         int ret;
 
-        /* if the bit is clear, return from here */
-        if (!(rtc_irq_bits & bit))
-                return 0;
-
         val = rtc_irq_bits & ~bit;
         ret = twl_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
         if (ret == 0)
@@ -233,60 +224,28 @@ static int twl_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
  */
 static int twl_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        unsigned char rtc_data[ALL_TIME_REGS];
+        unsigned char rtc_data[ALL_TIME_REGS + 1];
         int ret;
         u8 save_control;
-        u8 rtc_control;
 
         ret = twl_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
-        if (ret < 0) {
-                dev_err(dev, "%s: reading CTRL_REG, error %d\n", __func__, ret);
+        if (ret < 0)
                 return ret;
-        }
-        /* for twl6030/32 make sure BIT_RTC_CTRL_REG_GET_TIME_M is clear */
-        if (twl_class_is_6030()) {
-                if (save_control & BIT_RTC_CTRL_REG_GET_TIME_M) {
-                        save_control &= ~BIT_RTC_CTRL_REG_GET_TIME_M;
-                        ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
-                        if (ret < 0) {
-                                dev_err(dev, "%s clr GET_TIME, error %d\n",
-                                        __func__, ret);
-                                return ret;
-                        }
-                }
-        }
 
-        /* Copy RTC counting registers to static registers or latches */
-        rtc_control = save_control | BIT_RTC_CTRL_REG_GET_TIME_M;
+        save_control |= BIT_RTC_CTRL_REG_GET_TIME_M;
 
-        /* for twl6030/32 enable read access to static shadowed registers */
-        if (twl_class_is_6030())
-                rtc_control |= BIT_RTC_CTRL_REG_RTC_V_OPT;
-
-        ret = twl_rtc_write_u8(rtc_control, REG_RTC_CTRL_REG);
-        if (ret < 0) {
-                dev_err(dev, "%s: writing CTRL_REG, error %d\n", __func__, ret);
+        ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
+        if (ret < 0)
                 return ret;
-        }
 
         ret = twl_i2c_read(TWL_MODULE_RTC, rtc_data,
                         (rtc_reg_map[REG_SECONDS_REG]), ALL_TIME_REGS);
 
         if (ret < 0) {
-                dev_err(dev, "%s: reading data, error %d\n", __func__, ret);
+                dev_err(dev, "rtc_read_time error %d\n", ret);
                 return ret;
         }
 
-        /* for twl6030 restore original state of rtc control register */
-        if (twl_class_is_6030()) {
-                ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
-                if (ret < 0) {
-                        dev_err(dev, "%s: restore CTRL_REG, error %d\n",
-                                __func__, ret);
-                        return ret;
-                }
-        }
-
         tm->tm_sec = bcd2bin(rtc_data[0]);
         tm->tm_min = bcd2bin(rtc_data[1]);
         tm->tm_hour = bcd2bin(rtc_data[2]);
@@ -300,15 +259,15 @@ static int twl_rtc_read_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];
+        unsigned char rtc_data[ALL_TIME_REGS + 1];
         int ret;
 
-        rtc_data[0] = bin2bcd(tm->tm_sec);
-        rtc_data[1] = bin2bcd(tm->tm_min);
-        rtc_data[2] = bin2bcd(tm->tm_hour);
-        rtc_data[3] = bin2bcd(tm->tm_mday);
-        rtc_data[4] = bin2bcd(tm->tm_mon + 1);
-        rtc_data[5] = bin2bcd(tm->tm_year - 100);
+        rtc_data[1] = bin2bcd(tm->tm_sec);
+        rtc_data[2] = bin2bcd(tm->tm_min);
+        rtc_data[3] = bin2bcd(tm->tm_hour);
+        rtc_data[4] = bin2bcd(tm->tm_mday);
+        rtc_data[5] = bin2bcd(tm->tm_mon + 1);
+        rtc_data[6] = bin2bcd(tm->tm_year - 100);
 
         /* Stop RTC while updating the TC registers */
         ret = twl_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
@@ -341,7 +300,7 @@ out:
  */
 static int twl_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
-        unsigned char rtc_data[ALL_TIME_REGS];
+        unsigned char rtc_data[ALL_TIME_REGS + 1];
         int ret;
 
         ret = twl_i2c_read(TWL_MODULE_RTC, rtc_data,
@@ -368,19 +327,19 @@ static int twl_rtc_read_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];
+        unsigned char alarm_data[ALL_TIME_REGS + 1];
         int ret;
 
         ret = twl_rtc_alarm_irq_enable(dev, 0);
         if (ret)
                 goto out;
 
-        alarm_data[0] = bin2bcd(alm->time.tm_sec);
-        alarm_data[1] = bin2bcd(alm->time.tm_min);
-        alarm_data[2] = bin2bcd(alm->time.tm_hour);
-        alarm_data[3] = bin2bcd(alm->time.tm_mday);
-        alarm_data[4] = bin2bcd(alm->time.tm_mon + 1);
-        alarm_data[5] = bin2bcd(alm->time.tm_year - 100);
+        alarm_data[1] = bin2bcd(alm->time.tm_sec);
+        alarm_data[2] = bin2bcd(alm->time.tm_min);
+        alarm_data[3] = bin2bcd(alm->time.tm_hour);
+        alarm_data[4] = bin2bcd(alm->time.tm_mday);
+        alarm_data[5] = bin2bcd(alm->time.tm_mon + 1);
+        alarm_data[6] = bin2bcd(alm->time.tm_year - 100);
 
         /* update all the alarm registers in one shot */
         ret = twl_i2c_write(TWL_MODULE_RTC, alarm_data,
@@ -398,7 +357,7 @@ out:
 
 static irqreturn_t twl_rtc_interrupt(int irq, void *rtc)
 {
-        unsigned long events;
+        unsigned long events = 0;
         int ret = IRQ_NONE;
         int res;
         u8 rd_reg;
@@ -413,11 +372,11 @@ static irqreturn_t twl_rtc_interrupt(int irq, void *rtc)
          * by reading RTS_INTERRUPTS_REGISTER[IT_TIMER,IT_ALARM]
          */
         if (rd_reg & BIT_RTC_STATUS_REG_ALARM_M)
-                events = RTC_IRQF | RTC_AF;
+                events |= RTC_IRQF | RTC_AF;
         else
-                events = RTC_IRQF | RTC_PF;
+                events |= RTC_IRQF | RTC_UF;
 
-        res = twl_rtc_write_u8(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;
@@ -458,7 +417,7 @@ static struct rtc_class_ops twl_rtc_ops = {
 
 /*----------------------------------------------------------------------*/
 
-static int twl_rtc_probe(struct platform_device *pdev)
+static int __devinit twl_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
         int ret = -EINVAL;
@@ -490,15 +449,18 @@ static int twl_rtc_probe(struct platform_device *pdev)
                         REG_INT_MSK_STS_A);
         }
 
-        dev_info(&pdev->dev, "Enabling TWL-RTC\n");
-        ret = twl_rtc_write_u8(BIT_RTC_CTRL_REG_STOP_RTC_M, REG_RTC_CTRL_REG);
+        /* Check RTC module status, Enable if it is off */
+        ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG);
         if (ret < 0)
                 goto out1;
 
-        /* ensure interrupts are disabled, bootloaders can be strange */
-        ret = twl_rtc_write_u8(0, REG_RTC_INTERRUPTS_REG);
-        if (ret < 0)
-                dev_warn(&pdev->dev, "unable to disable interrupt\n");
+        if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) {
+                dev_info(&pdev->dev, "Enabling TWL-RTC.\n");
+                rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M;
+                ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG);
+                if (ret < 0)
+                        goto out1;
+        }
 
         /* init cached IRQ enable bits */
         ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG);
@@ -515,7 +477,7 @@ static int twl_rtc_probe(struct platform_device *pdev)
         }
 
         ret = request_threaded_irq(irq, NULL, twl_rtc_interrupt,
-                                   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                   IRQF_TRIGGER_RISING,
                                    dev_name(&rtc->dev), rtc);
         if (ret < 0) {
                 dev_err(&pdev->dev, "IRQ is not free.\n");
@@ -535,7 +497,7 @@ out1:
  * Disable all TWL RTC module interrupts.
  * Sets status flag to free.
  */
-static int twl_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);
@@ -588,23 +550,17 @@ static int twl_rtc_resume(struct platform_device *pdev)
 #define twl_rtc_resume  NULL
 #endif
 
-static const struct of_device_id twl_rtc_of_match[] = {
-        {.compatible = "ti,twl4030-rtc", },
-        { },
-};
-MODULE_DEVICE_TABLE(of, twl_rtc_of_match);
 MODULE_ALIAS("platform:twl_rtc");
 
 static struct platform_driver twl4030rtc_driver = {
         .probe          = twl_rtc_probe,
-        .remove         = twl_rtc_remove,
+        .remove         = __devexit_p(twl_rtc_remove),
         .shutdown       = twl_rtc_shutdown,
         .suspend        = twl_rtc_suspend,
         .resume         = twl_rtc_resume,
         .driver         = {
-                .owner          = THIS_MODULE,
-                .name           = "twl_rtc",
-                .of_match_table = twl_rtc_of_match,
+                .owner  = THIS_MODULE,
+                .name   = "twl_rtc",
         },
 };
 
diff --git a/drivers/rtc/rtc-tx4939.c b/drivers/rtc/rtc-tx4939.c
index a12bfac49d3..ec6313d1535 100644
--- a/drivers/rtc/rtc-tx4939.c
+++ b/drivers/rtc/rtc-tx4939.c
@@ -11,7 +11,6 @@
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
-#include <linux/module.h>
 #include <linux/io.h>
 #include <linux/gfp.h>
 #include <asm/txx9/tx4939.h>
@@ -266,7 +265,7 @@ static int __init tx4939_rtc_probe(struct platform_device *pdev)
         spin_lock_init(&pdata->lock);
         tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
         if (devm_request_irq(&pdev->dev, irq, tx4939_rtc_interrupt,
-                             0, pdev->name, &pdev->dev) < 0)
+                             IRQF_DISABLED, pdev->name, &pdev->dev) < 0)
                 return -EBUSY;
         rtc = rtc_device_register(pdev->name, &pdev->dev,
                                   &tx4939_rtc_ops, THIS_MODULE);
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
index bca5d677bc8..f71c3ce1803 100644
--- a/drivers/rtc/rtc-v3020.c
+++ b/drivers/rtc/rtc-v3020.c
@@ -393,7 +393,18 @@ static struct platform_driver rtc_device_driver = {
         },
 };
 
-module_platform_driver(rtc_device_driver);
+static __init int v3020_init(void)
+{
+        return platform_driver_register(&rtc_device_driver);
+}
+
+static __exit void v3020_exit(void)
+{
+        platform_driver_unregister(&rtc_device_driver);
+}
+
+module_init(v3020_init);
+module_exit(v3020_exit);
 
 MODULE_DESCRIPTION("V3020 RTC");
 MODULE_AUTHOR("Raphael Assenat");
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index 6c3774cf5a2..c5698cda366 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -280,7 +280,7 @@ static const struct rtc_class_ops vr41xx_rtc_ops = {
         .set_alarm      = vr41xx_rtc_set_alarm,
 };
 
-static int rtc_probe(struct platform_device *pdev)
+static int __devinit rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct rtc_device *rtc;
@@ -333,7 +333,7 @@ static int rtc_probe(struct platform_device *pdev)
                 goto err_device_unregister;
         }
 
-        retval = request_irq(aie_irq, elapsedtime_interrupt, 0,
+        retval = request_irq(aie_irq, elapsedtime_interrupt, IRQF_DISABLED,
                              "elapsed_time", pdev);
         if (retval < 0)
                 goto err_device_unregister;
@@ -342,7 +342,7 @@ static int rtc_probe(struct platform_device *pdev)
         if (pie_irq <= 0)
                 goto err_free_irq;
 
-        retval = request_irq(pie_irq, rtclong1_interrupt, 0,
+        retval = request_irq(pie_irq, rtclong1_interrupt, IRQF_DISABLED,
                              "rtclong1", pdev);
         if (retval < 0)
                 goto err_free_irq;
@@ -373,7 +373,7 @@ err_rtc1_iounmap:
         return retval;
 }
 
-static int rtc_remove(struct platform_device *pdev)
+static int __devexit rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
 
@@ -398,11 +398,22 @@ MODULE_ALIAS("platform:RTC");
 
 static struct platform_driver rtc_platform_driver = {
         .probe          = rtc_probe,
-        .remove         = rtc_remove,
+        .remove         = __devexit_p(rtc_remove),
         .driver         = {
                 .name   = rtc_name,
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(rtc_platform_driver);
+static int __init vr41xx_rtc_init(void)
+{
+        return platform_driver_register(&rtc_platform_driver);
+}
+
+static void __exit vr41xx_rtc_exit(void)
+{
+        platform_driver_unregister(&rtc_platform_driver);
+}
+
+module_init(vr41xx_rtc_init);
+module_exit(vr41xx_rtc_exit);
diff --git a/drivers/rtc/rtc-vt8500.c b/drivers/rtc/rtc-vt8500.c
index 00c930f4b6f..f93f412423c 100644
--- a/drivers/rtc/rtc-vt8500.c
+++ b/drivers/rtc/rtc-vt8500.c
@@ -23,7 +23,6 @@
 #include <linux/bcd.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
-#include <linux/of.h>
 
 /*
  * Register definitions
@@ -70,7 +69,7 @@
                                 | ALARM_SEC_BIT)
 
 #define VT8500_RTC_CR_ENABLE    (1 << 0)        /* Enable RTC */
-#define VT8500_RTC_CR_12H       (1 << 1)        /* 12h time format */
+#define VT8500_RTC_CR_24H       (1 << 1)        /* 24h time format */
 #define VT8500_RTC_CR_SM_ENABLE (1 << 2)        /* Enable periodic irqs */
 #define VT8500_RTC_CR_SM_SEC    (1 << 3)        /* 0: 1Hz/60, 1: 1Hz */
 #define VT8500_RTC_CR_CALIB     (1 << 4)        /* Enable calibration */
@@ -119,7 +118,7 @@ static int vt8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
         tm->tm_min = bcd2bin((time & TIME_MIN_MASK) >> TIME_MIN_S);
         tm->tm_hour = bcd2bin((time & TIME_HOUR_MASK) >> TIME_HOUR_S);
         tm->tm_mday = bcd2bin(date & DATE_DAY_MASK);
-        tm->tm_mon = bcd2bin((date & DATE_MONTH_MASK) >> DATE_MONTH_S) - 1;
+        tm->tm_mon = bcd2bin((date & DATE_MONTH_MASK) >> DATE_MONTH_S);
         tm->tm_year = bcd2bin((date & DATE_YEAR_MASK) >> DATE_YEAR_S)
                         + ((date >> DATE_CENTURY_S) & 1 ? 200 : 100);
         tm->tm_wday = (time & TIME_DOW_MASK) >> TIME_DOW_S;
@@ -138,9 +137,8 @@ static int vt8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
         }
 
         writel((bin2bcd(tm->tm_year - 100) << DATE_YEAR_S)
-                | (bin2bcd(tm->tm_mon + 1) << DATE_MONTH_S)
-                | (bin2bcd(tm->tm_mday))
-                | ((tm->tm_year >= 200) << DATE_CENTURY_S),
+                | (bin2bcd(tm->tm_mon) << DATE_MONTH_S)
+                | (bin2bcd(tm->tm_mday)),
                 vt8500_rtc->regbase + VT8500_RTC_DS);
         writel((bin2bcd(tm->tm_wday) << TIME_DOW_S)
                 | (bin2bcd(tm->tm_hour) << TIME_HOUR_S)
@@ -206,13 +204,12 @@ static const struct rtc_class_ops vt8500_rtc_ops = {
         .alarm_irq_enable = vt8500_alarm_irq_enable,
 };
 
-static int vt8500_rtc_probe(struct platform_device *pdev)
+static int __devinit vt8500_rtc_probe(struct platform_device *pdev)
 {
         struct vt8500_rtc *vt8500_rtc;
         int ret;
 
-        vt8500_rtc = devm_kzalloc(&pdev->dev,
-                           sizeof(struct vt8500_rtc), GFP_KERNEL);
+        vt8500_rtc = kzalloc(sizeof(struct vt8500_rtc), GFP_KERNEL);
         if (!vt8500_rtc)
                 return -ENOMEM;
 
@@ -222,13 +219,15 @@ static int vt8500_rtc_probe(struct platform_device *pdev)
         vt8500_rtc->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!vt8500_rtc->res) {
                 dev_err(&pdev->dev, "No I/O memory resource defined\n");
-                return -ENXIO;
+                ret = -ENXIO;
+                goto err_free;
         }
 
         vt8500_rtc->irq_alarm = platform_get_irq(pdev, 0);
         if (vt8500_rtc->irq_alarm < 0) {
                 dev_err(&pdev->dev, "No alarm IRQ resource defined\n");
-                return -ENXIO;
+                ret = -ENXIO;
+                goto err_free;
         }
 
         vt8500_rtc->res = request_mem_region(vt8500_rtc->res->start,
@@ -236,7 +235,8 @@ static int vt8500_rtc_probe(struct platform_device *pdev)
                                              "vt8500-rtc");
         if (vt8500_rtc->res == NULL) {
                 dev_err(&pdev->dev, "failed to request I/O memory\n");
-                return -EBUSY;
+                ret = -EBUSY;
+                goto err_free;
         }
 
         vt8500_rtc->regbase = ioremap(vt8500_rtc->res->start,
@@ -248,7 +248,7 @@ static int vt8500_rtc_probe(struct platform_device *pdev)
         }
 
         /* Enable RTC and set it to 24-hour mode */
-        writel(VT8500_RTC_CR_ENABLE,
+        writel(VT8500_RTC_CR_ENABLE | VT8500_RTC_CR_24H,
                vt8500_rtc->regbase + VT8500_RTC_CR);
 
         vt8500_rtc->rtc = rtc_device_register("vt8500-rtc", &pdev->dev,
@@ -277,10 +277,12 @@ err_unmap:
 err_release:
         release_mem_region(vt8500_rtc->res->start,
                            resource_size(vt8500_rtc->res));
+err_free:
+        kfree(vt8500_rtc);
         return ret;
 }
 
-static int vt8500_rtc_remove(struct platform_device *pdev)
+static int __devexit vt8500_rtc_remove(struct platform_device *pdev)
 {
         struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
 
@@ -294,29 +296,34 @@ static int vt8500_rtc_remove(struct platform_device *pdev)
         release_mem_region(vt8500_rtc->res->start,
                            resource_size(vt8500_rtc->res));
 
+        kfree(vt8500_rtc);
         platform_set_drvdata(pdev, NULL);
 
         return 0;
 }
 
-static const struct of_device_id wmt_dt_ids[] = {
-        { .compatible = "via,vt8500-rtc", },
-        {}
-};
-
 static struct platform_driver vt8500_rtc_driver = {
         .probe          = vt8500_rtc_probe,
-        .remove         = vt8500_rtc_remove,
+        .remove         = __devexit_p(vt8500_rtc_remove),
         .driver         = {
                 .name   = "vt8500-rtc",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(wmt_dt_ids),
         },
 };
 
-module_platform_driver(vt8500_rtc_driver);
+static int __init vt8500_rtc_init(void)
+{
+        return platform_driver_register(&vt8500_rtc_driver);
+}
+module_init(vt8500_rtc_init);
+
+static void __exit vt8500_rtc_exit(void)
+{
+        platform_driver_unregister(&vt8500_rtc_driver);
+}
+module_exit(vt8500_rtc_exit);
 
 MODULE_AUTHOR("Alexey Charkov <alchark@gmail.com>");
 MODULE_DESCRIPTION("VIA VT8500 SoC Realtime Clock Driver (RTC)");
-MODULE_LICENSE("GPL v2");
+MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:vt8500-rtc");
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
index 1b0affbe265..bdc909bd56d 100644
--- a/drivers/rtc/rtc-wm831x.c
+++ b/drivers/rtc/rtc-wm831x.c
@@ -24,7 +24,7 @@
 #include <linux/mfd/wm831x/core.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
-#include <linux/random.h>
+
 
 /*
  * R16416 (0x4020) - RTC Write Counter
@@ -96,26 +96,6 @@ struct wm831x_rtc {
         unsigned int alarm_enabled:1;
 };
 
-static void wm831x_rtc_add_randomness(struct wm831x *wm831x)
-{
-        int ret;
-        u16 reg;
-
-        /*
-         * The write counter contains a pseudo-random number which is
-         * regenerated every time we set the RTC so it should be a
-         * useful per-system source of entropy.
-         */
-        ret = wm831x_reg_read(wm831x, WM831X_RTC_WRITE_COUNTER);
-        if (ret >= 0) {
-                reg = ret;
-                add_device_randomness(&reg, sizeof(reg));
-        } else {
-                dev_warn(wm831x->dev, "Failed to read RTC write counter: %d\n",
-                         ret);
-        }
-}
-
 /*
  * Read current time and date in RTC
  */
@@ -344,6 +324,15 @@ static irqreturn_t wm831x_alm_irq(int irq, void *data)
         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,
@@ -416,10 +405,11 @@ static int wm831x_rtc_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_rtc *wm831x_rtc;
-        int alm_irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "ALM"));
+        int per_irq = platform_get_irq_byname(pdev, "PER");
+        int alm_irq = platform_get_irq_byname(pdev, "ALM");
         int ret = 0;
 
-        wm831x_rtc = devm_kzalloc(&pdev->dev, sizeof(*wm831x_rtc), GFP_KERNEL);
+        wm831x_rtc = kzalloc(sizeof(*wm831x_rtc), GFP_KERNEL);
         if (wm831x_rtc == NULL)
                 return -ENOMEM;
 
@@ -443,6 +433,14 @@ static int wm831x_rtc_probe(struct platform_device *pdev)
                 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);
@@ -451,21 +449,23 @@ static int wm831x_rtc_probe(struct platform_device *pdev)
                         alm_irq, ret);
         }
 
-        wm831x_rtc_add_randomness(wm831x);
-
         return 0;
 
 err:
+        kfree(wm831x_rtc);
         return ret;
 }
 
-static int wm831x_rtc_remove(struct platform_device *pdev)
+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;
 }
@@ -483,14 +483,24 @@ static const struct dev_pm_ops wm831x_rtc_pm_ops = {
 
 static struct platform_driver wm831x_rtc_driver = {
         .probe = wm831x_rtc_probe,
-        .remove = wm831x_rtc_remove,
+        .remove = __devexit_p(wm831x_rtc_remove),
         .driver = {
                 .name = "wm831x-rtc",
                 .pm = &wm831x_rtc_pm_ops,
         },
 };
 
-module_platform_driver(wm831x_rtc_driver);
+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");
diff --git a/drivers/rtc/rtc-wm8350.c b/drivers/rtc/rtc-wm8350.c
index 8ad86ae0d30..66421426e40 100644
--- a/drivers/rtc/rtc-wm8350.c
+++ b/drivers/rtc/rtc-wm8350.c
@@ -459,7 +459,7 @@ static int wm8350_rtc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int wm8350_rtc_remove(struct platform_device *pdev)
+static int __devexit wm8350_rtc_remove(struct platform_device *pdev)
 {
         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
         struct wm8350_rtc *wm_rtc = &wm8350->rtc;
@@ -479,14 +479,24 @@ static struct dev_pm_ops wm8350_rtc_pm_ops = {
 
 static struct platform_driver wm8350_rtc_driver = {
         .probe = wm8350_rtc_probe,
-        .remove = wm8350_rtc_remove,
+        .remove = __devexit_p(wm8350_rtc_remove),
         .driver = {
                 .name = "wm8350-rtc",
                 .pm = &wm8350_rtc_pm_ops,
         },
 };
 
-module_platform_driver(wm8350_rtc_driver);
+static int __init wm8350_rtc_init(void)
+{
+        return platform_driver_register(&wm8350_rtc_driver);
+}
+module_init(wm8350_rtc_init);
+
+static void __exit wm8350_rtc_exit(void)
+{
+        platform_driver_unregister(&wm8350_rtc_driver);
+}
+module_exit(wm8350_rtc_exit);
 
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_DESCRIPTION("RTC driver for the WM8350");
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index f36e59c6bc0..b00aad2620d 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -21,7 +21,6 @@
 #include <linux/bcd.h>
 #include <linux/rtc.h>
 #include <linux/delay.h>
-#include <linux/module.h>
 
 #define DRV_VERSION "1.0.8"
 
@@ -97,17 +96,8 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
         int i;
 
         struct i2c_msg msgs[] = {
-                {/* setup read ptr */
-                        .addr = client->addr,
-                        .len = 2,
-                        .buf = dt_addr
-                },
-                {/* read date */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 8,
-                        .buf = buf
-                },
+                { client->addr, 0, 2, dt_addr },        /* setup read ptr */
+                { client->addr, I2C_M_RD, 8, buf },     /* read date */
         };
 
         /* read date registers */
@@ -151,17 +141,8 @@ static int x1205_get_status(struct i2c_client *client, unsigned char *sr)
         static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
 
         struct i2c_msg msgs[] = {
-                {     /* setup read ptr */
-                        .addr = client->addr,
-                        .len = 2,
-                        .buf = sr_addr
-                },
-                {    /* read status */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 1,
-                        .buf = sr
-                },
+                { client->addr, 0, 2, sr_addr },        /* setup read ptr */
+                { client->addr, I2C_M_RD, 1, sr },      /* read status */
         };
 
         /* read status register */
@@ -297,17 +278,8 @@ static int x1205_get_dtrim(struct i2c_client *client, int *trim)
         static unsigned char dtr_addr[2] = { 0, X1205_REG_DTR };
 
         struct i2c_msg msgs[] = {
-                {       /* setup read ptr */
-                        .addr = client->addr,
-                        .len = 2,
-                        .buf = dtr_addr
-                },
-                {      /* read dtr */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 1,
-                        .buf = &dtr
-                },
+                { client->addr, 0, 2, dtr_addr },       /* setup read ptr */
+                { client->addr, I2C_M_RD, 1, &dtr },    /* read dtr */
         };
 
         /* read dtr register */
@@ -338,17 +310,8 @@ static int x1205_get_atrim(struct i2c_client *client, int *trim)
         static unsigned char atr_addr[2] = { 0, X1205_REG_ATR };
 
         struct i2c_msg msgs[] = {
-                {/* setup read ptr */
-                        .addr = client->addr,
-                        .len = 2,
-                        .buf = atr_addr
-                },
-                {/* read atr */
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 1,
-                        .buf = &atr
-                },
+                { client->addr, 0, 2, atr_addr },       /* setup read ptr */
+                { client->addr, I2C_M_RD, 1, &atr },    /* read atr */
         };
 
         /* read atr register */
@@ -417,17 +380,8 @@ static int x1205_validate_client(struct i2c_client *client)
                 unsigned char addr[2] = { 0, probe_zero_pattern[i] };
 
                 struct i2c_msg msgs[2] = {
-                        {
-                                .addr = client->addr,
-                                .len = 2,
-                                .buf = addr
-                        },
-                        {
-                                .addr = client->addr,
-                                .flags = I2C_M_RD,
-                                .len = 1,
-                                .buf = &buf
-                        },
+                        { client->addr, 0, 2, addr },
+                        { client->addr, I2C_M_RD, 1, &buf },
                 };
 
                 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
@@ -454,17 +408,8 @@ static int x1205_validate_client(struct i2c_client *client)
                 unsigned char addr[2] = { 0, probe_limits_pattern[i].reg };
 
                 struct i2c_msg msgs[2] = {
-                        {
-                                .addr = client->addr,
-                                .len = 2,
-                                .buf = addr
-                        },
-                        {
-                                .addr = client->addr,
-                                .flags = I2C_M_RD,
-                                .len = 1,
-                                .buf = &reg
-                        },
+                        { client->addr, 0, 2, addr },
+                        { client->addr, I2C_M_RD, 1, &reg },
                 };
 
                 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
@@ -498,18 +443,8 @@ static int x1205_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         static unsigned char int_addr[2] = { 0, X1205_REG_INT };
         struct i2c_client *client = to_i2c_client(dev);
         struct i2c_msg msgs[] = {
-                { /* setup read ptr */
-                        .addr = client->addr,
-                        .len = 2,
-                        .buf = int_addr
-                },
-                {/* read INT register */
-
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = 1,
-                        .buf = &intreg
-                },
+                { client->addr, 0, 2, int_addr },        /* setup read ptr */
+                { client->addr, I2C_M_RD, 1, &intreg },  /* read INT register */
         };
 
         /* read interrupt register and status register */
@@ -687,7 +622,15 @@ static struct i2c_driver x1205_driver = {
         .id_table       = x1205_id,
 };
 
-module_i2c_driver(x1205_driver);
+static int __init x1205_init(void)
+{
+        return i2c_add_driver(&x1205_driver);
+}
+
+static void __exit x1205_exit(void)
+{
+        i2c_del_driver(&x1205_driver);
+}
 
 MODULE_AUTHOR(
         "Karen Spearel <kas111 at gmail dot com>, "
@@ -695,3 +638,6 @@ MODULE_AUTHOR(
 MODULE_DESCRIPTION("Xicor/Intersil X1205 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
+
+module_init(x1205_init);
+module_exit(x1205_exit);