52 files changed, 5033 insertions, 1493 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index fc85bf2e4a97..8abbb2020af9 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -171,10 +171,10 @@ config RTC_DRV_MAX6900
           will be called rtc-max6900.
 
 config RTC_DRV_RS5C372
-        tristate "Ricoh RS5C372A/B, RV5C386, RV5C387A"
+        tristate "Ricoh R2025S/D, RS5C372A/B, RV5C386, RV5C387A"
         help
           If you say yes here you get support for the
-          Ricoh RS5C372A, RS5C372B, RV5C386, and RV5C387A RTC chips.
+          Ricoh R2025S/D, RS5C372A, RS5C372B, RV5C386, and RV5C387A RTC chips.
 
           This driver can also be built as a module. If so, the module
           will be called rtc-rs5c372.
@@ -220,22 +220,22 @@ config RTC_DRV_PCF8583
           will be called rtc-pcf8583.
 
 config RTC_DRV_M41T80
-        tristate "ST M41T80/81/82/83/84/85/87"
+        tristate "ST M41T65/M41T80/81/82/83/84/85/87"
         help
-          If you say Y here you will get support for the
-          ST M41T80 RTC chips series. Currently following chips are
-          supported: M41T80, M41T81, M41T82, M41T83, M41ST84, M41ST85
-          and M41ST87.
+          If you say Y here you will get support for the ST M41T60
+          and M41T80 RTC chips series. Currently, the following chips are
+          supported: M41T65, M41T80, M41T81, M41T82, M41T83, M41ST84,
+          M41ST85, and M41ST87.
 
           This driver can also be built as a module. If so, the module
           will be called rtc-m41t80.
 
 config RTC_DRV_M41T80_WDT
-        bool "ST M41T80 series RTC watchdog timer"
+        bool "ST M41T65/M41T80 series RTC watchdog timer"
         depends on RTC_DRV_M41T80
         help
           If you say Y here you will get support for the
-          watchdog timer in ST M41T80 RTC chips series.
+          watchdog timer in the ST M41T60 and M41T80 RTC chips series.
 
 config RTC_DRV_TWL92330
         boolean "TI TWL92330/Menelaus"
@@ -246,6 +246,16 @@ config RTC_DRV_TWL92330
           platforms.  The support is integrated with the rest of
           the Menelaus driver; it's not separate module.
 
+config RTC_DRV_TWL4030
+        tristate "TI TWL4030/TWL5030/TPS659x0"
+        depends on RTC_CLASS && TWL4030_CORE
+        help
+          If you say yes here you get support for the RTC on the
+          TWL4030 family chips, used mostly with OMAP3 platforms.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-twl4030.
+
 config RTC_DRV_S35390A
         tristate "Seiko Instruments S-35390A"
         select BITREVERSE
@@ -273,6 +283,25 @@ comment "SPI RTC drivers"
 
 if SPI_MASTER
 
+config RTC_DRV_M41T94
+        tristate "ST M41T94"
+        help
+          If you say yes here you will get support for the
+          ST M41T94 SPI RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-m41t94.
+
+config RTC_DRV_DS1305
+        tristate "Dallas/Maxim DS1305/DS1306"
+        help
+          Select this driver to get support for the Dallas/Maxim DS1305
+          and DS1306 real time clock chips.  These support a trickle
+          charger, alarms, and NVRAM in addition to the clock.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1305.
+
 config RTC_DRV_MAX6902
         tristate "Maxim MAX6902"
         help
@@ -300,6 +329,15 @@ config RTC_DRV_RS5C348
           This driver can also be built as a module. If so, the module
           will be called rtc-rs5c348.
 
+config RTC_DRV_DS3234
+        tristate "Maxim/Dallas DS3234"
+        help
+          If you say yes here you get support for the
+          Maxim/Dallas DS3234 SPI RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds3234.
+
 endif # SPI_MASTER
 
 comment "Platform RTC drivers"
@@ -310,7 +348,7 @@ comment "Platform RTC drivers"
 
 config RTC_DRV_CMOS
         tristate "PC-style 'CMOS'"
-        depends on X86 || ALPHA || ARM || M32R || ATARI || PPC || MIPS
+        depends on X86 || ALPHA || ARM || M32R || ATARI || PPC || MIPS || SPARC64
         default y if X86
         help
           Say "yes" here to get direct support for the real time clock
@@ -333,6 +371,11 @@ config RTC_DRV_DS1216
         help
           If you say yes here you get support for the Dallas DS1216 RTC chips.
 
+config RTC_DRV_DS1286
+        tristate "Dallas DS1286"
+        help
+          If you say yes here you get support for the Dallas DS1286 RTC chips.
+
 config RTC_DRV_DS1302
         tristate "Dallas DS1302"
         depends on SH_SECUREEDGE5410
@@ -386,15 +429,36 @@ config RTC_DRV_M48T86
           This driver can also be built as a module. If so, the module
           will be called rtc-m48t86.
 
+config RTC_DRV_M48T35
+        tristate "ST M48T35"
+        help
+          If you say Y here you will get support for the
+          ST M48T35 RTC chip.
+
+          This driver can also be built as a module, if so, the module
+          will be called "rtc-m48t35".
+
 config RTC_DRV_M48T59
-        tristate "ST M48T59"
+        tristate "ST M48T59/M48T08/M48T02"
         help
           If you say Y here you will get support for the
-          ST M48T59 RTC chip.
+          ST M48T59 RTC chip and compatible ST M48T08 and M48T02.
+
+          These chips are usually found in Sun SPARC and UltraSPARC
+          workstations.
 
           This driver can also be built as a module, if so, the module
           will be called "rtc-m48t59".
 
+config RTC_DRV_BQ4802
+        tristate "TI BQ4802"
+        help
+          If you say Y here you will get support for the TI
+          BQ4802 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-bq4802.
+
 config RTC_DRV_V3020
         tristate "EM Microelectronic V3020"
         help
@@ -542,7 +606,7 @@ config RTC_DRV_AT91SAM9_GPBR
 
 config RTC_DRV_BFIN
         tristate "Blackfin On-Chip RTC"
-        depends on BLACKFIN
+        depends on BLACKFIN && !BF561
         help
           If you say yes here you will get support for the
           Blackfin On-Chip Real Time Clock.
@@ -556,12 +620,34 @@ config RTC_DRV_RS5C313
         help
           If you say yes here you get support for the Ricoh RS5C313 RTC chips.
 
+config RTC_DRV_PARISC
+        tristate "PA-RISC firmware RTC support"
+        depends on PARISC
+        help
+          Say Y or M here to enable RTC support on PA-RISC systems using
+          firmware calls. If you do not know what you are doing, you should
+          just say Y.
+
 config RTC_DRV_PPC
        tristate "PowerPC machine dependent RTC support"
-       depends on PPC_MERGE
+       depends on PPC
        help
          The PowerPC kernel has machine-specific functions for accessing
          the RTC. This exposes that functionality through the generic RTC
          class.
 
+config RTC_DRV_SUN4V
+        bool "SUN4V Hypervisor RTC"
+        depends on SPARC64
+        help
+          If you say Y here you will get support for the Hypervisor
+          based RTC on SUN4V systems.
+
+config RTC_DRV_STARFIRE
+        bool "Starfire RTC"
+        depends on SPARC64
+        help
+          If you say Y here you will get support for the RTC found on
+          Starfire systems.
+
 endif # RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index b5d9d67df887..e9e8474cc8fe 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -23,19 +23,27 @@ obj-$(CONFIG_RTC_DRV_AT91SAM9)	+= rtc-at91sam9.o
 obj-$(CONFIG_RTC_DRV_BFIN)      += rtc-bfin.o
 obj-$(CONFIG_RTC_DRV_CMOS)      += rtc-cmos.o
 obj-$(CONFIG_RTC_DRV_DS1216)    += rtc-ds1216.o
+obj-$(CONFIG_RTC_DRV_DS1286)    += rtc-ds1286.o
 obj-$(CONFIG_RTC_DRV_DS1302)    += rtc-ds1302.o
+obj-$(CONFIG_RTC_DRV_DS1305)    += rtc-ds1305.o
 obj-$(CONFIG_RTC_DRV_DS1307)    += rtc-ds1307.o
 obj-$(CONFIG_RTC_DRV_DS1374)    += rtc-ds1374.o
 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_DS3234)    += rtc-ds3234.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
 obj-$(CONFIG_RTC_DRV_FM3130)    += rtc-fm3130.o
 obj-$(CONFIG_RTC_DRV_ISL1208)   += rtc-isl1208.o
 obj-$(CONFIG_RTC_DRV_M41T80)    += rtc-m41t80.o
+obj-$(CONFIG_RTC_DRV_M41T94)    += rtc-m41t94.o
+obj-$(CONFIG_RTC_DRV_M48T35)    += rtc-m48t35.o
 obj-$(CONFIG_RTC_DRV_M48T59)    += rtc-m48t59.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
+obj-$(CONFIG_RTC_DRV_BQ4802)    += rtc-bq4802.o
+obj-$(CONFIG_RTC_DRV_SUN4V)     += rtc-sun4v.o
+obj-$(CONFIG_RTC_DRV_STARFIRE)  += rtc-starfire.o
 obj-$(CONFIG_RTC_DRV_MAX6900)   += rtc-max6900.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
 obj-$(CONFIG_RTC_DRV_OMAP)      += rtc-omap.o
@@ -43,6 +51,7 @@ obj-$(CONFIG_RTC_DRV_PCF8563)	+= rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)   += rtc-pcf8583.o
 obj-$(CONFIG_RTC_DRV_PL030)     += rtc-pl030.o
 obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
+obj-$(CONFIG_RTC_DRV_PARISC)    += rtc-parisc.o
 obj-$(CONFIG_RTC_DRV_PPC)       += rtc-ppc.o
 obj-$(CONFIG_RTC_DRV_R9701)     += rtc-r9701.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
@@ -54,6 +63,7 @@ obj-$(CONFIG_RTC_DRV_SA1100)	+= rtc-sa1100.o
 obj-$(CONFIG_RTC_DRV_SH)        += rtc-sh.o
 obj-$(CONFIG_RTC_DRV_STK17TA8)  += rtc-stk17ta8.o
 obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
+obj-$(CONFIG_RTC_DRV_TWL4030)   += rtc-twl4030.o
 obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.o
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 58b7336640ff..7af60b98d8a4 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -20,7 +20,7 @@ int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
-                return -EBUSY;
+                return err;
 
         if (!rtc->ops)
                 err = -ENODEV;
@@ -46,7 +46,7 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
-                return -EBUSY;
+                return err;
 
         if (!rtc->ops)
                 err = -ENODEV;
@@ -66,7 +66,7 @@ int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
-                return -EBUSY;
+                return err;
 
         if (!rtc->ops)
                 err = -ENODEV;
@@ -106,7 +106,7 @@ static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *al
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
-                return -EBUSY;
+                return err;
 
         if (rtc->ops == NULL)
                 err = -ENODEV;
@@ -293,7 +293,7 @@ int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
-                return -EBUSY;
+                return err;
 
         if (!rtc->ops)
                 err = -ENODEV;
@@ -345,7 +345,7 @@ struct rtc_device *rtc_class_open(char *name)
         struct device *dev;
         struct rtc_device *rtc = NULL;
 
-        dev = class_find_device(rtc_class, name, __rtc_match);
+        dev = class_find_device(rtc_class, NULL, name, __rtc_match);
         if (dev)
                 rtc = to_rtc_device(dev);
 
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index 9c3db934cc24..b5bf93706913 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -29,10 +29,10 @@
 #include <linux/completion.h>
 
 #include <asm/uaccess.h>
-#include <asm/arch/at91_rtc.h>
+
+#include <mach/at91_rtc.h>
 
 
-#define AT91_RTC_FREQ           1
 #define AT91_RTC_EPOCH          1900UL  /* just like arch/arm/common/rtctime.c */
 
 static DECLARE_COMPLETION(at91_rtc_updated);
@@ -53,21 +53,21 @@ static void at91_rtc_decodetime(unsigned int timereg, unsigned int 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);
-        tm->tm_hour = BCD2BIN((time & AT91_RTC_HOUR) >> 16);
+        tm->tm_sec  = bcd2bin((time & AT91_RTC_SEC) >> 0);
+        tm->tm_min  = bcd2bin((time & AT91_RTC_MIN) >> 8);
+        tm->tm_hour = bcd2bin((time & AT91_RTC_HOUR) >> 16);
 
         /*
          * The Calendar Alarm register does not have a field for
          * the year - so these will return an invalid value.  When an
          * alarm is set, at91_alarm_year wille store the current year.
          */
-        tm->tm_year  = BCD2BIN(date & AT91_RTC_CENT) * 100;     /* century */
-        tm->tm_year += BCD2BIN((date & AT91_RTC_YEAR) >> 8);    /* year */
+        tm->tm_year  = bcd2bin(date & AT91_RTC_CENT) * 100;     /* century */
+        tm->tm_year += bcd2bin((date & AT91_RTC_YEAR) >> 8);    /* year */
 
-        tm->tm_wday = BCD2BIN((date & AT91_RTC_DAY) >> 21) - 1; /* day of the week [0-6], Sunday=0 */
-        tm->tm_mon  = BCD2BIN((date & AT91_RTC_MONTH) >> 16) - 1;
-        tm->tm_mday = BCD2BIN((date & AT91_RTC_DATE) >> 24);
+        tm->tm_wday = bcd2bin((date & AT91_RTC_DAY) >> 21) - 1; /* day of the week [0-6], Sunday=0 */
+        tm->tm_mon  = bcd2bin((date & AT91_RTC_MONTH) >> 16) - 1;
+        tm->tm_mday = bcd2bin((date & AT91_RTC_DATE) >> 24);
 }
 
 /*
@@ -106,16 +106,16 @@ static int at91_rtc_settime(struct device *dev, struct rtc_time *tm)
         at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD);
 
         at91_sys_write(AT91_RTC_TIMR,
-                          BIN2BCD(tm->tm_sec) << 0
-                        | BIN2BCD(tm->tm_min) << 8
-                        | BIN2BCD(tm->tm_hour) << 16);
+                          bin2bcd(tm->tm_sec) << 0
+                        | bin2bcd(tm->tm_min) << 8
+                        | bin2bcd(tm->tm_hour) << 16);
 
         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 */
-                        | BIN2BCD(tm->tm_wday + 1) << 21        /* day of the week [0-6], Sunday=0 */
-                        | BIN2BCD(tm->tm_mday) << 24);
+                          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 */
+                        | bin2bcd(tm->tm_wday + 1) << 21        /* day of the week [0-6], Sunday=0 */
+                        | bin2bcd(tm->tm_mday) << 24);
 
         /* Restart Time/Calendar */
         cr = at91_sys_read(AT91_RTC_CR);
@@ -162,17 +162,19 @@ static int at91_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         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
+                  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_sys_write(AT91_RTC_CALALR,
-                  BIN2BCD(tm.tm_mon + 1) << 16          /* tm_mon starts at zero */
-                | BIN2BCD(tm.tm_mday) << 24
+                  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)
+        if (alrm->enabled) {
+                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__,
                 at91_alarm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour,
@@ -191,28 +193,22 @@ static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
 
         pr_debug("%s(): cmd=%08x, arg=%08lx.\n", __func__, cmd, arg);
 
+        /* important:  scrub old status before enabling IRQs */
         switch (cmd) {
         case RTC_AIE_OFF:       /* alarm off */
                 at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
                 break;
         case RTC_AIE_ON:        /* alarm on */
+                at91_sys_write(AT91_RTC_SCCR, AT91_RTC_ALARM);
                 at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM);
                 break;
         case RTC_UIE_OFF:       /* update off */
-        case RTC_PIE_OFF:       /* periodic off */
                 at91_sys_write(AT91_RTC_IDR, AT91_RTC_SECEV);
                 break;
         case RTC_UIE_ON:        /* update on */
-        case RTC_PIE_ON:        /* periodic on */
+                at91_sys_write(AT91_RTC_SCCR, AT91_RTC_SECEV);
                 at91_sys_write(AT91_RTC_IER, AT91_RTC_SECEV);
                 break;
-        case RTC_IRQP_READ:     /* read periodic alarm frequency */
-                ret = put_user(AT91_RTC_FREQ, (unsigned long *) arg);
-                break;
-        case RTC_IRQP_SET:      /* set periodic alarm frequency */
-                if (arg != AT91_RTC_FREQ)
-                        ret = -EINVAL;
-                break;
         default:
                 ret = -ENOIOCTLCMD;
                 break;
@@ -232,8 +228,6 @@ static int at91_rtc_proc(struct device *dev, struct seq_file *seq)
                         (imr & AT91_RTC_ACKUPD) ? "yes" : "no");
         seq_printf(seq, "periodic_IRQ\t: %s\n",
                         (imr & AT91_RTC_SECEV) ? "yes" : "no");
-        seq_printf(seq, "periodic_freq\t: %ld\n",
-                        (unsigned long) AT91_RTC_FREQ);
 
         return 0;
 }
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index f0246ef413a4..2133f37906f2 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 <asm/arch/board.h>
-#include <asm/arch/at91_rtt.h>
+#include <mach/board.h>
+#include <mach/at91_rtt.h>
 
 
 /*
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index 8624f55d0560..34439ce3967e 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -2,7 +2,7 @@
  * Blackfin On-Chip Real Time Clock Driver
  *  Supports BF52[257]/BF53[123]/BF53[467]/BF54[24789]
  *
- * Copyright 2004-2007 Analog Devices Inc.
+ * Copyright 2004-2008 Analog Devices Inc.
  *
  * Enter bugs at http://blackfin.uclinux.org/
  *
@@ -32,6 +32,15 @@
  * writes to clear status registers complete immediately.
  */
 
+/* It may seem odd that there is no SWCNT code in here (which would be exposed
+ * via the periodic interrupt event, or PIE).  Since the Blackfin RTC peripheral
+ * runs in units of seconds (N/HZ) but the Linux framework runs in units of HZ
+ * (2^N HZ), there is no point in keeping code that only provides 1 HZ PIEs.
+ * The same exact behavior can be accomplished by using the update interrupt
+ * event (UIE).  Maybe down the line the RTC peripheral will suck less in which
+ * case we can re-introduce PIE support.
+ */
+
 #include <linux/bcd.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
@@ -144,14 +153,13 @@ static void bfin_rtc_sync_pending(struct device *dev)
  * Initialize the RTC.  Enable pre-scaler to scale RTC clock
  * to 1Hz and clear interrupt/status registers.
  */
-static void bfin_rtc_reset(struct device *dev)
+static void bfin_rtc_reset(struct device *dev, u16 rtc_ictl)
 {
         struct bfin_rtc *rtc = dev_get_drvdata(dev);
         dev_dbg_stamp(dev);
         bfin_rtc_sync_pending(dev);
         bfin_write_RTC_PREN(0x1);
-        bfin_write_RTC_ICTL(RTC_ISTAT_WRITE_COMPLETE);
-        bfin_write_RTC_SWCNT(0);
+        bfin_write_RTC_ICTL(rtc_ictl);
         bfin_write_RTC_ALARM(0);
         bfin_write_RTC_ISTAT(0xFFFF);
         rtc->rtc_wrote_regs = 0;
@@ -194,14 +202,6 @@ static irqreturn_t bfin_rtc_interrupt(int irq, void *dev_id)
                 }
         }
 
-        if (rtc_ictl & RTC_ISTAT_STOPWATCH) {
-                if (rtc_istat & RTC_ISTAT_STOPWATCH) {
-                        bfin_write_RTC_ISTAT(RTC_ISTAT_STOPWATCH);
-                        events |= RTC_PF | RTC_IRQF;
-                        bfin_write_RTC_SWCNT(rtc->rtc_dev->irq_freq);
-                }
-        }
-
         if (rtc_ictl & RTC_ISTAT_SEC) {
                 if (rtc_istat & RTC_ISTAT_SEC) {
                         bfin_write_RTC_ISTAT(RTC_ISTAT_SEC);
@@ -218,32 +218,12 @@ static irqreturn_t bfin_rtc_interrupt(int irq, void *dev_id)
                 return IRQ_NONE;
 }
 
-static int bfin_rtc_open(struct device *dev)
-{
-        int ret;
-
-        dev_dbg_stamp(dev);
-
-        ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, IRQF_SHARED, to_platform_device(dev)->name, dev);
-        if (!ret)
-                bfin_rtc_reset(dev);
-
-        return ret;
-}
-
-static void bfin_rtc_release(struct device *dev)
-{
-        dev_dbg_stamp(dev);
-        bfin_rtc_reset(dev);
-        free_irq(IRQ_RTC, dev);
-}
-
-static void bfin_rtc_int_set(struct bfin_rtc *rtc, u16 rtc_int)
+static void bfin_rtc_int_set(u16 rtc_int)
 {
         bfin_write_RTC_ISTAT(rtc_int);
         bfin_write_RTC_ICTL(bfin_read_RTC_ICTL() | rtc_int);
 }
-static void bfin_rtc_int_clear(struct bfin_rtc *rtc, u16 rtc_int)
+static void bfin_rtc_int_clear(u16 rtc_int)
 {
         bfin_write_RTC_ICTL(bfin_read_RTC_ICTL() & rtc_int);
 }
@@ -252,7 +232,7 @@ static void bfin_rtc_int_set_alarm(struct bfin_rtc *rtc)
         /* Blackfin has different bits for whether the alarm is
          * more than 24 hours away.
          */
-        bfin_rtc_int_set(rtc, (rtc->rtc_alarm.tm_yday == -1 ? RTC_ISTAT_ALARM : RTC_ISTAT_ALARM_DAY));
+        bfin_rtc_int_set(rtc->rtc_alarm.tm_yday == -1 ? RTC_ISTAT_ALARM : RTC_ISTAT_ALARM_DAY);
 }
 static int bfin_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
@@ -264,23 +244,13 @@ static int bfin_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long ar
         bfin_rtc_sync_pending(dev);
 
         switch (cmd) {
-        case RTC_PIE_ON:
-                dev_dbg_stamp(dev);
-                bfin_rtc_int_set(rtc, RTC_ISTAT_STOPWATCH);
-                bfin_write_RTC_SWCNT(rtc->rtc_dev->irq_freq);
-                break;
-        case RTC_PIE_OFF:
-                dev_dbg_stamp(dev);
-                bfin_rtc_int_clear(rtc, ~RTC_ISTAT_STOPWATCH);
-                break;
-
         case RTC_UIE_ON:
                 dev_dbg_stamp(dev);
-                bfin_rtc_int_set(rtc, RTC_ISTAT_SEC);
+                bfin_rtc_int_set(RTC_ISTAT_SEC);
                 break;
         case RTC_UIE_OFF:
                 dev_dbg_stamp(dev);
-                bfin_rtc_int_clear(rtc, ~RTC_ISTAT_SEC);
+                bfin_rtc_int_clear(~RTC_ISTAT_SEC);
                 break;
 
         case RTC_AIE_ON:
@@ -289,7 +259,7 @@ static int bfin_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long ar
                 break;
         case RTC_AIE_OFF:
                 dev_dbg_stamp(dev);
-                bfin_rtc_int_clear(rtc, ~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
+                bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
                 break;
 
         default:
@@ -371,64 +341,64 @@ static int bfin_rtc_proc(struct device *dev, struct seq_file *seq)
         seq_printf(seq,
                 "alarm_IRQ\t: %s\n"
                 "wkalarm_IRQ\t: %s\n"
-                "seconds_IRQ\t: %s\n"
-                "periodic_IRQ\t: %s\n",
+                "seconds_IRQ\t: %s\n",
                 yesno(ictl & RTC_ISTAT_ALARM),
                 yesno(ictl & RTC_ISTAT_ALARM_DAY),
-                yesno(ictl & RTC_ISTAT_SEC),
-                yesno(ictl & RTC_ISTAT_STOPWATCH));
+                yesno(ictl & RTC_ISTAT_SEC));
         return 0;
 #undef yesno
 }
 
-/**
- *      bfin_irq_set_freq - make sure hardware supports requested freq
- *      @dev: pointer to RTC device structure
- *      @freq: requested frequency rate
- *
- *      The Blackfin RTC can only generate periodic events at 1 per
- *      second (1 Hz), so reject any attempt at changing it.
- */
-static int bfin_irq_set_freq(struct device *dev, int freq)
-{
-        dev_dbg_stamp(dev);
-        return -ENOTTY;
-}
-
 static struct rtc_class_ops bfin_rtc_ops = {
-        .open          = bfin_rtc_open,
-        .release       = bfin_rtc_release,
         .ioctl         = bfin_rtc_ioctl,
         .read_time     = bfin_rtc_read_time,
         .set_time      = bfin_rtc_set_time,
         .read_alarm    = bfin_rtc_read_alarm,
         .set_alarm     = bfin_rtc_set_alarm,
         .proc          = bfin_rtc_proc,
-        .irq_set_freq  = bfin_irq_set_freq,
 };
 
 static int __devinit bfin_rtc_probe(struct platform_device *pdev)
 {
         struct bfin_rtc *rtc;
+        struct device *dev = &pdev->dev;
         int ret = 0;
+        unsigned long timeout;
 
-        dev_dbg_stamp(&pdev->dev);
+        dev_dbg_stamp(dev);
 
+        /* Allocate memory for our RTC struct */
         rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
         if (unlikely(!rtc))
                 return -ENOMEM;
+        platform_set_drvdata(pdev, rtc);
+        device_init_wakeup(dev, 1);
 
-        rtc->rtc_dev = rtc_device_register(pdev->name, &pdev->dev, &bfin_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc->rtc_dev);
+        /* Grab the IRQ and init the hardware */
+        ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, IRQF_SHARED, pdev->name, dev);
+        if (unlikely(ret))
                 goto err;
-        }
-        rtc->rtc_dev->irq_freq = 1;
+        /* sometimes the bootloader touched things, but the write complete was not
+         * enabled, so let's just do a quick timeout here since the IRQ will not fire ...
+         */
+        timeout = jiffies + HZ;
+        while (bfin_read_RTC_ISTAT() & RTC_ISTAT_WRITE_PENDING)
+                if (time_after(jiffies, timeout))
+                        break;
+        bfin_rtc_reset(dev, RTC_ISTAT_WRITE_COMPLETE);
+        bfin_write_RTC_SWCNT(0);
 
-        platform_set_drvdata(pdev, rtc);
+        /* Register our RTC with the RTC framework */
+        rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops, THIS_MODULE);
+        if (unlikely(IS_ERR(rtc))) {
+                ret = PTR_ERR(rtc->rtc_dev);
+                goto err_irq;
+        }
 
         return 0;
 
+ err_irq:
+        free_irq(IRQ_RTC, dev);
  err:
         kfree(rtc);
         return ret;
@@ -437,7 +407,10 @@ static int __devinit bfin_rtc_probe(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;
 
+        bfin_rtc_reset(dev, 0);
+        free_irq(IRQ_RTC, dev);
         rtc_device_unregister(rtc->rtc_dev);
         platform_set_drvdata(pdev, NULL);
         kfree(rtc);
@@ -445,6 +418,32 @@ static int __devexit bfin_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        if (device_may_wakeup(&pdev->dev)) {
+                enable_irq_wake(IRQ_RTC);
+                bfin_rtc_sync_pending(&pdev->dev);
+        } else
+                bfin_rtc_int_clear(-1);
+
+        return 0;
+}
+
+static int bfin_rtc_resume(struct platform_device *pdev)
+{
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(IRQ_RTC);
+        else
+                bfin_write_RTC_ISTAT(-1);
+
+        return 0;
+}
+#else
+# define bfin_rtc_suspend NULL
+# define bfin_rtc_resume  NULL
+#endif
+
 static struct platform_driver bfin_rtc_driver = {
         .driver         = {
                 .name   = "rtc-bfin",
@@ -452,6 +451,8 @@ static struct platform_driver bfin_rtc_driver = {
         },
         .probe          = bfin_rtc_probe,
         .remove         = __devexit_p(bfin_rtc_remove),
+        .suspend        = bfin_rtc_suspend,
+        .resume         = bfin_rtc_resume,
 };
 
 static int __init bfin_rtc_init(void)
diff --git a/drivers/rtc/rtc-bq4802.c b/drivers/rtc/rtc-bq4802.c
new file mode 100644
index 000000000000..d00a274df8fc
--- /dev/null
+++ b/drivers/rtc/rtc-bq4802.c
@@ -0,0 +1,230 @@
+/* rtc-bq4802.c: TI BQ4802 RTC driver.
+ *
+ * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+
+MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
+MODULE_DESCRIPTION("TI BQ4802 RTC driver");
+MODULE_LICENSE("GPL");
+
+struct bq4802 {
+        void __iomem            *regs;
+        unsigned long           ioport;
+        struct rtc_device       *rtc;
+        spinlock_t              lock;
+        struct resource         *r;
+        u8 (*read)(struct bq4802 *, int);
+        void (*write)(struct bq4802 *, int, u8);
+};
+
+static u8 bq4802_read_io(struct bq4802 *p, int off)
+{
+        return inb(p->ioport + off);
+}
+
+static void bq4802_write_io(struct bq4802 *p, int off, u8 val)
+{
+        outb(val, p->ioport + off);
+}
+
+static u8 bq4802_read_mem(struct bq4802 *p, int off)
+{
+        return readb(p->regs + off);
+}
+
+static void bq4802_write_mem(struct bq4802 *p, int off, u8 val)
+{
+        writeb(val, p->regs + off);
+}
+
+static int bq4802_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct bq4802 *p = platform_get_drvdata(pdev);
+        unsigned long flags;
+        unsigned int century;
+        u8 val;
+
+        spin_lock_irqsave(&p->lock, flags);
+
+        val = p->read(p, 0x0e);
+        p->write(p, 0xe, val | 0x08);
+
+        tm->tm_sec = p->read(p, 0x00);
+        tm->tm_min = p->read(p, 0x02);
+        tm->tm_hour = p->read(p, 0x04);
+        tm->tm_mday = p->read(p, 0x06);
+        tm->tm_mon = p->read(p, 0x09);
+        tm->tm_year = p->read(p, 0x0a);
+        tm->tm_wday = p->read(p, 0x08);
+        century = p->read(p, 0x0f);
+
+        p->write(p, 0x0e, val);
+
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        tm->tm_sec = bcd2bin(tm->tm_sec);
+        tm->tm_min = bcd2bin(tm->tm_min);
+        tm->tm_hour = bcd2bin(tm->tm_hour);
+        tm->tm_mday = bcd2bin(tm->tm_mday);
+        tm->tm_mon = bcd2bin(tm->tm_mon);
+        tm->tm_year = bcd2bin(tm->tm_year);
+        tm->tm_wday = bcd2bin(tm->tm_wday);
+        century = bcd2bin(century);
+
+        tm->tm_year += (century * 100);
+        tm->tm_year -= 1900;
+
+        tm->tm_mon--;
+
+        return 0;
+}
+
+static int bq4802_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct bq4802 *p = platform_get_drvdata(pdev);
+        u8 sec, min, hrs, day, mon, yrs, century, val;
+        unsigned long flags;
+        unsigned int year;
+
+        year = tm->tm_year + 1900;
+        century = year / 100;
+        yrs = year % 100;
+
+        mon = tm->tm_mon + 1;   /* tm_mon starts at zero */
+        day = tm->tm_mday;
+        hrs = tm->tm_hour;
+        min = tm->tm_min;
+        sec = tm->tm_sec;
+
+        sec = bin2bcd(sec);
+        min = bin2bcd(min);
+        hrs = bin2bcd(hrs);
+        day = bin2bcd(day);
+        mon = bin2bcd(mon);
+        yrs = bin2bcd(yrs);
+        century = bin2bcd(century);
+
+        spin_lock_irqsave(&p->lock, flags);
+
+        val = p->read(p, 0x0e);
+        p->write(p, 0x0e, val | 0x08);
+
+        p->write(p, 0x00, sec);
+        p->write(p, 0x02, min);
+        p->write(p, 0x04, hrs);
+        p->write(p, 0x06, day);
+        p->write(p, 0x09, mon);
+        p->write(p, 0x0a, yrs);
+        p->write(p, 0x0f, century);
+
+        p->write(p, 0x0e, val);
+
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        return 0;
+}
+
+static const struct rtc_class_ops bq4802_ops = {
+        .read_time      = bq4802_read_time,
+        .set_time       = bq4802_set_time,
+};
+
+static int __devinit bq4802_probe(struct platform_device *pdev)
+{
+        struct bq4802 *p = kzalloc(sizeof(*p), GFP_KERNEL);
+        int err = -ENOMEM;
+
+        if (!p)
+                goto out;
+
+        spin_lock_init(&p->lock);
+
+        p->r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!p->r) {
+                p->r = platform_get_resource(pdev, IORESOURCE_IO, 0);
+                err = -EINVAL;
+                if (!p->r)
+                        goto out_free;
+        }
+        if (p->r->flags & IORESOURCE_IO) {
+                p->ioport = p->r->start;
+                p->read = bq4802_read_io;
+                p->write = bq4802_write_io;
+        } else if (p->r->flags & IORESOURCE_MEM) {
+                p->regs = ioremap(p->r->start, resource_size(p->r));
+                p->read = bq4802_read_mem;
+                p->write = bq4802_write_mem;
+        } else {
+                err = -EINVAL;
+                goto out_free;
+        }
+
+        p->rtc = rtc_device_register("bq4802", &pdev->dev,
+                                     &bq4802_ops, THIS_MODULE);
+        if (IS_ERR(p->rtc)) {
+                err = PTR_ERR(p->rtc);
+                goto out_iounmap;
+        }
+
+        platform_set_drvdata(pdev, p);
+        err = 0;
+out:
+        return err;
+
+out_iounmap:
+        if (p->r->flags & IORESOURCE_MEM)
+                iounmap(p->regs);
+out_free:
+        kfree(p);
+        goto out;
+}
+
+static int __devexit bq4802_remove(struct platform_device *pdev)
+{
+        struct bq4802 *p = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(p->rtc);
+        if (p->r->flags & IORESOURCE_MEM)
+                iounmap(p->regs);
+
+        platform_set_drvdata(pdev, NULL);
+
+        kfree(p);
+
+        return 0;
+}
+
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:rtc-bq4802");
+
+static struct platform_driver bq4802_driver = {
+        .driver         = {
+                .name   = "rtc-bq4802",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = bq4802_probe,
+        .remove         = __devexit_p(bq4802_remove),
+};
+
+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 d7bb9bac71df..5549231179a2 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -36,25 +36,9 @@
 #include <linux/platform_device.h>
 #include <linux/mod_devicetable.h>
 
-#ifdef CONFIG_HPET_EMULATE_RTC
-#include <asm/hpet.h>
-#endif
-
 /* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
 #include <asm-generic/rtc.h>
 
-#ifndef CONFIG_HPET_EMULATE_RTC
-#define is_hpet_enabled()                       0
-#define hpet_set_alarm_time(hrs, min, sec)      do { } while (0)
-#define hpet_set_periodic_freq(arg)             0
-#define hpet_mask_rtc_irq_bit(arg)              do { } while (0)
-#define hpet_set_rtc_irq_bit(arg)               do { } while (0)
-#define hpet_rtc_timer_init()                   do { } while (0)
-#define hpet_register_irq_handler(h)            0
-#define hpet_unregister_irq_handler(h)          do { } while (0)
-extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id);
-#endif
-
 struct cmos_rtc {
         struct rtc_device       *rtc;
         struct device           *dev;
@@ -93,6 +77,109 @@ static inline int is_intr(u8 rtc_intr)
 
 /*----------------------------------------------------------------*/
 
+/* Much modern x86 hardware has HPETs (10+ MHz timers) which, because
+ * many BIOS programmers don't set up "sane mode" IRQ routing, are mostly
+ * used in a broken "legacy replacement" mode.  The breakage includes
+ * HPET #1 hijacking the IRQ for this RTC, and being unavailable for
+ * other (better) use.
+ *
+ * When that broken mode is in use, platform glue provides a partial
+ * emulation of hardware RTC IRQ facilities using HPET #1.  We don't
+ * want to use HPET for anything except those IRQs though...
+ */
+#ifdef CONFIG_HPET_EMULATE_RTC
+#include <asm/hpet.h>
+#else
+
+static inline int is_hpet_enabled(void)
+{
+        return 0;
+}
+
+static inline int hpet_mask_rtc_irq_bit(unsigned long mask)
+{
+        return 0;
+}
+
+static inline int hpet_set_rtc_irq_bit(unsigned long mask)
+{
+        return 0;
+}
+
+static inline int
+hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
+{
+        return 0;
+}
+
+static inline int hpet_set_periodic_freq(unsigned long freq)
+{
+        return 0;
+}
+
+static inline int hpet_rtc_dropped_irq(void)
+{
+        return 0;
+}
+
+static inline int hpet_rtc_timer_init(void)
+{
+        return 0;
+}
+
+extern irq_handler_t hpet_rtc_interrupt;
+
+static inline int hpet_register_irq_handler(irq_handler_t handler)
+{
+        return 0;
+}
+
+static inline int hpet_unregister_irq_handler(irq_handler_t handler)
+{
+        return 0;
+}
+
+#endif
+
+/*----------------------------------------------------------------*/
+
+#ifdef RTC_PORT
+
+/* Most newer x86 systems have two register banks, the first used
+ * for RTC and NVRAM and the second only for NVRAM.  Caller must
+ * own rtc_lock ... and we won't worry about access during NMI.
+ */
+#define can_bank2       true
+
+static inline unsigned char cmos_read_bank2(unsigned char addr)
+{
+        outb(addr, RTC_PORT(2));
+        return inb(RTC_PORT(3));
+}
+
+static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
+{
+        outb(addr, RTC_PORT(2));
+        outb(val, RTC_PORT(2));
+}
+
+#else
+
+#define can_bank2       false
+
+static inline unsigned char cmos_read_bank2(unsigned char addr)
+{
+        return 0;
+}
+
+static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
+{
+}
+
+#endif
+
+/*----------------------------------------------------------------*/
+
 static int cmos_read_time(struct device *dev, struct rtc_time *t)
 {
         /* REVISIT:  if the clock has a "century" register, use
@@ -153,26 +240,26 @@ static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
         /* REVISIT this assumes PC style usage:  always BCD */
 
         if (((unsigned)t->time.tm_sec) < 0x60)
-                t->time.tm_sec = BCD2BIN(t->time.tm_sec);
+                t->time.tm_sec = bcd2bin(t->time.tm_sec);
         else
                 t->time.tm_sec = -1;
         if (((unsigned)t->time.tm_min) < 0x60)
-                t->time.tm_min = BCD2BIN(t->time.tm_min);
+                t->time.tm_min = bcd2bin(t->time.tm_min);
         else
                 t->time.tm_min = -1;
         if (((unsigned)t->time.tm_hour) < 0x24)
-                t->time.tm_hour = BCD2BIN(t->time.tm_hour);
+                t->time.tm_hour = bcd2bin(t->time.tm_hour);
         else
                 t->time.tm_hour = -1;
 
         if (cmos->day_alrm) {
                 if (((unsigned)t->time.tm_mday) <= 0x31)
-                        t->time.tm_mday = BCD2BIN(t->time.tm_mday);
+                        t->time.tm_mday = bcd2bin(t->time.tm_mday);
                 else
                         t->time.tm_mday = -1;
                 if (cmos->mon_alrm) {
                         if (((unsigned)t->time.tm_mon) <= 0x12)
-                                t->time.tm_mon = BCD2BIN(t->time.tm_mon) - 1;
+                                t->time.tm_mon = bcd2bin(t->time.tm_mon) - 1;
                         else
                                 t->time.tm_mon = -1;
                 }
@@ -185,11 +272,56 @@ static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
         return 0;
 }
 
+static void cmos_checkintr(struct cmos_rtc *cmos, unsigned char rtc_control)
+{
+        unsigned char   rtc_intr;
+
+        /* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
+         * allegedly some older rtcs need that to handle irqs properly
+         */
+        rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
+
+        if (is_hpet_enabled())
+                return;
+
+        rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
+        if (is_intr(rtc_intr))
+                rtc_update_irq(cmos->rtc, 1, rtc_intr);
+}
+
+static void cmos_irq_enable(struct cmos_rtc *cmos, unsigned char mask)
+{
+        unsigned char   rtc_control;
+
+        /* flush any pending IRQ status, notably for update irqs,
+         * before we enable new IRQs
+         */
+        rtc_control = CMOS_READ(RTC_CONTROL);
+        cmos_checkintr(cmos, rtc_control);
+
+        rtc_control |= mask;
+        CMOS_WRITE(rtc_control, RTC_CONTROL);
+        hpet_set_rtc_irq_bit(mask);
+
+        cmos_checkintr(cmos, rtc_control);
+}
+
+static void cmos_irq_disable(struct cmos_rtc *cmos, unsigned char mask)
+{
+        unsigned char   rtc_control;
+
+        rtc_control = CMOS_READ(RTC_CONTROL);
+        rtc_control &= ~mask;
+        CMOS_WRITE(rtc_control, RTC_CONTROL);
+        hpet_mask_rtc_irq_bit(mask);
+
+        cmos_checkintr(cmos, rtc_control);
+}
+
 static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
         unsigned char   mon, mday, hrs, min, sec;
-        unsigned char   rtc_control, rtc_intr;
 
         if (!is_valid_irq(cmos->irq))
                 return -EIO;
@@ -199,31 +331,24 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
         /* Writing 0xff means "don't care" or "match all".  */
 
         mon = t->time.tm_mon + 1;
-        mon = (mon <= 12) ? BIN2BCD(mon) : 0xff;
+        mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
 
         mday = t->time.tm_mday;
-        mday = (mday >= 1 && mday <= 31) ? BIN2BCD(mday) : 0xff;
+        mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
 
         hrs = t->time.tm_hour;
-        hrs = (hrs < 24) ? BIN2BCD(hrs) : 0xff;
+        hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
 
         min = t->time.tm_min;
-        min = (min < 60) ? BIN2BCD(min) : 0xff;
+        min = (min < 60) ? bin2bcd(min) : 0xff;
 
         sec = t->time.tm_sec;
-        sec = (sec < 60) ? BIN2BCD(sec) : 0xff;
+        sec = (sec < 60) ? bin2bcd(sec) : 0xff;
 
-        hpet_set_alarm_time(t->time.tm_hour, t->time.tm_min, t->time.tm_sec);
         spin_lock_irq(&rtc_lock);
 
         /* next rtc irq must not be from previous alarm setting */
-        rtc_control = CMOS_READ(RTC_CONTROL);
-        rtc_control &= ~RTC_AIE;
-        CMOS_WRITE(rtc_control, RTC_CONTROL);
-        rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
-        rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
-        if (is_intr(rtc_intr))
-                rtc_update_irq(cmos->rtc, 1, rtc_intr);
+        cmos_irq_disable(cmos, RTC_AIE);
 
         /* update alarm */
         CMOS_WRITE(hrs, RTC_HOURS_ALARM);
@@ -237,14 +362,13 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
                         CMOS_WRITE(mon, cmos->mon_alrm);
         }
 
-        if (t->enabled) {
-                rtc_control |= RTC_AIE;
-                CMOS_WRITE(rtc_control, RTC_CONTROL);
-                rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
-                rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
-                if (is_intr(rtc_intr))
-                        rtc_update_irq(cmos->rtc, 1, rtc_intr);
-        }
+        /* FIXME the HPET alarm glue currently ignores day_alrm
+         * and mon_alrm ...
+         */
+        hpet_set_alarm_time(t->time.tm_hour, t->time.tm_min, t->time.tm_sec);
+
+        if (t->enabled)
+                cmos_irq_enable(cmos, RTC_AIE);
 
         spin_unlock_irq(&rtc_lock);
 
@@ -267,8 +391,8 @@ static int cmos_irq_set_freq(struct device *dev, int freq)
         f = 16 - f;
 
         spin_lock_irqsave(&rtc_lock, flags);
-        if (!hpet_set_periodic_freq(freq))
-                CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
+        hpet_set_periodic_freq(freq);
+        CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT);
         spin_unlock_irqrestore(&rtc_lock, flags);
 
         return 0;
@@ -277,26 +401,17 @@ static int cmos_irq_set_freq(struct device *dev, int freq)
 static int cmos_irq_set_state(struct device *dev, int enabled)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        unsigned char   rtc_control, rtc_intr;
         unsigned long   flags;
 
         if (!is_valid_irq(cmos->irq))
                 return -ENXIO;
 
         spin_lock_irqsave(&rtc_lock, flags);
-        rtc_control = CMOS_READ(RTC_CONTROL);
 
         if (enabled)
-                rtc_control |= RTC_PIE;
+                cmos_irq_enable(cmos, RTC_PIE);
         else
-                rtc_control &= ~RTC_PIE;
-
-        CMOS_WRITE(rtc_control, RTC_CONTROL);
-
-        rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
-        rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
-        if (is_intr(rtc_intr))
-                rtc_update_irq(cmos->rtc, 1, rtc_intr);
+                cmos_irq_disable(cmos, RTC_PIE);
 
         spin_unlock_irqrestore(&rtc_lock, flags);
         return 0;
@@ -308,7 +423,6 @@ static int
 cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        unsigned char   rtc_control, rtc_intr;
         unsigned long   flags;
 
         switch (cmd) {
@@ -316,51 +430,29 @@ cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         case RTC_AIE_ON:
         case RTC_UIE_OFF:
         case RTC_UIE_ON:
-        case RTC_PIE_OFF:
-        case RTC_PIE_ON:
                 if (!is_valid_irq(cmos->irq))
                         return -EINVAL;
                 break;
+        /* PIE ON/OFF is handled by cmos_irq_set_state() */
         default:
                 return -ENOIOCTLCMD;
         }
 
         spin_lock_irqsave(&rtc_lock, flags);
-        rtc_control = CMOS_READ(RTC_CONTROL);
         switch (cmd) {
         case RTC_AIE_OFF:       /* alarm off */
-                rtc_control &= ~RTC_AIE;
-                hpet_mask_rtc_irq_bit(RTC_AIE);
+                cmos_irq_disable(cmos, RTC_AIE);
                 break;
         case RTC_AIE_ON:        /* alarm on */
-                rtc_control |= RTC_AIE;
-                hpet_set_rtc_irq_bit(RTC_AIE);
+                cmos_irq_enable(cmos, RTC_AIE);
                 break;
         case RTC_UIE_OFF:       /* update off */
-                rtc_control &= ~RTC_UIE;
-                hpet_mask_rtc_irq_bit(RTC_UIE);
+                cmos_irq_disable(cmos, RTC_UIE);
                 break;
         case RTC_UIE_ON:        /* update on */
-                rtc_control |= RTC_UIE;
-                hpet_set_rtc_irq_bit(RTC_UIE);
-                break;
-        case RTC_PIE_OFF:       /* periodic off */
-                rtc_control &= ~RTC_PIE;
-                hpet_mask_rtc_irq_bit(RTC_PIE);
-                break;
-        case RTC_PIE_ON:        /* periodic on */
-                rtc_control |= RTC_PIE;
-                hpet_set_rtc_irq_bit(RTC_PIE);
+                cmos_irq_enable(cmos, RTC_UIE);
                 break;
         }
-        if (!is_hpet_enabled())
-                CMOS_WRITE(rtc_control, RTC_CONTROL);
-
-        rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
-        rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
-        if (is_intr(rtc_intr))
-                rtc_update_irq(cmos->rtc, 1, rtc_intr);
-
         spin_unlock_irqrestore(&rtc_lock, flags);
         return 0;
 }
@@ -436,12 +528,21 @@ cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 
         if (unlikely(off >= attr->size))
                 return 0;
+        if (unlikely(off < 0))
+                return -EINVAL;
         if ((off + count) > attr->size)
                 count = attr->size - off;
 
+        off += NVRAM_OFFSET;
         spin_lock_irq(&rtc_lock);
-        for (retval = 0, off += NVRAM_OFFSET; count--; retval++, off++)
-                *buf++ = CMOS_READ(off);
+        for (retval = 0; count; count--, off++, retval++) {
+                if (off < 128)
+                        *buf++ = CMOS_READ(off);
+                else if (can_bank2)
+                        *buf++ = cmos_read_bank2(off);
+                else
+                        break;
+        }
         spin_unlock_irq(&rtc_lock);
 
         return retval;
@@ -457,6 +558,8 @@ cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
         cmos = dev_get_drvdata(container_of(kobj, struct device, kobj));
         if (unlikely(off >= attr->size))
                 return -EFBIG;
+        if (unlikely(off < 0))
+                return -EINVAL;
         if ((off + count) > attr->size)
                 count = attr->size - off;
 
@@ -465,15 +568,20 @@ cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
          * here.  If userspace is smart enough to know what fields of
          * NVRAM to update, updating checksums is also part of its job.
          */
+        off += NVRAM_OFFSET;
         spin_lock_irq(&rtc_lock);
-        for (retval = 0, off += NVRAM_OFFSET; count--; retval++, off++) {
+        for (retval = 0; count; count--, off++, retval++) {
                 /* don't trash RTC registers */
                 if (off == cmos->day_alrm
                                 || off == cmos->mon_alrm
                                 || off == cmos->century)
                         buf++;
-                else
+                else if (off < 128)
                         CMOS_WRITE(*buf++, off);
+                else if (can_bank2)
+                        cmos_write_bank2(*buf++, off);
+                else
+                        break;
         }
         spin_unlock_irq(&rtc_lock);
 
@@ -484,7 +592,6 @@ static struct bin_attribute nvram = {
         .attr = {
                 .name   = "nvram",
                 .mode   = S_IRUGO | S_IWUSR,
-                .owner  = THIS_MODULE,
         },
 
         .read   = cmos_nvram_read,
@@ -502,27 +609,29 @@ static irqreturn_t cmos_interrupt(int irq, void *p)
         u8              rtc_control;
 
         spin_lock(&rtc_lock);
-        /*
-         * In this case it is HPET RTC interrupt handler
-         * calling us, with the interrupt information
-         * passed as arg1, instead of irq.
+
+        /* When the HPET interrupt handler calls us, the interrupt
+         * status is passed as arg1 instead of the irq number.  But
+         * always clear irq status, even when HPET is in the way.
+         *
+         * Note that HPET and RTC are almost certainly out of phase,
+         * giving different IRQ status ...
          */
+        irqstat = CMOS_READ(RTC_INTR_FLAGS);
+        rtc_control = CMOS_READ(RTC_CONTROL);
         if (is_hpet_enabled())
                 irqstat = (unsigned long)irq & 0xF0;
-        else {
-                irqstat = CMOS_READ(RTC_INTR_FLAGS);
-                rtc_control = CMOS_READ(RTC_CONTROL);
-                irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
-        }
+        irqstat &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
 
         /* All Linux RTC alarms should be treated as if they were oneshot.
          * Similar code may be needed in system wakeup paths, in case the
          * alarm woke the system.
          */
         if (irqstat & RTC_AIE) {
-                rtc_control = CMOS_READ(RTC_CONTROL);
                 rtc_control &= ~RTC_AIE;
                 CMOS_WRITE(rtc_control, RTC_CONTROL);
+                hpet_mask_rtc_irq_bit(RTC_AIE);
+
                 CMOS_READ(RTC_INTR_FLAGS);
         }
         spin_unlock(&rtc_lock);
@@ -574,17 +683,19 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 
         /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
          * driver did, but don't reject unknown configs.   Old hardware
-         * won't address 128 bytes, and for now we ignore the way newer
-         * chips can address 256 bytes (using two more i/o ports).
+         * won't address 128 bytes.  Newer chips have multiple banks,
+         * though they may not be listed in one I/O resource.
          */
 #if     defined(CONFIG_ATARI)
         address_space = 64;
-#elif defined(__i386__) || defined(__x86_64__) || defined(__arm__)
+#elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__sparc__)
         address_space = 128;
 #else
 #warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
         address_space = 128;
 #endif
+        if (can_bank2 && ports->end > (ports->start + 1))
+                address_space = 256;
 
         /* For ACPI systems extension info comes from the FADT.  On others,
          * board specific setup provides it as appropriate.  Systems where
@@ -629,25 +740,21 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
          * do something about other clock frequencies.
          */
         cmos_rtc.rtc->irq_freq = 1024;
-        if (!hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq))
-                CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
+        hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq);
+        CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
+
+        /* disable irqs */
+        cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE);
 
-        /* disable irqs.
-         *
-         * NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
-         * allegedly some older rtcs need that to handle irqs properly
-         */
         rtc_control = CMOS_READ(RTC_CONTROL);
-        rtc_control &= ~(RTC_PIE | RTC_AIE | RTC_UIE);
-        CMOS_WRITE(rtc_control, RTC_CONTROL);
-        CMOS_READ(RTC_INTR_FLAGS);
 
         spin_unlock_irq(&rtc_lock);
 
         /* FIXME teach the alarm code how to handle binary mode;
          * <asm-generic/rtc.h> doesn't know 12-hour mode either.
          */
-        if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY))) {
+        if (is_valid_irq(rtc_irq) &&
+            (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY)))) {
                 dev_dbg(dev, "only 24-hr BCD mode supported\n");
                 retval = -ENXIO;
                 goto cleanup1;
@@ -687,7 +794,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                 goto cleanup2;
         }
 
-        pr_info("%s: alarms up to one %s%s\n",
+        pr_info("%s: alarms up to one %s%s, %zd bytes nvram, %s irqs\n",
                         cmos_rtc.rtc->dev.bus_id,
                         is_valid_irq(rtc_irq)
                                 ?  (cmos_rtc.mon_alrm
@@ -695,8 +802,9 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                                         : (cmos_rtc.day_alrm
                                                 ? "month" : "day"))
                                 : "no",
-                        cmos_rtc.century ? ", y3k" : ""
-                        );
+                        cmos_rtc.century ? ", y3k" : "",
+                        nvram.size,
+                        is_hpet_enabled() ? ", hpet irqs" : "");
 
         return 0;
 
@@ -713,13 +821,8 @@ cleanup0:
 
 static void cmos_do_shutdown(void)
 {
-        unsigned char   rtc_control;
-
         spin_lock_irq(&rtc_lock);
-        rtc_control = CMOS_READ(RTC_CONTROL);
-        rtc_control &= ~(RTC_PIE|RTC_AIE|RTC_UIE);
-        CMOS_WRITE(rtc_control, RTC_CONTROL);
-        CMOS_READ(RTC_INTR_FLAGS);
+        cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
         spin_unlock_irq(&rtc_lock);
 }
 
@@ -753,24 +856,23 @@ static void __exit cmos_do_remove(struct device *dev)
 static int cmos_suspend(struct device *dev, pm_message_t mesg)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
-        int             do_wake = device_may_wakeup(dev);
         unsigned char   tmp;
 
         /* only the alarm might be a wakeup event source */
         spin_lock_irq(&rtc_lock);
         cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL);
         if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
-                unsigned char   irqstat;
+                unsigned char   mask;
 
-                if (do_wake)
-                        tmp &= ~(RTC_PIE|RTC_UIE);
+                if (device_may_wakeup(dev))
+                        mask = RTC_IRQMASK & ~RTC_AIE;
                 else
-                        tmp &= ~(RTC_PIE|RTC_AIE|RTC_UIE);
+                        mask = RTC_IRQMASK;
+                tmp &= ~mask;
                 CMOS_WRITE(tmp, RTC_CONTROL);
-                irqstat = CMOS_READ(RTC_INTR_FLAGS);
-                irqstat &= (tmp & RTC_IRQMASK) | RTC_IRQF;
-                if (is_intr(irqstat))
-                        rtc_update_irq(cmos->rtc, 1, irqstat);
+                hpet_mask_rtc_irq_bit(mask);
+
+                cmos_checkintr(cmos, tmp);
         }
         spin_unlock_irq(&rtc_lock);
 
@@ -790,13 +892,25 @@ static int cmos_suspend(struct device *dev, pm_message_t mesg)
         return 0;
 }
 
+/* We want RTC alarms to wake us from e.g. ACPI G2/S5 "soft off", even
+ * after a detour through G3 "mechanical off", although the ACPI spec
+ * says wakeup should only work from G1/S4 "hibernate".  To most users,
+ * distinctions between S4 and S5 are pointless.  So when the hardware
+ * allows, don't draw that distinction.
+ */
+static inline int cmos_poweroff(struct device *dev)
+{
+        return cmos_suspend(dev, PMSG_HIBERNATE);
+}
+
 static int cmos_resume(struct device *dev)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
         unsigned char   tmp = cmos->suspend_ctrl;
 
         /* re-enable any irqs previously active */
-        if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
+        if (tmp & RTC_IRQMASK) {
+                unsigned char   mask;
 
                 if (cmos->enabled_wake) {
                         if (cmos->wake_off)
@@ -807,18 +921,28 @@ static int cmos_resume(struct device *dev)
                 }
 
                 spin_lock_irq(&rtc_lock);
-                CMOS_WRITE(tmp, RTC_CONTROL);
-                tmp = CMOS_READ(RTC_INTR_FLAGS);
-                tmp &= (cmos->suspend_ctrl & RTC_IRQMASK) | RTC_IRQF;
-                if (is_intr(tmp))
-                        rtc_update_irq(cmos->rtc, 1, tmp);
+                do {
+                        CMOS_WRITE(tmp, RTC_CONTROL);
+                        hpet_set_rtc_irq_bit(tmp & RTC_IRQMASK);
+
+                        mask = CMOS_READ(RTC_INTR_FLAGS);
+                        mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
+                        if (!is_hpet_enabled() || !is_intr(mask))
+                                break;
+
+                        /* force one-shot behavior if HPET blocked
+                         * the wake alarm's irq
+                         */
+                        rtc_update_irq(cmos->rtc, 1, mask);
+                        tmp &= ~RTC_AIE;
+                        hpet_mask_rtc_irq_bit(RTC_AIE);
+                } while (mask & RTC_AIE);
                 spin_unlock_irq(&rtc_lock);
         }
 
         pr_debug("%s: resume, ctrl %02x\n",
                         cmos_rtc.rtc->dev.bus_id,
-                        cmos->suspend_ctrl);
-
+                        tmp);
 
         return 0;
 }
@@ -826,6 +950,12 @@ static int cmos_resume(struct device *dev)
 #else
 #define cmos_suspend    NULL
 #define cmos_resume     NULL
+
+static inline int cmos_poweroff(struct device *dev)
+{
+        return -ENOSYS;
+}
+
 #endif
 
 /*----------------------------------------------------------------*/
@@ -838,6 +968,92 @@ static int cmos_resume(struct device *dev)
  * predate even PNPBIOS should set up platform_bus devices.
  */
 
+#ifdef  CONFIG_ACPI
+
+#include <linux/acpi.h>
+
+#ifdef  CONFIG_PM
+static u32 rtc_handler(void *context)
+{
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+        return ACPI_INTERRUPT_HANDLED;
+}
+
+static inline void rtc_wake_setup(void)
+{
+        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.
+         */
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+}
+
+static void rtc_wake_on(struct device *dev)
+{
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_enable_event(ACPI_EVENT_RTC, 0);
+}
+
+static void rtc_wake_off(struct device *dev)
+{
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+}
+#else
+#define rtc_wake_setup()        do{}while(0)
+#define rtc_wake_on             NULL
+#define rtc_wake_off            NULL
+#endif
+
+/* Every ACPI platform has a mc146818 compatible "cmos rtc".  Here we find
+ * its device node and pass extra config data.  This helps its driver use
+ * capabilities that the now-obsolete mc146818 didn't have, and informs it
+ * that this board's RTC is wakeup-capable (per ACPI spec).
+ */
+static struct cmos_rtc_board_info acpi_rtc_info;
+
+static void __devinit
+cmos_wake_setup(struct device *dev)
+{
+        if (acpi_disabled)
+                return;
+
+        rtc_wake_setup();
+        acpi_rtc_info.wake_on = rtc_wake_on;
+        acpi_rtc_info.wake_off = rtc_wake_off;
+
+        /* workaround bug in some ACPI tables */
+        if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
+                dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
+                        acpi_gbl_FADT.month_alarm);
+                acpi_gbl_FADT.month_alarm = 0;
+        }
+
+        acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
+        acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
+        acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;
+
+        /* NOTE:  S4_RTC_WAKE is NOT currently useful to Linux */
+        if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
+                dev_info(dev, "RTC can wake from S4\n");
+
+        dev->platform_data = &acpi_rtc_info;
+
+        /* RTC always wakes from S1/S2/S3, and often S4/STD */
+        device_init_wakeup(dev, 1);
+}
+
+#else
+
+static void __devinit
+cmos_wake_setup(struct device *dev)
+{
+}
+
+#endif
+
 #ifdef  CONFIG_PNP
 
 #include <linux/pnp.h>
@@ -845,10 +1061,8 @@ static int cmos_resume(struct device *dev)
 static int __devinit
 cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
 {
-        /* REVISIT paranoia argues for a shutdown notifier, since PNP
-         * drivers can't provide shutdown() methods to disable IRQs.
-         * Or better yet, fix PNP to allow those methods...
-         */
+        cmos_wake_setup(&pnp->dev);
+
         if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
                 /* Some machines contain a PNP entry for the RTC, but
                  * don't define the IRQ. It should always be safe to
@@ -884,6 +1098,13 @@ static int cmos_pnp_resume(struct pnp_dev *pnp)
 #define cmos_pnp_resume         NULL
 #endif
 
+static void cmos_pnp_shutdown(struct device *pdev)
+{
+        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(pdev))
+                return;
+
+        cmos_do_shutdown();
+}
 
 static const struct pnp_device_id rtc_ids[] = {
         { .id = "PNP0b00", },
@@ -903,6 +1124,10 @@ static struct pnp_driver cmos_pnp_driver = {
         .flags          = PNP_DRIVER_RES_DO_NOT_CHANGE,
         .suspend        = cmos_pnp_suspend,
         .resume         = cmos_pnp_resume,
+        .driver         = {
+                .name     = (char *)driver_name,
+                .shutdown = cmos_pnp_shutdown,
+        }
 };
 
 #endif  /* CONFIG_PNP */
@@ -915,6 +1140,7 @@ static struct pnp_driver cmos_pnp_driver = {
 
 static int __init cmos_platform_probe(struct platform_device *pdev)
 {
+        cmos_wake_setup(&pdev->dev);
         return cmos_do_probe(&pdev->dev,
                         platform_get_resource(pdev, IORESOURCE_IO, 0),
                         platform_get_irq(pdev, 0));
@@ -928,6 +1154,9 @@ static int __exit cmos_platform_remove(struct platform_device *pdev)
 
 static void cmos_platform_shutdown(struct platform_device *pdev)
 {
+        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pdev->dev))
+                return;
+
         cmos_do_shutdown();
 }
 
@@ -946,29 +1175,32 @@ static struct platform_driver cmos_platform_driver = {
 
 static int __init cmos_init(void)
 {
+        int retval = 0;
+
 #ifdef  CONFIG_PNP
-        if (pnp_platform_devices)
-                return pnp_register_driver(&cmos_pnp_driver);
-        else
-                return platform_driver_probe(&cmos_platform_driver,
-                        cmos_platform_probe);
-#else
-        return platform_driver_probe(&cmos_platform_driver,
-                        cmos_platform_probe);
-#endif /* CONFIG_PNP */
+        pnp_register_driver(&cmos_pnp_driver);
+#endif
+
+        if (!cmos_rtc.dev)
+                retval = platform_driver_probe(&cmos_platform_driver,
+                                               cmos_platform_probe);
+
+        if (retval == 0)
+                return 0;
+
+#ifdef  CONFIG_PNP
+        pnp_unregister_driver(&cmos_pnp_driver);
+#endif
+        return retval;
 }
 module_init(cmos_init);
 
 static void __exit cmos_exit(void)
 {
 #ifdef  CONFIG_PNP
-        if (pnp_platform_devices)
-                pnp_unregister_driver(&cmos_pnp_driver);
-        else
-                platform_driver_unregister(&cmos_platform_driver);
-#else
+        pnp_unregister_driver(&cmos_pnp_driver);
+#endif
         platform_driver_unregister(&cmos_platform_driver);
-#endif /* CONFIG_PNP */
 }
 module_exit(cmos_exit);
 
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 0114a78b7cbb..079e9ed907e0 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -13,7 +13,6 @@
 
 #include <linux/module.h>
 #include <linux/rtc.h>
-#include <linux/smp_lock.h>
 #include "rtc-core.h"
 
 static dev_t rtc_devt;
@@ -27,11 +26,8 @@ static int rtc_dev_open(struct inode *inode, struct file *file)
                                         struct rtc_device, char_dev);
         const struct rtc_class_ops *ops = rtc->ops;
 
-        lock_kernel();
-        if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags)) {
-                err = -EBUSY;
-                goto out;
-        }
+        if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
+                return -EBUSY;
 
         file->private_data = rtc;
 
@@ -41,13 +37,11 @@ static int rtc_dev_open(struct inode *inode, struct file *file)
                 rtc->irq_data = 0;
                 spin_unlock_irq(&rtc->irq_lock);
 
-                goto out;
+                return 0;
         }
 
         /* something has gone wrong */
         clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
-out:
-        unlock_kernel();
         return err;
 }
 
@@ -209,7 +203,7 @@ static unsigned int rtc_dev_poll(struct file *file, poll_table *wait)
         return (data != 0) ? (POLLIN | POLLRDNORM) : 0;
 }
 
-static int rtc_dev_ioctl(struct inode *inode, struct file *file,
+static long rtc_dev_ioctl(struct file *file,
                 unsigned int cmd, unsigned long arg)
 {
         int err = 0;
@@ -219,6 +213,10 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
         struct rtc_wkalrm alarm;
         void __user *uarg = (void __user *) arg;
 
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return err;
+
         /* check that the calling task has appropriate permissions
          * for certain ioctls. doing this check here is useful
          * to avoid duplicate code in each driver.
@@ -227,26 +225,31 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
         case RTC_EPOCH_SET:
         case RTC_SET_TIME:
                 if (!capable(CAP_SYS_TIME))
-                        return -EACCES;
+                        err = -EACCES;
                 break;
 
         case RTC_IRQP_SET:
                 if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE))
-                        return -EACCES;
+                        err = -EACCES;
                 break;
 
         case RTC_PIE_ON:
                 if (rtc->irq_freq > rtc->max_user_freq &&
                                 !capable(CAP_SYS_RESOURCE))
-                        return -EACCES;
+                        err = -EACCES;
                 break;
         }
 
+        if (err)
+                goto done;
+
         /* try the driver's ioctl interface */
         if (ops->ioctl) {
                 err = ops->ioctl(rtc->dev.parent, cmd, arg);
-                if (err != -ENOIOCTLCMD)
+                if (err != -ENOIOCTLCMD) {
+                        mutex_unlock(&rtc->ops_lock);
                         return err;
+                }
         }
 
         /* if the driver does not provide the ioctl interface
@@ -265,15 +268,19 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
         case RTC_ALM_READ:
+                mutex_unlock(&rtc->ops_lock);
+
                 err = rtc_read_alarm(rtc, &alarm);
                 if (err < 0)
                         return err;
 
                 if (copy_to_user(uarg, &alarm.time, sizeof(tm)))
-                        return -EFAULT;
-                break;
+                        err = -EFAULT;
+                return err;
 
         case RTC_ALM_SET:
+                mutex_unlock(&rtc->ops_lock);
+
                 if (copy_from_user(&alarm.time, uarg, sizeof(tm)))
                         return -EFAULT;
 
@@ -321,24 +328,26 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
                         }
                 }
 
-                err = rtc_set_alarm(rtc, &alarm);
-                break;
+                return rtc_set_alarm(rtc, &alarm);
 
         case RTC_RD_TIME:
+                mutex_unlock(&rtc->ops_lock);
+
                 err = rtc_read_time(rtc, &tm);
                 if (err < 0)
                         return err;
 
                 if (copy_to_user(uarg, &tm, sizeof(tm)))
-                        return -EFAULT;
-                break;
+                        err = -EFAULT;
+                return err;
 
         case RTC_SET_TIME:
+                mutex_unlock(&rtc->ops_lock);
+
                 if (copy_from_user(&tm, uarg, sizeof(tm)))
                         return -EFAULT;
 
-                err = rtc_set_time(rtc, &tm);
-                break;
+                return rtc_set_time(rtc, &tm);
 
         case RTC_PIE_ON:
                 err = rtc_irq_set_state(rtc, NULL, 1);
@@ -376,63 +385,80 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
                 break;
 #endif
         case RTC_WKALM_SET:
+                mutex_unlock(&rtc->ops_lock);
                 if (copy_from_user(&alarm, uarg, sizeof(alarm)))
                         return -EFAULT;
 
-                err = rtc_set_alarm(rtc, &alarm);
-                break;
+                return rtc_set_alarm(rtc, &alarm);
 
         case RTC_WKALM_RD:
+                mutex_unlock(&rtc->ops_lock);
                 err = rtc_read_alarm(rtc, &alarm);
                 if (err < 0)
                         return err;
 
                 if (copy_to_user(uarg, &alarm, sizeof(alarm)))
-                        return -EFAULT;
-                break;
+                        err = -EFAULT;
+                return err;
 
 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
         case RTC_UIE_OFF:
+                mutex_unlock(&rtc->ops_lock);
                 clear_uie(rtc);
                 return 0;
 
         case RTC_UIE_ON:
-                return set_uie(rtc);
+                mutex_unlock(&rtc->ops_lock);
+                err = set_uie(rtc);
+                return err;
 #endif
         default:
                 err = -ENOTTY;
                 break;
         }
 
+done:
+        mutex_unlock(&rtc->ops_lock);
         return err;
 }
 
+static int rtc_dev_fasync(int fd, struct file *file, int on)
+{
+        struct rtc_device *rtc = file->private_data;
+        return fasync_helper(fd, file, on, &rtc->async_queue);
+}
+
 static int rtc_dev_release(struct inode *inode, struct file *file)
 {
         struct rtc_device *rtc = file->private_data;
 
-#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
-        clear_uie(rtc);
-#endif
+        /* We shut down the repeating IRQs that userspace enabled,
+         * since nothing is listening to them.
+         *  - Update (UIE) ... currently only managed through ioctls
+         *  - Periodic (PIE) ... also used through rtc_*() interface calls
+         *
+         * Leave the alarm alone; it may be set to trigger a system wakeup
+         * later, or be used by kernel code, and is a one-shot event anyway.
+         */
+        rtc_dev_ioctl(file, RTC_UIE_OFF, 0);
+        rtc_irq_set_state(rtc, NULL, 0);
+
         if (rtc->ops->release)
                 rtc->ops->release(rtc->dev.parent);
 
+        if (file->f_flags & FASYNC)
+                rtc_dev_fasync(-1, file, 0);
+
         clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
         return 0;
 }
 
-static int rtc_dev_fasync(int fd, struct file *file, int on)
-{
-        struct rtc_device *rtc = file->private_data;
-        return fasync_helper(fd, file, on, &rtc->async_queue);
-}
-
 static const struct file_operations rtc_dev_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .read           = rtc_dev_read,
         .poll           = rtc_dev_poll,
-        .ioctl          = rtc_dev_ioctl,
+        .unlocked_ioctl = rtc_dev_ioctl,
         .open           = rtc_dev_open,
         .release        = rtc_dev_release,
         .fasync         = rtc_dev_fasync,
diff --git a/drivers/rtc/rtc-ds1216.c b/drivers/rtc/rtc-ds1216.c
index 0b17770b032b..9a234a4ec06d 100644
--- a/drivers/rtc/rtc-ds1216.c
+++ b/drivers/rtc/rtc-ds1216.c
@@ -86,19 +86,19 @@ static int ds1216_rtc_read_time(struct device *dev, struct rtc_time *tm)
         ds1216_switch_ds_to_clock(priv->ioaddr);
         ds1216_read(priv->ioaddr, (u8 *)&regs);
 
-        tm->tm_sec = BCD2BIN(regs.sec);
-        tm->tm_min = BCD2BIN(regs.min);
+        tm->tm_sec = bcd2bin(regs.sec);
+        tm->tm_min = bcd2bin(regs.min);
         if (regs.hour & DS1216_HOUR_1224) {
                 /* AM/PM mode */
-                tm->tm_hour = BCD2BIN(regs.hour & 0x1f);
+                tm->tm_hour = bcd2bin(regs.hour & 0x1f);
                 if (regs.hour & DS1216_HOUR_AMPM)
                         tm->tm_hour += 12;
         } else
-                tm->tm_hour = BCD2BIN(regs.hour & 0x3f);
+                tm->tm_hour = bcd2bin(regs.hour & 0x3f);
         tm->tm_wday = (regs.wday & 7) - 1;
-        tm->tm_mday = BCD2BIN(regs.mday & 0x3f);
-        tm->tm_mon = BCD2BIN(regs.month & 0x1f);
-        tm->tm_year = BCD2BIN(regs.year);
+        tm->tm_mday = bcd2bin(regs.mday & 0x3f);
+        tm->tm_mon = bcd2bin(regs.month & 0x1f);
+        tm->tm_year = bcd2bin(regs.year);
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
         return 0;
@@ -114,19 +114,19 @@ static int ds1216_rtc_set_time(struct device *dev, struct rtc_time *tm)
         ds1216_read(priv->ioaddr, (u8 *)&regs);
 
         regs.tsec = 0; /* clear 0.1 and 0.01 seconds */
-        regs.sec = BIN2BCD(tm->tm_sec);
-        regs.min = BIN2BCD(tm->tm_min);
+        regs.sec = bin2bcd(tm->tm_sec);
+        regs.min = bin2bcd(tm->tm_min);
         regs.hour &= DS1216_HOUR_1224;
         if (regs.hour && tm->tm_hour > 12) {
                 regs.hour |= DS1216_HOUR_AMPM;
                 tm->tm_hour -= 12;
         }
-        regs.hour |= BIN2BCD(tm->tm_hour);
+        regs.hour |= bin2bcd(tm->tm_hour);
         regs.wday &= ~7;
         regs.wday |= tm->tm_wday;
-        regs.mday = BIN2BCD(tm->tm_mday);
-        regs.month = BIN2BCD(tm->tm_mon);
-        regs.year = BIN2BCD(tm->tm_year % 100);
+        regs.mday = bin2bcd(tm->tm_mday);
+        regs.month = bin2bcd(tm->tm_mon);
+        regs.year = bin2bcd(tm->tm_year % 100);
 
         ds1216_switch_ds_to_clock(priv->ioaddr);
         ds1216_write(priv->ioaddr, (u8 *)&regs);
diff --git a/drivers/rtc/rtc-ds1286.c b/drivers/rtc/rtc-ds1286.c
new file mode 100644
index 000000000000..4fcb16bbff4a
--- /dev/null
+++ b/drivers/rtc/rtc-ds1286.c
@@ -0,0 +1,410 @@
+/*
+ * DS1286 Real Time Clock interface for Linux
+ *
+ * Copyright (C) 1998, 1999, 2000 Ralf Baechle
+ * Copyright (C) 2008 Thomas Bogendoerfer
+ *
+ * Based on code written by Paul Gortmaker.
+ *
+ * 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/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/bcd.h>
+#include <linux/ds1286.h>
+#include <linux/io.h>
+
+#define DRV_VERSION             "1.0"
+
+struct ds1286_priv {
+        struct rtc_device *rtc;
+        u32 __iomem *rtcregs;
+        size_t size;
+        unsigned long baseaddr;
+        spinlock_t lock;
+};
+
+static inline u8 ds1286_rtc_read(struct ds1286_priv *priv, int reg)
+{
+        return __raw_readl(&priv->rtcregs[reg]) & 0xff;
+}
+
+static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg)
+{
+        __raw_writel(data, &priv->rtcregs[reg]);
+}
+
+#ifdef CONFIG_RTC_INTF_DEV
+
+static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        struct ds1286_priv *priv = dev_get_drvdata(dev);
+        unsigned long flags;
+        unsigned char val;
+
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                /* Mask alarm int. enab. bit    */
+                spin_lock_irqsave(&priv->lock, flags);
+                val = ds1286_rtc_read(priv, RTC_CMD);
+                val |=  RTC_TDM;
+                ds1286_rtc_write(priv, val, RTC_CMD);
+                spin_unlock_irqrestore(&priv->lock, flags);
+                break;
+        case RTC_AIE_ON:
+                /* Allow alarm interrupts.      */
+                spin_lock_irqsave(&priv->lock, flags);
+                val = ds1286_rtc_read(priv, RTC_CMD);
+                val &=  ~RTC_TDM;
+                ds1286_rtc_write(priv, val, RTC_CMD);
+                spin_unlock_irqrestore(&priv->lock, flags);
+                break;
+        case RTC_WIE_OFF:
+                /* Mask watchdog int. enab. bit */
+                spin_lock_irqsave(&priv->lock, flags);
+                val = ds1286_rtc_read(priv, RTC_CMD);
+                val |= RTC_WAM;
+                ds1286_rtc_write(priv, val, RTC_CMD);
+                spin_unlock_irqrestore(&priv->lock, flags);
+                break;
+        case RTC_WIE_ON:
+                /* Allow watchdog interrupts.   */
+                spin_lock_irqsave(&priv->lock, flags);
+                val = ds1286_rtc_read(priv, RTC_CMD);
+                val &= ~RTC_WAM;
+                ds1286_rtc_write(priv, val, RTC_CMD);
+                spin_unlock_irqrestore(&priv->lock, flags);
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+#else
+#define ds1286_ioctl    NULL
+#endif
+
+#ifdef CONFIG_PROC_FS
+
+static int ds1286_proc(struct device *dev, struct seq_file *seq)
+{
+        struct ds1286_priv *priv = dev_get_drvdata(dev);
+        unsigned char month, cmd, amode;
+        const char *s;
+
+        month = ds1286_rtc_read(priv, RTC_MONTH);
+        seq_printf(seq,
+                   "oscillator\t: %s\n"
+                   "square_wave\t: %s\n",
+                   (month & RTC_EOSC) ? "disabled" : "enabled",
+                   (month & RTC_ESQW) ? "disabled" : "enabled");
+
+        amode = ((ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x80) >> 5) |
+                ((ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x80) >> 6) |
+                ((ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x80) >> 7);
+        switch (amode) {
+        case 7:
+                s = "each minute";
+                break;
+        case 3:
+                s = "minutes match";
+                break;
+        case 1:
+                s = "hours and minutes match";
+                break;
+        case 0:
+                s = "days, hours and minutes match";
+                break;
+        default:
+                s = "invalid";
+                break;
+        }
+        seq_printf(seq, "alarm_mode\t: %s\n", s);
+
+        cmd = ds1286_rtc_read(priv, RTC_CMD);
+        seq_printf(seq,
+                   "alarm_enable\t: %s\n"
+                   "wdog_alarm\t: %s\n"
+                   "alarm_mask\t: %s\n"
+                   "wdog_alarm_mask\t: %s\n"
+                   "interrupt_mode\t: %s\n"
+                   "INTB_mode\t: %s_active\n"
+                   "interrupt_pins\t: %s\n",
+                   (cmd & RTC_TDF) ? "yes" : "no",
+                   (cmd & RTC_WAF) ? "yes" : "no",
+                   (cmd & RTC_TDM) ? "disabled" : "enabled",
+                   (cmd & RTC_WAM) ? "disabled" : "enabled",
+                   (cmd & RTC_PU_LVL) ? "pulse" : "level",
+                   (cmd & RTC_IBH_LO) ? "low" : "high",
+                   (cmd & RTC_IPSW) ? "unswapped" : "swapped");
+        return 0;
+}
+
+#else
+#define ds1286_proc     NULL
+#endif
+
+static int ds1286_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct ds1286_priv *priv = dev_get_drvdata(dev);
+        unsigned char save_control;
+        unsigned long flags;
+        unsigned long uip_watchdog = jiffies;
+
+        /*
+         * read RTC once any update in progress is done. The update
+         * can take just over 2ms. We wait 10 to 20ms. There is no need to
+         * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
+         * If you need to know *exactly* when a second has started, enable
+         * periodic update complete interrupts, (via ioctl) and then
+         * immediately read /dev/rtc which will block until you get the IRQ.
+         * Once the read clears, read the RTC time (again via ioctl). Easy.
+         */
+
+        if (ds1286_rtc_read(priv, RTC_CMD) & RTC_TE)
+                while (time_before(jiffies, uip_watchdog + 2*HZ/100))
+                        barrier();
+
+        /*
+         * Only the values that we read from the RTC are set. We leave
+         * tm_wday, tm_yday and tm_isdst untouched. Even though the
+         * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
+         * by the RTC when initially set to a non-zero value.
+         */
+        spin_lock_irqsave(&priv->lock, flags);
+        save_control = ds1286_rtc_read(priv, RTC_CMD);
+        ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
+
+        tm->tm_sec = ds1286_rtc_read(priv, RTC_SECONDS);
+        tm->tm_min = ds1286_rtc_read(priv, RTC_MINUTES);
+        tm->tm_hour = ds1286_rtc_read(priv, RTC_HOURS) & 0x3f;
+        tm->tm_mday = ds1286_rtc_read(priv, RTC_DATE);
+        tm->tm_mon = ds1286_rtc_read(priv, RTC_MONTH) & 0x1f;
+        tm->tm_year = ds1286_rtc_read(priv, RTC_YEAR);
+
+        ds1286_rtc_write(priv, save_control, RTC_CMD);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        tm->tm_sec = bcd2bin(tm->tm_sec);
+        tm->tm_min = bcd2bin(tm->tm_min);
+        tm->tm_hour = bcd2bin(tm->tm_hour);
+        tm->tm_mday = bcd2bin(tm->tm_mday);
+        tm->tm_mon = bcd2bin(tm->tm_mon);
+        tm->tm_year = bcd2bin(tm->tm_year);
+
+        /*
+         * Account for differences between how the RTC uses the values
+         * and how they are defined in a struct rtc_time;
+         */
+        if (tm->tm_year < 45)
+                tm->tm_year += 30;
+        tm->tm_year += 40;
+        if (tm->tm_year < 70)
+                tm->tm_year += 100;
+
+        tm->tm_mon--;
+
+        return rtc_valid_tm(tm);
+}
+
+static int ds1286_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct ds1286_priv *priv = dev_get_drvdata(dev);
+        unsigned char mon, day, hrs, min, sec;
+        unsigned char save_control;
+        unsigned int yrs;
+        unsigned long flags;
+
+        yrs = tm->tm_year + 1900;
+        mon = tm->tm_mon + 1;   /* tm_mon starts at zero */
+        day = tm->tm_mday;
+        hrs = tm->tm_hour;
+        min = tm->tm_min;
+        sec = tm->tm_sec;
+
+        if (yrs < 1970)
+                return -EINVAL;
+
+        yrs -= 1940;
+        if (yrs > 255)    /* They are unsigned */
+                return -EINVAL;
+
+        if (yrs >= 100)
+                yrs -= 100;
+
+        sec = bin2bcd(sec);
+        min = bin2bcd(min);
+        hrs = bin2bcd(hrs);
+        day = bin2bcd(day);
+        mon = bin2bcd(mon);
+        yrs = bin2bcd(yrs);
+
+        spin_lock_irqsave(&priv->lock, flags);
+        save_control = ds1286_rtc_read(priv, RTC_CMD);
+        ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
+
+        ds1286_rtc_write(priv, yrs, RTC_YEAR);
+        ds1286_rtc_write(priv, mon, RTC_MONTH);
+        ds1286_rtc_write(priv, day, RTC_DATE);
+        ds1286_rtc_write(priv, hrs, RTC_HOURS);
+        ds1286_rtc_write(priv, min, RTC_MINUTES);
+        ds1286_rtc_write(priv, sec, RTC_SECONDS);
+        ds1286_rtc_write(priv, 0, RTC_HUNDREDTH_SECOND);
+
+        ds1286_rtc_write(priv, save_control, RTC_CMD);
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return 0;
+}
+
+static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct ds1286_priv *priv = dev_get_drvdata(dev);
+        unsigned char cmd;
+        unsigned long flags;
+
+        /*
+         * Only the values that we read from the RTC are set. That
+         * means only tm_wday, tm_hour, tm_min.
+         */
+        spin_lock_irqsave(&priv->lock, flags);
+        alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
+        alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM)  & 0x1f;
+        alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM)    & 0x07;
+        cmd = ds1286_rtc_read(priv, RTC_CMD);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        alm->time.tm_min = bcd2bin(alm->time.tm_min);
+        alm->time.tm_hour = bcd2bin(alm->time.tm_hour);
+        alm->time.tm_sec = 0;
+        return 0;
+}
+
+static int ds1286_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct ds1286_priv *priv = dev_get_drvdata(dev);
+        unsigned char hrs, min, sec;
+
+        hrs = alm->time.tm_hour;
+        min = alm->time.tm_min;
+        sec = alm->time.tm_sec;
+
+        if (hrs >= 24)
+                hrs = 0xff;
+
+        if (min >= 60)
+                min = 0xff;
+
+        if (sec != 0)
+                return -EINVAL;
+
+        min = bin2bcd(min);
+        hrs = bin2bcd(hrs);
+
+        spin_lock(&priv->lock);
+        ds1286_rtc_write(priv, hrs, RTC_HOURS_ALARM);
+        ds1286_rtc_write(priv, min, RTC_MINUTES_ALARM);
+        spin_unlock(&priv->lock);
+
+        return 0;
+}
+
+static const struct rtc_class_ops ds1286_ops = {
+        .ioctl          = ds1286_ioctl,
+        .proc           = ds1286_proc,
+        .read_time      = ds1286_read_time,
+        .set_time       = ds1286_set_time,
+        .read_alarm     = ds1286_read_alarm,
+        .set_alarm      = ds1286_set_alarm,
+};
+
+static int __devinit ds1286_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        struct resource *res;
+        struct ds1286_priv *priv;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+        priv = kzalloc(sizeof(struct ds1286_priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->size = res->end - res->start + 1;
+        if (!request_mem_region(res->start, priv->size, pdev->name)) {
+                ret = -EBUSY;
+                goto out;
+        }
+        priv->baseaddr = res->start;
+        priv->rtcregs = ioremap(priv->baseaddr, priv->size);
+        if (!priv->rtcregs) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        spin_lock_init(&priv->lock);
+        rtc = rtc_device_register("ds1286", &pdev->dev,
+                                  &ds1286_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto out;
+        }
+        priv->rtc = rtc;
+        platform_set_drvdata(pdev, priv);
+        return 0;
+
+out:
+        if (priv->rtc)
+                rtc_device_unregister(priv->rtc);
+        if (priv->rtcregs)
+                iounmap(priv->rtcregs);
+        if (priv->baseaddr)
+                release_mem_region(priv->baseaddr, priv->size);
+        kfree(priv);
+        return ret;
+}
+
+static int __devexit ds1286_remove(struct platform_device *pdev)
+{
+        struct ds1286_priv *priv = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(priv->rtc);
+        iounmap(priv->rtcregs);
+        release_mem_region(priv->baseaddr, priv->size);
+        kfree(priv);
+        return 0;
+}
+
+static struct platform_driver ds1286_platform_driver = {
+        .driver         = {
+                .name   = "rtc-ds1286",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ds1286_probe,
+        .remove         = __devexit_p(ds1286_remove),
+};
+
+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 b9397818f73a..184556620778 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -40,7 +40,7 @@
 #define RTC_SCLK        0x0400
 
 #ifdef CONFIG_SH_SECUREEDGE5410
-#include <asm/snapgear.h>
+#include <mach/snapgear.h>
 #define set_dp(x)       SECUREEDGE_WRITE_IOPORT(x, 0x1c00)
 #define get_dp()        SECUREEDGE_READ_IOPORT()
 #else
@@ -107,13 +107,13 @@ static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
         spin_lock_irq(&rtc->lock);
 
-        tm->tm_sec      = BCD2BIN(ds1302_readbyte(RTC_ADDR_SEC));
-        tm->tm_min      = BCD2BIN(ds1302_readbyte(RTC_ADDR_MIN));
-        tm->tm_hour     = BCD2BIN(ds1302_readbyte(RTC_ADDR_HOUR));
-        tm->tm_wday     = BCD2BIN(ds1302_readbyte(RTC_ADDR_DAY));
-        tm->tm_mday     = BCD2BIN(ds1302_readbyte(RTC_ADDR_DATE));
-        tm->tm_mon      = BCD2BIN(ds1302_readbyte(RTC_ADDR_MON)) - 1;
-        tm->tm_year     = BCD2BIN(ds1302_readbyte(RTC_ADDR_YEAR));
+        tm->tm_sec      = bcd2bin(ds1302_readbyte(RTC_ADDR_SEC));
+        tm->tm_min      = bcd2bin(ds1302_readbyte(RTC_ADDR_MIN));
+        tm->tm_hour     = bcd2bin(ds1302_readbyte(RTC_ADDR_HOUR));
+        tm->tm_wday     = bcd2bin(ds1302_readbyte(RTC_ADDR_DAY));
+        tm->tm_mday     = bcd2bin(ds1302_readbyte(RTC_ADDR_DATE));
+        tm->tm_mon      = bcd2bin(ds1302_readbyte(RTC_ADDR_MON)) - 1;
+        tm->tm_year     = bcd2bin(ds1302_readbyte(RTC_ADDR_YEAR));
 
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
@@ -141,13 +141,13 @@ static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
         /* Stop RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) | 0x80);
 
-        ds1302_writebyte(RTC_ADDR_SEC, BIN2BCD(tm->tm_sec));
-        ds1302_writebyte(RTC_ADDR_MIN, BIN2BCD(tm->tm_min));
-        ds1302_writebyte(RTC_ADDR_HOUR, BIN2BCD(tm->tm_hour));
-        ds1302_writebyte(RTC_ADDR_DAY, BIN2BCD(tm->tm_wday));
-        ds1302_writebyte(RTC_ADDR_DATE, BIN2BCD(tm->tm_mday));
-        ds1302_writebyte(RTC_ADDR_MON, BIN2BCD(tm->tm_mon + 1));
-        ds1302_writebyte(RTC_ADDR_YEAR, BIN2BCD(tm->tm_year % 100));
+        ds1302_writebyte(RTC_ADDR_SEC, bin2bcd(tm->tm_sec));
+        ds1302_writebyte(RTC_ADDR_MIN, bin2bcd(tm->tm_min));
+        ds1302_writebyte(RTC_ADDR_HOUR, bin2bcd(tm->tm_hour));
+        ds1302_writebyte(RTC_ADDR_DAY, bin2bcd(tm->tm_wday));
+        ds1302_writebyte(RTC_ADDR_DATE, bin2bcd(tm->tm_mday));
+        ds1302_writebyte(RTC_ADDR_MON, bin2bcd(tm->tm_mon + 1));
+        ds1302_writebyte(RTC_ADDR_YEAR, bin2bcd(tm->tm_year % 100));
 
         /* Start RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) & ~0x80);
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
new file mode 100644
index 000000000000..fc372df6534b
--- /dev/null
+++ b/drivers/rtc/rtc-ds1305.c
@@ -0,0 +1,846 @@
+/*
+ * rtc-ds1305.c -- driver for DS1305 and DS1306 SPI RTC chips
+ *
+ * Copyright (C) 2008 David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/workqueue.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/ds1305.h>
+
+
+/*
+ * Registers ... mask DS1305_WRITE into register address to write,
+ * otherwise you're reading it.  All non-bitmask values are BCD.
+ */
+#define DS1305_WRITE            0x80
+
+
+/* RTC date/time ... the main special cases are that we:
+ *  - Need fancy "hours" encoding in 12hour mode
+ *  - Don't rely on the "day-of-week" field (or tm_wday)
+ *  - Are a 21st-century clock (2000 <= year < 2100)
+ */
+#define DS1305_RTC_LEN          7               /* bytes for RTC regs */
+
+#define DS1305_SEC              0x00            /* register addresses */
+#define DS1305_MIN              0x01
+#define DS1305_HOUR             0x02
+#       define DS1305_HR_12             0x40    /* set == 12 hr mode */
+#       define DS1305_HR_PM             0x20    /* set == PM (12hr mode) */
+#define DS1305_WDAY             0x03
+#define DS1305_MDAY             0x04
+#define DS1305_MON              0x05
+#define DS1305_YEAR             0x06
+
+
+/* The two alarms have only sec/min/hour/wday fields (ALM_LEN).
+ * DS1305_ALM_DISABLE disables a match field (some combos are bad).
+ *
+ * NOTE that since we don't use WDAY, we limit ourselves to alarms
+ * only one day into the future (vs potentially up to a week).
+ *
+ * NOTE ALSO that while we could generate once-a-second IRQs (UIE), we
+ * don't currently support them.  We'd either need to do it only when
+ * no alarm is pending (not the standard model), or to use the second
+ * alarm (implying that this is a DS1305 not DS1306, *and* that either
+ * it's wired up a second IRQ we know, or that INTCN is set)
+ */
+#define DS1305_ALM_LEN          4               /* bytes for ALM regs */
+#define DS1305_ALM_DISABLE      0x80
+
+#define DS1305_ALM0(r)          (0x07 + (r))    /* register addresses */
+#define DS1305_ALM1(r)          (0x0b + (r))
+
+
+/* three control registers */
+#define DS1305_CONTROL_LEN      3               /* bytes of control regs */
+
+#define DS1305_CONTROL          0x0f            /* register addresses */
+#       define DS1305_nEOSC             0x80    /* low enables oscillator */
+#       define DS1305_WP                0x40    /* write protect */
+#       define DS1305_INTCN             0x04    /* clear == only int0 used */
+#       define DS1306_1HZ               0x04    /* enable 1Hz output */
+#       define DS1305_AEI1              0x02    /* enable ALM1 IRQ */
+#       define DS1305_AEI0              0x01    /* enable ALM0 IRQ */
+#define DS1305_STATUS           0x10
+/* status has just AEIx bits, mirrored as IRQFx */
+#define DS1305_TRICKLE          0x11
+/* trickle bits are defined in <linux/spi/ds1305.h> */
+
+/* a bunch of NVRAM */
+#define DS1305_NVRAM_LEN        96              /* bytes of NVRAM */
+
+#define DS1305_NVRAM            0x20            /* register addresses */
+
+
+struct ds1305 {
+        struct spi_device       *spi;
+        struct rtc_device       *rtc;
+
+        struct work_struct      work;
+
+        unsigned long           flags;
+#define FLAG_EXITING    0
+
+        bool                    hr12;
+        u8                      ctrl[DS1305_CONTROL_LEN];
+};
+
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * Utilities ...  tolerate 12-hour AM/PM notation in case of non-Linux
+ * software (like a bootloader) which may require it.
+ */
+
+static unsigned bcd2hour(u8 bcd)
+{
+        if (bcd & DS1305_HR_12) {
+                unsigned        hour = 0;
+
+                bcd &= ~DS1305_HR_12;
+                if (bcd & DS1305_HR_PM) {
+                        hour = 12;
+                        bcd &= ~DS1305_HR_PM;
+                }
+                hour += bcd2bin(bcd);
+                return hour - 1;
+        }
+        return bcd2bin(bcd);
+}
+
+static u8 hour2bcd(bool hr12, int hour)
+{
+        if (hr12) {
+                hour++;
+                if (hour <= 12)
+                        return DS1305_HR_12 | bin2bcd(hour);
+                hour -= 12;
+                return DS1305_HR_12 | DS1305_HR_PM | bin2bcd(hour);
+        }
+        return bin2bcd(hour);
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * Interface to RTC framework
+ */
+
+#ifdef CONFIG_RTC_INTF_DEV
+
+/*
+ * Context: caller holds rtc->ops_lock (to protect ds1305->ctrl)
+ */
+static int ds1305_ioctl(struct device *dev, unsigned cmd, unsigned long arg)
+{
+        struct ds1305   *ds1305 = dev_get_drvdata(dev);
+        u8              buf[2];
+        int             status = -ENOIOCTLCMD;
+
+        buf[0] = DS1305_WRITE | DS1305_CONTROL;
+        buf[1] = ds1305->ctrl[0];
+
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                status = 0;
+                if (!(buf[1] & DS1305_AEI0))
+                        goto done;
+                buf[1] &= ~DS1305_AEI0;
+                break;
+
+        case RTC_AIE_ON:
+                status = 0;
+                if (ds1305->ctrl[0] & DS1305_AEI0)
+                        goto done;
+                buf[1] |= DS1305_AEI0;
+                break;
+        }
+        if (status == 0) {
+                status = spi_write_then_read(ds1305->spi, buf, sizeof buf,
+                                NULL, 0);
+                if (status >= 0)
+                        ds1305->ctrl[0] = buf[1];
+        }
+
+done:
+        return status;
+}
+
+#else
+#define ds1305_ioctl    NULL
+#endif
+
+/*
+ * Get/set of date and time is pretty normal.
+ */
+
+static int ds1305_get_time(struct device *dev, struct rtc_time *time)
+{
+        struct ds1305   *ds1305 = dev_get_drvdata(dev);
+        u8              addr = DS1305_SEC;
+        u8              buf[DS1305_RTC_LEN];
+        int             status;
+
+        /* Use write-then-read to get all the date/time registers
+         * since dma from stack is nonportable
+         */
+        status = spi_write_then_read(ds1305->spi, &addr, sizeof addr,
+                        buf, sizeof buf);
+        if (status < 0)
+                return status;
+
+        dev_vdbg(dev, "%s: %02x %02x %02x, %02x %02x %02x %02x\n",
+                "read", buf[0], buf[1], buf[2], buf[3],
+                buf[4], buf[5], buf[6]);
+
+        /* Decode the registers */
+        time->tm_sec = bcd2bin(buf[DS1305_SEC]);
+        time->tm_min = bcd2bin(buf[DS1305_MIN]);
+        time->tm_hour = bcd2hour(buf[DS1305_HOUR]);
+        time->tm_wday = buf[DS1305_WDAY] - 1;
+        time->tm_mday = bcd2bin(buf[DS1305_MDAY]);
+        time->tm_mon = bcd2bin(buf[DS1305_MON]) - 1;
+        time->tm_year = bcd2bin(buf[DS1305_YEAR]) + 100;
+
+        dev_vdbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "read", time->tm_sec, time->tm_min,
+                time->tm_hour, time->tm_mday,
+                time->tm_mon, time->tm_year, time->tm_wday);
+
+        /* Time may not be set */
+        return rtc_valid_tm(time);
+}
+
+static int ds1305_set_time(struct device *dev, struct rtc_time *time)
+{
+        struct ds1305   *ds1305 = dev_get_drvdata(dev);
+        u8              buf[1 + DS1305_RTC_LEN];
+        u8              *bp = buf;
+
+        dev_vdbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "write", time->tm_sec, time->tm_min,
+                time->tm_hour, time->tm_mday,
+                time->tm_mon, time->tm_year, time->tm_wday);
+
+        /* Write registers starting at the first time/date address. */
+        *bp++ = DS1305_WRITE | DS1305_SEC;
+
+        *bp++ = bin2bcd(time->tm_sec);
+        *bp++ = bin2bcd(time->tm_min);
+        *bp++ = hour2bcd(ds1305->hr12, time->tm_hour);
+        *bp++ = (time->tm_wday < 7) ? (time->tm_wday + 1) : 1;
+        *bp++ = bin2bcd(time->tm_mday);
+        *bp++ = bin2bcd(time->tm_mon + 1);
+        *bp++ = bin2bcd(time->tm_year - 100);
+
+        dev_dbg(dev, "%s: %02x %02x %02x, %02x %02x %02x %02x\n",
+                "write", buf[1], buf[2], buf[3],
+                buf[4], buf[5], buf[6], buf[7]);
+
+        /* use write-then-read since dma from stack is nonportable */
+        return spi_write_then_read(ds1305->spi, buf, sizeof buf,
+                        NULL, 0);
+}
+
+/*
+ * Get/set of alarm is a bit funky:
+ *
+ * - First there's the inherent raciness of getting the (partitioned)
+ *   status of an alarm that could trigger while we're reading parts
+ *   of that status.
+ *
+ * - Second there's its limited range (we could increase it a bit by
+ *   relying on WDAY), which means it will easily roll over.
+ *
+ * - Third there's the choice of two alarms and alarm signals.
+ *   Here we use ALM0 and expect that nINT0 (open drain) is used;
+ *   that's the only real option for DS1306 runtime alarms, and is
+ *   natural on DS1305.
+ *
+ * - Fourth, there's also ALM1, and a second interrupt signal:
+ *     + On DS1305 ALM1 uses nINT1 (when INTCN=1) else nINT0;
+ *     + On DS1306 ALM1 only uses INT1 (an active high pulse)
+ *       and it won't work when VCC1 is active.
+ *
+ *   So to be most general, we should probably set both alarms to the
+ *   same value, letting ALM1 be the wakeup event source on DS1306
+ *   and handling several wiring options on DS1305.
+ *
+ * - Fifth, we support the polled mode (as well as possible; why not?)
+ *   even when no interrupt line is wired to an IRQ.
+ */
+
+/*
+ * Context: caller holds rtc->ops_lock (to protect ds1305->ctrl)
+ */
+static int ds1305_get_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct ds1305   *ds1305 = dev_get_drvdata(dev);
+        struct spi_device *spi = ds1305->spi;
+        u8              addr;
+        int             status;
+        u8              buf[DS1305_ALM_LEN];
+
+        /* Refresh control register cache BEFORE reading ALM0 registers,
+         * since reading alarm registers acks any pending IRQ.  That
+         * makes returning "pending" status a bit of a lie, but that bit
+         * of EFI status is at best fragile anyway (given IRQ handlers).
+         */
+        addr = DS1305_CONTROL;
+        status = spi_write_then_read(spi, &addr, sizeof addr,
+                        ds1305->ctrl, sizeof ds1305->ctrl);
+        if (status < 0)
+                return status;
+
+        alm->enabled = !!(ds1305->ctrl[0] & DS1305_AEI0);
+        alm->pending = !!(ds1305->ctrl[1] & DS1305_AEI0);
+
+        /* get and check ALM0 registers */
+        addr = DS1305_ALM0(DS1305_SEC);
+        status = spi_write_then_read(spi, &addr, sizeof addr,
+                        buf, sizeof buf);
+        if (status < 0)
+                return status;
+
+        dev_vdbg(dev, "%s: %02x %02x %02x %02x\n",
+                "alm0 read", buf[DS1305_SEC], buf[DS1305_MIN],
+                buf[DS1305_HOUR], buf[DS1305_WDAY]);
+
+        if ((DS1305_ALM_DISABLE & buf[DS1305_SEC])
+                        || (DS1305_ALM_DISABLE & buf[DS1305_MIN])
+                        || (DS1305_ALM_DISABLE & buf[DS1305_HOUR]))
+                return -EIO;
+
+        /* Stuff these values into alm->time and let RTC framework code
+         * fill in the rest ... and also handle rollover to tomorrow when
+         * that's needed.
+         */
+        alm->time.tm_sec = bcd2bin(buf[DS1305_SEC]);
+        alm->time.tm_min = bcd2bin(buf[DS1305_MIN]);
+        alm->time.tm_hour = bcd2hour(buf[DS1305_HOUR]);
+        alm->time.tm_mday = -1;
+        alm->time.tm_mon = -1;
+        alm->time.tm_year = -1;
+        /* next three fields are unused by Linux */
+        alm->time.tm_wday = -1;
+        alm->time.tm_mday = -1;
+        alm->time.tm_isdst = -1;
+
+        return 0;
+}
+
+/*
+ * Context: caller holds rtc->ops_lock (to protect ds1305->ctrl)
+ */
+static int ds1305_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct ds1305   *ds1305 = dev_get_drvdata(dev);
+        struct spi_device *spi = ds1305->spi;
+        unsigned long   now, later;
+        struct rtc_time tm;
+        int             status;
+        u8              buf[1 + DS1305_ALM_LEN];
+
+        /* convert desired alarm to time_t */
+        status = rtc_tm_to_time(&alm->time, &later);
+        if (status < 0)
+                return status;
+
+        /* Read current time as time_t */
+        status = ds1305_get_time(dev, &tm);
+        if (status < 0)
+                return status;
+        status = rtc_tm_to_time(&tm, &now);
+        if (status < 0)
+                return status;
+
+        /* make sure alarm fires within the next 24 hours */
+        if (later <= now)
+                return -EINVAL;
+        if ((later - now) > 24 * 60 * 60)
+                return -EDOM;
+
+        /* disable alarm if needed */
+        if (ds1305->ctrl[0] & DS1305_AEI0) {
+                ds1305->ctrl[0] &= ~DS1305_AEI0;
+
+                buf[0] = DS1305_WRITE | DS1305_CONTROL;
+                buf[1] = ds1305->ctrl[0];
+                status = spi_write_then_read(ds1305->spi, buf, 2, NULL, 0);
+                if (status < 0)
+                        return status;
+        }
+
+        /* write alarm */
+        buf[0] = DS1305_WRITE | DS1305_ALM0(DS1305_SEC);
+        buf[1 + DS1305_SEC] = bin2bcd(alm->time.tm_sec);
+        buf[1 + DS1305_MIN] = bin2bcd(alm->time.tm_min);
+        buf[1 + DS1305_HOUR] = hour2bcd(ds1305->hr12, alm->time.tm_hour);
+        buf[1 + DS1305_WDAY] = DS1305_ALM_DISABLE;
+
+        dev_dbg(dev, "%s: %02x %02x %02x %02x\n",
+                "alm0 write", buf[1 + DS1305_SEC], buf[1 + DS1305_MIN],
+                buf[1 + DS1305_HOUR], buf[1 + DS1305_WDAY]);
+
+        status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0);
+        if (status < 0)
+                return status;
+
+        /* enable alarm if requested */
+        if (alm->enabled) {
+                ds1305->ctrl[0] |= DS1305_AEI0;
+
+                buf[0] = DS1305_WRITE | DS1305_CONTROL;
+                buf[1] = ds1305->ctrl[0];
+                status = spi_write_then_read(ds1305->spi, buf, 2, NULL, 0);
+        }
+
+        return status;
+}
+
+#ifdef CONFIG_PROC_FS
+
+static int ds1305_proc(struct device *dev, struct seq_file *seq)
+{
+        struct ds1305   *ds1305 = dev_get_drvdata(dev);
+        char            *diodes = "no";
+        char            *resistors = "";
+
+        /* ctrl[2] is treated as read-only; no locking needed */
+        if ((ds1305->ctrl[2] & 0xf0) == DS1305_TRICKLE_MAGIC) {
+                switch (ds1305->ctrl[2] & 0x0c) {
+                case DS1305_TRICKLE_DS2:
+                        diodes = "2 diodes, ";
+                        break;
+                case DS1305_TRICKLE_DS1:
+                        diodes = "1 diode, ";
+                        break;
+                default:
+                        goto done;
+                }
+                switch (ds1305->ctrl[2] & 0x03) {
+                case DS1305_TRICKLE_2K:
+                        resistors = "2k Ohm";
+                        break;
+                case DS1305_TRICKLE_4K:
+                        resistors = "4k Ohm";
+                        break;
+                case DS1305_TRICKLE_8K:
+                        resistors = "8k Ohm";
+                        break;
+                default:
+                        diodes = "no";
+                        break;
+                }
+        }
+
+done:
+        return seq_printf(seq,
+                        "trickle_charge\t: %s%s\n",
+                        diodes, resistors);
+}
+
+#else
+#define ds1305_proc     NULL
+#endif
+
+static const struct rtc_class_ops ds1305_ops = {
+        .ioctl          = ds1305_ioctl,
+        .read_time      = ds1305_get_time,
+        .set_time       = ds1305_set_time,
+        .read_alarm     = ds1305_get_alarm,
+        .set_alarm      = ds1305_set_alarm,
+        .proc           = ds1305_proc,
+};
+
+static void ds1305_work(struct work_struct *work)
+{
+        struct ds1305   *ds1305 = container_of(work, struct ds1305, work);
+        struct mutex    *lock = &ds1305->rtc->ops_lock;
+        struct spi_device *spi = ds1305->spi;
+        u8              buf[3];
+        int             status;
+
+        /* lock to protect ds1305->ctrl */
+        mutex_lock(lock);
+
+        /* Disable the IRQ, and clear its status ... for now, we "know"
+         * that if more than one alarm is active, they're in sync.
+         * Note that reading ALM data registers also clears IRQ status.
+         */
+        ds1305->ctrl[0] &= ~(DS1305_AEI1 | DS1305_AEI0);
+        ds1305->ctrl[1] = 0;
+
+        buf[0] = DS1305_WRITE | DS1305_CONTROL;
+        buf[1] = ds1305->ctrl[0];
+        buf[2] = 0;
+
+        status = spi_write_then_read(spi, buf, sizeof buf,
+                        NULL, 0);
+        if (status < 0)
+                dev_dbg(&spi->dev, "clear irq --> %d\n", status);
+
+        mutex_unlock(lock);
+
+        if (!test_bit(FLAG_EXITING, &ds1305->flags))
+                enable_irq(spi->irq);
+
+        /* rtc_update_irq() requires an IRQ-disabled context */
+        local_irq_disable();
+        rtc_update_irq(ds1305->rtc, 1, RTC_AF | RTC_IRQF);
+        local_irq_enable();
+}
+
+/*
+ * This "real" IRQ handler hands off to a workqueue mostly to allow
+ * mutex locking for ds1305->ctrl ... unlike I2C, we could issue async
+ * I/O requests in IRQ context (to clear the IRQ status).
+ */
+static irqreturn_t ds1305_irq(int irq, void *p)
+{
+        struct ds1305           *ds1305 = p;
+
+        disable_irq(irq);
+        schedule_work(&ds1305->work);
+        return IRQ_HANDLED;
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * Interface for NVRAM
+ */
+
+static void msg_init(struct spi_message *m, struct spi_transfer *x,
+                u8 *addr, size_t count, char *tx, char *rx)
+{
+        spi_message_init(m);
+        memset(x, 0, 2 * sizeof(*x));
+
+        x->tx_buf = addr;
+        x->len = 1;
+        spi_message_add_tail(x, m);
+
+        x++;
+
+        x->tx_buf = tx;
+        x->rx_buf = rx;
+        x->len = count;
+        spi_message_add_tail(x, m);
+}
+
+static ssize_t
+ds1305_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
+                char *buf, loff_t off, size_t count)
+{
+        struct spi_device       *spi;
+        u8                      addr;
+        struct spi_message      m;
+        struct spi_transfer     x[2];
+        int                     status;
+
+        spi = container_of(kobj, struct spi_device, dev.kobj);
+
+        if (unlikely(off >= DS1305_NVRAM_LEN))
+                return 0;
+        if (count >= DS1305_NVRAM_LEN)
+                count = DS1305_NVRAM_LEN;
+        if ((off + count) > DS1305_NVRAM_LEN)
+                count = DS1305_NVRAM_LEN - off;
+        if (unlikely(!count))
+                return count;
+
+        addr = DS1305_NVRAM + off;
+        msg_init(&m, x, &addr, count, NULL, buf);
+
+        status = spi_sync(spi, &m);
+        if (status < 0)
+                dev_err(&spi->dev, "nvram %s error %d\n", "read", status);
+        return (status < 0) ? status : count;
+}
+
+static ssize_t
+ds1305_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
+                char *buf, loff_t off, size_t count)
+{
+        struct spi_device       *spi;
+        u8                      addr;
+        struct spi_message      m;
+        struct spi_transfer     x[2];
+        int                     status;
+
+        spi = container_of(kobj, struct spi_device, dev.kobj);
+
+        if (unlikely(off >= DS1305_NVRAM_LEN))
+                return -EFBIG;
+        if (count >= DS1305_NVRAM_LEN)
+                count = DS1305_NVRAM_LEN;
+        if ((off + count) > DS1305_NVRAM_LEN)
+                count = DS1305_NVRAM_LEN - off;
+        if (unlikely(!count))
+                return count;
+
+        addr = (DS1305_WRITE | DS1305_NVRAM) + off;
+        msg_init(&m, x, &addr, count, buf, NULL);
+
+        status = spi_sync(spi, &m);
+        if (status < 0)
+                dev_err(&spi->dev, "nvram %s error %d\n", "write", status);
+        return (status < 0) ? status : count;
+}
+
+static struct bin_attribute nvram = {
+        .attr.name      = "nvram",
+        .attr.mode      = S_IRUGO | S_IWUSR,
+        .read           = ds1305_nvram_read,
+        .write          = ds1305_nvram_write,
+        .size           = DS1305_NVRAM_LEN,
+};
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * Interface to SPI stack
+ */
+
+static int __devinit ds1305_probe(struct spi_device *spi)
+{
+        struct ds1305                   *ds1305;
+        struct rtc_device               *rtc;
+        int                             status;
+        u8                              addr, value;
+        struct ds1305_platform_data     *pdata = spi->dev.platform_data;
+        bool                            write_ctrl = false;
+
+        /* Sanity check board setup data.  This may be hooked up
+         * in 3wire mode, but we don't care.  Note that unless
+         * there's an inverter in place, this needs SPI_CS_HIGH!
+         */
+        if ((spi->bits_per_word && spi->bits_per_word != 8)
+                        || (spi->max_speed_hz > 2000000)
+                        || !(spi->mode & SPI_CPHA))
+                return -EINVAL;
+
+        /* set up driver data */
+        ds1305 = kzalloc(sizeof *ds1305, GFP_KERNEL);
+        if (!ds1305)
+                return -ENOMEM;
+        ds1305->spi = spi;
+        spi_set_drvdata(spi, ds1305);
+
+        /* read and cache control registers */
+        addr = DS1305_CONTROL;
+        status = spi_write_then_read(spi, &addr, sizeof addr,
+                        ds1305->ctrl, sizeof ds1305->ctrl);
+        if (status < 0) {
+                dev_dbg(&spi->dev, "can't %s, %d\n",
+                                "read", status);
+                goto fail0;
+        }
+
+        dev_dbg(&spi->dev, "ctrl %s: %02x %02x %02x\n",
+                        "read", ds1305->ctrl[0],
+                        ds1305->ctrl[1], ds1305->ctrl[2]);
+
+        /* Sanity check register values ... partially compensating for the
+         * fact that SPI has no device handshake.  A pullup on MISO would
+         * make these tests fail; but not all systems will have one.  If
+         * some register is neither 0x00 nor 0xff, a chip is likely there.
+         */
+        if ((ds1305->ctrl[0] & 0x38) != 0 || (ds1305->ctrl[1] & 0xfc) != 0) {
+                dev_dbg(&spi->dev, "RTC chip is not present\n");
+                status = -ENODEV;
+                goto fail0;
+        }
+        if (ds1305->ctrl[2] == 0)
+                dev_dbg(&spi->dev, "chip may not be present\n");
+
+        /* enable writes if needed ... if we were paranoid it would
+         * make sense to enable them only when absolutely necessary.
+         */
+        if (ds1305->ctrl[0] & DS1305_WP) {
+                u8              buf[2];
+
+                ds1305->ctrl[0] &= ~DS1305_WP;
+
+                buf[0] = DS1305_WRITE | DS1305_CONTROL;
+                buf[1] = ds1305->ctrl[0];
+                status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0);
+
+                dev_dbg(&spi->dev, "clear WP --> %d\n", status);
+                if (status < 0)
+                        goto fail0;
+        }
+
+        /* on DS1305, maybe start oscillator; like most low power
+         * oscillators, it may take a second to stabilize
+         */
+        if (ds1305->ctrl[0] & DS1305_nEOSC) {
+                ds1305->ctrl[0] &= ~DS1305_nEOSC;
+                write_ctrl = true;
+                dev_warn(&spi->dev, "SET TIME!\n");
+        }
+
+        /* ack any pending IRQs */
+        if (ds1305->ctrl[1]) {
+                ds1305->ctrl[1] = 0;
+                write_ctrl = true;
+        }
+
+        /* this may need one-time (re)init */
+        if (pdata) {
+                /* maybe enable trickle charge */
+                if (((ds1305->ctrl[2] & 0xf0) != DS1305_TRICKLE_MAGIC)) {
+                        ds1305->ctrl[2] = DS1305_TRICKLE_MAGIC
+                                                | pdata->trickle;
+                        write_ctrl = true;
+                }
+
+                /* on DS1306, configure 1 Hz signal */
+                if (pdata->is_ds1306) {
+                        if (pdata->en_1hz) {
+                                if (!(ds1305->ctrl[0] & DS1306_1HZ)) {
+                                        ds1305->ctrl[0] |= DS1306_1HZ;
+                                        write_ctrl = true;
+                                }
+                        } else {
+                                if (ds1305->ctrl[0] & DS1306_1HZ) {
+                                        ds1305->ctrl[0] &= ~DS1306_1HZ;
+                                        write_ctrl = true;
+                                }
+                        }
+                }
+        }
+
+        if (write_ctrl) {
+                u8              buf[4];
+
+                buf[0] = DS1305_WRITE | DS1305_CONTROL;
+                buf[1] = ds1305->ctrl[0];
+                buf[2] = ds1305->ctrl[1];
+                buf[3] = ds1305->ctrl[2];
+                status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0);
+                if (status < 0) {
+                        dev_dbg(&spi->dev, "can't %s, %d\n",
+                                        "write", status);
+                        goto fail0;
+                }
+
+                dev_dbg(&spi->dev, "ctrl %s: %02x %02x %02x\n",
+                                "write", ds1305->ctrl[0],
+                                ds1305->ctrl[1], ds1305->ctrl[2]);
+        }
+
+        /* see if non-Linux software set up AM/PM mode */
+        addr = DS1305_HOUR;
+        status = spi_write_then_read(spi, &addr, sizeof addr,
+                                &value, sizeof value);
+        if (status < 0) {
+                dev_dbg(&spi->dev, "read HOUR --> %d\n", status);
+                goto fail0;
+        }
+
+        ds1305->hr12 = (DS1305_HR_12 & value) != 0;
+        if (ds1305->hr12)
+                dev_dbg(&spi->dev, "AM/PM\n");
+
+        /* register RTC ... from here on, ds1305->ctrl needs locking */
+        rtc = rtc_device_register("ds1305", &spi->dev,
+                        &ds1305_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                status = PTR_ERR(rtc);
+                dev_dbg(&spi->dev, "register rtc --> %d\n", status);
+                goto fail0;
+        }
+        ds1305->rtc = rtc;
+
+        /* Maybe set up alarm IRQ; be ready to handle it triggering right
+         * away.  NOTE that we don't share this.  The signal is active low,
+         * and we can't ack it before a SPI message delay.  We temporarily
+         * disable the IRQ until it's acked, which lets us work with more
+         * IRQ trigger modes (not all IRQ controllers can do falling edge).
+         */
+        if (spi->irq) {
+                INIT_WORK(&ds1305->work, ds1305_work);
+                status = request_irq(spi->irq, ds1305_irq,
+                                0, dev_name(&rtc->dev), ds1305);
+                if (status < 0) {
+                        dev_dbg(&spi->dev, "request_irq %d --> %d\n",
+                                        spi->irq, status);
+                        goto fail1;
+                }
+        }
+
+        /* export NVRAM */
+        status = sysfs_create_bin_file(&spi->dev.kobj, &nvram);
+        if (status < 0) {
+                dev_dbg(&spi->dev, "register nvram --> %d\n", status);
+                goto fail2;
+        }
+
+        return 0;
+
+fail2:
+        free_irq(spi->irq, ds1305);
+fail1:
+        rtc_device_unregister(rtc);
+fail0:
+        kfree(ds1305);
+        return status;
+}
+
+static int __devexit ds1305_remove(struct spi_device *spi)
+{
+        struct ds1305   *ds1305 = spi_get_drvdata(spi);
+
+        sysfs_remove_bin_file(&spi->dev.kobj, &nvram);
+
+        /* carefully shut down irq and workqueue, if present */
+        if (spi->irq) {
+                set_bit(FLAG_EXITING, &ds1305->flags);
+                free_irq(spi->irq, ds1305);
+                flush_scheduled_work();
+        }
+
+        rtc_device_unregister(ds1305->rtc);
+        spi_set_drvdata(spi, NULL);
+        kfree(ds1305);
+        return 0;
+}
+
+static struct spi_driver ds1305_driver = {
+        .driver.name    = "rtc-ds1305",
+        .driver.owner   = THIS_MODULE,
+        .probe          = ds1305_probe,
+        .remove         = __devexit_p(ds1305_remove),
+        /* REVISIT add suspend/resume */
+};
+
+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 bbf97e65202a..162330b9d1dc 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -23,10 +23,6 @@
  * 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.
- *
- * This is currently a simple no-alarms driver.  If your board has the
- * alarm irq wired up on a ds1337 or ds1339, and you want to use that,
- * then look at the rtc-rs5c372 driver for code to steal...
  */
 enum ds_type {
         ds_1307,
@@ -67,6 +63,7 @@ enum ds_type {
 #       define DS1307_BIT_RS0           0x01
 #define DS1337_REG_CONTROL      0x0e
 #       define DS1337_BIT_nEOSC         0x80
+#       define DS1339_BIT_BBSQI         0x20
 #       define DS1337_BIT_RS2           0x10
 #       define DS1337_BIT_RS1           0x08
 #       define DS1337_BIT_INTCN         0x04
@@ -83,19 +80,22 @@ enum ds_type {
 #       define DS1337_BIT_OSF           0x80
 #       define DS1337_BIT_A2I           0x02
 #       define DS1337_BIT_A1I           0x01
+#define DS1339_REG_ALARM1_SECS  0x07
 #define DS1339_REG_TRICKLE      0x10
 
 
 
 struct ds1307 {
         u8                      reg_addr;
-        bool                    has_nvram;
-        u8                      regs[8];
+        u8                      regs[11];
         enum ds_type            type;
+        unsigned long           flags;
+#define HAS_NVRAM       0               /* bit 0 == sysfs file active */
+#define HAS_ALARM       1               /* bit 1 == irq claimed */
         struct i2c_msg          msg[2];
         struct i2c_client       *client;
-        struct i2c_client       dev;
         struct rtc_device       *rtc;
+        struct work_struct      work;
 };
 
 struct chip_desc {
@@ -132,12 +132,79 @@ static const struct i2c_device_id ds1307_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, ds1307_id);
 
+/*----------------------------------------------------------------------*/
+
+/*
+ * The IRQ logic includes a "real" handler running in IRQ context just
+ * long enough to schedule this workqueue entry.   We need a task context
+ * to talk to the RTC, since I2C I/O calls require that; and disable the
+ * IRQ until we clear its status on the chip, so that this handler can
+ * work with any type of triggering (not just falling edge).
+ *
+ * The ds1337 and ds1339 both have two alarms, but we only use the first
+ * one (with a "seconds" field).  For ds1337 we expect nINTA is our alarm
+ * signal; ds1339 chips have only one alarm signal.
+ */
+static void ds1307_work(struct work_struct *work)
+{
+        struct ds1307           *ds1307;
+        struct i2c_client       *client;
+        struct mutex            *lock;
+        int                     stat, control;
+
+        ds1307 = container_of(work, struct ds1307, work);
+        client = ds1307->client;
+        lock = &ds1307->rtc->ops_lock;
+
+        mutex_lock(lock);
+        stat = i2c_smbus_read_byte_data(client, DS1337_REG_STATUS);
+        if (stat < 0)
+                goto out;
+
+        if (stat & DS1337_BIT_A1I) {
+                stat &= ~DS1337_BIT_A1I;
+                i2c_smbus_write_byte_data(client, DS1337_REG_STATUS, stat);
+
+                control = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
+                if (control < 0)
+                        goto out;
+
+                control &= ~DS1337_BIT_A1IE;
+                i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, control);
+
+                /* rtc_update_irq() assumes that it is called
+                 * from IRQ-disabled context.
+                 */
+                local_irq_disable();
+                rtc_update_irq(ds1307->rtc, 1, RTC_AF | RTC_IRQF);
+                local_irq_enable();
+        }
+
+out:
+        if (test_bit(HAS_ALARM, &ds1307->flags))
+                enable_irq(client->irq);
+        mutex_unlock(lock);
+}
+
+static irqreturn_t ds1307_irq(int irq, void *dev_id)
+{
+        struct i2c_client       *client = dev_id;
+        struct ds1307           *ds1307 = i2c_get_clientdata(client);
+
+        disable_irq_nosync(irq);
+        schedule_work(&ds1307->work);
+        return IRQ_HANDLED;
+}
+
+/*----------------------------------------------------------------------*/
+
 static int ds1307_get_time(struct device *dev, struct rtc_time *t)
 {
         struct ds1307   *ds1307 = dev_get_drvdata(dev);
         int             tmp;
 
         /* read the RTC date and time registers all at once */
+        ds1307->reg_addr = 0;
         ds1307->msg[1].flags = I2C_M_RD;
         ds1307->msg[1].len = 7;
 
@@ -155,17 +222,17 @@ static int ds1307_get_time(struct device *dev, struct rtc_time *t)
                         ds1307->regs[4], ds1307->regs[5],
                         ds1307->regs[6]);
 
-        t->tm_sec = BCD2BIN(ds1307->regs[DS1307_REG_SECS] & 0x7f);
-        t->tm_min = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
+        t->tm_sec = bcd2bin(ds1307->regs[DS1307_REG_SECS] & 0x7f);
+        t->tm_min = bcd2bin(ds1307->regs[DS1307_REG_MIN] & 0x7f);
         tmp = ds1307->regs[DS1307_REG_HOUR] & 0x3f;
-        t->tm_hour = BCD2BIN(tmp);
-        t->tm_wday = BCD2BIN(ds1307->regs[DS1307_REG_WDAY] & 0x07) - 1;
-        t->tm_mday = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
+        t->tm_hour = bcd2bin(tmp);
+        t->tm_wday = bcd2bin(ds1307->regs[DS1307_REG_WDAY] & 0x07) - 1;
+        t->tm_mday = bcd2bin(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
         tmp = ds1307->regs[DS1307_REG_MONTH] & 0x1f;
-        t->tm_mon = BCD2BIN(tmp) - 1;
+        t->tm_mon = bcd2bin(tmp) - 1;
 
         /* assume 20YY not 19YY, and ignore DS1337_BIT_CENTURY */
-        t->tm_year = BCD2BIN(ds1307->regs[DS1307_REG_YEAR]) + 100;
+        t->tm_year = bcd2bin(ds1307->regs[DS1307_REG_YEAR]) + 100;
 
         dev_dbg(dev, "%s secs=%d, mins=%d, "
                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -191,16 +258,16 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
                 t->tm_mon, t->tm_year, t->tm_wday);
 
         *buf++ = 0;             /* first register addr */
-        buf[DS1307_REG_SECS] = BIN2BCD(t->tm_sec);
-        buf[DS1307_REG_MIN] = BIN2BCD(t->tm_min);
-        buf[DS1307_REG_HOUR] = BIN2BCD(t->tm_hour);
-        buf[DS1307_REG_WDAY] = BIN2BCD(t->tm_wday + 1);
-        buf[DS1307_REG_MDAY] = BIN2BCD(t->tm_mday);
-        buf[DS1307_REG_MONTH] = BIN2BCD(t->tm_mon + 1);
+        buf[DS1307_REG_SECS] = bin2bcd(t->tm_sec);
+        buf[DS1307_REG_MIN] = bin2bcd(t->tm_min);
+        buf[DS1307_REG_HOUR] = bin2bcd(t->tm_hour);
+        buf[DS1307_REG_WDAY] = bin2bcd(t->tm_wday + 1);
+        buf[DS1307_REG_MDAY] = bin2bcd(t->tm_mday);
+        buf[DS1307_REG_MONTH] = bin2bcd(t->tm_mon + 1);
 
         /* assume 20YY not 19YY */
         tmp = t->tm_year - 100;
-        buf[DS1307_REG_YEAR] = BIN2BCD(tmp);
+        buf[DS1307_REG_YEAR] = bin2bcd(tmp);
 
         switch (ds1307->type) {
         case ds_1337:
@@ -231,9 +298,186 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
         return 0;
 }
 
+static int ds1307_read_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct i2c_client       *client = to_i2c_client(dev);
+        struct ds1307           *ds1307 = i2c_get_clientdata(client);
+        int                     ret;
+
+        if (!test_bit(HAS_ALARM, &ds1307->flags))
+                return -EINVAL;
+
+        /* read all ALARM1, ALARM2, and status registers at once */
+        ds1307->reg_addr = DS1339_REG_ALARM1_SECS;
+        ds1307->msg[1].flags = I2C_M_RD;
+        ds1307->msg[1].len = 9;
+
+        ret = i2c_transfer(to_i2c_adapter(client->dev.parent),
+                        ds1307->msg, 2);
+        if (ret != 2) {
+                dev_err(dev, "%s error %d\n", "alarm read", ret);
+                return -EIO;
+        }
+
+        dev_dbg(dev, "%s: %02x %02x %02x %02x, %02x %02x %02x, %02x %02x\n",
+                        "alarm read",
+                        ds1307->regs[0], ds1307->regs[1],
+                        ds1307->regs[2], ds1307->regs[3],
+                        ds1307->regs[4], ds1307->regs[5],
+                        ds1307->regs[6], ds1307->regs[7],
+                        ds1307->regs[8]);
+
+        /* 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);
+        t->time.tm_min = bcd2bin(ds1307->regs[1] & 0x7f);
+        t->time.tm_hour = bcd2bin(ds1307->regs[2] & 0x3f);
+        t->time.tm_mday = bcd2bin(ds1307->regs[3] & 0x3f);
+        t->time.tm_mon = -1;
+        t->time.tm_year = -1;
+        t->time.tm_wday = -1;
+        t->time.tm_yday = -1;
+        t->time.tm_isdst = -1;
+
+        /* ... and status */
+        t->enabled = !!(ds1307->regs[7] & DS1337_BIT_A1IE);
+        t->pending = !!(ds1307->regs[8] & DS1337_BIT_A1I);
+
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, enabled=%d, pending=%d\n",
+                "alarm read", t->time.tm_sec, t->time.tm_min,
+                t->time.tm_hour, t->time.tm_mday,
+                t->enabled, t->pending);
+
+        return 0;
+}
+
+static int ds1307_set_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct i2c_client       *client = to_i2c_client(dev);
+        struct ds1307           *ds1307 = i2c_get_clientdata(client);
+        unsigned char           *buf = ds1307->regs;
+        u8                      control, status;
+        int                     ret;
+
+        if (!test_bit(HAS_ALARM, &ds1307->flags))
+                return -EINVAL;
+
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, enabled=%d, pending=%d\n",
+                "alarm set", t->time.tm_sec, t->time.tm_min,
+                t->time.tm_hour, t->time.tm_mday,
+                t->enabled, t->pending);
+
+        /* read current status of both alarms and the chip */
+        ds1307->reg_addr = DS1339_REG_ALARM1_SECS;
+        ds1307->msg[1].flags = I2C_M_RD;
+        ds1307->msg[1].len = 9;
+
+        ret = i2c_transfer(to_i2c_adapter(client->dev.parent),
+                        ds1307->msg, 2);
+        if (ret != 2) {
+                dev_err(dev, "%s error %d\n", "alarm write", ret);
+                return -EIO;
+        }
+        control = ds1307->regs[7];
+        status = ds1307->regs[8];
+
+        dev_dbg(dev, "%s: %02x %02x %02x %02x, %02x %02x %02x, %02x %02x\n",
+                        "alarm set (old status)",
+                        ds1307->regs[0], ds1307->regs[1],
+                        ds1307->regs[2], ds1307->regs[3],
+                        ds1307->regs[4], ds1307->regs[5],
+                        ds1307->regs[6], control, status);
+
+        /* set ALARM1, using 24 hour and day-of-month modes */
+        *buf++ = DS1339_REG_ALARM1_SECS;        /* first register addr */
+        buf[0] = bin2bcd(t->time.tm_sec);
+        buf[1] = bin2bcd(t->time.tm_min);
+        buf[2] = bin2bcd(t->time.tm_hour);
+        buf[3] = bin2bcd(t->time.tm_mday);
+
+        /* set ALARM2 to non-garbage */
+        buf[4] = 0;
+        buf[5] = 0;
+        buf[6] = 0;
+
+        /* optionally enable ALARM1 */
+        buf[7] = control & ~(DS1337_BIT_A1IE | DS1337_BIT_A2IE);
+        if (t->enabled) {
+                dev_dbg(dev, "alarm IRQ armed\n");
+                buf[7] |= DS1337_BIT_A1IE;      /* only ALARM1 is used */
+        }
+        buf[8] = status & ~(DS1337_BIT_A1I | DS1337_BIT_A2I);
+
+        ds1307->msg[1].flags = 0;
+        ds1307->msg[1].len = 10;
+
+        ret = i2c_transfer(to_i2c_adapter(client->dev.parent),
+                        &ds1307->msg[1], 1);
+        if (ret != 1) {
+                dev_err(dev, "can't set alarm time\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int ds1307_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        struct i2c_client       *client = to_i2c_client(dev);
+        struct ds1307           *ds1307 = i2c_get_clientdata(client);
+        int                     ret;
+
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                if (!test_bit(HAS_ALARM, &ds1307->flags))
+                        return -ENOTTY;
+
+                ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
+                if (ret < 0)
+                        return ret;
+
+                ret &= ~DS1337_BIT_A1IE;
+
+                ret = i2c_smbus_write_byte_data(client,
+                                                DS1337_REG_CONTROL, ret);
+                if (ret < 0)
+                        return ret;
+
+                break;
+
+        case RTC_AIE_ON:
+                if (!test_bit(HAS_ALARM, &ds1307->flags))
+                        return -ENOTTY;
+
+                ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
+                if (ret < 0)
+                        return ret;
+
+                ret |= DS1337_BIT_A1IE;
+
+                ret = i2c_smbus_write_byte_data(client,
+                                                DS1337_REG_CONTROL, ret);
+                if (ret < 0)
+                        return ret;
+
+                break;
+
+        default:
+                return -ENOIOCTLCMD;
+        }
+
+        return 0;
+}
+
 static const struct rtc_class_ops ds13xx_rtc_ops = {
         .read_time      = ds1307_get_time,
         .set_time       = ds1307_set_time,
+        .read_alarm     = ds1307_read_alarm,
+        .set_alarm      = ds1307_set_alarm,
+        .ioctl          = ds1307_ioctl,
 };
 
 /*----------------------------------------------------------------------*/
@@ -307,7 +551,6 @@ static struct bin_attribute nvram = {
         .attr = {
                 .name   = "nvram",
                 .mode   = S_IRUGO | S_IWUSR,
-                .owner  = THIS_MODULE,
         },
 
         .read   = ds1307_nvram_read,
@@ -327,6 +570,7 @@ static int __devinit ds1307_probe(struct i2c_client *client,
         int                     tmp;
         const struct chip_desc  *chip = &chips[id->driver_data];
         struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
+        int                     want_irq = false;
 
         if (!i2c_check_functionality(adapter,
                         I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
@@ -353,6 +597,12 @@ static int __devinit ds1307_probe(struct i2c_client *client,
         switch (ds1307->type) {
         case ds_1337:
         case ds_1339:
+                /* has IRQ? */
+                if (ds1307->client->irq > 0 && chip->alarm) {
+                        INIT_WORK(&ds1307->work, ds1307_work);
+                        want_irq = true;
+                }
+
                 ds1307->reg_addr = DS1337_REG_CONTROL;
                 ds1307->msg[1].len = 2;
 
@@ -369,8 +619,20 @@ static int __devinit ds1307_probe(struct i2c_client *client,
 
                 /* oscillator off?  turn it on, so clock can tick. */
                 if (ds1307->regs[0] & DS1337_BIT_nEOSC)
-                        i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL,
-                                ds1307->regs[0] & ~DS1337_BIT_nEOSC);
+                        ds1307->regs[0] &= ~DS1337_BIT_nEOSC;
+
+                /* Using IRQ?  Disable the square wave and both alarms.
+                 * For ds1339, be sure alarms can trigger when we're
+                 * running on Vbackup (BBSQI); we assume ds1337 will
+                 * ignore that bit
+                 */
+                if (want_irq) {
+                        ds1307->regs[0] |= DS1337_BIT_INTCN | DS1339_BIT_BBSQI;
+                        ds1307->regs[0] &= ~(DS1337_BIT_A2IE | DS1337_BIT_A1IE);
+                }
+
+                i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL,
+                                                        ds1307->regs[0]);
 
                 /* oscillator fault?  clear flag, and warn */
                 if (ds1307->regs[1] & DS1337_BIT_OSF) {
@@ -446,18 +708,18 @@ read_rtc:
         }
 
         tmp = ds1307->regs[DS1307_REG_SECS];
-        tmp = BCD2BIN(tmp & 0x7f);
+        tmp = bcd2bin(tmp & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
-        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
+        tmp = bcd2bin(ds1307->regs[DS1307_REG_MIN] & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
 
-        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
+        tmp = bcd2bin(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
         if (tmp == 0 || tmp > 31)
                 goto exit_bad;
 
-        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MONTH] & 0x1f);
+        tmp = bcd2bin(ds1307->regs[DS1307_REG_MONTH] & 0x1f);
         if (tmp == 0 || tmp > 12)
                 goto exit_bad;
 
@@ -476,14 +738,14 @@ read_rtc:
                 /* Be sure we're in 24 hour mode.  Multi-master systems
                  * take note...
                  */
-                tmp = BCD2BIN(tmp & 0x1f);
+                tmp = bcd2bin(tmp & 0x1f);
                 if (tmp == 12)
                         tmp = 0;
                 if (ds1307->regs[DS1307_REG_HOUR] & DS1307_BIT_PM)
                         tmp += 12;
                 i2c_smbus_write_byte_data(client,
                                 DS1307_REG_HOUR,
-                                BIN2BCD(tmp));
+                                bin2bcd(tmp));
         }
 
         ds1307->rtc = rtc_device_register(client->name, &client->dev,
@@ -495,10 +757,22 @@ read_rtc:
                 goto exit_free;
         }
 
+        if (want_irq) {
+                err = request_irq(client->irq, ds1307_irq, 0,
+                          ds1307->rtc->name, client);
+                if (err) {
+                        dev_err(&client->dev,
+                                "unable to request IRQ!\n");
+                        goto exit_irq;
+                }
+                set_bit(HAS_ALARM, &ds1307->flags);
+                dev_dbg(&client->dev, "got IRQ %d\n", client->irq);
+        }
+
         if (chip->nvram56) {
                 err = sysfs_create_bin_file(&client->dev.kobj, &nvram);
                 if (err == 0) {
-                        ds1307->has_nvram = true;
+                        set_bit(HAS_NVRAM, &ds1307->flags);
                         dev_info(&client->dev, "56 bytes nvram\n");
                 }
         }
@@ -512,7 +786,9 @@ exit_bad:
                         ds1307->regs[2], ds1307->regs[3],
                         ds1307->regs[4], ds1307->regs[5],
                         ds1307->regs[6]);
-
+exit_irq:
+        if (ds1307->rtc)
+                rtc_device_unregister(ds1307->rtc);
 exit_free:
         kfree(ds1307);
         return err;
@@ -520,9 +796,14 @@ exit_free:
 
 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 (ds1307->has_nvram)
+        if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags))
                 sysfs_remove_bin_file(&client->dev.kobj, &nvram);
 
         rtc_device_unregister(ds1307->rtc);
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 640acd20fdde..a5b0fc09f0c6 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -173,7 +173,7 @@ static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         int cr, sr;
         int ret = 0;
 
-        if (client->irq < 0)
+        if (client->irq <= 0)
                 return -EINVAL;
 
         mutex_lock(&ds1374->mutex);
@@ -212,7 +212,7 @@ static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         int cr;
         int ret = 0;
 
-        if (client->irq < 0)
+        if (client->irq <= 0)
                 return -EINVAL;
 
         ret = ds1374_read_time(dev, &now);
@@ -381,7 +381,7 @@ static int ds1374_probe(struct i2c_client *client,
         if (ret)
                 goto out_free;
 
-        if (client->irq >= 0) {
+        if (client->irq > 0) {
                 ret = request_irq(client->irq, ds1374_irq, 0,
                                   "ds1374", client);
                 if (ret) {
@@ -401,7 +401,7 @@ static int ds1374_probe(struct i2c_client *client,
         return 0;
 
 out_irq:
-        if (client->irq >= 0)
+        if (client->irq > 0)
                 free_irq(client->irq, client);
 
 out_free:
@@ -414,7 +414,7 @@ static int __devexit ds1374_remove(struct i2c_client *client)
 {
         struct ds1374 *ds1374 = i2c_get_clientdata(client);
 
-        if (client->irq >= 0) {
+        if (client->irq > 0) {
                 mutex_lock(&ds1374->mutex);
                 ds1374->exiting = 1;
                 mutex_unlock(&ds1374->mutex);
@@ -429,12 +429,33 @@ static int __devexit ds1374_remove(struct i2c_client *client)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int ds1374_suspend(struct i2c_client *client, pm_message_t state)
+{
+        if (client->irq >= 0 && device_may_wakeup(&client->dev))
+                enable_irq_wake(client->irq);
+        return 0;
+}
+
+static int ds1374_resume(struct i2c_client *client)
+{
+        if (client->irq >= 0 && device_may_wakeup(&client->dev))
+                disable_irq_wake(client->irq);
+        return 0;
+}
+#else
+#define ds1374_suspend  NULL
+#define ds1374_resume   NULL
+#endif
+
 static struct i2c_driver ds1374_driver = {
         .driver = {
                 .name = "rtc-ds1374",
                 .owner = THIS_MODULE,
         },
         .probe = ds1374_probe,
+        .suspend = ds1374_suspend,
+        .resume = ds1374_resume,
         .remove = __devexit_p(ds1374_remove),
         .id_table = ds1374_id,
 };
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 0f0d27d1c4ca..25caada78398 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -153,8 +153,8 @@ ds1511_wdog_set(unsigned long deciseconds)
         /*
          * set the wdog values in the wdog registers
          */
-        rtc_write(BIN2BCD(deciseconds % 100), DS1511_WD_MSEC);
-        rtc_write(BIN2BCD(deciseconds / 100), DS1511_WD_SEC);
+        rtc_write(bin2bcd(deciseconds % 100), DS1511_WD_MSEC);
+        rtc_write(bin2bcd(deciseconds / 100), DS1511_WD_SEC);
         /*
          * set wdog enable and wdog 'steering' bit to issue a reset
          */
@@ -220,13 +220,13 @@ static int ds1511_rtc_set_time(struct device *dev, struct rtc_time *rtc_tm)
         /*
          * each register is a different number of valid bits
          */
-        sec = BIN2BCD(sec) & 0x7f;
-        min = BIN2BCD(min) & 0x7f;
-        hrs = BIN2BCD(hrs) & 0x3f;
-        day = BIN2BCD(day) & 0x3f;
-        mon = BIN2BCD(mon) & 0x1f;
-        yrs = BIN2BCD(yrs) & 0xff;
-        cen = BIN2BCD(cen) & 0xff;
+        sec = bin2bcd(sec) & 0x7f;
+        min = bin2bcd(min) & 0x7f;
+        hrs = bin2bcd(hrs) & 0x3f;
+        day = bin2bcd(day) & 0x3f;
+        mon = bin2bcd(mon) & 0x1f;
+        yrs = bin2bcd(yrs) & 0xff;
+        cen = bin2bcd(cen) & 0xff;
 
         spin_lock_irqsave(&ds1511_lock, flags);
         rtc_disable_update();
@@ -264,14 +264,14 @@ static int ds1511_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
         rtc_enable_update();
         spin_unlock_irqrestore(&ds1511_lock, flags);
 
-        rtc_tm->tm_sec = BCD2BIN(rtc_tm->tm_sec);
-        rtc_tm->tm_min = BCD2BIN(rtc_tm->tm_min);
-        rtc_tm->tm_hour = BCD2BIN(rtc_tm->tm_hour);
-        rtc_tm->tm_mday = BCD2BIN(rtc_tm->tm_mday);
-        rtc_tm->tm_wday = BCD2BIN(rtc_tm->tm_wday);
-        rtc_tm->tm_mon = BCD2BIN(rtc_tm->tm_mon);
-        rtc_tm->tm_year = BCD2BIN(rtc_tm->tm_year);
-        century = BCD2BIN(century) * 100;
+        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+        rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+        rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+        rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+        rtc_tm->tm_wday = bcd2bin(rtc_tm->tm_wday);
+        rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+        rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
+        century = bcd2bin(century) * 100;
 
         /*
          * Account for differences between how the RTC uses the values
@@ -304,16 +304,16 @@ ds1511_rtc_update_alarm(struct rtc_plat_data *pdata)
 
         spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
         rtc_write(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_mday) & 0x3f,
+               0x80 : bin2bcd(pdata->alrm_mday) & 0x3f,
                RTC_ALARM_DATE);
         rtc_write(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_hour) & 0x3f,
+               0x80 : bin2bcd(pdata->alrm_hour) & 0x3f,
                RTC_ALARM_HOUR);
         rtc_write(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_min) & 0x7f,
+               0x80 : bin2bcd(pdata->alrm_min) & 0x7f,
                RTC_ALARM_MIN);
         rtc_write(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_sec) & 0x7f,
+               0x80 : bin2bcd(pdata->alrm_sec) & 0x7f,
                RTC_ALARM_SEC);
         rtc_write(rtc_read(RTC_CMD) | (pdata->irqen ? RTC_TIE : 0), RTC_CMD);
         rtc_read(RTC_CMD1);     /* clear interrupts */
@@ -379,18 +379,6 @@ ds1511_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
- static void
-ds1511_rtc_release(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-
-        if (pdata->irq >= 0) {
-                pdata->irqen = 0;
-                ds1511_rtc_update_alarm(pdata);
-        }
-}
-
  static int
 ds1511_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
@@ -428,7 +416,6 @@ static const struct rtc_class_ops ds1511_rtc_ops = {
         .set_time       = ds1511_rtc_set_time,
         .read_alarm     = ds1511_rtc_read_alarm,
         .set_alarm      = ds1511_rtc_set_alarm,
-        .release        = ds1511_rtc_release,
         .ioctl          = ds1511_rtc_ioctl,
 };
 
@@ -494,7 +481,6 @@ static struct bin_attribute ds1511_nvram_attr = {
         .attr = {
                 .name = "nvram",
                 .mode = S_IRUGO | S_IWUGO,
-                .owner = THIS_MODULE,
         },
         .size = DS1511_RAM_MAX,
         .read = ds1511_nvram_read,
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index a19f11415540..b9475cd20210 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -78,17 +78,17 @@ static int ds1553_rtc_set_time(struct device *dev, struct rtc_time *tm)
         void __iomem *ioaddr = pdata->ioaddr;
         u8 century;
 
-        century = BIN2BCD((tm->tm_year + 1900) / 100);
+        century = bin2bcd((tm->tm_year + 1900) / 100);
 
         writeb(RTC_WRITE, pdata->ioaddr + RTC_CONTROL);
 
-        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
-        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
-        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
-        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
-        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
-        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
-        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
 
         /* RTC_CENTURY and RTC_CONTROL share same register */
         writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
@@ -118,14 +118,14 @@ static int ds1553_rtc_read_time(struct device *dev, struct rtc_time *tm)
         year = readb(ioaddr + RTC_YEAR);
         century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
         writeb(0, ioaddr + RTC_CONTROL);
-        tm->tm_sec = BCD2BIN(second);
-        tm->tm_min = BCD2BIN(minute);
-        tm->tm_hour = BCD2BIN(hour);
-        tm->tm_mday = BCD2BIN(day);
-        tm->tm_wday = BCD2BIN(week);
-        tm->tm_mon = BCD2BIN(month) - 1;
+        tm->tm_sec = bcd2bin(second);
+        tm->tm_min = bcd2bin(minute);
+        tm->tm_hour = bcd2bin(hour);
+        tm->tm_mday = bcd2bin(day);
+        tm->tm_wday = bcd2bin(week);
+        tm->tm_mon = bcd2bin(month) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+        tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
 
         if (rtc_valid_tm(tm) < 0) {
                 dev_err(dev, "retrieved date/time is not valid.\n");
@@ -141,16 +141,16 @@ static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata)
 
         spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
         writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_mday),
+               0x80 : bin2bcd(pdata->alrm_mday),
                ioaddr + RTC_DATE_ALARM);
         writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_hour),
+               0x80 : bin2bcd(pdata->alrm_hour),
                ioaddr + RTC_HOURS_ALARM);
         writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_min),
+               0x80 : bin2bcd(pdata->alrm_min),
                ioaddr + RTC_MINUTES_ALARM);
         writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_sec),
+               0x80 : bin2bcd(pdata->alrm_sec),
                ioaddr + RTC_SECONDS_ALARM);
         writeb(pdata->irqen ? RTC_INTS_AE : 0, ioaddr + RTC_INTERRUPTS);
         readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
@@ -207,17 +207,6 @@ static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static void ds1553_rtc_release(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-
-        if (pdata->irq >= 0) {
-                pdata->irqen = 0;
-                ds1553_rtc_update_alarm(pdata);
-        }
-}
-
 static int ds1553_rtc_ioctl(struct device *dev, unsigned int cmd,
                             unsigned long arg)
 {
@@ -254,7 +243,6 @@ static const struct rtc_class_ops ds1553_rtc_ops = {
         .set_time       = ds1553_rtc_set_time,
         .read_alarm     = ds1553_rtc_read_alarm,
         .set_alarm      = ds1553_rtc_set_alarm,
-        .release        = ds1553_rtc_release,
         .ioctl          = ds1553_rtc_ioctl,
 };
 
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 6fa4556f5f5c..341d7a5b45a2 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -9,17 +9,10 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/module.h>
 #include <linux/i2c.h>
 #include <linux/rtc.h>
 
-#define DRV_VERSION "0.3"
-
-/* Addresses to scan: none. This chip cannot be detected. */
-static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
-
-/* Insmod parameters */
-I2C_CLIENT_INSMOD;
+#define DRV_VERSION "0.4"
 
 /* Registers */
 
@@ -29,8 +22,7 @@ I2C_CLIENT_INSMOD;
 
 #define DS1672_REG_CONTROL_EOSC 0x80
 
-/* Prototypes */
-static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind);
+static struct i2c_driver ds1672_driver;
 
 /*
  * In the routines that deal directly with the ds1672 hardware, we use
@@ -44,8 +36,8 @@ static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         unsigned char buf[4];
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 1, &addr },          /* setup read ptr */
-                { client->addr, I2C_M_RD, 4, buf },     /* read date */
+                {client->addr, 0, 1, &addr},    /* setup read ptr */
+                {client->addr, I2C_M_RD, 4, buf},       /* read date */
         };
 
         /* read date registers */
@@ -80,7 +72,7 @@ static int ds1672_set_mmss(struct i2c_client *client, unsigned long secs)
         buf[2] = (secs & 0x0000FF00) >> 8;
         buf[3] = (secs & 0x00FF0000) >> 16;
         buf[4] = (secs & 0xFF000000) >> 24;
-        buf[5] = 0;     /* set control reg to enable counting */
+        buf[5] = 0;             /* set control reg to enable counting */
 
         xfer = i2c_master_send(client, buf, 6);
         if (xfer != 6) {
@@ -127,8 +119,8 @@ static int ds1672_get_control(struct i2c_client *client, u8 *status)
         unsigned char addr = DS1672_REG_CONTROL;
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 1, &addr },          /* setup read ptr */
-                { client->addr, I2C_M_RD, 1, status },  /* read control */
+                {client->addr, 0, 1, &addr},    /* setup read ptr */
+                {client->addr, I2C_M_RD, 1, status},    /* read control */
         };
 
         /* read control register */
@@ -141,7 +133,8 @@ static int ds1672_get_control(struct i2c_client *client, u8 *status)
 }
 
 /* following are the sysfs callback functions */
-static ssize_t show_control(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_control(struct device *dev, struct device_attribute *attr,
+                            char *buf)
 {
         struct i2c_client *client = to_i2c_client(dev);
         u8 control;
@@ -152,85 +145,46 @@ static ssize_t show_control(struct device *dev, struct device_attribute *attr, c
                 return err;
 
         return sprintf(buf, "%s\n", (control & DS1672_REG_CONTROL_EOSC)
-                                        ? "disabled" : "enabled");
+                       ? "disabled" : "enabled");
 }
+
 static DEVICE_ATTR(control, S_IRUGO, show_control, NULL);
 
 static const struct rtc_class_ops ds1672_rtc_ops = {
-        .read_time      = ds1672_rtc_read_time,
-        .set_time       = ds1672_rtc_set_time,
-        .set_mmss       = ds1672_rtc_set_mmss,
+        .read_time = ds1672_rtc_read_time,
+        .set_time = ds1672_rtc_set_time,
+        .set_mmss = ds1672_rtc_set_mmss,
 };
 
-static int ds1672_attach(struct i2c_adapter *adapter)
+static int ds1672_remove(struct i2c_client *client)
 {
-        return i2c_probe(adapter, &addr_data, ds1672_probe);
-}
-
-static int ds1672_detach(struct i2c_client *client)
-{
-        int err;
         struct rtc_device *rtc = i2c_get_clientdata(client);
 
-        if (rtc)
+        if (rtc)
                 rtc_device_unregister(rtc);
 
-        if ((err = i2c_detach_client(client)))
-                return err;
-
-        kfree(client);
-
         return 0;
 }
 
-static struct i2c_driver ds1672_driver = {
-        .driver         = {
-                .name   = "ds1672",
-        },
-        .id             = I2C_DRIVERID_DS1672,
-        .attach_adapter = &ds1672_attach,
-        .detach_client  = &ds1672_detach,
-};
-
-static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
+static int ds1672_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
 {
         int err = 0;
         u8 control;
-        struct i2c_client *client;
         struct rtc_device *rtc;
 
-        dev_dbg(&adapter->dev, "%s\n", __func__);
+        dev_dbg(&client->dev, "%s\n", __func__);
 
-        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
-                err = -ENODEV;
-                goto exit;
-        }
-
-        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto exit;
-        }
-
-        /* I2C client */
-        client->addr = address;
-        client->driver = &ds1672_driver;
-        client->adapter = adapter;
-
-        strlcpy(client->name, ds1672_driver.driver.name, I2C_NAME_SIZE);
-
-        /* Inform the i2c layer */
-        if ((err = i2c_attach_client(client)))
-                goto exit_kfree;
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+                return -ENODEV;
 
         dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
 
         rtc = rtc_device_register(ds1672_driver.driver.name, &client->dev,
-                                &ds1672_rtc_ops, THIS_MODULE);
+                                  &ds1672_rtc_ops, THIS_MODULE);
 
-        if (IS_ERR(rtc)) {
-                err = PTR_ERR(rtc);
-                goto exit_detach;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
 
         i2c_set_clientdata(client, rtc);
 
@@ -241,7 +195,7 @@ static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
 
         if (control & DS1672_REG_CONTROL_EOSC)
                 dev_warn(&client->dev, "Oscillator not enabled. "
-                                        "Set time to enable.\n");
+                         "Set time to enable.\n");
 
         /* Register sysfs hooks */
         err = device_create_file(&client->dev, &dev_attr_control);
@@ -250,19 +204,19 @@ static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
 
         return 0;
 
-exit_devreg:
+ exit_devreg:
         rtc_device_unregister(rtc);
-
-exit_detach:
-        i2c_detach_client(client);
-
-exit_kfree:
-        kfree(client);
-
-exit:
         return err;
 }
 
+static struct i2c_driver ds1672_driver = {
+        .driver = {
+                   .name = "rtc-ds1672",
+                   },
+        .probe = &ds1672_probe,
+        .remove = &ds1672_remove,
+};
+
 static int __init ds1672_init(void)
 {
         return i2c_add_driver(&ds1672_driver);
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 24d35ede2dbf..8bc8501bffc8 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -66,17 +66,17 @@ static int ds1742_rtc_set_time(struct device *dev, struct rtc_time *tm)
         void __iomem *ioaddr = pdata->ioaddr_rtc;
         u8 century;
 
-        century = BIN2BCD((tm->tm_year + 1900) / 100);
+        century = bin2bcd((tm->tm_year + 1900) / 100);
 
         writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
 
-        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
-        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
-        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
-        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
-        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
-        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
-        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
 
         /* RTC_CENTURY and RTC_CONTROL share same register */
         writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
@@ -106,14 +106,14 @@ static int ds1742_rtc_read_time(struct device *dev, struct rtc_time *tm)
         year = readb(ioaddr + RTC_YEAR);
         century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
         writeb(0, ioaddr + RTC_CONTROL);
-        tm->tm_sec = BCD2BIN(second);
-        tm->tm_min = BCD2BIN(minute);
-        tm->tm_hour = BCD2BIN(hour);
-        tm->tm_mday = BCD2BIN(day);
-        tm->tm_wday = BCD2BIN(week);
-        tm->tm_mon = BCD2BIN(month) - 1;
+        tm->tm_sec = bcd2bin(second);
+        tm->tm_min = bcd2bin(minute);
+        tm->tm_hour = bcd2bin(hour);
+        tm->tm_mday = bcd2bin(day);
+        tm->tm_wday = bcd2bin(week);
+        tm->tm_mon = bcd2bin(month) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+        tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
 
         if (rtc_valid_tm(tm) < 0) {
                 dev_err(dev, "retrieved date/time is not valid.\n");
diff --git a/drivers/rtc/rtc-ds3234.c b/drivers/rtc/rtc-ds3234.c
new file mode 100644
index 000000000000..37d131d03f33
--- /dev/null
+++ b/drivers/rtc/rtc-ds3234.c
@@ -0,0 +1,290 @@
+/* drivers/rtc/rtc-ds3234.c
+ *
+ * Driver for Dallas Semiconductor (DS3234) SPI RTC with Integrated Crystal
+ * and SRAM.
+ *
+ * Copyright (C) 2008 MIMOMax Wireless 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.
+ *
+ * Changelog:
+ *
+ * 07-May-2008: Dennis Aberilla <denzzzhome@yahoo.com>
+ *              - Created based on the max6902 code. Only implements the
+ *                date/time keeping functions; no SRAM yet.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/spi/spi.h>
+#include <linux/bcd.h>
+
+#define DS3234_REG_SECONDS      0x00
+#define DS3234_REG_MINUTES      0x01
+#define DS3234_REG_HOURS        0x02
+#define DS3234_REG_DAY          0x03
+#define DS3234_REG_DATE         0x04
+#define DS3234_REG_MONTH        0x05
+#define DS3234_REG_YEAR         0x06
+#define DS3234_REG_CENTURY      (1 << 7) /* Bit 7 of the Month register */
+
+#define DS3234_REG_CONTROL      0x0E
+#define DS3234_REG_CONT_STAT    0x0F
+
+#undef DS3234_DEBUG
+
+struct ds3234 {
+        struct rtc_device *rtc;
+        u8 buf[8]; /* Burst read: addr + 7 regs */
+        u8 tx_buf[2];
+        u8 rx_buf[2];
+};
+
+static void ds3234_set_reg(struct device *dev, unsigned char address,
+                                unsigned char data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned char buf[2];
+
+        /* MSB must be '1' to indicate write */
+        buf[0] = address | 0x80;
+        buf[1] = data;
+
+        spi_write(spi, buf, 2);
+}
+
+static int ds3234_get_reg(struct device *dev, unsigned char address,
+                                unsigned char *data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct ds3234 *chip = dev_get_drvdata(dev);
+        struct spi_message message;
+        struct spi_transfer xfer;
+        int status;
+
+        if (!data)
+                return -EINVAL;
+
+        /* Build our spi message */
+        spi_message_init(&message);
+        memset(&xfer, 0, sizeof(xfer));
+
+        /* Address + dummy tx byte */
+        xfer.len = 2;
+        xfer.tx_buf = chip->tx_buf;
+        xfer.rx_buf = chip->rx_buf;
+
+        chip->tx_buf[0] = address;
+        chip->tx_buf[1] = 0xff;
+
+        spi_message_add_tail(&xfer, &message);
+
+        /* do the i/o */
+        status = spi_sync(spi, &message);
+        if (status == 0)
+                status = message.status;
+        else
+                return status;
+
+        *data = chip->rx_buf[1];
+
+        return status;
+}
+
+static int ds3234_get_datetime(struct device *dev, struct rtc_time *dt)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct ds3234 *chip = dev_get_drvdata(dev);
+        struct spi_message message;
+        struct spi_transfer xfer;
+        int status;
+
+        /* build the message */
+        spi_message_init(&message);
+        memset(&xfer, 0, sizeof(xfer));
+        xfer.len = 1 + 7;       /* Addr + 7 registers */
+        xfer.tx_buf = chip->buf;
+        xfer.rx_buf = chip->buf;
+        chip->buf[0] = 0x00;    /* Start address */
+        spi_message_add_tail(&xfer, &message);
+
+        /* do the i/o */
+        status = spi_sync(spi, &message);
+        if (status == 0)
+                status = message.status;
+        else
+                return status;
+
+        /* Seconds, Minutes, Hours, Day, Date, Month, Year */
+        dt->tm_sec      = bcd2bin(chip->buf[1]);
+        dt->tm_min      = bcd2bin(chip->buf[2]);
+        dt->tm_hour     = bcd2bin(chip->buf[3] & 0x3f);
+        dt->tm_wday     = bcd2bin(chip->buf[4]) - 1; /* 0 = Sun */
+        dt->tm_mday     = bcd2bin(chip->buf[5]);
+        dt->tm_mon      = bcd2bin(chip->buf[6] & 0x1f) - 1; /* 0 = Jan */
+        dt->tm_year     = bcd2bin(chip->buf[7] & 0xff) + 100; /* Assume 20YY */
+
+#ifdef DS3234_DEBUG
+        dev_dbg(dev, "\n%s : Read RTC values\n", __func__);
+        dev_dbg(dev, "tm_hour: %i\n", dt->tm_hour);
+        dev_dbg(dev, "tm_min : %i\n", dt->tm_min);
+        dev_dbg(dev, "tm_sec : %i\n", dt->tm_sec);
+        dev_dbg(dev, "tm_wday: %i\n", dt->tm_wday);
+        dev_dbg(dev, "tm_mday: %i\n", dt->tm_mday);
+        dev_dbg(dev, "tm_mon : %i\n", dt->tm_mon);
+        dev_dbg(dev, "tm_year: %i\n", dt->tm_year);
+#endif
+
+        return 0;
+}
+
+static int ds3234_set_datetime(struct device *dev, struct rtc_time *dt)
+{
+#ifdef DS3234_DEBUG
+        dev_dbg(dev, "\n%s : Setting RTC values\n", __func__);
+        dev_dbg(dev, "tm_sec : %i\n", dt->tm_sec);
+        dev_dbg(dev, "tm_min : %i\n", dt->tm_min);
+        dev_dbg(dev, "tm_hour: %i\n", dt->tm_hour);
+        dev_dbg(dev, "tm_wday: %i\n", dt->tm_wday);
+        dev_dbg(dev, "tm_mday: %i\n", dt->tm_mday);
+        dev_dbg(dev, "tm_mon : %i\n", dt->tm_mon);
+        dev_dbg(dev, "tm_year: %i\n", dt->tm_year);
+#endif
+
+        ds3234_set_reg(dev, DS3234_REG_SECONDS, bin2bcd(dt->tm_sec));
+        ds3234_set_reg(dev, DS3234_REG_MINUTES, bin2bcd(dt->tm_min));
+        ds3234_set_reg(dev, DS3234_REG_HOURS, bin2bcd(dt->tm_hour) & 0x3f);
+
+        /* 0 = Sun */
+        ds3234_set_reg(dev, DS3234_REG_DAY, bin2bcd(dt->tm_wday + 1));
+        ds3234_set_reg(dev, DS3234_REG_DATE, bin2bcd(dt->tm_mday));
+
+        /* 0 = Jan */
+        ds3234_set_reg(dev, DS3234_REG_MONTH, bin2bcd(dt->tm_mon + 1));
+
+        /* Assume 20YY although we just want to make sure not to go negative. */
+        if (dt->tm_year > 100)
+                dt->tm_year -= 100;
+
+        ds3234_set_reg(dev, DS3234_REG_YEAR, bin2bcd(dt->tm_year));
+
+        return 0;
+}
+
+static int ds3234_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return ds3234_get_datetime(dev, tm);
+}
+
+static int ds3234_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return ds3234_set_datetime(dev, tm);
+}
+
+static const struct rtc_class_ops ds3234_rtc_ops = {
+        .read_time      = ds3234_read_time,
+        .set_time       = ds3234_set_time,
+};
+
+static int ds3234_probe(struct spi_device *spi)
+{
+        struct rtc_device *rtc;
+        unsigned char tmp;
+        struct ds3234 *chip;
+        int res;
+
+        rtc = rtc_device_register("ds3234",
+                                &spi->dev, &ds3234_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        spi->mode = SPI_MODE_3;
+        spi->bits_per_word = 8;
+        spi_setup(spi);
+
+        chip = kzalloc(sizeof(struct ds3234), GFP_KERNEL);
+        if (!chip) {
+                rtc_device_unregister(rtc);
+                return -ENOMEM;
+        }
+        chip->rtc = rtc;
+        dev_set_drvdata(&spi->dev, chip);
+
+        res = ds3234_get_reg(&spi->dev, DS3234_REG_SECONDS, &tmp);
+        if (res) {
+                rtc_device_unregister(rtc);
+                return res;
+        }
+
+        /* Control settings
+         *
+         * CONTROL_REG
+         * BIT 7        6       5       4       3       2       1       0
+         *     EOSC     BBSQW   CONV    RS2     RS1     INTCN   A2IE    A1IE
+         *
+         *     0        0       0       1       1       1       0       0
+         *
+         * CONTROL_STAT_REG
+         * BIT 7        6       5       4       3       2       1       0
+         *     OSF      BB32kHz CRATE1  CRATE0  EN32kHz BSY     A2F     A1F
+         *
+         *     1        0       0       0       1       0       0       0
+         */
+        ds3234_get_reg(&spi->dev, DS3234_REG_CONTROL, &tmp);
+        ds3234_set_reg(&spi->dev, DS3234_REG_CONTROL, tmp & 0x1c);
+
+        ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);
+        ds3234_set_reg(&spi->dev, DS3234_REG_CONT_STAT, tmp & 0x88);
+
+        /* Print our settings */
+        ds3234_get_reg(&spi->dev, DS3234_REG_CONTROL, &tmp);
+        dev_info(&spi->dev, "Control Reg: 0x%02x\n", tmp);
+
+        ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);
+        dev_info(&spi->dev, "Ctrl/Stat Reg: 0x%02x\n", tmp);
+
+        return 0;
+}
+
+static int __exit ds3234_remove(struct spi_device *spi)
+{
+        struct ds3234 *chip = platform_get_drvdata(spi);
+        struct rtc_device *rtc = chip->rtc;
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        kfree(chip);
+
+        return 0;
+}
+
+static struct spi_driver ds3234_driver = {
+        .driver = {
+                .name    = "ds3234",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe   = ds3234_probe,
+        .remove = __devexit_p(ds3234_remove),
+};
+
+static __init int ds3234_init(void)
+{
+        printk(KERN_INFO "DS3234 SPI RTC Driver\n");
+        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>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 1e99325270df..36e4ac0bd69c 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -12,7 +12,7 @@
 #include <linux/module.h>
 #include <linux/rtc.h>
 #include <linux/platform_device.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 
 #define EP93XX_RTC_REG(x)       (EP93XX_RTC_BASE + (x))
 #define EP93XX_RTC_DATA         EP93XX_RTC_REG(0x0000)
diff --git a/drivers/rtc/rtc-fm3130.c b/drivers/rtc/rtc-fm3130.c
index abfdfcbaa059..3a7be11cc6b9 100644
--- a/drivers/rtc/rtc-fm3130.c
+++ b/drivers/rtc/rtc-fm3130.c
@@ -131,17 +131,17 @@ static int fm3130_get_time(struct device *dev, struct rtc_time *t)
                         fm3130->regs[0xc], fm3130->regs[0xd],
                         fm3130->regs[0xe]);
 
-        t->tm_sec = BCD2BIN(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
-        t->tm_min = BCD2BIN(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
+        t->tm_sec = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
+        t->tm_min = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
         tmp = fm3130->regs[FM3130_RTC_HOURS] & 0x3f;
-        t->tm_hour = BCD2BIN(tmp);
-        t->tm_wday = BCD2BIN(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
-        t->tm_mday = BCD2BIN(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
+        t->tm_hour = bcd2bin(tmp);
+        t->tm_wday = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
+        t->tm_mday = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
         tmp = fm3130->regs[FM3130_RTC_MONTHS] & 0x1f;
-        t->tm_mon = BCD2BIN(tmp) - 1;
+        t->tm_mon = bcd2bin(tmp) - 1;
 
         /* assume 20YY not 19YY, and ignore CF bit */
-        t->tm_year = BCD2BIN(fm3130->regs[FM3130_RTC_YEARS]) + 100;
+        t->tm_year = bcd2bin(fm3130->regs[FM3130_RTC_YEARS]) + 100;
 
         dev_dbg(dev, "%s secs=%d, mins=%d, "
                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -167,16 +167,16 @@ static int fm3130_set_time(struct device *dev, struct rtc_time *t)
                 t->tm_mon, t->tm_year, t->tm_wday);
 
         /* first register addr */
-        buf[FM3130_RTC_SECONDS] = BIN2BCD(t->tm_sec);
-        buf[FM3130_RTC_MINUTES] = BIN2BCD(t->tm_min);
-        buf[FM3130_RTC_HOURS] = BIN2BCD(t->tm_hour);
-        buf[FM3130_RTC_DAY] = BIN2BCD(t->tm_wday + 1);
-        buf[FM3130_RTC_DATE] = BIN2BCD(t->tm_mday);
-        buf[FM3130_RTC_MONTHS] = BIN2BCD(t->tm_mon + 1);
+        buf[FM3130_RTC_SECONDS] = bin2bcd(t->tm_sec);
+        buf[FM3130_RTC_MINUTES] = bin2bcd(t->tm_min);
+        buf[FM3130_RTC_HOURS] = bin2bcd(t->tm_hour);
+        buf[FM3130_RTC_DAY] = bin2bcd(t->tm_wday + 1);
+        buf[FM3130_RTC_DATE] = bin2bcd(t->tm_mday);
+        buf[FM3130_RTC_MONTHS] = bin2bcd(t->tm_mon + 1);
 
         /* assume 20YY not 19YY */
         tmp = t->tm_year - 100;
-        buf[FM3130_RTC_YEARS] = BIN2BCD(tmp);
+        buf[FM3130_RTC_YEARS] = bin2bcd(tmp);
 
         dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x"
                 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
@@ -222,11 +222,11 @@ static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
                         fm3130->regs[FM3130_ALARM_MONTHS]);
 
 
-        tm->tm_sec      = BCD2BIN(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
-        tm->tm_min      = BCD2BIN(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
-        tm->tm_hour     = BCD2BIN(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
-        tm->tm_mday     = BCD2BIN(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
-        tm->tm_mon      = BCD2BIN(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
+        tm->tm_sec      = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
+        tm->tm_min      = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
+        tm->tm_hour     = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
+        tm->tm_mday     = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
+        tm->tm_mon      = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
         if (tm->tm_mon > 0)
                 tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
         dev_dbg(dev, "%s secs=%d, mins=%d, "
@@ -252,23 +252,23 @@ static int fm3130_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         if (tm->tm_sec != -1)
                 fm3130->regs[FM3130_ALARM_SECONDS] =
-                        BIN2BCD(tm->tm_sec) | 0x80;
+                        bin2bcd(tm->tm_sec) | 0x80;
 
         if (tm->tm_min != -1)
                 fm3130->regs[FM3130_ALARM_MINUTES] =
-                        BIN2BCD(tm->tm_min) | 0x80;
+                        bin2bcd(tm->tm_min) | 0x80;
 
         if (tm->tm_hour != -1)
                 fm3130->regs[FM3130_ALARM_HOURS] =
-                        BIN2BCD(tm->tm_hour) | 0x80;
+                        bin2bcd(tm->tm_hour) | 0x80;
 
         if (tm->tm_mday != -1)
                 fm3130->regs[FM3130_ALARM_DATE] =
-                        BIN2BCD(tm->tm_mday) | 0x80;
+                        bin2bcd(tm->tm_mday) | 0x80;
 
         if (tm->tm_mon != -1)
                 fm3130->regs[FM3130_ALARM_MONTHS] =
-                        BIN2BCD(tm->tm_mon + 1) | 0x80;
+                        bin2bcd(tm->tm_mon + 1) | 0x80;
 
         dev_dbg(dev, "alarm write %02x %02x %02x %02x %02x\n",
                         fm3130->regs[FM3130_ALARM_SECONDS],
@@ -414,18 +414,18 @@ static int __devinit fm3130_probe(struct i2c_client *client,
         /* TODO */
         /* TODO need to sanity check alarm */
         tmp = fm3130->regs[FM3130_RTC_SECONDS];
-        tmp = BCD2BIN(tmp & 0x7f);
+        tmp = bcd2bin(tmp & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
-        tmp = BCD2BIN(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
 
-        tmp = BCD2BIN(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
         if (tmp == 0 || tmp > 31)
                 goto exit_bad;
 
-        tmp = BCD2BIN(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
         if (tmp == 0 || tmp > 12)
                 goto exit_bad;
 
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index fbb90b1e4098..2cd77ab8fc66 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -259,26 +259,26 @@ isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
                 return sr;
         }
 
-        tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SC]);
-        tm->tm_min = BCD2BIN(regs[ISL1208_REG_MN]);
+        tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]);
+        tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]);
 
         /* HR field has a more complex interpretation */
         {
                 const u8 _hr = regs[ISL1208_REG_HR];
                 if (_hr & ISL1208_REG_HR_MIL)   /* 24h format */
-                        tm->tm_hour = BCD2BIN(_hr & 0x3f);
+                        tm->tm_hour = bcd2bin(_hr & 0x3f);
                 else {
                         /* 12h format */
-                        tm->tm_hour = BCD2BIN(_hr & 0x1f);
+                        tm->tm_hour = bcd2bin(_hr & 0x1f);
                         if (_hr & ISL1208_REG_HR_PM)    /* PM flag set */
                                 tm->tm_hour += 12;
                 }
         }
 
-        tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DT]);
-        tm->tm_mon = BCD2BIN(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
-        tm->tm_year = BCD2BIN(regs[ISL1208_REG_YR]) + 100;
-        tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DW]);
+        tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]);
+        tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
+        tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100;
+        tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]);
 
         return 0;
 }
@@ -305,13 +305,13 @@ isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
         }
 
         /* MSB of each alarm register is an enable bit */
-        tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
-        tm->tm_min = BCD2BIN(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
-        tm->tm_hour = BCD2BIN(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
-        tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
+        tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
+        tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
+        tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
+        tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
         tm->tm_mon =
-                BCD2BIN(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
-        tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
+                bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
+        tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
 
         return 0;
 }
@@ -328,15 +328,15 @@ isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
         int sr;
         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 
-        regs[ISL1208_REG_SC] = BIN2BCD(tm->tm_sec);
-        regs[ISL1208_REG_MN] = BIN2BCD(tm->tm_min);
-        regs[ISL1208_REG_HR] = BIN2BCD(tm->tm_hour) | ISL1208_REG_HR_MIL;
+        regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
+        regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
+        regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
 
-        regs[ISL1208_REG_DT] = BIN2BCD(tm->tm_mday);
-        regs[ISL1208_REG_MO] = BIN2BCD(tm->tm_mon + 1);
-        regs[ISL1208_REG_YR] = BIN2BCD(tm->tm_year - 100);
+        regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
+        regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
+        regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
 
-        regs[ISL1208_REG_DW] = BIN2BCD(tm->tm_wday & 7);
+        regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
 
         sr = isl1208_i2c_get_sr(client);
         if (sr < 0) {
@@ -482,7 +482,7 @@ isl1208_sysfs_register(struct device *dev)
 static int
 isl1208_sysfs_unregister(struct device *dev)
 {
-        device_remove_file(dev, &dev_attr_atrim);
+        device_remove_file(dev, &dev_attr_dtrim);
         device_remove_file(dev, &dev_attr_atrim);
         device_remove_file(dev, &dev_attr_usr);
 
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index 9f996ec881ce..dd70bf73ce9d 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -51,10 +51,11 @@ EXPORT_SYMBOL(rtc_year_days);
  */
 void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
 {
-        unsigned int days, month, year;
+        unsigned int month, year;
+        int days;
 
         days = time / 86400;
-        time -= days * 86400;
+        time -= (unsigned int) days * 86400;
 
         /* day of the week, 1970-01-01 was a Thursday */
         tm->tm_wday = (days + 4) % 7;
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index 0a19c06019be..893f7dece239 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -13,21 +13,21 @@
  *
  */
 
-#include <linux/module.h>
+#include <linux/bcd.h>
+#include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/rtc.h>
 #include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include <linux/string.h>
-#include <linux/i2c.h>
-#include <linux/rtc.h>
-#include <linux/bcd.h>
 #ifdef CONFIG_RTC_DRV_M41T80_WDT
-#include <linux/miscdevice.h>
-#include <linux/watchdog.h>
-#include <linux/reboot.h>
 #include <linux/fs.h>
 #include <linux/ioctl.h>
+#include <linux/miscdevice.h>
+#include <linux/reboot.h>
+#include <linux/watchdog.h>
 #endif
 
 #define M41T80_REG_SSEC 0
@@ -56,21 +56,27 @@
 #define M41T80_ALHOUR_HT        (1 << 6)        /* HT: Halt Update Bit */
 #define M41T80_FLAGS_AF         (1 << 6)        /* AF: Alarm Flag Bit */
 #define M41T80_FLAGS_BATT_LOW   (1 << 4)        /* BL: Battery Low Bit */
+#define M41T80_WATCHDOG_RB2     (1 << 7)        /* RB: Watchdog resolution */
+#define M41T80_WATCHDOG_RB1     (1 << 1)        /* RB: Watchdog resolution */
+#define M41T80_WATCHDOG_RB0     (1 << 0)        /* RB: Watchdog resolution */
 
-#define M41T80_FEATURE_HT       (1 << 0)
-#define M41T80_FEATURE_BL       (1 << 1)
+#define M41T80_FEATURE_HT       (1 << 0)        /* Halt feature */
+#define M41T80_FEATURE_BL       (1 << 1)        /* Battery low indicator */
+#define M41T80_FEATURE_SQ       (1 << 2)        /* Squarewave feature */
+#define M41T80_FEATURE_WD       (1 << 3)        /* Extra watchdog resolution */
 
 #define DRV_VERSION "0.05"
 
 static const struct i2c_device_id m41t80_id[] = {
-        { "m41t80", 0 },
-        { "m41t81", M41T80_FEATURE_HT },
-        { "m41t81s", M41T80_FEATURE_HT | M41T80_FEATURE_BL },
-        { "m41t82", M41T80_FEATURE_HT | M41T80_FEATURE_BL },
-        { "m41t83", M41T80_FEATURE_HT | M41T80_FEATURE_BL },
-        { "m41st84", M41T80_FEATURE_HT | M41T80_FEATURE_BL },
-        { "m41st85", M41T80_FEATURE_HT | M41T80_FEATURE_BL },
-        { "m41st87", M41T80_FEATURE_HT | M41T80_FEATURE_BL },
+        { "m41t65", M41T80_FEATURE_HT | M41T80_FEATURE_WD },
+        { "m41t80", M41T80_FEATURE_SQ },
+        { "m41t81", M41T80_FEATURE_HT | M41T80_FEATURE_SQ},
+        { "m41t81s", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
+        { "m41t82", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
+        { "m41t83", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
+        { "m41st84", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
+        { "m41st85", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
+        { "m41st87", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, m41t80_id);
@@ -104,15 +110,15 @@ static int m41t80_get_datetime(struct i2c_client *client,
                 return -EIO;
         }
 
-        tm->tm_sec = BCD2BIN(buf[M41T80_REG_SEC] & 0x7f);
-        tm->tm_min = BCD2BIN(buf[M41T80_REG_MIN] & 0x7f);
-        tm->tm_hour = BCD2BIN(buf[M41T80_REG_HOUR] & 0x3f);
-        tm->tm_mday = BCD2BIN(buf[M41T80_REG_DAY] & 0x3f);
+        tm->tm_sec = bcd2bin(buf[M41T80_REG_SEC] & 0x7f);
+        tm->tm_min = bcd2bin(buf[M41T80_REG_MIN] & 0x7f);
+        tm->tm_hour = bcd2bin(buf[M41T80_REG_HOUR] & 0x3f);
+        tm->tm_mday = bcd2bin(buf[M41T80_REG_DAY] & 0x3f);
         tm->tm_wday = buf[M41T80_REG_WDAY] & 0x07;
-        tm->tm_mon = BCD2BIN(buf[M41T80_REG_MON] & 0x1f) - 1;
+        tm->tm_mon = bcd2bin(buf[M41T80_REG_MON] & 0x1f) - 1;
 
         /* assume 20YY not 19YY, and ignore the Century Bit */
-        tm->tm_year = BCD2BIN(buf[M41T80_REG_YEAR]) + 100;
+        tm->tm_year = bcd2bin(buf[M41T80_REG_YEAR]) + 100;
         return 0;
 }
 
@@ -155,19 +161,19 @@ static int m41t80_set_datetime(struct i2c_client *client, struct rtc_time *tm)
         /* Merge time-data and register flags into buf[0..7] */
         buf[M41T80_REG_SSEC] = 0;
         buf[M41T80_REG_SEC] =
-                BIN2BCD(tm->tm_sec) | (buf[M41T80_REG_SEC] & ~0x7f);
+                bin2bcd(tm->tm_sec) | (buf[M41T80_REG_SEC] & ~0x7f);
         buf[M41T80_REG_MIN] =
-                BIN2BCD(tm->tm_min) | (buf[M41T80_REG_MIN] & ~0x7f);
+                bin2bcd(tm->tm_min) | (buf[M41T80_REG_MIN] & ~0x7f);
         buf[M41T80_REG_HOUR] =
-                BIN2BCD(tm->tm_hour) | (buf[M41T80_REG_HOUR] & ~0x3f) ;
+                bin2bcd(tm->tm_hour) | (buf[M41T80_REG_HOUR] & ~0x3f) ;
         buf[M41T80_REG_WDAY] =
                 (tm->tm_wday & 0x07) | (buf[M41T80_REG_WDAY] & ~0x07);
         buf[M41T80_REG_DAY] =
-                BIN2BCD(tm->tm_mday) | (buf[M41T80_REG_DAY] & ~0x3f);
+                bin2bcd(tm->tm_mday) | (buf[M41T80_REG_DAY] & ~0x3f);
         buf[M41T80_REG_MON] =
-                BIN2BCD(tm->tm_mon + 1) | (buf[M41T80_REG_MON] & ~0x1f);
+                bin2bcd(tm->tm_mon + 1) | (buf[M41T80_REG_MON] & ~0x1f);
         /* assume 20YY not 19YY */
-        buf[M41T80_REG_YEAR] = BIN2BCD(tm->tm_year % 100);
+        buf[M41T80_REG_YEAR] = bin2bcd(tm->tm_year % 100);
 
         if (i2c_transfer(client->adapter, msgs, 1) != 1) {
                 dev_err(&client->dev, "write error\n");
@@ -282,15 +288,15 @@ static int m41t80_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 
         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;
+                bin2bcd(t->time.tm_sec) : 0x80;
         reg[M41T80_REG_ALARM_MIN] |= t->time.tm_min >= 0 ?
-                BIN2BCD(t->time.tm_min) : 0x80;
+                bin2bcd(t->time.tm_min) : 0x80;
         reg[M41T80_REG_ALARM_HOUR] |= t->time.tm_hour >= 0 ?
-                BIN2BCD(t->time.tm_hour) : 0x80;
+                bin2bcd(t->time.tm_hour) : 0x80;
         reg[M41T80_REG_ALARM_DAY] |= t->time.tm_mday >= 0 ?
-                BIN2BCD(t->time.tm_mday) : 0x80;
+                bin2bcd(t->time.tm_mday) : 0x80;
         if (t->time.tm_mon >= 0)
-                reg[M41T80_REG_ALARM_MON] |= BIN2BCD(t->time.tm_mon + 1);
+                reg[M41T80_REG_ALARM_MON] |= bin2bcd(t->time.tm_mon + 1);
         else
                 reg[M41T80_REG_ALARM_DAY] |= 0x40;
 
@@ -341,15 +347,15 @@ static int m41t80_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *t)
         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);
+                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);
+                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);
+                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);
+                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_mon = bcd2bin(reg[M41T80_REG_ALARM_MON] & 0x1f) - 1;
         t->time.tm_year = -1;
         t->time.tm_wday = -1;
         t->time.tm_yday = -1;
@@ -386,8 +392,12 @@ static ssize_t m41t80_sysfs_show_sqwfreq(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
         struct i2c_client *client = to_i2c_client(dev);
+        struct m41t80_data *clientdata = i2c_get_clientdata(client);
         int val;
 
+        if (!(clientdata->features & M41T80_FEATURE_SQ))
+                return -EINVAL;
+
         val = i2c_smbus_read_byte_data(client, M41T80_REG_SQW);
         if (val < 0)
                 return -EIO;
@@ -408,9 +418,13 @@ static ssize_t m41t80_sysfs_set_sqwfreq(struct device *dev,
                                 const char *buf, size_t count)
 {
         struct i2c_client *client = to_i2c_client(dev);
+        struct m41t80_data *clientdata = i2c_get_clientdata(client);
         int almon, sqw;
         int val = simple_strtoul(buf, NULL, 0);
 
+        if (!(clientdata->features & M41T80_FEATURE_SQ))
+                return -EINVAL;
+
         if (val) {
                 if (!is_power_of_2(val))
                         return -EINVAL;
@@ -499,6 +513,8 @@ static void wdt_ping(void)
                         .buf    = i2c_data,
                 },
         };
+        struct m41t80_data *clientdata = i2c_get_clientdata(save_client);
+
         i2c_data[0] = 0x09;             /* watchdog register */
 
         if (wdt_margin > 31)
@@ -509,6 +525,13 @@ static void wdt_ping(void)
                  */
                 i2c_data[1] = wdt_margin<<2 | 0x82;
 
+        /*
+         * M41T65 has three bits for watchdog resolution.  Don't set bit 7, as
+         * that would be an invalid resolution.
+         */
+        if (clientdata->features & M41T80_FEATURE_WD)
+                i2c_data[1] &= ~M41T80_WATCHDOG_RB2;
+
         i2c_transfer(save_client->adapter, msgs1, 1);
 }
 
@@ -631,14 +654,12 @@ static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         return -EFAULT;
 
                 if (rv & WDIOS_DISABLECARD) {
-                        printk(KERN_INFO
-                               "rtc-m41t80: disable watchdog\n");
+                        pr_info("rtc-m41t80: disable watchdog\n");
                         wdt_disable();
                 }
 
                 if (rv & WDIOS_ENABLECARD) {
-                        printk(KERN_INFO
-                               "rtc-m41t80: enable watchdog\n");
+                        pr_info("rtc-m41t80: enable watchdog\n");
                         wdt_ping();
                 }
 
diff --git a/drivers/rtc/rtc-m41t94.c b/drivers/rtc/rtc-m41t94.c
new file mode 100644
index 000000000000..c3a18c58daf6
--- /dev/null
+++ b/drivers/rtc/rtc-m41t94.c
@@ -0,0 +1,173 @@
+/*
+ * Driver for ST M41T94 SPI RTC
+ *
+ * Copyright (C) 2008 Kim B. Heino
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/spi/spi.h>
+#include <linux/bcd.h>
+
+#define M41T94_REG_SECONDS      0x01
+#define M41T94_REG_MINUTES      0x02
+#define M41T94_REG_HOURS        0x03
+#define M41T94_REG_WDAY         0x04
+#define M41T94_REG_DAY          0x05
+#define M41T94_REG_MONTH        0x06
+#define M41T94_REG_YEAR         0x07
+#define M41T94_REG_HT           0x0c
+
+#define M41T94_BIT_HALT         0x40
+#define M41T94_BIT_STOP         0x80
+#define M41T94_BIT_CB           0x40
+#define M41T94_BIT_CEB          0x80
+
+static int m41t94_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        u8 buf[8]; /* write cmd + 7 registers */
+
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "write", tm->tm_sec, tm->tm_min,
+                tm->tm_hour, tm->tm_mday,
+                tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        buf[0] = 0x80 | M41T94_REG_SECONDS; /* write time + date */
+        buf[M41T94_REG_SECONDS] = bin2bcd(tm->tm_sec);
+        buf[M41T94_REG_MINUTES] = bin2bcd(tm->tm_min);
+        buf[M41T94_REG_HOURS]   = bin2bcd(tm->tm_hour);
+        buf[M41T94_REG_WDAY]    = bin2bcd(tm->tm_wday + 1);
+        buf[M41T94_REG_DAY]     = bin2bcd(tm->tm_mday);
+        buf[M41T94_REG_MONTH]   = bin2bcd(tm->tm_mon + 1);
+
+        buf[M41T94_REG_HOURS] |= M41T94_BIT_CEB;
+        if (tm->tm_year >= 100)
+                buf[M41T94_REG_HOURS] |= M41T94_BIT_CB;
+        buf[M41T94_REG_YEAR] = bin2bcd(tm->tm_year % 100);
+
+        return spi_write(spi, buf, 8);
+}
+
+static int m41t94_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        u8 buf[2];
+        int ret, hour;
+
+        /* clear halt update bit */
+        ret = spi_w8r8(spi, M41T94_REG_HT);
+        if (ret < 0)
+                return ret;
+        if (ret & M41T94_BIT_HALT) {
+                buf[0] = 0x80 | M41T94_REG_HT;
+                buf[1] = ret & ~M41T94_BIT_HALT;
+                spi_write(spi, buf, 2);
+        }
+
+        /* clear stop bit */
+        ret = spi_w8r8(spi, M41T94_REG_SECONDS);
+        if (ret < 0)
+                return ret;
+        if (ret & M41T94_BIT_STOP) {
+                buf[0] = 0x80 | M41T94_REG_SECONDS;
+                buf[1] = ret & ~M41T94_BIT_STOP;
+                spi_write(spi, buf, 2);
+        }
+
+        tm->tm_sec  = bcd2bin(spi_w8r8(spi, M41T94_REG_SECONDS));
+        tm->tm_min  = bcd2bin(spi_w8r8(spi, M41T94_REG_MINUTES));
+        hour = spi_w8r8(spi, M41T94_REG_HOURS);
+        tm->tm_hour = bcd2bin(hour & 0x3f);
+        tm->tm_wday = bcd2bin(spi_w8r8(spi, M41T94_REG_WDAY)) - 1;
+        tm->tm_mday = bcd2bin(spi_w8r8(spi, M41T94_REG_DAY));
+        tm->tm_mon  = bcd2bin(spi_w8r8(spi, M41T94_REG_MONTH)) - 1;
+        tm->tm_year = bcd2bin(spi_w8r8(spi, M41T94_REG_YEAR));
+        if ((hour & M41T94_BIT_CB) || !(hour & M41T94_BIT_CEB))
+                tm->tm_year += 100;
+
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "read", tm->tm_sec, tm->tm_min,
+                tm->tm_hour, tm->tm_mday,
+                tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* initial clock setting can be undefined */
+        return rtc_valid_tm(tm);
+}
+
+static const struct rtc_class_ops m41t94_rtc_ops = {
+        .read_time      = m41t94_read_time,
+        .set_time       = m41t94_set_time,
+};
+
+static struct spi_driver m41t94_driver;
+
+static int __devinit m41t94_probe(struct spi_device *spi)
+{
+        struct rtc_device *rtc;
+        int res;
+
+        spi->bits_per_word = 8;
+        spi_setup(spi);
+
+        res = spi_w8r8(spi, M41T94_REG_SECONDS);
+        if (res < 0) {
+                dev_err(&spi->dev, "not found.\n");
+                return res;
+        }
+
+        rtc = rtc_device_register(m41t94_driver.driver.name,
+                &spi->dev, &m41t94_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        dev_set_drvdata(&spi->dev, rtc);
+
+        return 0;
+}
+
+static int __devexit m41t94_remove(struct spi_device *spi)
+{
+        struct rtc_device *rtc = platform_get_drvdata(spi);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        return 0;
+}
+
+static struct spi_driver m41t94_driver = {
+        .driver = {
+                .name   = "rtc-m41t94",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe  = m41t94_probe,
+        .remove = __devexit_p(m41t94_remove),
+};
+
+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");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-m48t35.c b/drivers/rtc/rtc-m48t35.c
new file mode 100644
index 000000000000..0b2197559940
--- /dev/null
+++ b/drivers/rtc/rtc-m48t35.c
@@ -0,0 +1,235 @@
+/*
+ * Driver for the SGS-Thomson M48T35 Timekeeper RAM chip
+ *
+ * Copyright (C) 2000 Silicon Graphics, Inc.
+ * Written by Ulf Carlsson (ulfc@engr.sgi.com)
+ *
+ * Copyright (C) 2008 Thomas Bogendoerfer
+ *
+ * Based on code written by Paul Gortmaker.
+ *
+ * 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/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/bcd.h>
+#include <linux/io.h>
+
+#define DRV_VERSION             "1.0"
+
+struct m48t35_rtc {
+        u8      pad[0x7ff8];    /* starts at 0x7ff8 */
+        u8      control;
+        u8      sec;
+        u8      min;
+        u8      hour;
+        u8      day;
+        u8      date;
+        u8      month;
+        u8      year;
+};
+
+#define M48T35_RTC_SET          0x80
+#define M48T35_RTC_READ         0x40
+
+struct m48t35_priv {
+        struct rtc_device *rtc;
+        struct m48t35_rtc __iomem *reg;
+        size_t size;
+        unsigned long baseaddr;
+        spinlock_t lock;
+};
+
+static int m48t35_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct m48t35_priv *priv = dev_get_drvdata(dev);
+        u8 control;
+
+        /*
+         * Only the values that we read from the RTC are set. We leave
+         * tm_wday, tm_yday and tm_isdst untouched. Even though the
+         * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
+         * by the RTC when initially set to a non-zero value.
+         */
+        spin_lock_irq(&priv->lock);
+        control = readb(&priv->reg->control);
+        writeb(control | M48T35_RTC_READ, &priv->reg->control);
+        tm->tm_sec = readb(&priv->reg->sec);
+        tm->tm_min = readb(&priv->reg->min);
+        tm->tm_hour = readb(&priv->reg->hour);
+        tm->tm_mday = readb(&priv->reg->date);
+        tm->tm_mon = readb(&priv->reg->month);
+        tm->tm_year = readb(&priv->reg->year);
+        writeb(control, &priv->reg->control);
+        spin_unlock_irq(&priv->lock);
+
+        tm->tm_sec = bcd2bin(tm->tm_sec);
+        tm->tm_min = bcd2bin(tm->tm_min);
+        tm->tm_hour = bcd2bin(tm->tm_hour);
+        tm->tm_mday = bcd2bin(tm->tm_mday);
+        tm->tm_mon = bcd2bin(tm->tm_mon);
+        tm->tm_year = bcd2bin(tm->tm_year);
+
+        /*
+         * Account for differences between how the RTC uses the values
+         * and how they are defined in a struct rtc_time;
+         */
+        tm->tm_year += 70;
+        if (tm->tm_year <= 69)
+                tm->tm_year += 100;
+
+        tm->tm_mon--;
+        return rtc_valid_tm(tm);
+}
+
+static int m48t35_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct m48t35_priv *priv = dev_get_drvdata(dev);
+        unsigned char mon, day, hrs, min, sec;
+        unsigned int yrs;
+        u8 control;
+
+        yrs = tm->tm_year + 1900;
+        mon = tm->tm_mon + 1;   /* tm_mon starts at zero */
+        day = tm->tm_mday;
+        hrs = tm->tm_hour;
+        min = tm->tm_min;
+        sec = tm->tm_sec;
+
+        if (yrs < 1970)
+                return -EINVAL;
+
+        yrs -= 1970;
+        if (yrs > 255)    /* They are unsigned */
+                return -EINVAL;
+
+        if (yrs > 169)
+                return -EINVAL;
+
+        if (yrs >= 100)
+                yrs -= 100;
+
+        sec = bin2bcd(sec);
+        min = bin2bcd(min);
+        hrs = bin2bcd(hrs);
+        day = bin2bcd(day);
+        mon = bin2bcd(mon);
+        yrs = bin2bcd(yrs);
+
+        spin_lock_irq(&priv->lock);
+        control = readb(&priv->reg->control);
+        writeb(control | M48T35_RTC_SET, &priv->reg->control);
+        writeb(yrs, &priv->reg->year);
+        writeb(mon, &priv->reg->month);
+        writeb(day, &priv->reg->date);
+        writeb(hrs, &priv->reg->hour);
+        writeb(min, &priv->reg->min);
+        writeb(sec, &priv->reg->sec);
+        writeb(control, &priv->reg->control);
+        spin_unlock_irq(&priv->lock);
+        return 0;
+}
+
+static const struct rtc_class_ops m48t35_ops = {
+        .read_time      = m48t35_read_time,
+        .set_time       = m48t35_set_time,
+};
+
+static int __devinit m48t35_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        struct resource *res;
+        struct m48t35_priv *priv;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+        priv = kzalloc(sizeof(struct m48t35_priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->size = res->end - res->start + 1;
+        /*
+         * kludge: remove the #ifndef after ioc3 resource
+         * conflicts are resolved
+         */
+#ifndef CONFIG_SGI_IP27
+        if (!request_mem_region(res->start, priv->size, pdev->name)) {
+                ret = -EBUSY;
+                goto out;
+        }
+#endif
+        priv->baseaddr = res->start;
+        priv->reg = ioremap(priv->baseaddr, priv->size);
+        if (!priv->reg) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        spin_lock_init(&priv->lock);
+        rtc = rtc_device_register("m48t35", &pdev->dev,
+                                  &m48t35_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto out;
+        }
+        priv->rtc = rtc;
+        platform_set_drvdata(pdev, priv);
+        return 0;
+
+out:
+        if (priv->rtc)
+                rtc_device_unregister(priv->rtc);
+        if (priv->reg)
+                iounmap(priv->reg);
+        if (priv->baseaddr)
+                release_mem_region(priv->baseaddr, priv->size);
+        kfree(priv);
+        return ret;
+}
+
+static int __devexit m48t35_remove(struct platform_device *pdev)
+{
+        struct m48t35_priv *priv = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(priv->rtc);
+        iounmap(priv->reg);
+#ifndef CONFIG_SGI_IP27
+        release_mem_region(priv->baseaddr, priv->size);
+#endif
+        kfree(priv);
+        return 0;
+}
+
+static struct platform_driver m48t35_platform_driver = {
+        .driver         = {
+                .name   = "rtc-m48t35",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = m48t35_probe,
+        .remove         = __devexit_p(m48t35_remove),
+};
+
+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 013e6c103b9c..04b63dab6932 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -24,8 +24,9 @@
 #define NO_IRQ  (-1)
 #endif
 
-#define M48T59_READ(reg)        pdata->read_byte(dev, reg)
-#define M48T59_WRITE(val, reg)  pdata->write_byte(dev, reg, val)
+#define M48T59_READ(reg) (pdata->read_byte(dev, pdata->offset + reg))
+#define M48T59_WRITE(val, reg) \
+        (pdata->write_byte(dev, pdata->offset + reg, val))
 
 #define M48T59_SET_BITS(mask, reg)      \
         M48T59_WRITE((M48T59_READ(reg) | (mask)), (reg))
@@ -34,7 +35,6 @@
 
 struct m48t59_private {
         void __iomem *ioaddr;
-        unsigned int size; /* iomem size */
         int irq;
         struct rtc_device *rtc;
         spinlock_t lock; /* serialize the NVRAM and RTC access */
@@ -76,21 +76,22 @@ static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
         /* Issue the READ command */
         M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
 
-        tm->tm_year     = BCD2BIN(M48T59_READ(M48T59_YEAR));
+        tm->tm_year     = bcd2bin(M48T59_READ(M48T59_YEAR));
         /* tm_mon is 0-11 */
-        tm->tm_mon      = BCD2BIN(M48T59_READ(M48T59_MONTH)) - 1;
-        tm->tm_mday     = BCD2BIN(M48T59_READ(M48T59_MDAY));
+        tm->tm_mon      = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
+        tm->tm_mday     = bcd2bin(M48T59_READ(M48T59_MDAY));
 
         val = M48T59_READ(M48T59_WDAY);
-        if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB)) {
+        if ((pdata->type == M48T59RTC_TYPE_M48T59) &&
+            (val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB)) {
                 dev_dbg(dev, "Century bit is enabled\n");
                 tm->tm_year += 100;     /* one century */
         }
 
-        tm->tm_wday     = BCD2BIN(val & 0x07);
-        tm->tm_hour     = BCD2BIN(M48T59_READ(M48T59_HOUR) & 0x3F);
-        tm->tm_min      = BCD2BIN(M48T59_READ(M48T59_MIN) & 0x7F);
-        tm->tm_sec      = BCD2BIN(M48T59_READ(M48T59_SEC) & 0x7F);
+        tm->tm_wday     = bcd2bin(val & 0x07);
+        tm->tm_hour     = bcd2bin(M48T59_READ(M48T59_HOUR) & 0x3F);
+        tm->tm_min      = bcd2bin(M48T59_READ(M48T59_MIN) & 0x7F);
+        tm->tm_sec      = bcd2bin(M48T59_READ(M48T59_SEC) & 0x7F);
 
         /* Clear the READ bit */
         M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
@@ -118,17 +119,17 @@ static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm)
         /* Issue the WRITE command */
         M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
 
-        M48T59_WRITE((BIN2BCD(tm->tm_sec) & 0x7F), M48T59_SEC);
-        M48T59_WRITE((BIN2BCD(tm->tm_min) & 0x7F), M48T59_MIN);
-        M48T59_WRITE((BIN2BCD(tm->tm_hour) & 0x3F), M48T59_HOUR);
-        M48T59_WRITE((BIN2BCD(tm->tm_mday) & 0x3F), M48T59_MDAY);
+        M48T59_WRITE((bin2bcd(tm->tm_sec) & 0x7F), M48T59_SEC);
+        M48T59_WRITE((bin2bcd(tm->tm_min) & 0x7F), M48T59_MIN);
+        M48T59_WRITE((bin2bcd(tm->tm_hour) & 0x3F), M48T59_HOUR);
+        M48T59_WRITE((bin2bcd(tm->tm_mday) & 0x3F), M48T59_MDAY);
         /* tm_mon is 0-11 */
-        M48T59_WRITE((BIN2BCD(tm->tm_mon + 1) & 0x1F), M48T59_MONTH);
-        M48T59_WRITE(BIN2BCD(tm->tm_year % 100), M48T59_YEAR);
+        M48T59_WRITE((bin2bcd(tm->tm_mon + 1) & 0x1F), M48T59_MONTH);
+        M48T59_WRITE(bin2bcd(tm->tm_year % 100), M48T59_YEAR);
 
-        if (tm->tm_year/100)
+        if (pdata->type == M48T59RTC_TYPE_M48T59 && (tm->tm_year / 100))
                 val = (M48T59_WDAY_CEB | M48T59_WDAY_CB);
-        val |= (BIN2BCD(tm->tm_wday) & 0x07);
+        val |= (bin2bcd(tm->tm_wday) & 0x07);
         M48T59_WRITE(val, M48T59_WDAY);
 
         /* Clear the WRITE bit */
@@ -157,18 +158,18 @@ static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
         /* Issue the READ command */
         M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
 
-        tm->tm_year = BCD2BIN(M48T59_READ(M48T59_YEAR));
+        tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR));
         /* tm_mon is 0-11 */
-        tm->tm_mon = BCD2BIN(M48T59_READ(M48T59_MONTH)) - 1;
+        tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
 
         val = M48T59_READ(M48T59_WDAY);
         if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB))
                 tm->tm_year += 100;     /* one century */
 
-        tm->tm_mday = BCD2BIN(M48T59_READ(M48T59_ALARM_DATE));
-        tm->tm_hour = BCD2BIN(M48T59_READ(M48T59_ALARM_HOUR));
-        tm->tm_min = BCD2BIN(M48T59_READ(M48T59_ALARM_MIN));
-        tm->tm_sec = BCD2BIN(M48T59_READ(M48T59_ALARM_SEC));
+        tm->tm_mday = bcd2bin(M48T59_READ(M48T59_ALARM_DATE));
+        tm->tm_hour = bcd2bin(M48T59_READ(M48T59_ALARM_HOUR));
+        tm->tm_min = bcd2bin(M48T59_READ(M48T59_ALARM_MIN));
+        tm->tm_sec = bcd2bin(M48T59_READ(M48T59_ALARM_SEC));
 
         /* Clear the READ bit */
         M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
@@ -200,18 +201,18 @@ static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
          * 0xff means "always match"
          */
         mday = tm->tm_mday;
-        mday = (mday >= 1 && mday <= 31) ? BIN2BCD(mday) : 0xff;
+        mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
         if (mday == 0xff)
                 mday = M48T59_READ(M48T59_MDAY);
 
         hour = tm->tm_hour;
-        hour = (hour < 24) ? BIN2BCD(hour) : 0x00;
+        hour = (hour < 24) ? bin2bcd(hour) : 0x00;
 
         min = tm->tm_min;
-        min = (min < 60) ? BIN2BCD(min) : 0x00;
+        min = (min < 60) ? bin2bcd(min) : 0x00;
 
         sec = tm->tm_sec;
-        sec = (sec < 60) ? BIN2BCD(sec) : 0x00;
+        sec = (sec < 60) ? bin2bcd(sec) : 0x00;
 
         spin_lock_irqsave(&m48t59->lock, flags);
         /* Issue the WRITE command */
@@ -310,6 +311,11 @@ static const struct rtc_class_ops m48t59_rtc_ops = {
         .proc           = m48t59_rtc_proc,
 };
 
+static const struct rtc_class_ops m48t02_rtc_ops = {
+        .read_time      = m48t59_rtc_read_time,
+        .set_time       = m48t59_rtc_set_time,
+};
+
 static ssize_t m48t59_nvram_read(struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t pos, size_t size)
@@ -321,7 +327,7 @@ static ssize_t m48t59_nvram_read(struct kobject *kobj,
         ssize_t cnt = 0;
         unsigned long flags;
 
-        for (; size > 0 && pos < M48T59_NVRAM_SIZE; cnt++, size--) {
+        for (; size > 0 && pos < pdata->offset; cnt++, size--) {
                 spin_lock_irqsave(&m48t59->lock, flags);
                 *buf++ = M48T59_READ(cnt);
                 spin_unlock_irqrestore(&m48t59->lock, flags);
@@ -341,7 +347,7 @@ static ssize_t m48t59_nvram_write(struct kobject *kobj,
         ssize_t cnt = 0;
         unsigned long flags;
 
-        for (; size > 0 && pos < M48T59_NVRAM_SIZE; cnt++, size--) {
+        for (; size > 0 && pos < pdata->offset; cnt++, size--) {
                 spin_lock_irqsave(&m48t59->lock, flags);
                 M48T59_WRITE(*buf++, cnt);
                 spin_unlock_irqrestore(&m48t59->lock, flags);
@@ -354,11 +360,9 @@ static struct bin_attribute m48t59_nvram_attr = {
         .attr = {
                 .name = "nvram",
                 .mode = S_IRUGO | S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .read = m48t59_nvram_read,
         .write = m48t59_nvram_write,
-        .size = M48T59_NVRAM_SIZE,
 };
 
 static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
@@ -367,6 +371,8 @@ static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
         struct m48t59_private *m48t59 = NULL;
         struct resource *res;
         int ret = -ENOMEM;
+        char *name;
+        const struct rtc_class_ops *ops;
 
         /* This chip could be memory-mapped or I/O-mapped */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -391,6 +397,8 @@ static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
                         /* Ensure we only kmalloc platform data once */
                         pdev->dev.platform_data = pdata;
                 }
+                if (!pdata->type)
+                        pdata->type = M48T59RTC_TYPE_M48T59;
 
                 /* Try to use the generic memory read/write ops */
                 if (!pdata->write_byte)
@@ -403,10 +411,14 @@ static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
         if (!m48t59)
                 return -ENOMEM;
 
-        m48t59->size = res->end - res->start + 1;
-        m48t59->ioaddr = ioremap(res->start, m48t59->size);
-        if (!m48t59->ioaddr)
-                goto out;
+        m48t59->ioaddr = pdata->ioaddr;
+
+        if (!m48t59->ioaddr) {
+                /* ioaddr not mapped externally */
+                m48t59->ioaddr = ioremap(res->start, res->end - res->start + 1);
+                if (!m48t59->ioaddr)
+                        goto out;
+        }
 
         /* Try to get irq number. We also can work in
          * the mode without IRQ.
@@ -421,14 +433,36 @@ static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
                 if (ret)
                         goto out;
         }
+        switch (pdata->type) {
+        case M48T59RTC_TYPE_M48T59:
+                name = "m48t59";
+                ops = &m48t59_rtc_ops;
+                pdata->offset = 0x1ff0;
+                break;
+        case M48T59RTC_TYPE_M48T02:
+                name = "m48t02";
+                ops = &m48t02_rtc_ops;
+                pdata->offset = 0x7f0;
+                break;
+        case M48T59RTC_TYPE_M48T08:
+                name = "m48t08";
+                ops = &m48t02_rtc_ops;
+                pdata->offset = 0x1ff0;
+                break;
+        default:
+                dev_err(&pdev->dev, "Unknown RTC type\n");
+                ret = -ENODEV;
+                goto out;
+        }
 
-        m48t59->rtc = rtc_device_register("m48t59", &pdev->dev,
-                                &m48t59_rtc_ops, THIS_MODULE);
+        m48t59->rtc = rtc_device_register(name, &pdev->dev, ops, THIS_MODULE);
         if (IS_ERR(m48t59->rtc)) {
                 ret = PTR_ERR(m48t59->rtc);
                 goto out;
         }
 
+        m48t59_nvram_attr.size = pdata->offset;
+
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
         if (ret)
                 goto out;
@@ -452,11 +486,12 @@ out:
 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;
 
         sysfs_remove_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
         if (!IS_ERR(m48t59->rtc))
                 rtc_device_unregister(m48t59->rtc);
-        if (m48t59->ioaddr)
+        if (m48t59->ioaddr && !pdata->ioaddr)
                 iounmap(m48t59->ioaddr);
         if (m48t59->irq != NO_IRQ)
                 free_irq(m48t59->irq, &pdev->dev);
@@ -491,5 +526,5 @@ module_init(m48t59_rtc_init);
 module_exit(m48t59_rtc_exit);
 
 MODULE_AUTHOR("Mark Zhan <rongkai.zhan@windriver.com>");
-MODULE_DESCRIPTION("M48T59 RTC driver");
+MODULE_DESCRIPTION("M48T59/M48T02/M48T08 RTC driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
index 3f7f99a5d96a..7c045cffa9ff 100644
--- a/drivers/rtc/rtc-m48t86.c
+++ b/drivers/rtc/rtc-m48t86.c
@@ -62,14 +62,14 @@ static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 tm->tm_wday     = ops->readbyte(M48T86_REG_DOW);
         } else {
                 /* bcd mode */
-                tm->tm_sec      = BCD2BIN(ops->readbyte(M48T86_REG_SEC));
-                tm->tm_min      = BCD2BIN(ops->readbyte(M48T86_REG_MIN));
-                tm->tm_hour     = BCD2BIN(ops->readbyte(M48T86_REG_HOUR) & 0x3F);
-                tm->tm_mday     = BCD2BIN(ops->readbyte(M48T86_REG_DOM));
+                tm->tm_sec      = bcd2bin(ops->readbyte(M48T86_REG_SEC));
+                tm->tm_min      = bcd2bin(ops->readbyte(M48T86_REG_MIN));
+                tm->tm_hour     = bcd2bin(ops->readbyte(M48T86_REG_HOUR) & 0x3F);
+                tm->tm_mday     = bcd2bin(ops->readbyte(M48T86_REG_DOM));
                 /* tm_mon is 0-11 */
-                tm->tm_mon      = BCD2BIN(ops->readbyte(M48T86_REG_MONTH)) - 1;
-                tm->tm_year     = BCD2BIN(ops->readbyte(M48T86_REG_YEAR)) + 100;
-                tm->tm_wday     = BCD2BIN(ops->readbyte(M48T86_REG_DOW));
+                tm->tm_mon      = bcd2bin(ops->readbyte(M48T86_REG_MONTH)) - 1;
+                tm->tm_year     = bcd2bin(ops->readbyte(M48T86_REG_YEAR)) + 100;
+                tm->tm_wday     = bcd2bin(ops->readbyte(M48T86_REG_DOW));
         }
 
         /* correct the hour if the clock is in 12h mode */
@@ -103,13 +103,13 @@ static int m48t86_rtc_set_time(struct device *dev, struct rtc_time *tm)
                 ops->writebyte(tm->tm_wday, M48T86_REG_DOW);
         } else {
                 /* bcd mode */
-                ops->writebyte(BIN2BCD(tm->tm_sec), M48T86_REG_SEC);
-                ops->writebyte(BIN2BCD(tm->tm_min), M48T86_REG_MIN);
-                ops->writebyte(BIN2BCD(tm->tm_hour), M48T86_REG_HOUR);
-                ops->writebyte(BIN2BCD(tm->tm_mday), M48T86_REG_DOM);
-                ops->writebyte(BIN2BCD(tm->tm_mon + 1), M48T86_REG_MONTH);
-                ops->writebyte(BIN2BCD(tm->tm_year % 100), M48T86_REG_YEAR);
-                ops->writebyte(BIN2BCD(tm->tm_wday), M48T86_REG_DOW);
+                ops->writebyte(bin2bcd(tm->tm_sec), M48T86_REG_SEC);
+                ops->writebyte(bin2bcd(tm->tm_min), M48T86_REG_MIN);
+                ops->writebyte(bin2bcd(tm->tm_hour), M48T86_REG_HOUR);
+                ops->writebyte(bin2bcd(tm->tm_mday), M48T86_REG_DOM);
+                ops->writebyte(bin2bcd(tm->tm_mon + 1), M48T86_REG_MONTH);
+                ops->writebyte(bin2bcd(tm->tm_year % 100), M48T86_REG_YEAR);
+                ops->writebyte(bin2bcd(tm->tm_wday), M48T86_REG_DOW);
         }
 
         /* update ended */
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index ded3c0abad83..80782798763f 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -17,19 +17,18 @@
 #include <linux/rtc.h>
 #include <linux/delay.h>
 
-#define DRV_NAME "max6900"
-#define DRV_VERSION "0.1"
+#define DRV_VERSION "0.2"
 
 /*
  * register indices
  */
-#define MAX6900_REG_SC                  0       /* seconds      00-59 */
-#define MAX6900_REG_MN                  1       /* minutes      00-59 */
-#define MAX6900_REG_HR                  2       /* hours        00-23 */
-#define MAX6900_REG_DT                  3       /* day of month 00-31 */
-#define MAX6900_REG_MO                  4       /* month        01-12 */
-#define MAX6900_REG_DW                  5       /* day of week   1-7  */
-#define MAX6900_REG_YR                  6       /* year         00-99 */
+#define MAX6900_REG_SC                  0       /* seconds      00-59 */
+#define MAX6900_REG_MN                  1       /* minutes      00-59 */
+#define MAX6900_REG_HR                  2       /* hours        00-23 */
+#define MAX6900_REG_DT                  3       /* day of month 00-31 */
+#define MAX6900_REG_MO                  4       /* month        01-12 */
+#define MAX6900_REG_DW                  5       /* day of week   1-7  */
+#define MAX6900_REG_YR                  6       /* year         00-99 */
 #define MAX6900_REG_CT                  7       /* control */
                                                 /* register 8 is undocumented */
 #define MAX6900_REG_CENTURY             9       /* century */
@@ -39,7 +38,6 @@
 
 #define MAX6900_REG_CT_WP               (1 << 7)        /* Write Protect */
 
-
 /*
  * register read/write commands
  */
@@ -52,16 +50,7 @@
 
 #define MAX6900_IDLE_TIME_AFTER_WRITE   3       /* specification says 2.5 mS */
 
-#define MAX6900_I2C_ADDR                0xa0
-
-static const unsigned short normal_i2c[] = {
-        MAX6900_I2C_ADDR >> 1,
-        I2C_CLIENT_END
-};
-
-I2C_CLIENT_INSMOD;                      /* defines addr_data */
-
-static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind);
+static struct i2c_driver max6900_driver;
 
 static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
 {
@@ -69,36 +58,35 @@ static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
         u8 reg_century_read[1] = { MAX6900_REG_CENTURY_READ };
         struct i2c_msg msgs[4] = {
                 {
-                        .addr   = client->addr,
-                        .flags  = 0, /* write */
-                        .len    = sizeof(reg_burst_read),
-                        .buf    = reg_burst_read
-                },
+                 .addr = client->addr,
+                 .flags = 0,    /* write */
+                 .len = sizeof(reg_burst_read),
+                 .buf = reg_burst_read}
+                ,
                 {
-                        .addr   = client->addr,
-                        .flags  = I2C_M_RD,
-                        .len    = MAX6900_BURST_LEN,
-                        .buf    = buf
-                },
+                 .addr = client->addr,
+                 .flags = I2C_M_RD,
+                 .len = MAX6900_BURST_LEN,
+                 .buf = buf}
+                ,
                 {
-                        .addr   = client->addr,
-                        .flags  = 0, /* write */
-                        .len    = sizeof(reg_century_read),
-                        .buf    = reg_century_read
-                },
+                 .addr = client->addr,
+                 .flags = 0,    /* write */
+                 .len = sizeof(reg_century_read),
+                 .buf = reg_century_read}
+                ,
                 {
-                        .addr   = client->addr,
-                        .flags  = I2C_M_RD,
-                        .len    = sizeof(buf[MAX6900_REG_CENTURY]),
-                        .buf    = &buf[MAX6900_REG_CENTURY]
-                }
+                 .addr = client->addr,
+                 .flags = I2C_M_RD,
+                 .len = sizeof(buf[MAX6900_REG_CENTURY]),
+                 .buf = &buf[MAX6900_REG_CENTURY]
+                 }
         };
         int rc;
 
         rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
         if (rc != ARRAY_SIZE(msgs)) {
-                dev_err(&client->dev, "%s: register read failed\n",
-                        __func__);
+                dev_err(&client->dev, "%s: register read failed\n", __func__);
                 return -EIO;
         }
         return 0;
@@ -109,20 +97,18 @@ static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
         u8 i2c_century_buf[1 + 1] = { MAX6900_REG_CENTURY_WRITE };
         struct i2c_msg century_msgs[1] = {
                 {
-                        .addr   = client->addr,
-                        .flags  = 0, /* write */
-                        .len    = sizeof(i2c_century_buf),
-                        .buf    = i2c_century_buf
-                }
+                 .addr = client->addr,
+                 .flags = 0,    /* write */
+                 .len = sizeof(i2c_century_buf),
+                 .buf = i2c_century_buf}
         };
         u8 i2c_burst_buf[MAX6900_BURST_LEN + 1] = { MAX6900_REG_BURST_WRITE };
         struct i2c_msg burst_msgs[1] = {
                 {
-                        .addr   = client->addr,
-                        .flags  = 0, /* write */
-                        .len    = sizeof(i2c_burst_buf),
-                        .buf    = i2c_burst_buf
-                }
+                 .addr = client->addr,
+                 .flags = 0,    /* write */
+                 .len = sizeof(i2c_burst_buf),
+                 .buf = i2c_burst_buf}
         };
         int rc;
 
@@ -133,10 +119,12 @@ static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
          * bit as part of the burst write.
          */
         i2c_century_buf[1] = buf[MAX6900_REG_CENTURY];
+
         rc = i2c_transfer(client->adapter, century_msgs,
                           ARRAY_SIZE(century_msgs));
         if (rc != ARRAY_SIZE(century_msgs))
                 goto write_failed;
+
         msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
 
         memcpy(&i2c_burst_buf[1], buf, MAX6900_BURST_LEN);
@@ -148,45 +136,11 @@ static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
 
         return 0;
 
-write_failed:
-        dev_err(&client->dev, "%s: register write failed\n",
-                __func__);
+ write_failed:
+        dev_err(&client->dev, "%s: register write failed\n", __func__);
         return -EIO;
 }
 
-static int max6900_i2c_validate_client(struct i2c_client *client)
-{
-        u8 regs[MAX6900_REG_LEN];
-        u8 zero_mask[] = {
-                0x80,   /* seconds */
-                0x80,   /* minutes */
-                0x40,   /* hours */
-                0xc0,   /* day of month */
-                0xe0,   /* month */
-                0xf8,   /* day of week */
-                0x00,   /* year */
-                0x7f,   /* control */
-        };
-        int i;
-        int rc;
-        int reserved;
-
-        reserved = i2c_smbus_read_byte_data(client, MAX6900_REG_RESERVED_READ);
-        if (reserved != 0x07)
-                return -ENODEV;
-
-        rc = max6900_i2c_read_regs(client, regs);
-        if (rc < 0)
-                return rc;
-
-        for (i = 0; i < ARRAY_SIZE(zero_mask); ++i) {
-                if (regs[i] & zero_mask[i])
-                        return -ENODEV;
-        }
-
-        return 0;
-}
-
 static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 {
         int rc;
@@ -196,14 +150,14 @@ static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
         if (rc < 0)
                 return rc;
 
-        tm->tm_sec = BCD2BIN(regs[MAX6900_REG_SC]);
-        tm->tm_min = BCD2BIN(regs[MAX6900_REG_MN]);
-        tm->tm_hour = BCD2BIN(regs[MAX6900_REG_HR] & 0x3f);
-        tm->tm_mday = BCD2BIN(regs[MAX6900_REG_DT]);
-        tm->tm_mon = BCD2BIN(regs[MAX6900_REG_MO]) - 1;
-        tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) +
-                      BCD2BIN(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
-        tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);
+        tm->tm_sec = bcd2bin(regs[MAX6900_REG_SC]);
+        tm->tm_min = bcd2bin(regs[MAX6900_REG_MN]);
+        tm->tm_hour = bcd2bin(regs[MAX6900_REG_HR] & 0x3f);
+        tm->tm_mday = bcd2bin(regs[MAX6900_REG_DT]);
+        tm->tm_mon = bcd2bin(regs[MAX6900_REG_MO]) - 1;
+        tm->tm_year = bcd2bin(regs[MAX6900_REG_YR]) +
+                      bcd2bin(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
+        tm->tm_wday = bcd2bin(regs[MAX6900_REG_DW]);
 
         return 0;
 }
@@ -211,7 +165,7 @@ static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 static int max6900_i2c_clear_write_protect(struct i2c_client *client)
 {
         int rc;
-        rc = i2c_smbus_write_byte_data (client, MAX6900_REG_CONTROL_WRITE, 0);
+        rc = i2c_smbus_write_byte_data(client, MAX6900_REG_CONTROL_WRITE, 0);
         if (rc < 0) {
                 dev_err(&client->dev, "%s: control register write failed\n",
                         __func__);
@@ -220,8 +174,8 @@ static int max6900_i2c_clear_write_protect(struct i2c_client *client)
         return 0;
 }
 
-static int max6900_i2c_set_time(struct i2c_client *client,
-                                struct rtc_time const *tm)
+static int
+max6900_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
 {
         u8 regs[MAX6900_REG_LEN];
         int rc;
@@ -230,14 +184,14 @@ static int max6900_i2c_set_time(struct i2c_client *client,
         if (rc < 0)
                 return rc;
 
-        regs[MAX6900_REG_SC] = BIN2BCD(tm->tm_sec);
-        regs[MAX6900_REG_MN] = BIN2BCD(tm->tm_min);
-        regs[MAX6900_REG_HR] = BIN2BCD(tm->tm_hour);
-        regs[MAX6900_REG_DT] = BIN2BCD(tm->tm_mday);
-        regs[MAX6900_REG_MO] = BIN2BCD(tm->tm_mon + 1);
-        regs[MAX6900_REG_DW] = BIN2BCD(tm->tm_wday);
-        regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year % 100);
-        regs[MAX6900_REG_CENTURY] = BIN2BCD((tm->tm_year + 1900) / 100);
+        regs[MAX6900_REG_SC] = bin2bcd(tm->tm_sec);
+        regs[MAX6900_REG_MN] = bin2bcd(tm->tm_min);
+        regs[MAX6900_REG_HR] = bin2bcd(tm->tm_hour);
+        regs[MAX6900_REG_DT] = bin2bcd(tm->tm_mday);
+        regs[MAX6900_REG_MO] = bin2bcd(tm->tm_mon + 1);
+        regs[MAX6900_REG_DW] = bin2bcd(tm->tm_wday);
+        regs[MAX6900_REG_YR] = bin2bcd(tm->tm_year % 100);
+        regs[MAX6900_REG_CENTURY] = bin2bcd((tm->tm_year + 1900) / 100);
         /* set write protect */
         regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;
 
@@ -258,89 +212,49 @@ static int max6900_rtc_set_time(struct device *dev, struct rtc_time *tm)
         return max6900_i2c_set_time(to_i2c_client(dev), tm);
 }
 
-static int max6900_attach_adapter(struct i2c_adapter *adapter)
-{
-        return i2c_probe(adapter, &addr_data, max6900_probe);
-}
-
-static int max6900_detach_client(struct i2c_client *client)
+static int max6900_remove(struct i2c_client *client)
 {
-        struct rtc_device *const rtc = i2c_get_clientdata(client);
+        struct rtc_device *rtc = i2c_get_clientdata(client);
 
         if (rtc)
                 rtc_device_unregister(rtc);
 
-        return i2c_detach_client(client);
+        return 0;
 }
 
-static struct i2c_driver max6900_driver = {
-        .driver         = {
-                .name   = DRV_NAME,
-        },
-        .id             = I2C_DRIVERID_MAX6900,
-        .attach_adapter = max6900_attach_adapter,
-        .detach_client  = max6900_detach_client,
-};
-
 static const struct rtc_class_ops max6900_rtc_ops = {
-        .read_time      = max6900_rtc_read_time,
-        .set_time       = max6900_rtc_set_time,
+        .read_time = max6900_rtc_read_time,
+        .set_time = max6900_rtc_set_time,
 };
 
-static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind)
+static int
+max6900_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
-        int rc = 0;
-        struct i2c_client *client = NULL;
-        struct rtc_device *rtc = NULL;
-
-        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
-                rc = -ENODEV;
-                goto failout;
-        }
-
-        client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
-        if (client == NULL) {
-                rc = -ENOMEM;
-                goto failout;
-        }
-
-        client->addr = addr;
-        client->adapter = adapter;
-        client->driver = &max6900_driver;
-        strlcpy(client->name, DRV_NAME, I2C_NAME_SIZE);
-
-        if (kind < 0) {
-                rc = max6900_i2c_validate_client(client);
-                if (rc < 0)
-                        goto failout;
-        }
+        struct rtc_device *rtc;
 
-        rc = i2c_attach_client(client);
-        if (rc < 0)
-                goto failout;
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+                return -ENODEV;
 
-        dev_info(&client->dev,
-                 "chip found, driver version " DRV_VERSION "\n");
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
 
         rtc = rtc_device_register(max6900_driver.driver.name,
-                                  &client->dev,
-                                  &max6900_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                rc = PTR_ERR(rtc);
-                goto failout_detach;
-        }
+                                  &client->dev, &max6900_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
 
         i2c_set_clientdata(client, rtc);
 
         return 0;
-
-failout_detach:
-        i2c_detach_client(client);
-failout:
-        kfree(client);
-        return rc;
 }
 
+static struct i2c_driver max6900_driver = {
+        .driver = {
+                   .name = "rtc-max6900",
+                   },
+        .probe = max6900_probe,
+        .remove = max6900_remove,
+};
+
 static int __init max6900_init(void)
 {
         return i2c_add_driver(&max6900_driver);
@@ -352,6 +266,7 @@ static void __exit max6900_exit(void)
 }
 
 MODULE_DESCRIPTION("Maxim MAX6900 RTC driver");
+MODULE_AUTHOR("Dale Farnsworth <dale@farnsworth.org>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index 12f0310ae89c..2f6507df7b49 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -20,8 +20,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/version.h>
-
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/init.h>
@@ -126,15 +124,15 @@ static int max6902_get_datetime(struct device *dev, struct rtc_time *dt)
 
         /* The chip sends data in this order:
          * Seconds, Minutes, Hours, Date, Month, Day, Year */
-        dt->tm_sec      = BCD2BIN(chip->buf[1]);
-        dt->tm_min      = BCD2BIN(chip->buf[2]);
-        dt->tm_hour     = BCD2BIN(chip->buf[3]);
-        dt->tm_mday     = BCD2BIN(chip->buf[4]);
-        dt->tm_mon      = BCD2BIN(chip->buf[5]) - 1;
-        dt->tm_wday     = BCD2BIN(chip->buf[6]);
-        dt->tm_year = BCD2BIN(chip->buf[7]);
+        dt->tm_sec      = bcd2bin(chip->buf[1]);
+        dt->tm_min      = bcd2bin(chip->buf[2]);
+        dt->tm_hour     = bcd2bin(chip->buf[3]);
+        dt->tm_mday     = bcd2bin(chip->buf[4]);
+        dt->tm_mon      = bcd2bin(chip->buf[5]) - 1;
+        dt->tm_wday     = bcd2bin(chip->buf[6]);
+        dt->tm_year = bcd2bin(chip->buf[7]);
 
-        century = BCD2BIN(tmp) * 100;
+        century = bcd2bin(tmp) * 100;
 
         dt->tm_year += century;
         dt->tm_year -= 1900;
@@ -170,15 +168,15 @@ static int max6902_set_datetime(struct device *dev, struct rtc_time *dt)
         /* Remove write protection */
         max6902_set_reg(dev, 0xF, 0);
 
-        max6902_set_reg(dev, 0x01, BIN2BCD(dt->tm_sec));
-        max6902_set_reg(dev, 0x03, BIN2BCD(dt->tm_min));
-        max6902_set_reg(dev, 0x05, BIN2BCD(dt->tm_hour));
+        max6902_set_reg(dev, 0x01, bin2bcd(dt->tm_sec));
+        max6902_set_reg(dev, 0x03, bin2bcd(dt->tm_min));
+        max6902_set_reg(dev, 0x05, bin2bcd(dt->tm_hour));
 
-        max6902_set_reg(dev, 0x07, BIN2BCD(dt->tm_mday));
-        max6902_set_reg(dev, 0x09, BIN2BCD(dt->tm_mon+1));
-        max6902_set_reg(dev, 0x0B, BIN2BCD(dt->tm_wday));
-        max6902_set_reg(dev, 0x0D, BIN2BCD(dt->tm_year%100));
-        max6902_set_reg(dev, 0x13, BIN2BCD(dt->tm_year/100));
+        max6902_set_reg(dev, 0x07, bin2bcd(dt->tm_mday));
+        max6902_set_reg(dev, 0x09, bin2bcd(dt->tm_mon+1));
+        max6902_set_reg(dev, 0x0B, bin2bcd(dt->tm_wday));
+        max6902_set_reg(dev, 0x0D, bin2bcd(dt->tm_year%100));
+        max6902_set_reg(dev, 0x13, bin2bcd(dt->tm_year/100));
 
         /* Compulab used a delay here. However, the datasheet
          * does not mention a delay being required anywhere... */
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index eb23d8423f42..2cbeb0794f14 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -92,18 +92,6 @@
 #define rtc_write(val, addr)    omap_writeb(val, OMAP_RTC_BASE + (addr))
 
 
-/* platform_bus isn't hotpluggable, so for static linkage it'd be safe
- * to get rid of probe() and remove() code ... too bad the driver struct
- * remembers probe(), that's about 25% of the runtime footprint!!
- */
-#ifndef MODULE
-#undef  __devexit
-#undef  __devexit_p
-#define __devexit       __exit
-#define __devexit_p     __exit_p
-#endif
-
-
 /* we rely on the rtc framework to handle locking (rtc->ops_lock),
  * so the only other requirement is that register accesses which
  * require BUSY to be clear are made with IRQs locally disabled
@@ -198,30 +186,30 @@ static int tm2bcd(struct rtc_time *tm)
         if (rtc_valid_tm(tm) != 0)
                 return -EINVAL;
 
-        tm->tm_sec = BIN2BCD(tm->tm_sec);
-        tm->tm_min = BIN2BCD(tm->tm_min);
-        tm->tm_hour = BIN2BCD(tm->tm_hour);
-        tm->tm_mday = BIN2BCD(tm->tm_mday);
+        tm->tm_sec = bin2bcd(tm->tm_sec);
+        tm->tm_min = bin2bcd(tm->tm_min);
+        tm->tm_hour = bin2bcd(tm->tm_hour);
+        tm->tm_mday = bin2bcd(tm->tm_mday);
 
-        tm->tm_mon = BIN2BCD(tm->tm_mon + 1);
+        tm->tm_mon = bin2bcd(tm->tm_mon + 1);
 
         /* epoch == 1900 */
         if (tm->tm_year < 100 || tm->tm_year > 199)
                 return -EINVAL;
-        tm->tm_year = BIN2BCD(tm->tm_year - 100);
+        tm->tm_year = bin2bcd(tm->tm_year - 100);
 
         return 0;
 }
 
 static void bcd2tm(struct rtc_time *tm)
 {
-        tm->tm_sec = BCD2BIN(tm->tm_sec);
-        tm->tm_min = BCD2BIN(tm->tm_min);
-        tm->tm_hour = BCD2BIN(tm->tm_hour);
-        tm->tm_mday = BCD2BIN(tm->tm_mday);
-        tm->tm_mon = BCD2BIN(tm->tm_mon) - 1;
+        tm->tm_sec = bcd2bin(tm->tm_sec);
+        tm->tm_min = bcd2bin(tm->tm_min);
+        tm->tm_hour = bcd2bin(tm->tm_hour);
+        tm->tm_mday = bcd2bin(tm->tm_mday);
+        tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
         /* epoch == 1900 */
-        tm->tm_year = BCD2BIN(tm->tm_year) + 100;
+        tm->tm_year = bcd2bin(tm->tm_year) + 100;
 }
 
 
@@ -324,7 +312,7 @@ static struct rtc_class_ops omap_rtc_ops = {
 static int omap_rtc_alarm;
 static int omap_rtc_timer;
 
-static int __devinit omap_rtc_probe(struct platform_device *pdev)
+static int __init omap_rtc_probe(struct platform_device *pdev)
 {
         struct resource         *res, *mem;
         struct rtc_device       *rtc;
@@ -440,7 +428,7 @@ fail:
         return -EIO;
 }
 
-static int __devexit omap_rtc_remove(struct platform_device *pdev)
+static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device       *rtc = platform_get_drvdata(pdev);;
 
@@ -498,8 +486,7 @@ static void omap_rtc_shutdown(struct platform_device *pdev)
 
 MODULE_ALIAS("platform:omap_rtc");
 static struct platform_driver omap_rtc_driver = {
-        .probe          = omap_rtc_probe,
-        .remove         = __devexit_p(omap_rtc_remove),
+        .remove         = __exit_p(omap_rtc_remove),
         .suspend        = omap_rtc_suspend,
         .resume         = omap_rtc_resume,
         .shutdown       = omap_rtc_shutdown,
@@ -511,7 +498,7 @@ static struct platform_driver omap_rtc_driver = {
 
 static int __init rtc_init(void)
 {
-        return platform_driver_register(&omap_rtc_driver);
+        return platform_driver_probe(&omap_rtc_driver, omap_rtc_probe);
 }
 module_init(rtc_init);
 
diff --git a/drivers/rtc/rtc-parisc.c b/drivers/rtc/rtc-parisc.c
new file mode 100644
index 000000000000..346d633655e7
--- /dev/null
+++ b/drivers/rtc/rtc-parisc.c
@@ -0,0 +1,111 @@
+/* rtc-parisc: RTC for HP PA-RISC firmware
+ *
+ * Copyright (C) 2008 Kyle McMartin <kyle@mcmartin.ca>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/time.h>
+#include <linux/platform_device.h>
+
+#include <asm/rtc.h>
+
+/* as simple as can be, and no simpler. */
+struct parisc_rtc {
+        struct rtc_device *rtc;
+        spinlock_t lock;
+};
+
+static int parisc_get_time(struct device *dev, struct rtc_time *tm)
+{
+        struct parisc_rtc *p = dev_get_drvdata(dev);
+        unsigned long flags, ret;
+
+        spin_lock_irqsave(&p->lock, flags);
+        ret = get_rtc_time(tm);
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        if (ret & RTC_BATT_BAD)
+                return -EOPNOTSUPP;
+
+        return 0;
+}
+
+static int parisc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct parisc_rtc *p = dev_get_drvdata(dev);
+        unsigned long flags, ret;
+
+        spin_lock_irqsave(&p->lock, flags);
+        ret = set_rtc_time(tm);
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        if (ret < 0)
+                return -EOPNOTSUPP;
+
+        return 0;
+}
+
+static const struct rtc_class_ops parisc_rtc_ops = {
+        .read_time = parisc_get_time,
+        .set_time = parisc_set_time,
+};
+
+static int __devinit parisc_rtc_probe(struct platform_device *dev)
+{
+        struct parisc_rtc *p;
+
+        p = kzalloc(sizeof (*p), GFP_KERNEL);
+        if (!p)
+                return -ENOMEM;
+
+        spin_lock_init(&p->lock);
+
+        p->rtc = rtc_device_register("rtc-parisc", &dev->dev, &parisc_rtc_ops,
+                                        THIS_MODULE);
+        if (IS_ERR(p->rtc)) {
+                int err = PTR_ERR(p->rtc);
+                kfree(p);
+                return err;
+        }
+
+        platform_set_drvdata(dev, p);
+
+        return 0;
+}
+
+static int __devexit parisc_rtc_remove(struct platform_device *dev)
+{
+        struct parisc_rtc *p = platform_get_drvdata(dev);
+
+        rtc_device_unregister(p->rtc);
+        kfree(p);
+
+        return 0;
+}
+
+static struct platform_driver parisc_rtc_driver = {
+        .driver = {
+                .name = "rtc-parisc",
+                .owner = THIS_MODULE,
+        },
+        .probe = parisc_rtc_probe,
+        .remove = __devexit_p(parisc_rtc_remove),
+};
+
+static int __init parisc_rtc_init(void)
+{
+        return platform_driver_register(&parisc_rtc_driver);
+}
+
+static void __exit parisc_rtc_fini(void)
+{
+        platform_driver_unregister(&parisc_rtc_driver);
+}
+
+module_init(parisc_rtc_init);
+module_exit(parisc_rtc_fini);
+
+MODULE_AUTHOR("Kyle McMartin <kyle@mcmartin.ca>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("HP PA-RISC RTC driver");
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index 748a502a6355..b725913ccbe8 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -97,13 +97,13 @@ static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
                 buf[8]);
 
 
-        tm->tm_sec = BCD2BIN(buf[PCF8563_REG_SC] & 0x7F);
-        tm->tm_min = BCD2BIN(buf[PCF8563_REG_MN] & 0x7F);
-        tm->tm_hour = BCD2BIN(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
-        tm->tm_mday = BCD2BIN(buf[PCF8563_REG_DM] & 0x3F);
+        tm->tm_sec = bcd2bin(buf[PCF8563_REG_SC] & 0x7F);
+        tm->tm_min = bcd2bin(buf[PCF8563_REG_MN] & 0x7F);
+        tm->tm_hour = bcd2bin(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
+        tm->tm_mday = bcd2bin(buf[PCF8563_REG_DM] & 0x3F);
         tm->tm_wday = buf[PCF8563_REG_DW] & 0x07;
-        tm->tm_mon = BCD2BIN(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
-        tm->tm_year = BCD2BIN(buf[PCF8563_REG_YR]);
+        tm->tm_mon = bcd2bin(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
+        tm->tm_year = bcd2bin(buf[PCF8563_REG_YR]);
         if (tm->tm_year < 70)
                 tm->tm_year += 100;     /* assume we are in 1970...2069 */
         /* detect the polarity heuristically. see note above. */
@@ -138,17 +138,17 @@ static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
         /* hours, minutes and seconds */
-        buf[PCF8563_REG_SC] = BIN2BCD(tm->tm_sec);
-        buf[PCF8563_REG_MN] = BIN2BCD(tm->tm_min);
-        buf[PCF8563_REG_HR] = BIN2BCD(tm->tm_hour);
+        buf[PCF8563_REG_SC] = bin2bcd(tm->tm_sec);
+        buf[PCF8563_REG_MN] = bin2bcd(tm->tm_min);
+        buf[PCF8563_REG_HR] = bin2bcd(tm->tm_hour);
 
-        buf[PCF8563_REG_DM] = BIN2BCD(tm->tm_mday);
+        buf[PCF8563_REG_DM] = bin2bcd(tm->tm_mday);
 
         /* month, 1 - 12 */
-        buf[PCF8563_REG_MO] = BIN2BCD(tm->tm_mon + 1);
+        buf[PCF8563_REG_MO] = bin2bcd(tm->tm_mon + 1);
 
         /* year and century */
-        buf[PCF8563_REG_YR] = BIN2BCD(tm->tm_year % 100);
+        buf[PCF8563_REG_YR] = bin2bcd(tm->tm_year % 100);
         if (pcf8563->c_polarity ? (tm->tm_year >= 100) : (tm->tm_year < 100))
                 buf[PCF8563_REG_MO] |= PCF8563_MO_C;
 
@@ -179,58 +179,6 @@ struct pcf8563_limit
         unsigned char max;
 };
 
-static int pcf8563_validate_client(struct i2c_client *client)
-{
-        int i;
-
-        static const struct pcf8563_limit pattern[] = {
-                /* register, mask, min, max */
-                { PCF8563_REG_SC,       0x7F,   0,      59      },
-                { PCF8563_REG_MN,       0x7F,   0,      59      },
-                { PCF8563_REG_HR,       0x3F,   0,      23      },
-                { PCF8563_REG_DM,       0x3F,   0,      31      },
-                { PCF8563_REG_MO,       0x1F,   0,      12      },
-        };
-
-        /* check limits (only registers with bcd values) */
-        for (i = 0; i < ARRAY_SIZE(pattern); i++) {
-                int xfer;
-                unsigned char value;
-                unsigned char buf = pattern[i].reg;
-
-                struct i2c_msg msgs[] = {
-                        { client->addr, 0, 1, &buf },
-                        { client->addr, I2C_M_RD, 1, &buf },
-                };
-
-                xfer = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-
-                if (xfer != ARRAY_SIZE(msgs)) {
-                        dev_err(&client->dev,
-                                "%s: could not read register 0x%02X\n",
-                                __func__, pattern[i].reg);
-
-                        return -EIO;
-                }
-
-                value = BCD2BIN(buf & pattern[i].mask);
-
-                if (value > pattern[i].max ||
-                        value < pattern[i].min) {
-                        dev_dbg(&client->dev,
-                                "%s: pattern=%d, reg=%x, mask=0x%02x, min=%d, "
-                                "max=%d, value=%d, raw=0x%02X\n",
-                                __func__, i, pattern[i].reg, pattern[i].mask,
-                                pattern[i].min, pattern[i].max,
-                                value, buf);
-
-                        return -ENODEV;
-                }
-        }
-
-        return 0;
-}
-
 static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         return pcf8563_get_datetime(to_i2c_client(dev), tm);
@@ -262,12 +210,6 @@ static int pcf8563_probe(struct i2c_client *client,
         if (!pcf8563)
                 return -ENOMEM;
 
-        /* Verify the chip is really an PCF8563 */
-        if (pcf8563_validate_client(client) < 0) {
-                err = -ENODEV;
-                goto exit_kfree;
-        }
-
         dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
 
         pcf8563->rtc = rtc_device_register(pcf8563_driver.driver.name,
diff --git a/drivers/rtc/rtc-pcf8583.c b/drivers/rtc/rtc-pcf8583.c
index 3d09d8f0b1f0..7d33cda3f8f6 100644
--- a/drivers/rtc/rtc-pcf8583.c
+++ b/drivers/rtc/rtc-pcf8583.c
@@ -2,6 +2,7 @@
  *  drivers/rtc/rtc-pcf8583.c
  *
  *  Copyright (C) 2000 Russell King
+ *  Copyright (C) 2008 Wolfram Sang & Juergen Beisert, Pengutronix
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -14,7 +15,6 @@
 #include <linux/module.h>
 #include <linux/i2c.h>
 #include <linux/slab.h>
-#include <linux/string.h>
 #include <linux/rtc.h>
 #include <linux/init.h>
 #include <linux/errno.h>
@@ -27,7 +27,6 @@ struct rtc_mem {
 };
 
 struct pcf8583 {
-        struct i2c_client client;
         struct rtc_device *rtc;
         unsigned char ctrl;
 };
@@ -40,10 +39,6 @@ struct pcf8583 {
 #define CTRL_ALARM      0x02
 #define CTRL_TIMER      0x01
 
-static const unsigned short normal_i2c[] = { 0x50, I2C_CLIENT_END };
-
-/* Module parameters */
-I2C_CLIENT_INSMOD;
 
 static struct i2c_driver pcf8583_driver;
 
@@ -81,11 +76,11 @@ static int pcf8583_get_datetime(struct i2c_client *client, struct rtc_time *dt)
                 buf[4] &= 0x3f;
                 buf[5] &= 0x1f;
 
-                dt->tm_sec = BCD2BIN(buf[1]);
-                dt->tm_min = BCD2BIN(buf[2]);
-                dt->tm_hour = BCD2BIN(buf[3]);
-                dt->tm_mday = BCD2BIN(buf[4]);
-                dt->tm_mon = BCD2BIN(buf[5]) - 1;
+                dt->tm_sec = bcd2bin(buf[1]);
+                dt->tm_min = bcd2bin(buf[2]);
+                dt->tm_hour = bcd2bin(buf[3]);
+                dt->tm_mday = bcd2bin(buf[4]);
+                dt->tm_mon = bcd2bin(buf[5]) - 1;
         }
 
         return ret == 2 ? 0 : -EIO;
@@ -99,14 +94,14 @@ static int pcf8583_set_datetime(struct i2c_client *client, struct rtc_time *dt,
         buf[0] = 0;
         buf[1] = get_ctrl(client) | 0x80;
         buf[2] = 0;
-        buf[3] = BIN2BCD(dt->tm_sec);
-        buf[4] = BIN2BCD(dt->tm_min);
-        buf[5] = BIN2BCD(dt->tm_hour);
+        buf[3] = bin2bcd(dt->tm_sec);
+        buf[4] = bin2bcd(dt->tm_min);
+        buf[5] = bin2bcd(dt->tm_hour);
 
         if (datetoo) {
                 len = 8;
-                buf[6] = BIN2BCD(dt->tm_mday) | (dt->tm_year << 6);
-                buf[7] = BIN2BCD(dt->tm_mon + 1)  | (dt->tm_wday << 5);
+                buf[6] = bin2bcd(dt->tm_mday) | (dt->tm_year << 6);
+                buf[7] = bin2bcd(dt->tm_mon + 1)  | (dt->tm_wday << 5);
         }
 
         ret = i2c_master_send(client, (char *)buf, len);
@@ -269,106 +264,60 @@ static const struct rtc_class_ops pcf8583_rtc_ops = {
         .set_time       = pcf8583_rtc_set_time,
 };
 
-static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind);
-
-static int pcf8583_attach(struct i2c_adapter *adap)
-{
-        return i2c_probe(adap, &addr_data, pcf8583_probe);
-}
-
-static int pcf8583_detach(struct i2c_client *client)
-{
-        int err;
-        struct pcf8583 *pcf = i2c_get_clientdata(client);
-        struct rtc_device *rtc = pcf->rtc;
-
-        if (rtc)
-                rtc_device_unregister(rtc);
-
-        if ((err = i2c_detach_client(client)))
-                return err;
-
-        kfree(pcf);
-        return 0;
-}
-
-static struct i2c_driver pcf8583_driver = {
-        .driver = {
-                .name   = "pcf8583",
-        },
-        .id             = I2C_DRIVERID_PCF8583,
-        .attach_adapter = pcf8583_attach,
-        .detach_client  = pcf8583_detach,
-};
-
-static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind)
+static int pcf8583_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
 {
-        struct pcf8583 *pcf;
-        struct i2c_client *client;
-        struct rtc_device *rtc;
-        unsigned char buf[1], ad[1] = { 0 };
+        struct pcf8583 *pcf8583;
         int err;
-        struct i2c_msg msgs[2] = {
-                {
-                        .addr = addr,
-                        .flags = 0,
-                        .len = 1,
-                        .buf = ad,
-                }, {
-                        .addr = addr,
-                        .flags = I2C_M_RD,
-                        .len = 1,
-                        .buf = buf,
-                }
-        };
 
-        if (!i2c_check_functionality(adap, I2C_FUNC_I2C))
-                return 0;
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+                return -ENODEV;
 
-        pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);
-        if (!pcf)
+        pcf8583 = kzalloc(sizeof(struct pcf8583), GFP_KERNEL);
+        if (!pcf8583)
                 return -ENOMEM;
 
-        client = &pcf->client;
+        pcf8583->rtc = rtc_device_register(pcf8583_driver.driver.name,
+                        &client->dev, &pcf8583_rtc_ops, THIS_MODULE);
 
-        client->addr            = addr;
-        client->adapter = adap;
-        client->driver  = &pcf8583_driver;
-
-        strlcpy(client->name, pcf8583_driver.driver.name, I2C_NAME_SIZE);
-
-        if (i2c_transfer(client->adapter, msgs, 2) != 2) {
-                err = -EIO;
+        if (IS_ERR(pcf8583->rtc)) {
+                err = PTR_ERR(pcf8583->rtc);
                 goto exit_kfree;
         }
 
-        err = i2c_attach_client(client);
-
-        if (err)
-                goto exit_kfree;
-
-        rtc = rtc_device_register(pcf8583_driver.driver.name, &client->dev,
-                                  &pcf8583_rtc_ops, THIS_MODULE);
+        i2c_set_clientdata(client, pcf8583);
+        return 0;
 
-        if (IS_ERR(rtc)) {
-                err = PTR_ERR(rtc);
-                goto exit_detach;
-        }
+exit_kfree:
+        kfree(pcf8583);
+        return err;
+}
 
-        pcf->rtc = rtc;
-        i2c_set_clientdata(client, pcf);
-        set_ctrl(client, buf[0]);
+static int __devexit pcf8583_remove(struct i2c_client *client)
+{
+        struct pcf8583 *pcf8583 = i2c_get_clientdata(client);
 
+        if (pcf8583->rtc)
+                rtc_device_unregister(pcf8583->rtc);
+        kfree(pcf8583);
         return 0;
+}
 
-exit_detach:
-        i2c_detach_client(client);
-
-exit_kfree:
-        kfree(pcf);
+static const struct i2c_device_id pcf8583_id[] = {
+        { "pcf8583", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, pcf8583_id);
 
-        return err;
-}
+static struct i2c_driver pcf8583_driver = {
+        .driver = {
+                .name   = "pcf8583",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = pcf8583_probe,
+        .remove         = __devexit_p(pcf8583_remove),
+        .id_table       = pcf8583_id,
+};
 
 static __init int pcf8583_init(void)
 {
diff --git a/drivers/rtc/rtc-pl030.c b/drivers/rtc/rtc-pl030.c
index 8448eeb9d675..826153552157 100644
--- a/drivers/rtc/rtc-pl030.c
+++ b/drivers/rtc/rtc-pl030.c
@@ -34,15 +34,6 @@ static irqreturn_t pl030_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int pl030_open(struct device *dev)
-{
-        return 0;
-}
-
-static void pl030_release(struct device *dev)
-{
-}
-
 static int pl030_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
         return -ENOIOCTLCMD;
@@ -104,8 +95,6 @@ static int pl030_set_time(struct device *dev, struct rtc_time *tm)
 }
 
 static const struct rtc_class_ops pl030_ops = {
-        .open           = pl030_open,
-        .release        = pl030_release,
         .ioctl          = pl030_ioctl,
         .read_time      = pl030_read_time,
         .set_time       = pl030_set_time,
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index 08b4610ec5a6..333eec689d2f 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -45,18 +45,6 @@ static irqreturn_t pl031_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int pl031_open(struct device *dev)
-{
-        /*
-         * We request IRQ in pl031_probe, so nothing to do here...
-         */
-        return 0;
-}
-
-static void pl031_release(struct device *dev)
-{
-}
-
 static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
         struct pl031_local *ldata = dev_get_drvdata(dev);
@@ -118,8 +106,6 @@ static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 }
 
 static const struct rtc_class_ops pl031_ops = {
-        .open = pl031_open,
-        .release = pl031_release,
         .ioctl = pl031_ioctl,
         .read_time = pl031_read_time,
         .set_time = pl031_set_time,
diff --git a/drivers/rtc/rtc-r9701.c b/drivers/rtc/rtc-r9701.c
index b35f9bfa2af4..42028f233bef 100644
--- a/drivers/rtc/rtc-r9701.c
+++ b/drivers/rtc/rtc-r9701.c
@@ -14,7 +14,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/device.h>
@@ -81,13 +80,13 @@ static int r9701_get_datetime(struct device *dev, struct rtc_time *dt)
 
         memset(dt, 0, sizeof(*dt));
 
-        dt->tm_sec = BCD2BIN(buf[0]); /* RSECCNT */
-        dt->tm_min = BCD2BIN(buf[1]); /* RMINCNT */
-        dt->tm_hour = BCD2BIN(buf[2]); /* RHRCNT */
+        dt->tm_sec = bcd2bin(buf[0]); /* RSECCNT */
+        dt->tm_min = bcd2bin(buf[1]); /* RMINCNT */
+        dt->tm_hour = bcd2bin(buf[2]); /* RHRCNT */
 
-        dt->tm_mday = BCD2BIN(buf[3]); /* RDAYCNT */
-        dt->tm_mon = BCD2BIN(buf[4]) - 1; /* RMONCNT */
-        dt->tm_year = BCD2BIN(buf[5]) + 100; /* RYRCNT */
+        dt->tm_mday = bcd2bin(buf[3]); /* RDAYCNT */
+        dt->tm_mon = bcd2bin(buf[4]) - 1; /* RMONCNT */
+        dt->tm_year = bcd2bin(buf[5]) + 100; /* RYRCNT */
 
         /* the rtc device may contain illegal values on power up
          * according to the data sheet. make sure they are valid.
@@ -104,12 +103,12 @@ static int r9701_set_datetime(struct device *dev, struct rtc_time *dt)
         if (year >= 2100 || year < 2000)
                 return -EINVAL;
 
-        ret = write_reg(dev, RHRCNT, BIN2BCD(dt->tm_hour));
-        ret = ret ? ret : write_reg(dev, RMINCNT, BIN2BCD(dt->tm_min));
-        ret = ret ? ret : write_reg(dev, RSECCNT, BIN2BCD(dt->tm_sec));
-        ret = ret ? ret : write_reg(dev, RDAYCNT, BIN2BCD(dt->tm_mday));
-        ret = ret ? ret : write_reg(dev, RMONCNT, BIN2BCD(dt->tm_mon + 1));
-        ret = ret ? ret : write_reg(dev, RYRCNT, BIN2BCD(dt->tm_year - 100));
+        ret = write_reg(dev, RHRCNT, bin2bcd(dt->tm_hour));
+        ret = ret ? ret : write_reg(dev, RMINCNT, bin2bcd(dt->tm_min));
+        ret = ret ? ret : write_reg(dev, RSECCNT, bin2bcd(dt->tm_sec));
+        ret = ret ? ret : write_reg(dev, RDAYCNT, bin2bcd(dt->tm_mday));
+        ret = ret ? ret : write_reg(dev, RMONCNT, bin2bcd(dt->tm_mon + 1));
+        ret = ret ? ret : write_reg(dev, RYRCNT, bin2bcd(dt->tm_year - 100));
         ret = ret ? ret : write_reg(dev, RWKCNT, 1 << dt->tm_wday);
 
         return ret;
diff --git a/drivers/rtc/rtc-rs5c313.c b/drivers/rtc/rtc-rs5c313.c
index 1c14d4497c4d..e6ea3f5ee1eb 100644
--- a/drivers/rtc/rtc-rs5c313.c
+++ b/drivers/rtc/rtc-rs5c313.c
@@ -235,33 +235,33 @@ static int rs5c313_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
         data = rs5c313_read_reg(RS5C313_ADDR_SEC);
         data |= (rs5c313_read_reg(RS5C313_ADDR_SEC10) << 4);
-        tm->tm_sec = BCD2BIN(data);
+        tm->tm_sec = bcd2bin(data);
 
         data = rs5c313_read_reg(RS5C313_ADDR_MIN);
         data |= (rs5c313_read_reg(RS5C313_ADDR_MIN10) << 4);
-        tm->tm_min = BCD2BIN(data);
+        tm->tm_min = bcd2bin(data);
 
         data = rs5c313_read_reg(RS5C313_ADDR_HOUR);
         data |= (rs5c313_read_reg(RS5C313_ADDR_HOUR10) << 4);
-        tm->tm_hour = BCD2BIN(data);
+        tm->tm_hour = bcd2bin(data);
 
         data = rs5c313_read_reg(RS5C313_ADDR_DAY);
         data |= (rs5c313_read_reg(RS5C313_ADDR_DAY10) << 4);
-        tm->tm_mday = BCD2BIN(data);
+        tm->tm_mday = bcd2bin(data);
 
         data = rs5c313_read_reg(RS5C313_ADDR_MON);
         data |= (rs5c313_read_reg(RS5C313_ADDR_MON10) << 4);
-        tm->tm_mon = BCD2BIN(data) - 1;
+        tm->tm_mon = bcd2bin(data) - 1;
 
         data = rs5c313_read_reg(RS5C313_ADDR_YEAR);
         data |= (rs5c313_read_reg(RS5C313_ADDR_YEAR10) << 4);
-        tm->tm_year = BCD2BIN(data);
+        tm->tm_year = bcd2bin(data);
 
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
 
         data = rs5c313_read_reg(RS5C313_ADDR_WEEK);
-        tm->tm_wday = BCD2BIN(data);
+        tm->tm_wday = bcd2bin(data);
 
         RS5C313_CEDISABLE;
         ndelay(700);            /* CE:L */
@@ -294,31 +294,31 @@ static int rs5c313_rtc_set_time(struct device *dev, struct rtc_time *tm)
                 }
         }
 
-        data = BIN2BCD(tm->tm_sec);
+        data = bin2bcd(tm->tm_sec);
         rs5c313_write_reg(RS5C313_ADDR_SEC, data);
         rs5c313_write_reg(RS5C313_ADDR_SEC10, (data >> 4));
 
-        data = BIN2BCD(tm->tm_min);
+        data = bin2bcd(tm->tm_min);
         rs5c313_write_reg(RS5C313_ADDR_MIN, data );
         rs5c313_write_reg(RS5C313_ADDR_MIN10, (data >> 4));
 
-        data = BIN2BCD(tm->tm_hour);
+        data = bin2bcd(tm->tm_hour);
         rs5c313_write_reg(RS5C313_ADDR_HOUR, data);
         rs5c313_write_reg(RS5C313_ADDR_HOUR10, (data >> 4));
 
-        data = BIN2BCD(tm->tm_mday);
+        data = bin2bcd(tm->tm_mday);
         rs5c313_write_reg(RS5C313_ADDR_DAY, data);
         rs5c313_write_reg(RS5C313_ADDR_DAY10, (data>> 4));
 
-        data = BIN2BCD(tm->tm_mon + 1);
+        data = bin2bcd(tm->tm_mon + 1);
         rs5c313_write_reg(RS5C313_ADDR_MON, data);
         rs5c313_write_reg(RS5C313_ADDR_MON10, (data >> 4));
 
-        data = BIN2BCD(tm->tm_year % 100);
+        data = bin2bcd(tm->tm_year % 100);
         rs5c313_write_reg(RS5C313_ADDR_YEAR, data);
         rs5c313_write_reg(RS5C313_ADDR_YEAR10, (data >> 4));
 
-        data = BIN2BCD(tm->tm_wday);
+        data = bin2bcd(tm->tm_wday);
         rs5c313_write_reg(RS5C313_ADDR_WEEK, data);
 
         RS5C313_CEDISABLE;      /* CE:H */
diff --git a/drivers/rtc/rtc-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
index 839462659afa..dd1e2bc7a472 100644
--- a/drivers/rtc/rtc-rs5c348.c
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -74,20 +74,20 @@ rs5c348_rtc_set_time(struct device *dev, struct rtc_time *tm)
         txbuf[3] = 0;   /* dummy */
         txbuf[4] = RS5C348_CMD_MW(RS5C348_REG_SECS); /* cmd, sec, ... */
         txp = &txbuf[5];
-        txp[RS5C348_REG_SECS] = BIN2BCD(tm->tm_sec);
-        txp[RS5C348_REG_MINS] = BIN2BCD(tm->tm_min);
+        txp[RS5C348_REG_SECS] = bin2bcd(tm->tm_sec);
+        txp[RS5C348_REG_MINS] = bin2bcd(tm->tm_min);
         if (pdata->rtc_24h) {
-                txp[RS5C348_REG_HOURS] = BIN2BCD(tm->tm_hour);
+                txp[RS5C348_REG_HOURS] = bin2bcd(tm->tm_hour);
         } else {
                 /* hour 0 is AM12, noon is PM12 */
-                txp[RS5C348_REG_HOURS] = BIN2BCD((tm->tm_hour + 11) % 12 + 1) |
+                txp[RS5C348_REG_HOURS] = bin2bcd((tm->tm_hour + 11) % 12 + 1) |
                         (tm->tm_hour >= 12 ? RS5C348_BIT_PM : 0);
         }
-        txp[RS5C348_REG_WDAY] = BIN2BCD(tm->tm_wday);
-        txp[RS5C348_REG_DAY] = BIN2BCD(tm->tm_mday);
-        txp[RS5C348_REG_MONTH] = BIN2BCD(tm->tm_mon + 1) |
+        txp[RS5C348_REG_WDAY] = bin2bcd(tm->tm_wday);
+        txp[RS5C348_REG_DAY] = bin2bcd(tm->tm_mday);
+        txp[RS5C348_REG_MONTH] = bin2bcd(tm->tm_mon + 1) |
                 (tm->tm_year >= 100 ? RS5C348_BIT_Y2K : 0);
-        txp[RS5C348_REG_YEAR] = BIN2BCD(tm->tm_year % 100);
+        txp[RS5C348_REG_YEAR] = bin2bcd(tm->tm_year % 100);
         /* write in one transfer to avoid data inconsistency */
         ret = spi_write_then_read(spi, txbuf, sizeof(txbuf), NULL, 0);
         udelay(62);     /* Tcsr 62us */
@@ -116,20 +116,20 @@ rs5c348_rtc_read_time(struct device *dev, struct rtc_time *tm)
         if (ret < 0)
                 return ret;
 
-        tm->tm_sec = BCD2BIN(rxbuf[RS5C348_REG_SECS] & RS5C348_SECS_MASK);
-        tm->tm_min = BCD2BIN(rxbuf[RS5C348_REG_MINS] & RS5C348_MINS_MASK);
-        tm->tm_hour = BCD2BIN(rxbuf[RS5C348_REG_HOURS] & RS5C348_HOURS_MASK);
+        tm->tm_sec = bcd2bin(rxbuf[RS5C348_REG_SECS] & RS5C348_SECS_MASK);
+        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) {
                 tm->tm_hour %= 12;
                 if (rxbuf[RS5C348_REG_HOURS] & RS5C348_BIT_PM)
                         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);
+        tm->tm_wday = bcd2bin(rxbuf[RS5C348_REG_WDAY] & RS5C348_WDAY_MASK);
+        tm->tm_mday = bcd2bin(rxbuf[RS5C348_REG_DAY] & RS5C348_DAY_MASK);
         tm->tm_mon =
-                BCD2BIN(rxbuf[RS5C348_REG_MONTH] & RS5C348_MONTH_MASK) - 1;
+                bcd2bin(rxbuf[RS5C348_REG_MONTH] & RS5C348_MONTH_MASK) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(rxbuf[RS5C348_REG_YEAR]) +
+        tm->tm_year = bcd2bin(rxbuf[RS5C348_REG_YEAR]) +
                 ((rxbuf[RS5C348_REG_MONTH] & RS5C348_BIT_Y2K) ? 100 : 0);
 
         if (rtc_valid_tm(tm) < 0) {
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index 56caf6b2c3e5..2f2c68d476da 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -1,8 +1,9 @@
 /*
- * An I2C driver for Ricoh RS5C372 and RV5C38[67] RTCs
+ * An I2C driver for Ricoh RS5C372, R2025S/D and RV5C38[67] RTCs
  *
  * Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
  * Copyright (C) 2006 Tower Technologies
+ * Copyright (C) 2008 Paul Mundt
  *
  * 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
@@ -13,7 +14,7 @@
 #include <linux/rtc.h>
 #include <linux/bcd.h>
 
-#define DRV_VERSION "0.5"
+#define DRV_VERSION "0.6"
 
 
 /*
@@ -51,7 +52,8 @@
 #       define RS5C_CTRL1_CT4           (4 << 0)        /* 1 Hz level irq */
 #define RS5C_REG_CTRL2          15
 #       define RS5C372_CTRL2_24         (1 << 5)
-#       define RS5C_CTRL2_XSTP          (1 << 4)
+#       define R2025_CTRL2_XST          (1 << 5)
+#       define RS5C_CTRL2_XSTP          (1 << 4)        /* only if !R2025S/D */
 #       define RS5C_CTRL2_CTFG          (1 << 2)
 #       define RS5C_CTRL2_AAFG          (1 << 1)        /* or WAFG */
 #       define RS5C_CTRL2_BAFG          (1 << 0)        /* or DAFG */
@@ -63,6 +65,7 @@
 
 enum rtc_type {
         rtc_undef = 0,
+        rtc_r2025sd,
         rtc_rs5c372a,
         rtc_rs5c372b,
         rtc_rv5c386,
@@ -70,6 +73,7 @@ enum rtc_type {
 };
 
 static const struct i2c_device_id rs5c372_id[] = {
+        { "r2025sd", rtc_r2025sd },
         { "rs5c372a", rtc_rs5c372a },
         { "rs5c372b", rtc_rs5c372b },
         { "rv5c386", rtc_rv5c386 },
@@ -89,6 +93,7 @@ struct rs5c372 {
         enum rtc_type           type;
         unsigned                time24:1;
         unsigned                has_irq:1;
+        unsigned                smbus:1;
         char                    buf[17];
         char                    *regs;
 };
@@ -106,10 +111,25 @@ static int rs5c_get_regs(struct rs5c372 *rs5c)
          *
          * The first method doesn't work with the iop3xx adapter driver, on at
          * least 80219 chips; this works around that bug.
+         *
+         * The third method on the other hand doesn't work for the SMBus-only
+         * configurations, so we use the the first method there, stripping off
+         * the extra register in the process.
          */
-        if ((i2c_transfer(client->adapter, msgs, 1)) != 1) {
-                dev_warn(&client->dev, "can't read registers\n");
-                return -EIO;
+        if (rs5c->smbus) {
+                int addr = RS5C_ADDR(RS5C372_REG_SECS);
+                int size = sizeof(rs5c->buf) - 1;
+
+                if (i2c_smbus_read_i2c_block_data(client, addr, size,
+                                                  rs5c->buf + 1) != size) {
+                        dev_warn(&client->dev, "can't read registers\n");
+                        return -EIO;
+                }
+        } else {
+                if ((i2c_transfer(client->adapter, msgs, 1)) != 1) {
+                        dev_warn(&client->dev, "can't read registers\n");
+                        return -EIO;
+                }
         }
 
         dev_dbg(&client->dev,
@@ -128,9 +148,9 @@ static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
         unsigned        hour;
 
         if (rs5c->time24)
-                return BCD2BIN(reg & 0x3f);
+                return bcd2bin(reg & 0x3f);
 
-        hour = BCD2BIN(reg & 0x1f);
+        hour = bcd2bin(reg & 0x1f);
         if (hour == 12)
                 hour = 0;
         if (reg & 0x20)
@@ -141,15 +161,15 @@ static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
 static unsigned rs5c_hr2reg(struct rs5c372 *rs5c, unsigned hour)
 {
         if (rs5c->time24)
-                return BIN2BCD(hour);
+                return bin2bcd(hour);
 
         if (hour > 12)
-                return 0x20 | BIN2BCD(hour - 12);
+                return 0x20 | bin2bcd(hour - 12);
         if (hour == 12)
-                return 0x20 | BIN2BCD(12);
+                return 0x20 | bin2bcd(12);
         if (hour == 0)
-                return BIN2BCD(12);
-        return BIN2BCD(hour);
+                return bin2bcd(12);
+        return bin2bcd(hour);
 }
 
 static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
@@ -160,18 +180,18 @@ static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         if (status < 0)
                 return status;
 
-        tm->tm_sec = BCD2BIN(rs5c->regs[RS5C372_REG_SECS] & 0x7f);
-        tm->tm_min = BCD2BIN(rs5c->regs[RS5C372_REG_MINS] & 0x7f);
+        tm->tm_sec = bcd2bin(rs5c->regs[RS5C372_REG_SECS] & 0x7f);
+        tm->tm_min = bcd2bin(rs5c->regs[RS5C372_REG_MINS] & 0x7f);
         tm->tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C372_REG_HOURS]);
 
-        tm->tm_wday = BCD2BIN(rs5c->regs[RS5C372_REG_WDAY] & 0x07);
-        tm->tm_mday = BCD2BIN(rs5c->regs[RS5C372_REG_DAY] & 0x3f);
+        tm->tm_wday = bcd2bin(rs5c->regs[RS5C372_REG_WDAY] & 0x07);
+        tm->tm_mday = bcd2bin(rs5c->regs[RS5C372_REG_DAY] & 0x3f);
 
         /* tm->tm_mon is zero-based */
-        tm->tm_mon = BCD2BIN(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1;
+        tm->tm_mon = bcd2bin(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1;
 
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(rs5c->regs[RS5C372_REG_YEAR]) + 100;
+        tm->tm_year = bcd2bin(rs5c->regs[RS5C372_REG_YEAR]) + 100;
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                 "mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -187,6 +207,7 @@ static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
 {
         struct rs5c372  *rs5c = i2c_get_clientdata(client);
         unsigned char   buf[8];
+        int             addr;
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
                 "mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -194,16 +215,16 @@ static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 tm->tm_sec, tm->tm_min, tm->tm_hour,
                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
-        buf[0] = RS5C_ADDR(RS5C372_REG_SECS);
-        buf[1] = BIN2BCD(tm->tm_sec);
-        buf[2] = BIN2BCD(tm->tm_min);
-        buf[3] = rs5c_hr2reg(rs5c, tm->tm_hour);
-        buf[4] = BIN2BCD(tm->tm_wday);
-        buf[5] = BIN2BCD(tm->tm_mday);
-        buf[6] = BIN2BCD(tm->tm_mon + 1);
-        buf[7] = BIN2BCD(tm->tm_year - 100);
+        addr   = RS5C_ADDR(RS5C372_REG_SECS);
+        buf[0] = bin2bcd(tm->tm_sec);
+        buf[1] = bin2bcd(tm->tm_min);
+        buf[2] = rs5c_hr2reg(rs5c, tm->tm_hour);
+        buf[3] = bin2bcd(tm->tm_wday);
+        buf[4] = bin2bcd(tm->tm_mday);
+        buf[5] = bin2bcd(tm->tm_mon + 1);
+        buf[6] = bin2bcd(tm->tm_year - 100);
 
-        if ((i2c_master_send(client, buf, 8)) != 8) {
+        if (i2c_smbus_write_i2c_block_data(client, addr, sizeof(buf), buf) < 0) {
                 dev_err(&client->dev, "%s: write error\n", __func__);
                 return -EIO;
         }
@@ -266,16 +287,16 @@ rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
         struct i2c_client       *client = to_i2c_client(dev);
         struct rs5c372          *rs5c = i2c_get_clientdata(client);
-        unsigned char           buf[2];
-        int                     status;
+        unsigned char           buf;
+        int                     status, addr;
 
-        buf[1] = rs5c->regs[RS5C_REG_CTRL1];
+        buf = rs5c->regs[RS5C_REG_CTRL1];
         switch (cmd) {
         case RTC_UIE_OFF:
         case RTC_UIE_ON:
                 /* some 327a modes use a different IRQ pin for 1Hz irqs */
                 if (rs5c->type == rtc_rs5c372a
-                                && (buf[1] & RS5C372A_CTRL1_SL1))
+                                && (buf & RS5C372A_CTRL1_SL1))
                         return -ENOIOCTLCMD;
         case RTC_AIE_OFF:
         case RTC_AIE_ON:
@@ -293,28 +314,30 @@ rs5c_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         if (status < 0)
                 return status;
 
-        buf[0] = RS5C_ADDR(RS5C_REG_CTRL1);
+        addr = RS5C_ADDR(RS5C_REG_CTRL1);
         switch (cmd) {
         case RTC_AIE_OFF:       /* alarm off */
-                buf[1] &= ~RS5C_CTRL1_AALE;
+                buf &= ~RS5C_CTRL1_AALE;
                 break;
         case RTC_AIE_ON:        /* alarm on */
-                buf[1] |= RS5C_CTRL1_AALE;
+                buf |= RS5C_CTRL1_AALE;
                 break;
         case RTC_UIE_OFF:       /* update off */
-                buf[1] &= ~RS5C_CTRL1_CT_MASK;
+                buf &= ~RS5C_CTRL1_CT_MASK;
                 break;
         case RTC_UIE_ON:        /* update on */
-                buf[1] &= ~RS5C_CTRL1_CT_MASK;
-                buf[1] |= RS5C_CTRL1_CT4;
+                buf &= ~RS5C_CTRL1_CT_MASK;
+                buf |= RS5C_CTRL1_CT4;
                 break;
         }
-        if ((i2c_master_send(client, buf, 2)) != 2) {
+
+        if (i2c_smbus_write_byte_data(client, addr, buf) < 0) {
                 printk(KERN_WARNING "%s: can't update alarm\n",
                         rs5c->rtc->name);
                 status = -EIO;
         } else
-                rs5c->regs[RS5C_REG_CTRL1] = buf[1];
+                rs5c->regs[RS5C_REG_CTRL1] = buf;
+
         return status;
 }
 
@@ -344,7 +367,7 @@ static int rs5c_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 
         /* report alarm time */
         t->time.tm_sec = 0;
-        t->time.tm_min = BCD2BIN(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f);
+        t->time.tm_min = bcd2bin(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f);
         t->time.tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C_REG_ALARM_A_HOURS]);
         t->time.tm_mday = -1;
         t->time.tm_mon = -1;
@@ -364,8 +387,8 @@ static int rs5c_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
         struct i2c_client       *client = to_i2c_client(dev);
         struct rs5c372          *rs5c = i2c_get_clientdata(client);
-        int                     status;
-        unsigned char           buf[4];
+        int                     status, addr, i;
+        unsigned char           buf[3];
 
         /* only handle up to 24 hours in the future, like RTC_ALM_SET */
         if (t->time.tm_mday != -1
@@ -380,33 +403,36 @@ static int rs5c_set_alarm(struct device *dev, struct rtc_wkalrm *t)
         if (status < 0)
                 return status;
         if (rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE) {
-                buf[0] = RS5C_ADDR(RS5C_REG_CTRL1);
-                buf[1] = rs5c->regs[RS5C_REG_CTRL1] & ~RS5C_CTRL1_AALE;
-                if (i2c_master_send(client, buf, 2) != 2) {
+                addr = RS5C_ADDR(RS5C_REG_CTRL1);
+                buf[0] = rs5c->regs[RS5C_REG_CTRL1] & ~RS5C_CTRL1_AALE;
+                if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0) {
                         pr_debug("%s: can't disable alarm\n", rs5c->rtc->name);
                         return -EIO;
                 }
-                rs5c->regs[RS5C_REG_CTRL1] = buf[1];
+                rs5c->regs[RS5C_REG_CTRL1] = buf[0];
         }
 
         /* set alarm */
-        buf[0] = RS5C_ADDR(RS5C_REG_ALARM_A_MIN);
-        buf[1] = BIN2BCD(t->time.tm_min);
-        buf[2] = rs5c_hr2reg(rs5c, t->time.tm_hour);
-        buf[3] = 0x7f;  /* any/all days */
-        if ((i2c_master_send(client, buf, 4)) != 4) {
-                pr_debug("%s: can't set alarm time\n", rs5c->rtc->name);
-                return -EIO;
+        buf[0] = bin2bcd(t->time.tm_min);
+        buf[1] = rs5c_hr2reg(rs5c, t->time.tm_hour);
+        buf[2] = 0x7f;  /* any/all days */
+
+        for (i = 0; i < sizeof(buf); i++) {
+                addr = RS5C_ADDR(RS5C_REG_ALARM_A_MIN + i);
+                if (i2c_smbus_write_byte_data(client, addr, buf[i]) < 0) {
+                        pr_debug("%s: can't set alarm time\n", rs5c->rtc->name);
+                        return -EIO;
+                }
         }
 
         /* ... and maybe enable its irq */
         if (t->enabled) {
-                buf[0] = RS5C_ADDR(RS5C_REG_CTRL1);
-                buf[1] = rs5c->regs[RS5C_REG_CTRL1] | RS5C_CTRL1_AALE;
-                if ((i2c_master_send(client, buf, 2)) != 2)
+                addr = RS5C_ADDR(RS5C_REG_CTRL1);
+                buf[0] = rs5c->regs[RS5C_REG_CTRL1] | RS5C_CTRL1_AALE;
+                if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0)
                         printk(KERN_WARNING "%s: can't enable alarm\n",
                                 rs5c->rtc->name);
-                rs5c->regs[RS5C_REG_CTRL1] = buf[1];
+                rs5c->regs[RS5C_REG_CTRL1] = buf[0];
         }
 
         return 0;
@@ -503,18 +529,81 @@ static void rs5c_sysfs_unregister(struct device *dev)
 
 static struct i2c_driver rs5c372_driver;
 
+static int rs5c_oscillator_setup(struct rs5c372 *rs5c372)
+{
+        unsigned char buf[2];
+        int addr, i, ret = 0;
+
+        if (rs5c372->type == rtc_r2025sd) {
+                if (!(rs5c372->regs[RS5C_REG_CTRL2] & R2025_CTRL2_XST))
+                        return ret;
+                rs5c372->regs[RS5C_REG_CTRL2] &= ~R2025_CTRL2_XST;
+        } else {
+                if (!(rs5c372->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_XSTP))
+                        return ret;
+                rs5c372->regs[RS5C_REG_CTRL2] &= ~RS5C_CTRL2_XSTP;
+        }
+
+        addr   = RS5C_ADDR(RS5C_REG_CTRL1);
+        buf[0] = rs5c372->regs[RS5C_REG_CTRL1];
+        buf[1] = rs5c372->regs[RS5C_REG_CTRL2];
+
+        /* use 24hr mode */
+        switch (rs5c372->type) {
+        case rtc_rs5c372a:
+        case rtc_rs5c372b:
+                buf[1] |= RS5C372_CTRL2_24;
+                rs5c372->time24 = 1;
+                break;
+        case rtc_r2025sd:
+        case rtc_rv5c386:
+        case rtc_rv5c387a:
+                buf[0] |= RV5C387_CTRL1_24;
+                rs5c372->time24 = 1;
+                break;
+        default:
+                /* impossible */
+                break;
+        }
+
+        for (i = 0; i < sizeof(buf); i++) {
+                addr = RS5C_ADDR(RS5C_REG_CTRL1 + i);
+                ret = i2c_smbus_write_byte_data(rs5c372->client, addr, buf[i]);
+                if (unlikely(ret < 0))
+                        return ret;
+        }
+
+        rs5c372->regs[RS5C_REG_CTRL1] = buf[0];
+        rs5c372->regs[RS5C_REG_CTRL2] = buf[1];
+
+        return 0;
+}
+
 static int rs5c372_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
         int err = 0;
+        int smbus_mode = 0;
         struct rs5c372 *rs5c372;
         struct rtc_time tm;
 
         dev_dbg(&client->dev, "%s\n", __func__);
 
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
-                err = -ENODEV;
-                goto exit;
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
+                        I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) {
+                /*
+                 * If we don't have any master mode adapter, try breaking
+                 * it down in to the barest of capabilities.
+                 */
+                if (i2c_check_functionality(client->adapter,
+                                I2C_FUNC_SMBUS_BYTE_DATA |
+                                I2C_FUNC_SMBUS_I2C_BLOCK))
+                        smbus_mode = 1;
+                else {
+                        /* Still no good, give up */
+                        err = -ENODEV;
+                        goto exit;
+                }
         }
 
         if (!(rs5c372 = kzalloc(sizeof(struct rs5c372), GFP_KERNEL))) {
@@ -528,6 +617,7 @@ static int rs5c372_probe(struct i2c_client *client,
 
         /* we read registers 0x0f then 0x00-0x0f; skip the first one */
         rs5c372->regs = &rs5c372->buf[1];
+        rs5c372->smbus = smbus_mode;
 
         err = rs5c_get_regs(rs5c372);
         if (err < 0)
@@ -543,6 +633,7 @@ static int rs5c372_probe(struct i2c_client *client,
                 if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C372_CTRL2_24)
                         rs5c372->time24 = 1;
                 break;
+        case rtc_r2025sd:
         case rtc_rv5c386:
         case rtc_rv5c387a:
                 if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24)
@@ -558,39 +649,14 @@ static int rs5c372_probe(struct i2c_client *client,
 
         /* if the oscillator lost power and no other software (like
          * the bootloader) set it up, do it here.
+         *
+         * The R2025S/D does this a little differently than the other
+         * parts, so we special case that..
          */
-        if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_XSTP) {
-                unsigned char buf[3];
-
-                rs5c372->regs[RS5C_REG_CTRL2] &= ~RS5C_CTRL2_XSTP;
-
-                buf[0] = RS5C_ADDR(RS5C_REG_CTRL1);
-                buf[1] = rs5c372->regs[RS5C_REG_CTRL1];
-                buf[2] = rs5c372->regs[RS5C_REG_CTRL2];
-
-                /* use 24hr mode */
-                switch (rs5c372->type) {
-                case rtc_rs5c372a:
-                case rtc_rs5c372b:
-                        buf[2] |= RS5C372_CTRL2_24;
-                        rs5c372->time24 = 1;
-                        break;
-                case rtc_rv5c386:
-                case rtc_rv5c387a:
-                        buf[1] |= RV5C387_CTRL1_24;
-                        rs5c372->time24 = 1;
-                        break;
-                default:
-                        /* impossible */
-                        break;
-                }
-
-                if ((i2c_master_send(client, buf, 3)) != 3) {
-                        dev_err(&client->dev, "setup error\n");
-                        goto exit_kfree;
-                }
-                rs5c372->regs[RS5C_REG_CTRL1] = buf[1];
-                rs5c372->regs[RS5C_REG_CTRL2] = buf[2];
+        err = rs5c_oscillator_setup(rs5c372);
+        if (unlikely(err < 0)) {
+                dev_err(&client->dev, "setup error\n");
+                goto exit_kfree;
         }
 
         if (rs5c372_get_datetime(client, &tm) < 0)
@@ -598,6 +664,7 @@ static int rs5c372_probe(struct i2c_client *client,
 
         dev_info(&client->dev, "%s found, %s, driver version " DRV_VERSION "\n",
                         ({ char *s; switch (rs5c372->type) {
+                        case rtc_r2025sd:       s = "r2025sd"; break;
                         case rtc_rs5c372a:      s = "rs5c372a"; break;
                         case rtc_rs5c372b:      s = "rs5c372b"; break;
                         case rtc_rv5c386:       s = "rv5c386"; break;
@@ -667,7 +734,8 @@ module_exit(rs5c372_exit);
 
 MODULE_AUTHOR(
                 "Pavel Mironchik <pmironchik@optifacio.net>, "
-                "Alessandro Zummo <a.zummo@towertech.it>");
+                "Alessandro Zummo <a.zummo@towertech.it>, "
+                "Paul Mundt <lethal@linux-sh.org>");
 MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-s35390a.c b/drivers/rtc/rtc-s35390a.c
index a6fa1f2f2ca6..def4d396d0b0 100644
--- a/drivers/rtc/rtc-s35390a.c
+++ b/drivers/rtc/rtc-s35390a.c
@@ -104,12 +104,12 @@ static int s35390a_disable_test_mode(struct s35390a *s35390a)
 static char s35390a_hr2reg(struct s35390a *s35390a, int hour)
 {
         if (s35390a->twentyfourhour)
-                return BIN2BCD(hour);
+                return bin2bcd(hour);
 
         if (hour < 12)
-                return BIN2BCD(hour);
+                return bin2bcd(hour);
 
-        return 0x40 | BIN2BCD(hour - 12);
+        return 0x40 | bin2bcd(hour - 12);
 }
 
 static int s35390a_reg2hr(struct s35390a *s35390a, char reg)
@@ -117,9 +117,9 @@ static int s35390a_reg2hr(struct s35390a *s35390a, char reg)
         unsigned hour;
 
         if (s35390a->twentyfourhour)
-                return BCD2BIN(reg & 0x3f);
+                return bcd2bin(reg & 0x3f);
 
-        hour = BCD2BIN(reg & 0x3f);
+        hour = bcd2bin(reg & 0x3f);
         if (reg & 0x40)
                 hour += 12;
 
@@ -137,13 +137,13 @@ static int s35390a_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
                 tm->tm_wday);
 
-        buf[S35390A_BYTE_YEAR] = BIN2BCD(tm->tm_year - 100);
-        buf[S35390A_BYTE_MONTH] = BIN2BCD(tm->tm_mon + 1);
-        buf[S35390A_BYTE_DAY] = BIN2BCD(tm->tm_mday);
-        buf[S35390A_BYTE_WDAY] = BIN2BCD(tm->tm_wday);
+        buf[S35390A_BYTE_YEAR] = bin2bcd(tm->tm_year - 100);
+        buf[S35390A_BYTE_MONTH] = bin2bcd(tm->tm_mon + 1);
+        buf[S35390A_BYTE_DAY] = bin2bcd(tm->tm_mday);
+        buf[S35390A_BYTE_WDAY] = bin2bcd(tm->tm_wday);
         buf[S35390A_BYTE_HOURS] = s35390a_hr2reg(s35390a, tm->tm_hour);
-        buf[S35390A_BYTE_MINS] = BIN2BCD(tm->tm_min);
-        buf[S35390A_BYTE_SECS] = BIN2BCD(tm->tm_sec);
+        buf[S35390A_BYTE_MINS] = bin2bcd(tm->tm_min);
+        buf[S35390A_BYTE_SECS] = bin2bcd(tm->tm_sec);
 
         /* This chip expects the bits of each byte to be in reverse order */
         for (i = 0; i < 7; ++i)
@@ -168,13 +168,13 @@ static int s35390a_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         for (i = 0; i < 7; ++i)
                 buf[i] = bitrev8(buf[i]);
 
-        tm->tm_sec = BCD2BIN(buf[S35390A_BYTE_SECS]);
-        tm->tm_min = BCD2BIN(buf[S35390A_BYTE_MINS]);
+        tm->tm_sec = bcd2bin(buf[S35390A_BYTE_SECS]);
+        tm->tm_min = bcd2bin(buf[S35390A_BYTE_MINS]);
         tm->tm_hour = s35390a_reg2hr(s35390a, buf[S35390A_BYTE_HOURS]);
-        tm->tm_wday = BCD2BIN(buf[S35390A_BYTE_WDAY]);
-        tm->tm_mday = BCD2BIN(buf[S35390A_BYTE_DAY]);
-        tm->tm_mon = BCD2BIN(buf[S35390A_BYTE_MONTH]) - 1;
-        tm->tm_year = BCD2BIN(buf[S35390A_BYTE_YEAR]) + 100;
+        tm->tm_wday = bcd2bin(buf[S35390A_BYTE_WDAY]);
+        tm->tm_mday = bcd2bin(buf[S35390A_BYTE_DAY]);
+        tm->tm_mon = bcd2bin(buf[S35390A_BYTE_MONTH]) - 1;
+        tm->tm_year = bcd2bin(buf[S35390A_BYTE_YEAR]) + 100;
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "
                 "mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index fed86e507fdf..910bc704939c 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -22,7 +22,7 @@
 #include <linux/clk.h>
 #include <linux/log2.h>
 
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -36,10 +36,8 @@ static struct resource *s3c_rtc_mem;
 static void __iomem *s3c_rtc_base;
 static int s3c_rtc_alarmno = NO_IRQ;
 static int s3c_rtc_tickno  = NO_IRQ;
-static int s3c_rtc_freq    = 1;
 
 static DEFINE_SPINLOCK(s3c_rtc_pie_lock);
-static unsigned int tick_count;
 
 /* IRQ Handlers */
 
@@ -55,7 +53,7 @@ static irqreturn_t s3c_rtc_tickirq(int irq, void *id)
 {
         struct rtc_device *rdev = id;
 
-        rtc_update_irq(rdev, tick_count++, RTC_PF | RTC_IRQF);
+        rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
         return IRQ_HANDLED;
 }
 
@@ -74,35 +72,37 @@ static void s3c_rtc_setaie(int to)
         writeb(tmp, s3c_rtc_base + S3C2410_RTCALM);
 }
 
-static void s3c_rtc_setpie(int to)
+static int s3c_rtc_setpie(struct device *dev, int enabled)
 {
         unsigned int tmp;
 
-        pr_debug("%s: pie=%d\n", __func__, to);
+        pr_debug("%s: pie=%d\n", __func__, enabled);
 
         spin_lock_irq(&s3c_rtc_pie_lock);
         tmp = readb(s3c_rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;
 
-        if (to)
+        if (enabled)
                 tmp |= S3C2410_TICNT_ENABLE;
 
         writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
         spin_unlock_irq(&s3c_rtc_pie_lock);
+
+        return 0;
 }
 
-static void s3c_rtc_setfreq(int freq)
+static int s3c_rtc_setfreq(struct device *dev, int freq)
 {
         unsigned int tmp;
 
         spin_lock_irq(&s3c_rtc_pie_lock);
-        tmp = readb(s3c_rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
-
-        s3c_rtc_freq = freq;
 
+        tmp = readb(s3c_rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
         tmp |= (128 / freq)-1;
 
         writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
         spin_unlock_irq(&s3c_rtc_pie_lock);
+
+        return 0;
 }
 
 /* Time read/write */
@@ -134,12 +134,12 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
                  rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
                  rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
 
-        BCD_TO_BIN(rtc_tm->tm_sec);
-        BCD_TO_BIN(rtc_tm->tm_min);
-        BCD_TO_BIN(rtc_tm->tm_hour);
-        BCD_TO_BIN(rtc_tm->tm_mday);
-        BCD_TO_BIN(rtc_tm->tm_mon);
-        BCD_TO_BIN(rtc_tm->tm_year);
+        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+        rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+        rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+        rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+        rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+        rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 
         rtc_tm->tm_year += 100;
         rtc_tm->tm_mon -= 1;
@@ -163,12 +163,12 @@ static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
                 return -EINVAL;
         }
 
-        writeb(BIN2BCD(tm->tm_sec),  base + S3C2410_RTCSEC);
-        writeb(BIN2BCD(tm->tm_min),  base + S3C2410_RTCMIN);
-        writeb(BIN2BCD(tm->tm_hour), base + S3C2410_RTCHOUR);
-        writeb(BIN2BCD(tm->tm_mday), base + S3C2410_RTCDATE);
-        writeb(BIN2BCD(tm->tm_mon + 1), base + S3C2410_RTCMON);
-        writeb(BIN2BCD(year), base + S3C2410_RTCYEAR);
+        writeb(bin2bcd(tm->tm_sec),  base + S3C2410_RTCSEC);
+        writeb(bin2bcd(tm->tm_min),  base + S3C2410_RTCMIN);
+        writeb(bin2bcd(tm->tm_hour), base + S3C2410_RTCHOUR);
+        writeb(bin2bcd(tm->tm_mday), base + S3C2410_RTCDATE);
+        writeb(bin2bcd(tm->tm_mon + 1), base + S3C2410_RTCMON);
+        writeb(bin2bcd(year), base + S3C2410_RTCYEAR);
 
         return 0;
 }
@@ -199,34 +199,34 @@ static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
         /* decode the alarm enable field */
 
         if (alm_en & S3C2410_RTCALM_SECEN)
-                BCD_TO_BIN(alm_tm->tm_sec);
+                alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
         else
                 alm_tm->tm_sec = 0xff;
 
         if (alm_en & S3C2410_RTCALM_MINEN)
-                BCD_TO_BIN(alm_tm->tm_min);
+                alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
         else
                 alm_tm->tm_min = 0xff;
 
         if (alm_en & S3C2410_RTCALM_HOUREN)
-                BCD_TO_BIN(alm_tm->tm_hour);
+                alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
         else
                 alm_tm->tm_hour = 0xff;
 
         if (alm_en & S3C2410_RTCALM_DAYEN)
-                BCD_TO_BIN(alm_tm->tm_mday);
+                alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
         else
                 alm_tm->tm_mday = 0xff;
 
         if (alm_en & S3C2410_RTCALM_MONEN) {
-                BCD_TO_BIN(alm_tm->tm_mon);
+                alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
                 alm_tm->tm_mon -= 1;
         } else {
                 alm_tm->tm_mon = 0xff;
         }
 
         if (alm_en & S3C2410_RTCALM_YEAREN)
-                BCD_TO_BIN(alm_tm->tm_year);
+                alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
         else
                 alm_tm->tm_year = 0xffff;
 
@@ -250,29 +250,24 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         if (tm->tm_sec < 60 && tm->tm_sec >= 0) {
                 alrm_en |= S3C2410_RTCALM_SECEN;
-                writeb(BIN2BCD(tm->tm_sec), base + S3C2410_ALMSEC);
+                writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC);
         }
 
         if (tm->tm_min < 60 && tm->tm_min >= 0) {
                 alrm_en |= S3C2410_RTCALM_MINEN;
-                writeb(BIN2BCD(tm->tm_min), base + S3C2410_ALMMIN);
+                writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN);
         }
 
         if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
                 alrm_en |= S3C2410_RTCALM_HOUREN;
-                writeb(BIN2BCD(tm->tm_hour), base + S3C2410_ALMHOUR);
+                writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR);
         }
 
         pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en);
 
         writeb(alrm_en, base + S3C2410_RTCALM);
 
-        if (0) {
-                alrm_en = readb(base + S3C2410_RTCALM);
-                alrm_en &= ~S3C2410_RTCALM_ALMEN;
-                writeb(alrm_en, base + S3C2410_RTCALM);
-                disable_irq_wake(s3c_rtc_alarmno);
-        }
+        s3c_rtc_setaie(alrm->enabled);
 
         if (alrm->enabled)
                 enable_irq_wake(s3c_rtc_alarmno);
@@ -282,59 +277,12 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
         return 0;
 }
 
-static int s3c_rtc_ioctl(struct device *dev,
-                         unsigned int cmd, unsigned long arg)
-{
-        unsigned int ret = -ENOIOCTLCMD;
-
-        switch (cmd) {
-        case RTC_AIE_OFF:
-        case RTC_AIE_ON:
-                s3c_rtc_setaie((cmd == RTC_AIE_ON) ? 1 : 0);
-                ret = 0;
-                break;
-
-        case RTC_PIE_OFF:
-        case RTC_PIE_ON:
-                tick_count = 0;
-                s3c_rtc_setpie((cmd == RTC_PIE_ON) ? 1 : 0);
-                ret = 0;
-                break;
-
-        case RTC_IRQP_READ:
-                ret = put_user(s3c_rtc_freq, (unsigned long __user *)arg);
-                break;
-
-        case RTC_IRQP_SET:
-                if (!is_power_of_2(arg)) {
-                        ret = -EINVAL;
-                        goto exit;
-                }
-
-                pr_debug("s3c2410_rtc: setting frequency %ld\n", arg);
-
-                s3c_rtc_setfreq(arg);
-                ret = 0;
-                break;
-
-        case RTC_UIE_ON:
-        case RTC_UIE_OFF:
-                ret = -EINVAL;
-        }
-
- exit:
-        return ret;
-}
-
 static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
 {
         unsigned int ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
 
         seq_printf(seq, "periodic_IRQ\t: %s\n",
                      (ticnt & S3C2410_TICNT_ENABLE) ? "yes" : "no" );
-
-        seq_printf(seq, "periodic_freq\t: %d\n", s3c_rtc_freq);
-
         return 0;
 }
 
@@ -374,7 +322,7 @@ static void s3c_rtc_release(struct device *dev)
 
         /* do not clear AIE here, it may be needed for wake */
 
-        s3c_rtc_setpie(0);
+        s3c_rtc_setpie(dev, 0);
         free_irq(s3c_rtc_alarmno, rtc_dev);
         free_irq(s3c_rtc_tickno, rtc_dev);
 }
@@ -382,11 +330,12 @@ static void s3c_rtc_release(struct device *dev)
 static const struct rtc_class_ops s3c_rtcops = {
         .open           = s3c_rtc_open,
         .release        = s3c_rtc_release,
-        .ioctl          = s3c_rtc_ioctl,
         .read_time      = s3c_rtc_gettime,
         .set_time       = s3c_rtc_settime,
         .read_alarm     = s3c_rtc_getalarm,
         .set_alarm      = s3c_rtc_setalarm,
+        .irq_set_freq   = s3c_rtc_setfreq,
+        .irq_set_state  = s3c_rtc_setpie,
         .proc           = s3c_rtc_proc,
 };
 
@@ -430,14 +379,14 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
         }
 }
 
-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);
 
         platform_set_drvdata(dev, NULL);
         rtc_device_unregister(rtc);
 
-        s3c_rtc_setpie(0);
+        s3c_rtc_setpie(&dev->dev, 0);
         s3c_rtc_setaie(0);
 
         iounmap(s3c_rtc_base);
@@ -447,7 +396,7 @@ static int s3c_rtc_remove(struct platform_device *dev)
         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 resource *res;
@@ -504,7 +453,7 @@ static int s3c_rtc_probe(struct platform_device *pdev)
         pr_debug("s3c2410_rtc: RTCCON=%02x\n",
                  readb(s3c_rtc_base + S3C2410_RTCCON));
 
-        s3c_rtc_setfreq(s3c_rtc_freq);
+        s3c_rtc_setfreq(&pdev->dev, 1);
 
         /* register RTC and exit */
 
@@ -560,7 +509,7 @@ static int s3c_rtc_resume(struct platform_device *pdev)
 
 static struct platform_driver s3c2410_rtcdrv = {
         .probe          = s3c_rtc_probe,
-        .remove         = s3c_rtc_remove,
+        .remove         = __devexit_p(s3c_rtc_remove),
         .suspend        = s3c_rtc_suspend,
         .resume         = s3c_rtc_resume,
         .driver         = {
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index f47294c60148..66a9bb85bbe8 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -31,11 +31,11 @@
 #include <linux/pm.h>
 #include <linux/bitops.h>
 
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/irq.h>
 
 #ifdef CONFIG_ARCH_PXA
-#include <asm/arch/pxa-regs.h>
+#include <mach/pxa-regs.h>
 #endif
 
 #define TIMER_FREQ              CLOCK_TICK_RATE
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 1f88e9e914ec..aaf9d6a337cc 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -257,12 +257,6 @@ static inline void sh_rtc_setaie(struct device *dev, unsigned int enable)
         spin_unlock_irq(&rtc->lock);
 }
 
-static void sh_rtc_release(struct device *dev)
-{
-        sh_rtc_setpie(dev, 0);
-        sh_rtc_setaie(dev, 0);
-}
-
 static int sh_rtc_proc(struct device *dev, struct seq_file *seq)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
@@ -330,23 +324,23 @@ static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
                 sec128 = readb(rtc->regbase + R64CNT);
 
-                tm->tm_sec      = BCD2BIN(readb(rtc->regbase + RSECCNT));
-                tm->tm_min      = BCD2BIN(readb(rtc->regbase + RMINCNT));
-                tm->tm_hour     = BCD2BIN(readb(rtc->regbase + RHRCNT));
-                tm->tm_wday     = BCD2BIN(readb(rtc->regbase + RWKCNT));
-                tm->tm_mday     = BCD2BIN(readb(rtc->regbase + RDAYCNT));
-                tm->tm_mon      = BCD2BIN(readb(rtc->regbase + RMONCNT)) - 1;
+                tm->tm_sec      = bcd2bin(readb(rtc->regbase + RSECCNT));
+                tm->tm_min      = bcd2bin(readb(rtc->regbase + RMINCNT));
+                tm->tm_hour     = bcd2bin(readb(rtc->regbase + RHRCNT));
+                tm->tm_wday     = bcd2bin(readb(rtc->regbase + RWKCNT));
+                tm->tm_mday     = bcd2bin(readb(rtc->regbase + RDAYCNT));
+                tm->tm_mon      = bcd2bin(readb(rtc->regbase + RMONCNT)) - 1;
 
                 if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
                         yr  = readw(rtc->regbase + RYRCNT);
-                        yr100 = BCD2BIN(yr >> 8);
+                        yr100 = bcd2bin(yr >> 8);
                         yr &= 0xff;
                 } else {
                         yr  = readb(rtc->regbase + RYRCNT);
-                        yr100 = BCD2BIN((yr == 0x99) ? 0x19 : 0x20);
+                        yr100 = bcd2bin((yr == 0x99) ? 0x19 : 0x20);
                 }
 
-                tm->tm_year = (yr100 * 100 + BCD2BIN(yr)) - 1900;
+                tm->tm_year = (yr100 * 100 + bcd2bin(yr)) - 1900;
 
                 sec2 = readb(rtc->regbase + R64CNT);
                 cf_bit = readb(rtc->regbase + RCR1) & RCR1_CF;
@@ -388,20 +382,20 @@ static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm)
         tmp &= ~RCR2_START;
         writeb(tmp, rtc->regbase + RCR2);
 
-        writeb(BIN2BCD(tm->tm_sec),  rtc->regbase + RSECCNT);
-        writeb(BIN2BCD(tm->tm_min),  rtc->regbase + RMINCNT);
-        writeb(BIN2BCD(tm->tm_hour), rtc->regbase + RHRCNT);
-        writeb(BIN2BCD(tm->tm_wday), rtc->regbase + RWKCNT);
-        writeb(BIN2BCD(tm->tm_mday), rtc->regbase + RDAYCNT);
-        writeb(BIN2BCD(tm->tm_mon + 1), rtc->regbase + RMONCNT);
+        writeb(bin2bcd(tm->tm_sec),  rtc->regbase + RSECCNT);
+        writeb(bin2bcd(tm->tm_min),  rtc->regbase + RMINCNT);
+        writeb(bin2bcd(tm->tm_hour), rtc->regbase + RHRCNT);
+        writeb(bin2bcd(tm->tm_wday), rtc->regbase + RWKCNT);
+        writeb(bin2bcd(tm->tm_mday), rtc->regbase + RDAYCNT);
+        writeb(bin2bcd(tm->tm_mon + 1), rtc->regbase + RMONCNT);
 
         if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
-                year = (BIN2BCD((tm->tm_year + 1900) / 100) << 8) |
-                        BIN2BCD(tm->tm_year % 100);
+                year = (bin2bcd((tm->tm_year + 1900) / 100) << 8) |
+                        bin2bcd(tm->tm_year % 100);
                 writew(year, rtc->regbase + RYRCNT);
         } else {
                 year = tm->tm_year % 100;
-                writeb(BIN2BCD(year), rtc->regbase + RYRCNT);
+                writeb(bin2bcd(year), rtc->regbase + RYRCNT);
         }
 
         /* Start RTC */
@@ -423,7 +417,7 @@ static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)
         byte = readb(rtc->regbase + reg_off);
         if (byte & AR_ENB) {
                 byte &= ~AR_ENB;        /* strip the enable bit */
-                value = BCD2BIN(byte);
+                value = bcd2bin(byte);
         }
 
         return value;
@@ -461,7 +455,7 @@ static inline void sh_rtc_write_alarm_value(struct sh_rtc *rtc,
         if (value < 0)
                 writeb(0, rtc->regbase + reg_off);
         else
-                writeb(BIN2BCD(value) | AR_ENB,  rtc->regbase + reg_off);
+                writeb(bin2bcd(value) | AR_ENB,  rtc->regbase + reg_off);
 }
 
 static int sh_rtc_check_alarm(struct rtc_time *tm)
@@ -559,7 +553,6 @@ static int sh_rtc_irq_set_freq(struct device *dev, int freq)
 }
 
 static struct rtc_class_ops sh_rtc_ops = {
-        .release        = sh_rtc_release,
         .ioctl          = sh_rtc_ioctl,
         .read_time      = sh_rtc_read_time,
         .set_time       = sh_rtc_set_time,
@@ -575,7 +568,7 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
         struct sh_rtc *rtc;
         struct resource *res;
         unsigned int tmp;
-        int ret = -ENOENT;
+        int ret;
 
         rtc = kzalloc(sizeof(struct sh_rtc), GFP_KERNEL);
         if (unlikely(!rtc))
@@ -584,26 +577,33 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
         spin_lock_init(&rtc->lock);
 
         /* get periodic/carry/alarm irqs */
-        rtc->periodic_irq = platform_get_irq(pdev, 0);
-        if (unlikely(rtc->periodic_irq < 0)) {
+        ret = platform_get_irq(pdev, 0);
+        if (unlikely(ret < 0)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IRQ for period\n");
                 goto err_badres;
         }
+        rtc->periodic_irq = ret;
 
-        rtc->carry_irq = platform_get_irq(pdev, 1);
-        if (unlikely(rtc->carry_irq < 0)) {
+        ret = platform_get_irq(pdev, 1);
+        if (unlikely(ret < 0)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IRQ for carry\n");
                 goto err_badres;
         }
+        rtc->carry_irq = ret;
 
-        rtc->alarm_irq = platform_get_irq(pdev, 2);
-        if (unlikely(rtc->alarm_irq < 0)) {
+        ret = platform_get_irq(pdev, 2);
+        if (unlikely(ret < 0)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IRQ for alarm\n");
                 goto err_badres;
         }
+        rtc->alarm_irq = ret;
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
         if (unlikely(res == NULL)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IO resource\n");
                 goto err_badres;
         }
diff --git a/drivers/rtc/rtc-starfire.c b/drivers/rtc/rtc-starfire.c
new file mode 100644
index 000000000000..7ccb0dd700af
--- /dev/null
+++ b/drivers/rtc/rtc-starfire.c
@@ -0,0 +1,120 @@
+/* rtc-starfire.c: Starfire platform RTC driver.
+ *
+ * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+
+#include <asm/oplib.h>
+
+MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
+MODULE_DESCRIPTION("Starfire RTC driver");
+MODULE_LICENSE("GPL");
+
+struct starfire_rtc {
+        struct rtc_device       *rtc;
+        spinlock_t              lock;
+};
+
+static u32 starfire_get_time(void)
+{
+        static char obp_gettod[32];
+        static u32 unix_tod;
+
+        sprintf(obp_gettod, "h# %08x unix-gettod",
+                (unsigned int) (long) &unix_tod);
+        prom_feval(obp_gettod);
+
+        return unix_tod;
+}
+
+static int starfire_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct starfire_rtc *p = dev_get_drvdata(dev);
+        unsigned long flags, secs;
+
+        spin_lock_irqsave(&p->lock, flags);
+        secs = starfire_get_time();
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        rtc_time_to_tm(secs, tm);
+
+        return 0;
+}
+
+static int starfire_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long secs;
+        int err;
+
+        err = rtc_tm_to_time(tm, &secs);
+        if (err)
+                return err;
+
+        /* Do nothing, time is set using the service processor
+         * console on this platform.
+         */
+        return 0;
+}
+
+static const struct rtc_class_ops starfire_rtc_ops = {
+        .read_time      = starfire_read_time,
+        .set_time       = starfire_set_time,
+};
+
+static int __devinit starfire_rtc_probe(struct platform_device *pdev)
+{
+        struct starfire_rtc *p = kzalloc(sizeof(*p), GFP_KERNEL);
+
+        if (!p)
+                return -ENOMEM;
+
+        spin_lock_init(&p->lock);
+
+        p->rtc = rtc_device_register("starfire", &pdev->dev,
+                                     &starfire_rtc_ops, THIS_MODULE);
+        if (IS_ERR(p->rtc)) {
+                int err = PTR_ERR(p->rtc);
+                kfree(p);
+                return err;
+        }
+        platform_set_drvdata(pdev, p);
+        return 0;
+}
+
+static int __devexit starfire_rtc_remove(struct platform_device *pdev)
+{
+        struct starfire_rtc *p = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(p->rtc);
+        kfree(p);
+
+        return 0;
+}
+
+static struct platform_driver starfire_rtc_driver = {
+        .driver         = {
+                .name   = "rtc-starfire",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = starfire_rtc_probe,
+        .remove         = __devexit_p(starfire_rtc_remove),
+};
+
+static int __init starfire_rtc_init(void)
+{
+        return platform_driver_register(&starfire_rtc_driver);
+}
+
+static void __exit starfire_rtc_exit(void)
+{
+        platform_driver_unregister(&starfire_rtc_driver);
+}
+
+module_init(starfire_rtc_init);
+module_exit(starfire_rtc_exit);
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
index 31d3c8c28588..f4cd46e15af9 100644
--- a/drivers/rtc/rtc-stk17ta8.c
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -82,14 +82,14 @@ static int stk17ta8_rtc_set_time(struct device *dev, struct rtc_time *tm)
         flags = readb(pdata->ioaddr + RTC_FLAGS);
         writeb(flags | RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
 
-        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
-        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
-        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
-        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
-        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
-        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
-        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
-        writeb(BIN2BCD((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);
+        writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(bin2bcd((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);
 
         writeb(flags & ~RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
         return 0;
@@ -120,14 +120,14 @@ static int stk17ta8_rtc_read_time(struct device *dev, struct rtc_time *tm)
         year = readb(ioaddr + RTC_YEAR);
         century = readb(ioaddr + RTC_CENTURY);
         writeb(flags & ~RTC_READ, ioaddr + RTC_FLAGS);
-        tm->tm_sec = BCD2BIN(second);
-        tm->tm_min = BCD2BIN(minute);
-        tm->tm_hour = BCD2BIN(hour);
-        tm->tm_mday = BCD2BIN(day);
-        tm->tm_wday = BCD2BIN(week);
-        tm->tm_mon = BCD2BIN(month) - 1;
+        tm->tm_sec = bcd2bin(second);
+        tm->tm_min = bcd2bin(minute);
+        tm->tm_hour = bcd2bin(hour);
+        tm->tm_mday = bcd2bin(day);
+        tm->tm_wday = bcd2bin(week);
+        tm->tm_mon = bcd2bin(month) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+        tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
 
         if (rtc_valid_tm(tm) < 0) {
                 dev_err(dev, "retrieved date/time is not valid.\n");
@@ -148,16 +148,16 @@ static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
         writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
 
         writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_mday),
+               0x80 : bin2bcd(pdata->alrm_mday),
                ioaddr + RTC_DATE_ALARM);
         writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_hour),
+               0x80 : bin2bcd(pdata->alrm_hour),
                ioaddr + RTC_HOURS_ALARM);
         writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_min),
+               0x80 : bin2bcd(pdata->alrm_min),
                ioaddr + RTC_MINUTES_ALARM);
         writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_sec),
+               0x80 : bin2bcd(pdata->alrm_sec),
                ioaddr + RTC_SECONDS_ALARM);
         writeb(pdata->irqen ? RTC_INTS_AIE : 0, ioaddr + RTC_INTERRUPTS);
         readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
@@ -215,17 +215,6 @@ static irqreturn_t stk17ta8_rtc_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static void stk17ta8_rtc_release(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-
-        if (pdata->irq >= 0) {
-                pdata->irqen = 0;
-                stk17ta8_rtc_update_alarm(pdata);
-        }
-}
-
 static int stk17ta8_rtc_ioctl(struct device *dev, unsigned int cmd,
                             unsigned long arg)
 {
@@ -254,7 +243,6 @@ static const struct rtc_class_ops stk17ta8_rtc_ops = {
         .set_time       = stk17ta8_rtc_set_time,
         .read_alarm     = stk17ta8_rtc_read_alarm,
         .set_alarm      = stk17ta8_rtc_set_alarm,
-        .release        = stk17ta8_rtc_release,
         .ioctl          = stk17ta8_rtc_ioctl,
 };
 
@@ -292,7 +280,6 @@ static struct bin_attribute stk17ta8_nvram_attr = {
         .attr = {
                 .name = "nvram",
                 .mode = S_IRUGO | S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .size = RTC_OFFSET,
         .read = stk17ta8_nvram_read,
diff --git a/drivers/rtc/rtc-sun4v.c b/drivers/rtc/rtc-sun4v.c
new file mode 100644
index 000000000000..2012ccbb4a53
--- /dev/null
+++ b/drivers/rtc/rtc-sun4v.c
@@ -0,0 +1,153 @@
+/* rtc-sun4c.c: Hypervisor based RTC for SUN4V systems.
+ *
+ * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+
+#include <asm/hypervisor.h>
+
+MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
+MODULE_DESCRIPTION("SUN4V RTC driver");
+MODULE_LICENSE("GPL");
+
+struct sun4v_rtc {
+        struct rtc_device       *rtc;
+        spinlock_t              lock;
+};
+
+static unsigned long hypervisor_get_time(void)
+{
+        unsigned long ret, time;
+        int retries = 10000;
+
+retry:
+        ret = sun4v_tod_get(&time);
+        if (ret == HV_EOK)
+                return time;
+        if (ret == HV_EWOULDBLOCK) {
+                if (--retries > 0) {
+                        udelay(100);
+                        goto retry;
+                }
+                printk(KERN_WARNING "SUN4V: tod_get() timed out.\n");
+                return 0;
+        }
+        printk(KERN_WARNING "SUN4V: tod_get() not supported.\n");
+        return 0;
+}
+
+static int sun4v_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct sun4v_rtc *p = dev_get_drvdata(dev);
+        unsigned long flags, secs;
+
+        spin_lock_irqsave(&p->lock, flags);
+        secs = hypervisor_get_time();
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        rtc_time_to_tm(secs, tm);
+
+        return 0;
+}
+
+static int hypervisor_set_time(unsigned long secs)
+{
+        unsigned long ret;
+        int retries = 10000;
+
+retry:
+        ret = sun4v_tod_set(secs);
+        if (ret == HV_EOK)
+                return 0;
+        if (ret == HV_EWOULDBLOCK) {
+                if (--retries > 0) {
+                        udelay(100);
+                        goto retry;
+                }
+                printk(KERN_WARNING "SUN4V: tod_set() timed out.\n");
+                return -EAGAIN;
+        }
+        printk(KERN_WARNING "SUN4V: tod_set() not supported.\n");
+        return -EOPNOTSUPP;
+}
+
+static int sun4v_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct sun4v_rtc *p = dev_get_drvdata(dev);
+        unsigned long flags, secs;
+        int err;
+
+        err = rtc_tm_to_time(tm, &secs);
+        if (err)
+                return err;
+
+        spin_lock_irqsave(&p->lock, flags);
+        err = hypervisor_set_time(secs);
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        return err;
+}
+
+static const struct rtc_class_ops sun4v_rtc_ops = {
+        .read_time      = sun4v_read_time,
+        .set_time       = sun4v_set_time,
+};
+
+static int __devinit sun4v_rtc_probe(struct platform_device *pdev)
+{
+        struct sun4v_rtc *p = kzalloc(sizeof(*p), GFP_KERNEL);
+
+        if (!p)
+                return -ENOMEM;
+
+        spin_lock_init(&p->lock);
+
+        p->rtc = rtc_device_register("sun4v", &pdev->dev,
+                                     &sun4v_rtc_ops, THIS_MODULE);
+        if (IS_ERR(p->rtc)) {
+                int err = PTR_ERR(p->rtc);
+                kfree(p);
+                return err;
+        }
+        platform_set_drvdata(pdev, p);
+        return 0;
+}
+
+static int __devexit sun4v_rtc_remove(struct platform_device *pdev)
+{
+        struct sun4v_rtc *p = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(p->rtc);
+        kfree(p);
+
+        return 0;
+}
+
+static struct platform_driver sun4v_rtc_driver = {
+        .driver         = {
+                .name   = "rtc-sun4v",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sun4v_rtc_probe,
+        .remove         = __devexit_p(sun4v_rtc_remove),
+};
+
+static int __init sun4v_rtc_init(void)
+{
+        return platform_driver_register(&sun4v_rtc_driver);
+}
+
+static void __exit sun4v_rtc_exit(void)
+{
+        platform_driver_unregister(&sun4v_rtc_driver);
+}
+
+module_init(sun4v_rtc_init);
+module_exit(sun4v_rtc_exit);
diff --git a/drivers/rtc/rtc-twl4030.c b/drivers/rtc/rtc-twl4030.c
new file mode 100644
index 000000000000..abe87a4d2665
--- /dev/null
+++ b/drivers/rtc/rtc-twl4030.c
@@ -0,0 +1,564 @@
+/*
+ * rtc-twl4030.c -- TWL4030 Real Time Clock interface
+ *
+ * Copyright (C) 2007 MontaVista Software, Inc
+ * Author: Alexandre Rusev <source@mvista.com>
+ *
+ * Based on original TI driver twl4030-rtc.c
+ *   Copyright (C) 2006 Texas Instruments, Inc.
+ *
+ * Based on rtc-omap.c
+ *   Copyright (C) 2003 MontaVista Software, Inc.
+ *   Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
+ *   Copyright (C) 2006 David Brownell
+ *
+ * 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/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/i2c/twl4030.h>
+
+
+/*
+ * RTC block register offsets (use TWL_MODULE_RTC)
+ */
+#define REG_SECONDS_REG                          0x00
+#define REG_MINUTES_REG                          0x01
+#define REG_HOURS_REG                            0x02
+#define REG_DAYS_REG                             0x03
+#define REG_MONTHS_REG                           0x04
+#define REG_YEARS_REG                            0x05
+#define REG_WEEKS_REG                            0x06
+
+#define REG_ALARM_SECONDS_REG                    0x07
+#define REG_ALARM_MINUTES_REG                    0x08
+#define REG_ALARM_HOURS_REG                      0x09
+#define REG_ALARM_DAYS_REG                       0x0A
+#define REG_ALARM_MONTHS_REG                     0x0B
+#define REG_ALARM_YEARS_REG                      0x0C
+
+#define REG_RTC_CTRL_REG                         0x0D
+#define REG_RTC_STATUS_REG                       0x0E
+#define REG_RTC_INTERRUPTS_REG                   0x0F
+
+#define REG_RTC_COMP_LSB_REG                     0x10
+#define REG_RTC_COMP_MSB_REG                     0x11
+
+/* RTC_CTRL_REG bitfields */
+#define BIT_RTC_CTRL_REG_STOP_RTC_M              0x01
+#define BIT_RTC_CTRL_REG_ROUND_30S_M             0x02
+#define BIT_RTC_CTRL_REG_AUTO_COMP_M             0x04
+#define BIT_RTC_CTRL_REG_MODE_12_24_M            0x08
+#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
+
+/* RTC_STATUS_REG bitfields */
+#define BIT_RTC_STATUS_REG_RUN_M                 0x02
+#define BIT_RTC_STATUS_REG_1S_EVENT_M            0x04
+#define BIT_RTC_STATUS_REG_1M_EVENT_M            0x08
+#define BIT_RTC_STATUS_REG_1H_EVENT_M            0x10
+#define BIT_RTC_STATUS_REG_1D_EVENT_M            0x20
+#define BIT_RTC_STATUS_REG_ALARM_M               0x40
+#define BIT_RTC_STATUS_REG_POWER_UP_M            0x80
+
+/* RTC_INTERRUPTS_REG bitfields */
+#define BIT_RTC_INTERRUPTS_REG_EVERY_M           0x03
+#define BIT_RTC_INTERRUPTS_REG_IT_TIMER_M        0x04
+#define BIT_RTC_INTERRUPTS_REG_IT_ALARM_M        0x08
+
+
+/* REG_SECONDS_REG through REG_YEARS_REG is how many registers? */
+#define ALL_TIME_REGS           6
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * Supports 1 byte read from TWL4030 RTC register.
+ */
+static int twl4030_rtc_read_u8(u8 *data, u8 reg)
+{
+        int ret;
+
+        ret = twl4030_i2c_read_u8(TWL4030_MODULE_RTC, data, reg);
+        if (ret < 0)
+                pr_err("twl4030_rtc: Could not read TWL4030"
+                       "register %X - error %d\n", reg, ret);
+        return ret;
+}
+
+/*
+ * Supports 1 byte write to TWL4030 RTC registers.
+ */
+static int twl4030_rtc_write_u8(u8 data, u8 reg)
+{
+        int ret;
+
+        ret = twl4030_i2c_write_u8(TWL4030_MODULE_RTC, data, reg);
+        if (ret < 0)
+                pr_err("twl4030_rtc: Could not write TWL4030"
+                       "register %X - error %d\n", reg, ret);
+        return ret;
+}
+
+/*
+ * Cache the value for timer/alarm interrupts register; this is
+ * only changed by callers holding rtc ops lock (or resume).
+ */
+static unsigned char rtc_irq_bits;
+
+/*
+ * Enable timer and/or alarm interrupts.
+ */
+static int set_rtc_irq_bit(unsigned char bit)
+{
+        unsigned char val;
+        int ret;
+
+        val = rtc_irq_bits | bit;
+        ret = twl4030_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
+        if (ret == 0)
+                rtc_irq_bits = val;
+
+        return ret;
+}
+
+/*
+ * Disable timer and/or alarm interrupts.
+ */
+static int mask_rtc_irq_bit(unsigned char bit)
+{
+        unsigned char val;
+        int ret;
+
+        val = rtc_irq_bits & ~bit;
+        ret = twl4030_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
+        if (ret == 0)
+                rtc_irq_bits = val;
+
+        return ret;
+}
+
+static inline int twl4030_rtc_alarm_irq_set_state(int enabled)
+{
+        int ret;
+
+        if (enabled)
+                ret = set_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
+        else
+                ret = mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
+
+        return ret;
+}
+
+static inline int twl4030_rtc_irq_set_state(int enabled)
+{
+        int ret;
+
+        if (enabled)
+                ret = set_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
+        else
+                ret = mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
+
+        return ret;
+}
+
+/*
+ * Gets current TWL4030 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 twl4030_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char rtc_data[ALL_TIME_REGS + 1];
+        int ret;
+        u8 save_control;
+
+        ret = twl4030_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
+        if (ret < 0)
+                return ret;
+
+        save_control |= BIT_RTC_CTRL_REG_GET_TIME_M;
+
+        ret = twl4030_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
+        if (ret < 0)
+                return ret;
+
+        ret = twl4030_i2c_read(TWL4030_MODULE_RTC, rtc_data,
+                               REG_SECONDS_REG, ALL_TIME_REGS);
+
+        if (ret < 0) {
+                dev_err(dev, "rtc_read_time error %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 twl4030_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char save_control;
+        unsigned char rtc_data[ALL_TIME_REGS + 1];
+        int ret;
+
+        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 = twl4030_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);
+        if (ret < 0)
+                goto out;
+
+        save_control &= ~BIT_RTC_CTRL_REG_STOP_RTC_M;
+        twl4030_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
+        if (ret < 0)
+                goto out;
+
+        /* update all the time registers in one shot */
+        ret = twl4030_i2c_write(TWL4030_MODULE_RTC, rtc_data,
+                        REG_SECONDS_REG, ALL_TIME_REGS);
+        if (ret < 0) {
+                dev_err(dev, "rtc_set_time error %d\n", ret);
+                goto out;
+        }
+
+        /* Start back RTC */
+        save_control |= BIT_RTC_CTRL_REG_STOP_RTC_M;
+        ret = twl4030_rtc_write_u8(save_control, REG_RTC_CTRL_REG);
+
+out:
+        return ret;
+}
+
+/*
+ * Gets current TWL4030 RTC alarm time.
+ */
+static int twl4030_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        unsigned char rtc_data[ALL_TIME_REGS + 1];
+        int ret;
+
+        ret = twl4030_i2c_read(TWL4030_MODULE_RTC, rtc_data,
+                               REG_ALARM_SECONDS_REG, ALL_TIME_REGS);
+        if (ret < 0) {
+                dev_err(dev, "rtc_read_alarm error %d\n", ret);
+                return ret;
+        }
+
+        /* some of these fields may be wildcard/"match all" */
+        alm->time.tm_sec = bcd2bin(rtc_data[0]);
+        alm->time.tm_min = bcd2bin(rtc_data[1]);
+        alm->time.tm_hour = bcd2bin(rtc_data[2]);
+        alm->time.tm_mday = bcd2bin(rtc_data[3]);
+        alm->time.tm_mon = bcd2bin(rtc_data[4]) - 1;
+        alm->time.tm_year = bcd2bin(rtc_data[5]) + 100;
+
+        /* report cached alarm enable state */
+        if (rtc_irq_bits & BIT_RTC_INTERRUPTS_REG_IT_ALARM_M)
+                alm->enabled = 1;
+
+        return ret;
+}
+
+static int twl4030_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        unsigned char alarm_data[ALL_TIME_REGS + 1];
+        int ret;
+
+        ret = twl4030_rtc_alarm_irq_set_state(0);
+        if (ret)
+                goto out;
+
+        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 = twl4030_i2c_write(TWL4030_MODULE_RTC, alarm_data,
+                        REG_ALARM_SECONDS_REG, ALL_TIME_REGS);
+        if (ret) {
+                dev_err(dev, "rtc_set_alarm error %d\n", ret);
+                goto out;
+        }
+
+        if (alm->enabled)
+                ret = twl4030_rtc_alarm_irq_set_state(1);
+out:
+        return ret;
+}
+
+#ifdef  CONFIG_RTC_INTF_DEV
+
+static int twl4030_rtc_ioctl(struct device *dev, unsigned int cmd,
+                             unsigned long arg)
+{
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                return twl4030_rtc_alarm_irq_set_state(0);
+        case RTC_AIE_ON:
+                return twl4030_rtc_alarm_irq_set_state(1);
+        case RTC_UIE_OFF:
+                return twl4030_rtc_irq_set_state(0);
+        case RTC_UIE_ON:
+                return twl4030_rtc_irq_set_state(1);
+
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+
+#else
+#define omap_rtc_ioctl  NULL
+#endif
+
+static irqreturn_t twl4030_rtc_interrupt(int irq, void *rtc)
+{
+        unsigned long events = 0;
+        int ret = IRQ_NONE;
+        int res;
+        u8 rd_reg;
+
+#ifdef CONFIG_LOCKDEP
+        /* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which
+         * we don't want and can't tolerate.  Although it might be
+         * friendlier not to borrow this thread context...
+         */
+        local_irq_enable();
+#endif
+
+        res = twl4030_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
+        if (res)
+                goto out;
+        /*
+         * Figure out source of interrupt: ALARM or TIMER in RTC_STATUS_REG.
+         * only one (ALARM or RTC) interrupt source may be enabled
+         * at time, we also could check our results
+         * by reading RTS_INTERRUPTS_REGISTER[IT_TIMER,IT_ALARM]
+         */
+        if (rd_reg & BIT_RTC_STATUS_REG_ALARM_M)
+                events |= RTC_IRQF | RTC_AF;
+        else
+                events |= RTC_IRQF | RTC_UF;
+
+        res = twl4030_rtc_write_u8(rd_reg | BIT_RTC_STATUS_REG_ALARM_M,
+                                   REG_RTC_STATUS_REG);
+        if (res)
+                goto out;
+
+        /* Clear on Read enabled. RTC_IT bit of TWL4030_INT_PWR_ISR1
+         * needs 2 reads to clear the interrupt. One read is done in
+         * do_twl4030_pwrirq(). Doing the second read, to clear
+         * the bit.
+         *
+         * FIXME the reason PWR_ISR1 needs an extra read is that
+         * RTC_IF retriggered until we cleared REG_ALARM_M above.
+         * But re-reading like this is a bad hack; by doing so we
+         * risk wrongly clearing status for some other IRQ (losing
+         * the interrupt).  Be smarter about handling RTC_UF ...
+         */
+        res = twl4030_i2c_read_u8(TWL4030_MODULE_INT,
+                        &rd_reg, TWL4030_INT_PWR_ISR1);
+        if (res)
+                goto out;
+
+        /* Notify RTC core on event */
+        rtc_update_irq(rtc, 1, events);
+
+        ret = IRQ_HANDLED;
+out:
+        return ret;
+}
+
+static struct rtc_class_ops twl4030_rtc_ops = {
+        .ioctl          = twl4030_rtc_ioctl,
+        .read_time      = twl4030_rtc_read_time,
+        .set_time       = twl4030_rtc_set_time,
+        .read_alarm     = twl4030_rtc_read_alarm,
+        .set_alarm      = twl4030_rtc_set_alarm,
+};
+
+/*----------------------------------------------------------------------*/
+
+static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        int ret = 0;
+        int irq = platform_get_irq(pdev, 0);
+        u8 rd_reg;
+
+        if (irq < 0)
+                return irq;
+
+        rtc = rtc_device_register(pdev->name,
+                                  &pdev->dev, &twl4030_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = -EINVAL;
+                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
+                        PTR_ERR(rtc));
+                goto out0;
+
+        }
+
+        platform_set_drvdata(pdev, rtc);
+
+        ret = twl4030_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
+
+        if (ret < 0)
+                goto out1;
+
+        if (rd_reg & BIT_RTC_STATUS_REG_POWER_UP_M)
+                dev_warn(&pdev->dev, "Power up reset detected.\n");
+
+        if (rd_reg & BIT_RTC_STATUS_REG_ALARM_M)
+                dev_warn(&pdev->dev, "Pending Alarm interrupt detected.\n");
+
+        /* Clear RTC Power up reset and pending alarm interrupts */
+        ret = twl4030_rtc_write_u8(rd_reg, REG_RTC_STATUS_REG);
+        if (ret < 0)
+                goto out1;
+
+        ret = request_irq(irq, twl4030_rtc_interrupt,
+                                IRQF_TRIGGER_RISING,
+                                rtc->dev.bus_id, rtc);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "IRQ is not free.\n");
+                goto out1;
+        }
+
+        /* Check RTC module status, Enable if it is off */
+        ret = twl4030_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG);
+        if (ret < 0)
+                goto out2;
+
+        if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) {
+                dev_info(&pdev->dev, "Enabling TWL4030-RTC.\n");
+                rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M;
+                ret = twl4030_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG);
+                if (ret < 0)
+                        goto out2;
+        }
+
+        /* init cached IRQ enable bits */
+        ret = twl4030_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG);
+        if (ret < 0)
+                goto out2;
+
+        return ret;
+
+
+out2:
+        free_irq(irq, rtc);
+out1:
+        rtc_device_unregister(rtc);
+out0:
+        return ret;
+}
+
+/*
+ * Disable all TWL4030 RTC module interrupts.
+ * Sets status flag to free.
+ */
+static int __devexit twl4030_rtc_remove(struct platform_device *pdev)
+{
+        /* leave rtc running, but disable irqs */
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
+        mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
+
+        free_irq(irq, rtc);
+
+        rtc_device_unregister(rtc);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static void twl4030_rtc_shutdown(struct platform_device *pdev)
+{
+        mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M |
+                         BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
+}
+
+#ifdef CONFIG_PM
+
+static unsigned char irqstat;
+
+static int twl4030_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        irqstat = rtc_irq_bits;
+
+        /* REVISIT alarm may need to wake us from sleep */
+        mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M |
+                         BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
+        return 0;
+}
+
+static int twl4030_rtc_resume(struct platform_device *pdev)
+{
+        set_rtc_irq_bit(irqstat);
+        return 0;
+}
+
+#else
+#define twl4030_rtc_suspend NULL
+#define twl4030_rtc_resume  NULL
+#endif
+
+MODULE_ALIAS("platform:twl4030_rtc");
+
+static struct platform_driver twl4030rtc_driver = {
+        .probe          = twl4030_rtc_probe,
+        .remove         = __devexit_p(twl4030_rtc_remove),
+        .shutdown       = twl4030_rtc_shutdown,
+        .suspend        = twl4030_rtc_suspend,
+        .resume         = twl4030_rtc_resume,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "twl4030_rtc",
+        },
+};
+
+static int __init twl4030_rtc_init(void)
+{
+        return platform_driver_register(&twl4030rtc_driver);
+}
+module_init(twl4030_rtc_init);
+
+static void __exit twl4030_rtc_exit(void)
+{
+        platform_driver_unregister(&twl4030rtc_driver);
+}
+module_exit(twl4030_rtc_exit);
+
+MODULE_AUTHOR("Texas Instruments, MontaVista Software");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
index 10025d840268..14d4f036a768 100644
--- a/drivers/rtc/rtc-v3020.c
+++ b/drivers/rtc/rtc-v3020.c
@@ -92,19 +92,19 @@ static int v3020_read_time(struct device *dev, struct rtc_time *dt)
 
         /* ...and then read constant values. */
         tmp = v3020_get_reg(chip, V3020_SECONDS);
-        dt->tm_sec      = BCD2BIN(tmp);
+        dt->tm_sec      = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_MINUTES);
-        dt->tm_min      = BCD2BIN(tmp);
+        dt->tm_min      = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_HOURS);
-        dt->tm_hour     = BCD2BIN(tmp);
+        dt->tm_hour     = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_MONTH_DAY);
-        dt->tm_mday     = BCD2BIN(tmp);
+        dt->tm_mday     = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_MONTH);
-        dt->tm_mon    = BCD2BIN(tmp) - 1;
+        dt->tm_mon    = bcd2bin(tmp) - 1;
         tmp = v3020_get_reg(chip, V3020_WEEK_DAY);
-        dt->tm_wday     = BCD2BIN(tmp);
+        dt->tm_wday     = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_YEAR);
-        dt->tm_year = BCD2BIN(tmp)+100;
+        dt->tm_year = bcd2bin(tmp)+100;
 
 #ifdef DEBUG
         printk("\n%s : Read RTC values\n",__func__);
@@ -136,13 +136,13 @@ static int v3020_set_time(struct device *dev, struct rtc_time *dt)
 #endif
 
         /* Write all the values to ram... */
-        v3020_set_reg(chip, V3020_SECONDS,      BIN2BCD(dt->tm_sec));
-        v3020_set_reg(chip, V3020_MINUTES,      BIN2BCD(dt->tm_min));
-        v3020_set_reg(chip, V3020_HOURS,        BIN2BCD(dt->tm_hour));
-        v3020_set_reg(chip, V3020_MONTH_DAY,    BIN2BCD(dt->tm_mday));
-        v3020_set_reg(chip, V3020_MONTH,     BIN2BCD(dt->tm_mon + 1));
-        v3020_set_reg(chip, V3020_WEEK_DAY,     BIN2BCD(dt->tm_wday));
-        v3020_set_reg(chip, V3020_YEAR,         BIN2BCD(dt->tm_year % 100));
+        v3020_set_reg(chip, V3020_SECONDS,      bin2bcd(dt->tm_sec));
+        v3020_set_reg(chip, V3020_MINUTES,      bin2bcd(dt->tm_min));
+        v3020_set_reg(chip, V3020_HOURS,        bin2bcd(dt->tm_hour));
+        v3020_set_reg(chip, V3020_MONTH_DAY,    bin2bcd(dt->tm_mday));
+        v3020_set_reg(chip, V3020_MONTH,     bin2bcd(dt->tm_mon + 1));
+        v3020_set_reg(chip, V3020_WEEK_DAY,     bin2bcd(dt->tm_wday));
+        v3020_set_reg(chip, V3020_YEAR,         bin2bcd(dt->tm_year % 100));
 
         /* ...and set the clock. */
         v3020_set_reg(chip, V3020_CMD_RAM2CLOCK, 0);
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index be9c70d0b193..834dcc6d785f 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -1,7 +1,7 @@
 /*
  *  Driver for NEC VR4100 series Real Time Clock unit.
  *
- *  Copyright (C) 2003-2006  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2003-2008  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
  *
  *  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
@@ -34,7 +34,7 @@
 
 MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
 MODULE_DESCRIPTION("NEC VR4100 series RTC driver");
-MODULE_LICENSE("GPL");
+MODULE_LICENSE("GPL v2");
 
 /* RTC 1 registers */
 #define ETIMELREG               0x00
@@ -82,7 +82,6 @@ static unsigned long epoch = 1970;	/* Jan 1 1970 00:00:00 */
 
 static DEFINE_SPINLOCK(rtc_lock);
 static char rtc_name[] = "RTC";
-static unsigned long periodic_frequency;
 static unsigned long periodic_count;
 static unsigned int alarm_enabled;
 static int aie_irq = -1;
@@ -207,10 +206,37 @@ static int vr41xx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
         return 0;
 }
 
-static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+static int vr41xx_rtc_irq_set_freq(struct device *dev, int freq)
 {
         unsigned long count;
 
+        count = RTC_FREQUENCY;
+        do_div(count, freq);
+
+        periodic_count = count;
+
+        spin_lock_irq(&rtc_lock);
+
+        rtc1_write(RTCL1LREG, count);
+        rtc1_write(RTCL1HREG, count >> 16);
+
+        spin_unlock_irq(&rtc_lock);
+
+        return 0;
+}
+
+static int vr41xx_rtc_irq_set_state(struct device *dev, int enabled)
+{
+        if (enabled)
+                enable_irq(pie_irq);
+        else
+                disable_irq(pie_irq);
+
+        return 0;
+}
+
+static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
         switch (cmd) {
         case RTC_AIE_ON:
                 spin_lock_irq(&rtc_lock);
@@ -232,33 +258,6 @@ static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long
 
                 spin_unlock_irq(&rtc_lock);
                 break;
-        case RTC_PIE_ON:
-                enable_irq(pie_irq);
-                break;
-        case RTC_PIE_OFF:
-                disable_irq(pie_irq);
-                break;
-        case RTC_IRQP_READ:
-                return put_user(periodic_frequency, (unsigned long __user *)arg);
-                break;
-        case RTC_IRQP_SET:
-                if (arg > MAX_PERIODIC_RATE)
-                        return -EINVAL;
-
-                periodic_frequency = arg;
-
-                count = RTC_FREQUENCY;
-                do_div(count, arg);
-
-                periodic_count = count;
-
-                spin_lock_irq(&rtc_lock);
-
-                rtc1_write(RTCL1LREG, count);
-                rtc1_write(RTCL1HREG, count >> 16);
-
-                spin_unlock_irq(&rtc_lock);
-                break;
         case RTC_EPOCH_READ:
                 return put_user(epoch, (unsigned long __user *)arg);
         case RTC_EPOCH_SET:
@@ -309,6 +308,8 @@ static const struct rtc_class_ops vr41xx_rtc_ops = {
         .set_time       = vr41xx_rtc_set_time,
         .read_alarm     = vr41xx_rtc_read_alarm,
         .set_alarm      = vr41xx_rtc_set_alarm,
+        .irq_set_freq   = vr41xx_rtc_irq_set_freq,
+        .irq_set_state  = vr41xx_rtc_irq_set_state,
 };
 
 static int __devinit rtc_probe(struct platform_device *pdev)
@@ -346,6 +347,8 @@ static int __devinit rtc_probe(struct platform_device *pdev)
                 goto err_iounmap_all;
         }
 
+        rtc->max_user_freq = MAX_PERIODIC_RATE;
+
         spin_lock_irq(&rtc_lock);
 
         rtc1_write(ECMPLREG, 0);
@@ -357,7 +360,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
         spin_unlock_irq(&rtc_lock);
 
         aie_irq = platform_get_irq(pdev, 0);
-        if (aie_irq < 0 || aie_irq >= NR_IRQS) {
+        if (aie_irq < 0 || aie_irq >= nr_irqs) {
                 retval = -EBUSY;
                 goto err_device_unregister;
         }
@@ -368,7 +371,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
                 goto err_device_unregister;
 
         pie_irq = platform_get_irq(pdev, 1);
-        if (pie_irq < 0 || pie_irq >= NR_IRQS)
+        if (pie_irq < 0 || pie_irq >= nr_irqs)
                 goto err_free_irq;
 
         retval = request_irq(pie_irq, rtclong1_interrupt, IRQF_DISABLED,
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index 7dcfba1bbfe1..310c10795e9a 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -118,13 +118,13 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
                 for (i = 0; i <= 4; i++)
                         buf[i] &= 0x7F;
 
-        tm->tm_sec = BCD2BIN(buf[CCR_SEC]);
-        tm->tm_min = BCD2BIN(buf[CCR_MIN]);
-        tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
-        tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
-        tm->tm_mon = BCD2BIN(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
-        tm->tm_year = BCD2BIN(buf[CCR_YEAR])
-                        + (BCD2BIN(buf[CCR_Y2K]) * 100) - 1900;
+        tm->tm_sec = bcd2bin(buf[CCR_SEC]);
+        tm->tm_min = bcd2bin(buf[CCR_MIN]);
+        tm->tm_hour = bcd2bin(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
+        tm->tm_mday = bcd2bin(buf[CCR_MDAY]);
+        tm->tm_mon = bcd2bin(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
+        tm->tm_year = bcd2bin(buf[CCR_YEAR])
+                        + (bcd2bin(buf[CCR_Y2K]) * 100) - 1900;
         tm->tm_wday = buf[CCR_WDAY];
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
@@ -174,11 +174,11 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                 __func__,
                 tm->tm_sec, tm->tm_min, tm->tm_hour);
 
-        buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
-        buf[CCR_MIN] = BIN2BCD(tm->tm_min);
+        buf[CCR_SEC] = bin2bcd(tm->tm_sec);
+        buf[CCR_MIN] = bin2bcd(tm->tm_min);
 
         /* set hour and 24hr bit */
-        buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_HR_MIL;
+        buf[CCR_HOUR] = bin2bcd(tm->tm_hour) | X1205_HR_MIL;
 
         /* should we also set the date? */
         if (datetoo) {
@@ -187,15 +187,15 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                         __func__,
                         tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
-                buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
+                buf[CCR_MDAY] = bin2bcd(tm->tm_mday);
 
                 /* month, 1 - 12 */
-                buf[CCR_MONTH] = BIN2BCD(tm->tm_mon + 1);
+                buf[CCR_MONTH] = bin2bcd(tm->tm_mon + 1);
 
                 /* year, since the rtc epoch*/
-                buf[CCR_YEAR] = BIN2BCD(tm->tm_year % 100);
+                buf[CCR_YEAR] = bin2bcd(tm->tm_year % 100);
                 buf[CCR_WDAY] = tm->tm_wday & 0x07;
-                buf[CCR_Y2K] = BIN2BCD(tm->tm_year / 100);
+                buf[CCR_Y2K] = bin2bcd(tm->tm_year / 100);
         }
 
         /* If writing alarm registers, set compare bits on registers 0-4 */
@@ -437,7 +437,7 @@ static int x1205_validate_client(struct i2c_client *client)
                         return -EIO;
                 }
 
-                value = BCD2BIN(reg & probe_limits_pattern[i].mask);
+                value = bcd2bin(reg & probe_limits_pattern[i].mask);
 
                 if (value > probe_limits_pattern[i].max ||
                         value < probe_limits_pattern[i].min) {