17 files changed, 1455 insertions, 175 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index fc766a7a611e..09660e2ab051 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -154,15 +154,23 @@ config RTC_DRV_DS1672
           will be called rtc-ds1672.
 
 config RTC_DRV_DS1742
-        tristate "Dallas DS1742"
+        tristate "Dallas DS1742/1743"
         depends on RTC_CLASS
         help
           If you say yes here you get support for the
-          Dallas DS1742 timekeeping chip.
+          Dallas DS1742/1743 timekeeping chip.
 
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1742.
 
+config RTC_DRV_OMAP
+        tristate "TI OMAP1"
+        depends on RTC_CLASS && ( \
+                ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 )
+        help
+          Say "yes" here to support the real time clock on TI OMAP1 chips.
+          This driver can also be built as a module called rtc-omap.
+
 config RTC_DRV_PCF8563
         tristate "Philips PCF8563/Epson RTC8564"
         depends on RTC_CLASS && I2C
@@ -280,7 +288,7 @@ config RTC_DRV_PL031
           To compile this driver as a module, choose M here: the
           module will be called rtc-pl031.
 
-config RTC_DRV_AT91
+config RTC_DRV_AT91RM9200
         tristate "AT91RM9200"
         depends on RTC_CLASS && ARCH_AT91RM9200
         help
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 3ba5ff6e6800..e6beedacc966 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_RTC_DRV_TEST)	+= rtc-test.o
 obj-$(CONFIG_RTC_DRV_DS1307)    += rtc-ds1307.o
 obj-$(CONFIG_RTC_DRV_DS1672)    += rtc-ds1672.o
 obj-$(CONFIG_RTC_DRV_DS1742)    += rtc-ds1742.o
+obj-$(CONFIG_RTC_DRV_OMAP)      += rtc-omap.o
 obj-$(CONFIG_RTC_DRV_PCF8563)   += rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)   += rtc-pcf8583.o
 obj-$(CONFIG_RTC_DRV_RS5C372)   += rtc-rs5c372.o
@@ -34,5 +35,5 @@ obj-$(CONFIG_RTC_DRV_VR41XX)	+= rtc-vr41xx.o
 obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
 obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
-obj-$(CONFIG_RTC_DRV_AT91)      += rtc-at91.o
+obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
 obj-$(CONFIG_RTC_DRV_SH)        += rtc-sh.o
diff --git a/drivers/rtc/rtc-at91.c b/drivers/rtc/rtc-at91rm9200.c
index 5c8addcaf1fb..a724ab49a797 100644
--- a/drivers/rtc/rtc-at91.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -33,6 +33,8 @@
 
 #include <asm/mach/time.h>
 
+#include <asm/arch/at91_rtc.h>
+
 
 #define AT91_RTC_FREQ           1
 #define AT91_RTC_EPOCH          1900UL  /* just like arch/arm/common/rtctime.c */
@@ -137,6 +139,9 @@ static int at91_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
         tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
         tm->tm_year = at91_alarm_year - 1900;
 
+        alrm->enabled = (at91_sys_read(AT91_RTC_IMR) & AT91_RTC_ALARM)
+                        ? 1 : 0;
+
         pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
                 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
                 tm->tm_hour, tm->tm_min, tm->tm_sec);
@@ -223,8 +228,6 @@ static int at91_rtc_proc(struct device *dev, struct seq_file *seq)
 {
         unsigned long imr = at91_sys_read(AT91_RTC_IMR);
 
-        seq_printf(seq, "alarm_IRQ\t: %s\n",
-                        (imr & AT91_RTC_ALARM) ? "yes" : "no");
         seq_printf(seq, "update_IRQ\t: %s\n",
                         (imr & AT91_RTC_ACKUPD) ? "yes" : "no");
         seq_printf(seq, "periodic_IRQ\t: %s\n",
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 814b9e1873f5..94d3df62a5fa 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -53,9 +53,10 @@ static int rtc_dev_open(struct inode *inode, struct file *file)
  * Routine to poll RTC seconds field for change as often as possible,
  * after first RTC_UIE use timer to reduce polling
  */
-static void rtc_uie_task(void *data)
+static void rtc_uie_task(struct work_struct *work)
 {
-        struct rtc_device *rtc = data;
+        struct rtc_device *rtc =
+                container_of(work, struct rtc_device, uie_task);
         struct rtc_time tm;
         int num = 0;
         int err;
@@ -411,7 +412,7 @@ static int rtc_dev_add_device(struct class_device *class_dev,
         spin_lock_init(&rtc->irq_lock);
         init_waitqueue_head(&rtc->irq_queue);
 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
-        INIT_WORK(&rtc->uie_task, rtc_uie_task, rtc);
+        INIT_WORK(&rtc->uie_task, rtc_uie_task);
         setup_timer(&rtc->uie_timer, rtc_uie_timer, (unsigned long)rtc);
 #endif
 
@@ -434,7 +435,7 @@ static int rtc_dev_add_device(struct class_device *class_dev,
                 goto err_cdev_del;
         }
 
-        dev_info(class_dev->dev, "rtc intf: dev (%d:%d)\n",
+        dev_dbg(class_dev->dev, "rtc intf: dev (%d:%d)\n",
                 MAJOR(rtc->rtc_dev->devt),
                 MINOR(rtc->rtc_dev->devt));
 
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 67e816a9a39f..205fa28593b7 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -199,7 +199,7 @@ static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
         struct i2c_client *client;
         struct rtc_device *rtc;
 
-        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        dev_dbg(adapter->class_dev.dev, "%s\n", __FUNCTION__);
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
                 err = -ENODEV;
@@ -237,17 +237,22 @@ static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
         /* read control register */
         err = ds1672_get_control(client, &control);
         if (err)
-                goto exit_detach;
+                goto exit_devreg;
 
         if (control & DS1672_REG_CONTROL_EOSC)
                 dev_warn(&client->dev, "Oscillator not enabled. "
                                         "Set time to enable.\n");
 
         /* Register sysfs hooks */
-        device_create_file(&client->dev, &dev_attr_control);
+        err = device_create_file(&client->dev, &dev_attr_control);
+        if (err)
+                goto exit_devreg;
 
         return 0;
 
+exit_devreg:
+        rtc_device_unregister(rtc);
+
 exit_detach:
         i2c_detach_client(client);
 
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 6273a3d240a2..17633bfa8480 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -6,6 +6,10 @@
  * 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.
+ *
+ * Copyright (C) 2006 Torsten Ertbjerg Rasmussen <tr@newtec.dk>
+ *  - nvram size determined from resource
+ *  - this ds1742 driver now supports ds1743.
  */
 
 #include <linux/bcd.h>
@@ -17,20 +21,19 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#define DRV_VERSION "0.2"
+#define DRV_VERSION "0.3"
 
-#define RTC_REG_SIZE            0x800
-#define RTC_OFFSET              0x7f8
+#define RTC_SIZE                8
 
-#define RTC_CONTROL             (RTC_OFFSET + 0)
-#define RTC_CENTURY             (RTC_OFFSET + 0)
-#define RTC_SECONDS             (RTC_OFFSET + 1)
-#define RTC_MINUTES             (RTC_OFFSET + 2)
-#define RTC_HOURS               (RTC_OFFSET + 3)
-#define RTC_DAY                 (RTC_OFFSET + 4)
-#define RTC_DATE                (RTC_OFFSET + 5)
-#define RTC_MONTH               (RTC_OFFSET + 6)
-#define RTC_YEAR                (RTC_OFFSET + 7)
+#define RTC_CONTROL             0
+#define RTC_CENTURY             0
+#define RTC_SECONDS             1
+#define RTC_MINUTES             2
+#define RTC_HOURS               3
+#define RTC_DAY                 4
+#define RTC_DATE                5
+#define RTC_MONTH               6
+#define RTC_YEAR                7
 
 #define RTC_CENTURY_MASK        0x3f
 #define RTC_SECONDS_MASK        0x7f
@@ -48,7 +51,10 @@
 
 struct rtc_plat_data {
         struct rtc_device *rtc;
-        void __iomem *ioaddr;
+        void __iomem *ioaddr_nvram;
+        void __iomem *ioaddr_rtc;
+        size_t size_nvram;
+        size_t size;
         unsigned long baseaddr;
         unsigned long last_jiffies;
 };
@@ -57,7 +63,7 @@ static int ds1742_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        void __iomem *ioaddr = pdata->ioaddr;
+        void __iomem *ioaddr = pdata->ioaddr_rtc;
         u8 century;
 
         century = BIN2BCD((tm->tm_year + 1900) / 100);
@@ -82,7 +88,7 @@ static int ds1742_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        void __iomem *ioaddr = pdata->ioaddr;
+        void __iomem *ioaddr = pdata->ioaddr_rtc;
         unsigned int year, month, day, hour, minute, second, week;
         unsigned int century;
 
@@ -127,10 +133,10 @@ static ssize_t ds1742_nvram_read(struct kobject *kobj, char *buf,
         struct platform_device *pdev =
                 to_platform_device(container_of(kobj, struct device, kobj));
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        void __iomem *ioaddr = pdata->ioaddr;
+        void __iomem *ioaddr = pdata->ioaddr_nvram;
         ssize_t count;
 
-        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+        for (count = 0; size > 0 && pos < pdata->size_nvram; count++, size--)
                 *buf++ = readb(ioaddr + pos++);
         return count;
 }
@@ -141,10 +147,10 @@ static ssize_t ds1742_nvram_write(struct kobject *kobj, char *buf,
         struct platform_device *pdev =
                 to_platform_device(container_of(kobj, struct device, kobj));
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        void __iomem *ioaddr = pdata->ioaddr;
+        void __iomem *ioaddr = pdata->ioaddr_nvram;
         ssize_t count;
 
-        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+        for (count = 0; size > 0 && pos < pdata->size_nvram; count++, size--)
                 writeb(*buf++, ioaddr + pos++);
         return count;
 }
@@ -155,7 +161,6 @@ static struct bin_attribute ds1742_nvram_attr = {
                 .mode = S_IRUGO | S_IWUGO,
                 .owner = THIS_MODULE,
         },
-        .size = RTC_OFFSET,
         .read = ds1742_nvram_read,
         .write = ds1742_nvram_write,
 };
@@ -175,19 +180,23 @@ static int __init ds1742_rtc_probe(struct platform_device *pdev)
         pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
                 return -ENOMEM;
-        if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) {
+        pdata->size = res->end - res->start + 1;
+        if (!request_mem_region(res->start, pdata->size, pdev->name)) {
                 ret = -EBUSY;
                 goto out;
         }
         pdata->baseaddr = res->start;
-        ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE);
+        ioaddr = ioremap(pdata->baseaddr, pdata->size);
         if (!ioaddr) {
                 ret = -ENOMEM;
                 goto out;
         }
-        pdata->ioaddr = ioaddr;
+        pdata->ioaddr_nvram = ioaddr;
+        pdata->size_nvram = pdata->size - RTC_SIZE;
+        pdata->ioaddr_rtc = ioaddr + pdata->size_nvram;
 
         /* turn RTC on if it was not on */
+        ioaddr = pdata->ioaddr_rtc;
         sec = readb(ioaddr + RTC_SECONDS);
         if (sec & RTC_STOP) {
                 sec &= RTC_SECONDS_MASK;
@@ -208,6 +217,8 @@ static int __init ds1742_rtc_probe(struct platform_device *pdev)
         pdata->rtc = rtc;
         pdata->last_jiffies = jiffies;
         platform_set_drvdata(pdev, pdata);
+        ds1742_nvram_attr.size = max(ds1742_nvram_attr.size,
+                                     pdata->size_nvram);
         ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
         if (ret)
                 goto out;
@@ -215,10 +226,10 @@ static int __init ds1742_rtc_probe(struct platform_device *pdev)
  out:
         if (pdata->rtc)
                 rtc_device_unregister(pdata->rtc);
-        if (ioaddr)
-                iounmap(ioaddr);
+        if (pdata->ioaddr_nvram)
+                iounmap(pdata->ioaddr_nvram);
         if (pdata->baseaddr)
-                release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+                release_mem_region(pdata->baseaddr, pdata->size);
         kfree(pdata);
         return ret;
 }
@@ -229,8 +240,8 @@ static int __devexit ds1742_rtc_remove(struct platform_device *pdev)
 
         sysfs_remove_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
         rtc_device_unregister(pdata->rtc);
-        iounmap(pdata->ioaddr);
-        release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        iounmap(pdata->ioaddr_nvram);
+        release_mem_region(pdata->baseaddr, pdata->size);
         kfree(pdata);
         return 0;
 }
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index ba795a4db1e9..7bbc26a34bd2 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -117,4 +117,85 @@ int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
 }
 EXPORT_SYMBOL(rtc_tm_to_time);
 
+
+/* Merge the valid (i.e. non-negative) fields of alarm into the current
+ * time.  If the valid alarm fields are earlier than the equivalent
+ * fields in the time, carry one into the least significant invalid
+ * field, so that the alarm expiry is in the future.  It assumes that the
+ * least significant invalid field is more significant than the most
+ * significant valid field, and that the seconds field is valid.
+ *
+ * This is used by alarms that take relative (rather than absolute)
+ * times, and/or have a simple binary second counter instead of
+ * day/hour/minute/sec registers.
+ */
+void rtc_merge_alarm(struct rtc_time *now, struct rtc_time *alarm)
+{
+        int *alarmp = &alarm->tm_sec;
+        int *timep = &now->tm_sec;
+        int carry_into, i;
+
+        /* Ignore everything past the 6th element (tm_year). */
+        for (i = 5; i > 0; i--) {
+                if (alarmp[i] < 0)
+                        alarmp[i] = timep[i];
+                else
+                        break;
+        }
+
+        /* No carry needed if all fields are valid. */
+        if (i == 5)
+                return;
+
+        for (carry_into = i + 1; i >= 0; i--) {
+                if (alarmp[i] < timep[i])
+                        break;
+
+                if (alarmp[i] > timep[i])
+                        return;
+        }
+
+        switch (carry_into) {
+                case 1:
+                        alarm->tm_min++;
+
+                        if (alarm->tm_min < 60)
+                                return;
+
+                        alarm->tm_min = 0;
+                        /* fall-through */
+
+                case 2:
+                        alarm->tm_hour++;
+
+                        if (alarm->tm_hour < 60)
+                                return;
+
+                        alarm->tm_hour = 0;
+                        /* fall-through */
+
+                case 3:
+                        alarm->tm_mday++;
+
+                        if (alarm->tm_mday <= rtc_days_in_month[alarm->tm_mon])
+                                return;
+
+                        alarm->tm_mday = 1;
+                        /* fall-through */
+
+                case 4:
+                        alarm->tm_mon++;
+
+                        if (alarm->tm_mon <= 12)
+                                return;
+
+                        alarm->tm_mon = 1;
+                        /* fall-through */
+
+                case 5:
+                        alarm->tm_year++;
+        }
+}
+EXPORT_SYMBOL(rtc_merge_alarm);
+
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
new file mode 100644
index 000000000000..d59880d44fba
--- /dev/null
+++ b/drivers/rtc/rtc-omap.c
@@ -0,0 +1,571 @@
+/*
+ * TI OMAP1 Real Time Clock interface for Linux
+ *
+ * Copyright (C) 2003 MontaVista Software, Inc.
+ * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
+ *
+ * Copyright (C) 2006 David Brownell (new RTC framework)
+ *
+ * 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/ioport.h>
+#include <linux/delay.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/platform_device.h>
+
+#include <asm/io.h>
+#include <asm/mach/time.h>
+
+
+/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
+ * with century-range alarm matching, driven by the 32kHz clock.
+ *
+ * The main user-visible ways it differs from PC RTCs are by omitting
+ * "don't care" alarm fields and sub-second periodic IRQs, and having
+ * an autoadjust mechanism to calibrate to the true oscillator rate.
+ *
+ * Board-specific wiring options include using split power mode with
+ * RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
+ * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
+ * low power modes).  See the BOARD-SPECIFIC CUSTOMIZATION comment.
+ */
+
+#define OMAP_RTC_BASE                   0xfffb4800
+
+/* RTC registers */
+#define OMAP_RTC_SECONDS_REG            0x00
+#define OMAP_RTC_MINUTES_REG            0x04
+#define OMAP_RTC_HOURS_REG              0x08
+#define OMAP_RTC_DAYS_REG               0x0C
+#define OMAP_RTC_MONTHS_REG             0x10
+#define OMAP_RTC_YEARS_REG              0x14
+#define OMAP_RTC_WEEKS_REG              0x18
+
+#define OMAP_RTC_ALARM_SECONDS_REG      0x20
+#define OMAP_RTC_ALARM_MINUTES_REG      0x24
+#define OMAP_RTC_ALARM_HOURS_REG        0x28
+#define OMAP_RTC_ALARM_DAYS_REG         0x2c
+#define OMAP_RTC_ALARM_MONTHS_REG       0x30
+#define OMAP_RTC_ALARM_YEARS_REG        0x34
+
+#define OMAP_RTC_CTRL_REG               0x40
+#define OMAP_RTC_STATUS_REG             0x44
+#define OMAP_RTC_INTERRUPTS_REG         0x48
+
+#define OMAP_RTC_COMP_LSB_REG           0x4c
+#define OMAP_RTC_COMP_MSB_REG           0x50
+#define OMAP_RTC_OSC_REG                0x54
+
+/* OMAP_RTC_CTRL_REG bit fields: */
+#define OMAP_RTC_CTRL_SPLIT             (1<<7)
+#define OMAP_RTC_CTRL_DISABLE           (1<<6)
+#define OMAP_RTC_CTRL_SET_32_COUNTER    (1<<5)
+#define OMAP_RTC_CTRL_TEST              (1<<4)
+#define OMAP_RTC_CTRL_MODE_12_24        (1<<3)
+#define OMAP_RTC_CTRL_AUTO_COMP         (1<<2)
+#define OMAP_RTC_CTRL_ROUND_30S         (1<<1)
+#define OMAP_RTC_CTRL_STOP              (1<<0)
+
+/* OMAP_RTC_STATUS_REG bit fields: */
+#define OMAP_RTC_STATUS_POWER_UP        (1<<7)
+#define OMAP_RTC_STATUS_ALARM           (1<<6)
+#define OMAP_RTC_STATUS_1D_EVENT        (1<<5)
+#define OMAP_RTC_STATUS_1H_EVENT        (1<<4)
+#define OMAP_RTC_STATUS_1M_EVENT        (1<<3)
+#define OMAP_RTC_STATUS_1S_EVENT        (1<<2)
+#define OMAP_RTC_STATUS_RUN             (1<<1)
+#define OMAP_RTC_STATUS_BUSY            (1<<0)
+
+/* OMAP_RTC_INTERRUPTS_REG bit fields: */
+#define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
+#define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
+
+
+#define rtc_read(addr)          omap_readb(OMAP_RTC_BASE + (addr))
+#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
+ */
+static void rtc_wait_not_busy(void)
+{
+        int     count = 0;
+        u8      status;
+
+        /* BUSY may stay active for 1/32768 second (~30 usec) */
+        for (count = 0; count < 50; count++) {
+                status = rtc_read(OMAP_RTC_STATUS_REG);
+                if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
+                        break;
+                udelay(1);
+        }
+        /* now we have ~15 usec to read/write various registers */
+}
+
+static irqreturn_t rtc_irq(int irq, void *class_dev)
+{
+        unsigned long           events = 0;
+        u8                      irq_data;
+
+        irq_data = rtc_read(OMAP_RTC_STATUS_REG);
+
+        /* alarm irq? */
+        if (irq_data & OMAP_RTC_STATUS_ALARM) {
+                rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
+                events |= RTC_IRQF | RTC_AF;
+        }
+
+        /* 1/sec periodic/update irq? */
+        if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
+                events |= RTC_IRQF | RTC_UF;
+
+        rtc_update_irq(class_dev, 1, events);
+
+        return IRQ_HANDLED;
+}
+
+#ifdef  CONFIG_RTC_INTF_DEV
+
+static int
+omap_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        u8 reg;
+
+        switch (cmd) {
+        case RTC_AIE_OFF:
+        case RTC_AIE_ON:
+        case RTC_UIE_OFF:
+        case RTC_UIE_ON:
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+
+        local_irq_disable();
+        rtc_wait_not_busy();
+        reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+        switch (cmd) {
+        /* AIE = Alarm Interrupt Enable */
+        case RTC_AIE_OFF:
+                reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
+                break;
+        case RTC_AIE_ON:
+                reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
+                break;
+        /* UIE = Update Interrupt Enable (1/second) */
+        case RTC_UIE_OFF:
+                reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER;
+                break;
+        case RTC_UIE_ON:
+                reg |= OMAP_RTC_INTERRUPTS_IT_TIMER;
+                break;
+        }
+        rtc_wait_not_busy();
+        rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
+        local_irq_enable();
+
+        return 0;
+}
+
+#else
+#define omap_rtc_ioctl  NULL
+#endif
+
+/* this hardware doesn't support "don't care" alarm fields */
+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_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);
+
+        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;
+        /* epoch == 1900 */
+        tm->tm_year = BCD2BIN(tm->tm_year) + 100;
+}
+
+
+static int omap_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        /* we don't report wday/yday/isdst ... */
+        local_irq_disable();
+        rtc_wait_not_busy();
+
+        tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
+        tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
+        tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
+        tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
+        tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
+        tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
+
+        local_irq_enable();
+
+        bcd2tm(tm);
+        return 0;
+}
+
+static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        if (tm2bcd(tm) < 0)
+                return -EINVAL;
+        local_irq_disable();
+        rtc_wait_not_busy();
+
+        rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
+        rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
+        rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
+        rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
+        rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
+        rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
+
+        local_irq_enable();
+
+        return 0;
+}
+
+static int omap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        local_irq_disable();
+        rtc_wait_not_busy();
+
+        alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
+        alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
+        alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
+        alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
+        alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
+        alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
+
+        local_irq_enable();
+
+        bcd2tm(&alm->time);
+        alm->enabled = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
+                        & OMAP_RTC_INTERRUPTS_IT_ALARM);
+
+        return 0;
+}
+
+static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        u8 reg;
+
+        /* Much userspace code uses RTC_ALM_SET, thus "don't care" for
+         * day/month/year specifies alarms up to 24 hours in the future.
+         * So we need to handle that ... but let's ignore the "don't care"
+         * values for hours/minutes/seconds.
+         */
+        if (alm->time.tm_mday <= 0
+                        && alm->time.tm_mon < 0
+                        && alm->time.tm_year < 0) {
+                struct rtc_time tm;
+                unsigned long now, then;
+
+                omap_rtc_read_time(dev, &tm);
+                rtc_tm_to_time(&tm, &now);
+
+                alm->time.tm_mday = tm.tm_mday;
+                alm->time.tm_mon = tm.tm_mon;
+                alm->time.tm_year = tm.tm_year;
+                rtc_tm_to_time(&alm->time, &then);
+
+                /* sometimes the alarm wraps into tomorrow */
+                if (then < now) {
+                        rtc_time_to_tm(now + 24 * 60 * 60, &tm);
+                        alm->time.tm_mday = tm.tm_mday;
+                        alm->time.tm_mon = tm.tm_mon;
+                        alm->time.tm_year = tm.tm_year;
+                }
+        }
+
+        if (tm2bcd(&alm->time) < 0)
+                return -EINVAL;
+
+        local_irq_disable();
+        rtc_wait_not_busy();
+
+        rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
+        rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
+        rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
+        rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
+        rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
+        rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
+
+        reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+        if (alm->enabled)
+                reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
+        else
+                reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
+        rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
+
+        local_irq_enable();
+
+        return 0;
+}
+
+static struct rtc_class_ops omap_rtc_ops = {
+        .ioctl          = omap_rtc_ioctl,
+        .read_time      = omap_rtc_read_time,
+        .set_time       = omap_rtc_set_time,
+        .read_alarm     = omap_rtc_read_alarm,
+        .set_alarm      = omap_rtc_set_alarm,
+};
+
+static int omap_rtc_alarm;
+static int omap_rtc_timer;
+
+static int __devinit omap_rtc_probe(struct platform_device *pdev)
+{
+        struct resource         *res, *mem;
+        struct rtc_device       *rtc;
+        u8                      reg, new_ctrl;
+
+        omap_rtc_timer = platform_get_irq(pdev, 0);
+        if (omap_rtc_timer <= 0) {
+                pr_debug("%s: no update irq?\n", pdev->name);
+                return -ENOENT;
+        }
+
+        omap_rtc_alarm = platform_get_irq(pdev, 1);
+        if (omap_rtc_alarm <= 0) {
+                pr_debug("%s: no alarm irq?\n", pdev->name);
+                return -ENOENT;
+        }
+
+        /* NOTE:  using static mapping for RTC registers */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res && res->start != OMAP_RTC_BASE) {
+                pr_debug("%s: RTC registers at %08x, expected %08x\n",
+                        pdev->name, (unsigned) res->start, OMAP_RTC_BASE);
+                return -ENOENT;
+        }
+
+        if (res)
+                mem = request_mem_region(res->start,
+                                res->end - res->start + 1,
+                                pdev->name);
+        else
+                mem = NULL;
+        if (!mem) {
+                pr_debug("%s: RTC registers at %08x are not free\n",
+                        pdev->name, OMAP_RTC_BASE);
+                return -EBUSY;
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev,
+                        &omap_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                pr_debug("%s: can't register RTC device, err %ld\n",
+                        pdev->name, PTR_ERR(rtc));
+                goto fail;
+        }
+        platform_set_drvdata(pdev, rtc);
+        class_set_devdata(&rtc->class_dev, mem);
+
+        /* clear pending irqs, and set 1/second periodic,
+         * which we'll use instead of update irqs
+         */
+        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+
+        /* clear old status */
+        reg = rtc_read(OMAP_RTC_STATUS_REG);
+        if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
+                pr_info("%s: RTC power up reset detected\n",
+                        pdev->name);
+                rtc_write(OMAP_RTC_STATUS_POWER_UP, OMAP_RTC_STATUS_REG);
+        }
+        if (reg & (u8) OMAP_RTC_STATUS_ALARM)
+                rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
+
+        /* handle periodic and alarm irqs */
+        if (request_irq(omap_rtc_timer, rtc_irq, SA_INTERRUPT,
+                        rtc->class_dev.class_id, &rtc->class_dev)) {
+                pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
+                        pdev->name, omap_rtc_timer);
+                goto fail0;
+        }
+        if (request_irq(omap_rtc_alarm, rtc_irq, SA_INTERRUPT,
+                        rtc->class_dev.class_id, &rtc->class_dev)) {
+                pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
+                        pdev->name, omap_rtc_alarm);
+                goto fail1;
+        }
+
+        /* On boards with split power, RTC_ON_NOFF won't reset the RTC */
+        reg = rtc_read(OMAP_RTC_CTRL_REG);
+        if (reg & (u8) OMAP_RTC_CTRL_STOP)
+                pr_info("%s: already running\n", pdev->name);
+
+        /* force to 24 hour mode */
+        new_ctrl = reg & ~(OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
+        new_ctrl |= OMAP_RTC_CTRL_STOP;
+
+        /* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
+         *
+         *  - Boards wired so that RTC_WAKE_INT does something, and muxed
+         *    right (W13_1610_RTC_WAKE_INT is the default after chip reset),
+         *    should initialize the device wakeup flag appropriately.
+         *
+         *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
+         *    rather than nPWRON_RESET, should forcibly enable split
+         *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
+         *    is write-only, and always reads as zero...)
+         */
+        device_init_wakeup(&pdev->dev, 0);
+
+        if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
+                pr_info("%s: split power mode\n", pdev->name);
+
+        if (reg != new_ctrl)
+                rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
+
+        return 0;
+
+fail1:
+        free_irq(omap_rtc_timer, NULL);
+fail0:
+        rtc_device_unregister(rtc);
+fail:
+        release_resource(mem);
+        return -EIO;
+}
+
+static int __devexit omap_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device       *rtc = platform_get_drvdata(pdev);;
+
+        device_init_wakeup(&pdev->dev, 0);
+
+        /* leave rtc running, but disable irqs */
+        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+
+        free_irq(omap_rtc_timer, rtc);
+        free_irq(omap_rtc_alarm, rtc);
+
+        release_resource(class_get_devdata(&rtc->class_dev));
+        rtc_device_unregister(rtc);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+static struct timespec rtc_delta;
+static u8 irqstat;
+
+static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct rtc_time rtc_tm;
+        struct timespec time;
+
+        time.tv_nsec = 0;
+        omap_rtc_read_time(NULL, &rtc_tm);
+        rtc_tm_to_time(&rtc_tm, &time.tv_sec);
+
+        save_time_delta(&rtc_delta, &time);
+        irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+
+        /* FIXME the RTC alarm is not currently acting as a wakeup event
+         * source, and in fact this enable() call is just saving a flag
+         * that's never used...
+         */
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(omap_rtc_alarm);
+        else
+                rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+
+        return 0;
+}
+
+static int omap_rtc_resume(struct platform_device *pdev)
+{
+        struct rtc_time rtc_tm;
+        struct timespec time;
+
+        time.tv_nsec = 0;
+        omap_rtc_read_time(NULL, &rtc_tm);
+        rtc_tm_to_time(&rtc_tm, &time.tv_sec);
+
+        restore_time_delta(&rtc_delta, &time);
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(omap_rtc_alarm);
+        else
+                rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
+        return 0;
+}
+
+#else
+#define omap_rtc_suspend NULL
+#define omap_rtc_resume  NULL
+#endif
+
+static void omap_rtc_shutdown(struct platform_device *pdev)
+{
+        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+}
+
+MODULE_ALIAS("omap_rtc");
+static struct platform_driver omap_rtc_driver = {
+        .probe          = omap_rtc_probe,
+        .remove         = __devexit_p(omap_rtc_remove),
+        .suspend        = omap_rtc_suspend,
+        .resume         = omap_rtc_resume,
+        .shutdown       = omap_rtc_shutdown,
+        .driver         = {
+                .name   = "omap_rtc",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init rtc_init(void)
+{
+        return platform_driver_register(&omap_rtc_driver);
+}
+module_init(rtc_init);
+
+static void __exit rtc_exit(void)
+{
+        platform_driver_unregister(&omap_rtc_driver);
+}
+module_exit(rtc_exit);
+
+MODULE_AUTHOR("George G. Davis (and others)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index a760cf69af90..4b72b8ef5d66 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -192,7 +192,7 @@ static int pcf8563_validate_client(struct i2c_client *client)
                 xfer = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 
                 if (xfer != ARRAY_SIZE(msgs)) {
-                        dev_err(&client->adapter->dev,
+                        dev_err(&client->dev,
                                 "%s: could not read register 0x%02X\n",
                                 __FUNCTION__, pattern[i].reg);
 
@@ -203,7 +203,7 @@ static int pcf8563_validate_client(struct i2c_client *client)
 
                 if (value > pattern[i].max ||
                         value < pattern[i].min) {
-                        dev_dbg(&client->adapter->dev,
+                        dev_dbg(&client->dev,
                                 "%s: pattern=%d, reg=%x, mask=0x%02x, min=%d, "
                                 "max=%d, value=%d, raw=0x%02X\n",
                                 __FUNCTION__, i, pattern[i].reg, pattern[i].mask,
@@ -253,7 +253,7 @@ static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind)
 
         int err = 0;
 
-        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        dev_dbg(adapter->class_dev.dev, "%s\n", __FUNCTION__);
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
                 err = -ENODEV;
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
index d51d8f20e634..c272afd62173 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -65,7 +65,7 @@ static int rtc_proc_show(struct seq_file *seq, void *offset)
                         seq_printf(seq, "%02d\n", alrm.time.tm_mday);
                 else
                         seq_printf(seq, "**\n");
-                seq_printf(seq, "alrm_wakeup\t: %s\n",
+                seq_printf(seq, "alarm_IRQ\t: %s\n",
                                 alrm.enabled ? "yes" : "no");
                 seq_printf(seq, "alrm_pending\t: %s\n",
                                 alrm.pending ? "yes" : "no");
@@ -120,7 +120,7 @@ static int rtc_proc_add_device(struct class_device *class_dev,
                         ent->owner = rtc->owner;
                         ent->data = class_dev;
 
-                        dev_info(class_dev->dev, "rtc intf: proc\n");
+                        dev_dbg(class_dev->dev, "rtc intf: proc\n");
                 }
                 else
                         rtc_dev = NULL;
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index a44fe4efa216..e7851e3739ab 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -1,5 +1,5 @@
 /*
- * An I2C driver for the Ricoh RS5C372 RTC
+ * An I2C driver for Ricoh RS5C372 and RV5C38[67] RTCs
  *
  * Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
  * Copyright (C) 2006 Tower Technologies
@@ -13,7 +13,7 @@
 #include <linux/rtc.h>
 #include <linux/bcd.h>
 
-#define DRV_VERSION "0.2"
+#define DRV_VERSION "0.4"
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { /* 0x32,*/ I2C_CLIENT_END };
@@ -21,6 +21,13 @@ static unsigned short normal_i2c[] = { /* 0x32,*/ I2C_CLIENT_END };
 /* Insmod parameters */
 I2C_CLIENT_INSMOD;
 
+
+/*
+ * Ricoh has a family of I2C based RTCs, which differ only slightly from
+ * each other.  Differences center on pinout (e.g. how many interrupts,
+ * output clock, etc) and how the control registers are used.  The '372
+ * is significant only because that's the one this driver first supported.
+ */
 #define RS5C372_REG_SECS        0
 #define RS5C372_REG_MINS        1
 #define RS5C372_REG_HOURS       2
@@ -29,53 +36,142 @@ I2C_CLIENT_INSMOD;
 #define RS5C372_REG_MONTH       5
 #define RS5C372_REG_YEAR        6
 #define RS5C372_REG_TRIM        7
+#       define RS5C372_TRIM_XSL         0x80
+#       define RS5C372_TRIM_MASK        0x7F
+
+#define RS5C_REG_ALARM_A_MIN    8                       /* or ALARM_W */
+#define RS5C_REG_ALARM_A_HOURS  9
+#define RS5C_REG_ALARM_A_WDAY   10
+
+#define RS5C_REG_ALARM_B_MIN    11                      /* or ALARM_D */
+#define RS5C_REG_ALARM_B_HOURS  12
+#define RS5C_REG_ALARM_B_WDAY   13                      /* (ALARM_B only) */
+
+#define RS5C_REG_CTRL1          14
+#       define RS5C_CTRL1_AALE          (1 << 7)        /* or WALE */
+#       define RS5C_CTRL1_BALE          (1 << 6)        /* or DALE */
+#       define RV5C387_CTRL1_24         (1 << 5)
+#       define RS5C372A_CTRL1_SL1       (1 << 5)
+#       define RS5C_CTRL1_CT_MASK       (7 << 0)
+#       define RS5C_CTRL1_CT0           (0 << 0)        /* no periodic irq */
+#       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 RS5C_CTRL2_CTFG          (1 << 2)
+#       define RS5C_CTRL2_AAFG          (1 << 1)        /* or WAFG */
+#       define RS5C_CTRL2_BAFG          (1 << 0)        /* or DAFG */
+
+
+/* to read (style 1) or write registers starting at R */
+#define RS5C_ADDR(R)            (((R) << 4) | 0)
+
+
+enum rtc_type {
+        rtc_undef = 0,
+        rtc_rs5c372a,
+        rtc_rs5c372b,
+        rtc_rv5c386,
+        rtc_rv5c387a,
+};
 
-#define RS5C372_TRIM_XSL        0x80
-#define RS5C372_TRIM_MASK       0x7F
+/* REVISIT:  this assumes that:
+ *  - we're in the 21st century, so it's safe to ignore the century
+ *    bit for rv5c38[67] (REG_MONTH bit 7);
+ *  - we should use ALARM_A not ALARM_B (may be wrong on some boards)
+ */
+struct rs5c372 {
+        struct i2c_client       *client;
+        struct rtc_device       *rtc;
+        enum rtc_type           type;
+        unsigned                time24:1;
+        unsigned                has_irq:1;
+        char                    buf[17];
+        char                    *regs;
+
+        /* on conversion to a "new style" i2c driver, this vanishes */
+        struct i2c_client       dev;
+};
 
-#define RS5C372_REG_BASE        0
+static int rs5c_get_regs(struct rs5c372 *rs5c)
+{
+        struct i2c_client       *client = rs5c->client;
+        struct i2c_msg          msgs[] = {
+                { client->addr, I2C_M_RD, sizeof rs5c->buf, rs5c->buf },
+        };
 
-static int rs5c372_attach(struct i2c_adapter *adapter);
-static int rs5c372_detach(struct i2c_client *client);
-static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind);
+        /* This implements the third reading method from the datasheet, using
+         * an internal address that's reset after each transaction (by STOP)
+         * to 0x0f ... so we read extra registers, and skip the first one.
+         *
+         * The first method doesn't work with the iop3xx adapter driver, on at
+         * least 80219 chips; this works around that bug.
+         */
+        if ((i2c_transfer(client->adapter, msgs, 1)) != 1) {
+                pr_debug("%s: can't read registers\n", rs5c->rtc->name);
+                return -EIO;
+        }
 
-static struct i2c_driver rs5c372_driver = {
-        .driver         = {
-                .name   = "rs5c372",
-        },
-        .attach_adapter = &rs5c372_attach,
-        .detach_client  = &rs5c372_detach,
-};
+        dev_dbg(&client->dev,
+                "%02x %02x %02x (%02x) %02x %02x %02x (%02x), "
+                "%02x %02x %02x, %02x %02x %02x; %02x %02x\n",
+                rs5c->regs[0],  rs5c->regs[1],  rs5c->regs[2],  rs5c->regs[3],
+                rs5c->regs[4],  rs5c->regs[5],  rs5c->regs[6],  rs5c->regs[7],
+                rs5c->regs[8],  rs5c->regs[9],  rs5c->regs[10], rs5c->regs[11],
+                rs5c->regs[12], rs5c->regs[13], rs5c->regs[14], rs5c->regs[15]);
+
+        return 0;
+}
+
+static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
+{
+        unsigned        hour;
+
+        if (rs5c->time24)
+                return BCD2BIN(reg & 0x3f);
+
+        hour = BCD2BIN(reg & 0x1f);
+        if (hour == 12)
+                hour = 0;
+        if (reg & 0x20)
+                hour += 12;
+        return hour;
+}
+
+static unsigned rs5c_hr2reg(struct rs5c372 *rs5c, unsigned hour)
+{
+        if (rs5c->time24)
+                return BIN2BCD(hour);
+
+        if (hour > 12)
+                return 0x20 | BIN2BCD(hour - 12);
+        if (hour == 12)
+                return 0x20 | BIN2BCD(12);
+        if (hour == 0)
+                return BIN2BCD(12);
+        return BIN2BCD(hour);
+}
 
 static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
 {
-        unsigned char buf[7] = { RS5C372_REG_BASE };
+        struct rs5c372  *rs5c = i2c_get_clientdata(client);
+        int             status = rs5c_get_regs(rs5c);
 
-        /* this implements the 1st reading method, according
-         * to the datasheet. buf[0] is initialized with
-         * address ptr and transmission format register.
-         */
-        struct i2c_msg msgs[] = {
-                { client->addr, 0, 1, buf },
-                { client->addr, I2C_M_RD, 7, buf },
-        };
+        if (status < 0)
+                return status;
 
-        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
-                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
-                return -EIO;
-        }
+        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_sec = BCD2BIN(buf[RS5C372_REG_SECS] & 0x7f);
-        tm->tm_min = BCD2BIN(buf[RS5C372_REG_MINS] & 0x7f);
-        tm->tm_hour = BCD2BIN(buf[RS5C372_REG_HOURS] & 0x3f);
-        tm->tm_wday = BCD2BIN(buf[RS5C372_REG_WDAY] & 0x07);
-        tm->tm_mday = BCD2BIN(buf[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(buf[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(buf[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",
@@ -83,22 +179,25 @@ static int rs5c372_get_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);
 
-        return 0;
+        /* rtc might need initialization */
+        return rtc_valid_tm(tm);
 }
 
 static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
 {
-        unsigned char buf[8] = { RS5C372_REG_BASE };
+        struct rs5c372  *rs5c = i2c_get_clientdata(client);
+        unsigned char   buf[8];
 
-        dev_dbg(&client->dev,
-                "%s: secs=%d, mins=%d, hours=%d "
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
                 "mday=%d, mon=%d, year=%d, wday=%d\n",
-                __FUNCTION__, tm->tm_sec, tm->tm_min, tm->tm_hour,
+                __FUNCTION__,
+                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] = BIN2BCD(tm->tm_hour);
+        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);
@@ -112,30 +211,43 @@ static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
         return 0;
 }
 
-static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
-{
-        unsigned char buf = RS5C372_REG_TRIM;
+#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
+#define NEED_TRIM
+#endif
 
-        struct i2c_msg msgs[] = {
-                { client->addr, 0, 1, &buf },
-                { client->addr, I2C_M_RD, 1, &buf },
-        };
+#if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
+#define NEED_TRIM
+#endif
 
-        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
-                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
-                return -EIO;
-        }
+#ifdef  NEED_TRIM
+static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
+{
+        struct rs5c372 *rs5c372 = i2c_get_clientdata(client);
+        u8 tmp = rs5c372->regs[RS5C372_REG_TRIM];
 
         if (osc)
-                *osc = (buf & RS5C372_TRIM_XSL) ? 32000 : 32768;
+                *osc = (tmp & RS5C372_TRIM_XSL) ? 32000 : 32768;
 
         if (trim) {
-                *trim = buf & RS5C372_TRIM_MASK;
-                dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, *trim);
+                dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, tmp);
+                tmp &= RS5C372_TRIM_MASK;
+                if (tmp & 0x3e) {
+                        int t = tmp & 0x3f;
+
+                        if (tmp & 0x40)
+                                t = (~t | (s8)0xc0) + 1;
+                        else
+                                t = t - 1;
+
+                        tmp = t * 2;
+                } else
+                        tmp = 0;
+                *trim = tmp;
         }
 
         return 0;
 }
+#endif
 
 static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
@@ -147,25 +259,190 @@ static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
         return rs5c372_set_datetime(to_i2c_client(dev), tm);
 }
 
+#if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
+
+static int
+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;
+
+        buf[1] = 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))
+                        return -ENOIOCTLCMD;
+        case RTC_AIE_OFF:
+        case RTC_AIE_ON:
+                /* these irq management calls only make sense for chips
+                 * which are wired up to an IRQ.
+                 */
+                if (!rs5c->has_irq)
+                        return -ENOIOCTLCMD;
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+
+        status = rs5c_get_regs(rs5c);
+        if (status < 0)
+                return status;
+
+        buf[0] = RS5C_ADDR(RS5C_REG_CTRL1);
+        switch (cmd) {
+        case RTC_AIE_OFF:       /* alarm off */
+                buf[1] &= ~RS5C_CTRL1_AALE;
+                break;
+        case RTC_AIE_ON:        /* alarm on */
+                buf[1] |= RS5C_CTRL1_AALE;
+                break;
+        case RTC_UIE_OFF:       /* update off */
+                buf[1] &= ~RS5C_CTRL1_CT_MASK;
+                break;
+        case RTC_UIE_ON:        /* update on */
+                buf[1] &= ~RS5C_CTRL1_CT_MASK;
+                buf[1] |= RS5C_CTRL1_CT4;
+                break;
+        }
+        if ((i2c_master_send(client, buf, 2)) != 2) {
+                printk(KERN_WARNING "%s: can't update alarm\n",
+                        rs5c->rtc->name);
+                status = -EIO;
+        } else
+                rs5c->regs[RS5C_REG_CTRL1] = buf[1];
+        return status;
+}
+
+#else
+#define rs5c_rtc_ioctl  NULL
+#endif
+
+
+/* NOTE:  Since RTC_WKALM_{RD,SET} were originally defined for EFI,
+ * which only exposes a polled programming interface; and since
+ * these calls map directly to those EFI requests; we don't demand
+ * we have an IRQ for this chip when we go through this API.
+ *
+ * The older x86_pc derived RTC_ALM_{READ,SET} calls require irqs
+ * though, managed through RTC_AIE_{ON,OFF} requests.
+ */
+
+static int rs5c_read_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;
+
+        status = rs5c_get_regs(rs5c);
+        if (status < 0)
+                return status;
+
+        /* report alarm time */
+        t->time.tm_sec = 0;
+        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;
+        t->time.tm_year = -1;
+        t->time.tm_wday = -1;
+        t->time.tm_yday = -1;
+        t->time.tm_isdst = -1;
+
+        /* ... and status */
+        t->enabled = !!(rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE);
+        t->pending = !!(rs5c->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_AAFG);
+
+        return 0;
+}
+
+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];
+
+        /* only handle up to 24 hours in the future, like RTC_ALM_SET */
+        if (t->time.tm_mday != -1
+                        || t->time.tm_mon != -1
+                        || t->time.tm_year != -1)
+                return -EINVAL;
+
+        /* REVISIT: round up tm_sec */
+
+        /* if needed, disable irq (clears pending status) */
+        status = rs5c_get_regs(rs5c);
+        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) {
+                        pr_debug("%s: can't disable alarm\n", rs5c->rtc->name);
+                        return -EIO;
+                }
+                rs5c->regs[RS5C_REG_CTRL1] = buf[1];
+        }
+
+        /* 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;
+        }
+
+        /* ... 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)
+                        printk(KERN_WARNING "%s: can't enable alarm\n",
+                                rs5c->rtc->name);
+                rs5c->regs[RS5C_REG_CTRL1] = buf[1];
+        }
+
+        return 0;
+}
+
+#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
+
 static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
 {
         int err, osc, trim;
 
         err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim);
         if (err == 0) {
-                seq_printf(seq, "%d.%03d KHz\n", osc / 1000, osc % 1000);
-                seq_printf(seq, "trim\t: %d\n", trim);
+                seq_printf(seq, "crystal\t\t: %d.%03d KHz\n",
+                                osc / 1000, osc % 1000);
+                seq_printf(seq, "trim\t\t: %d\n", trim);
         }
 
         return 0;
 }
 
+#else
+#define rs5c372_rtc_proc        NULL
+#endif
+
 static const struct rtc_class_ops rs5c372_rtc_ops = {
         .proc           = rs5c372_rtc_proc,
+        .ioctl          = rs5c_rtc_ioctl,
         .read_time      = rs5c372_rtc_read_time,
         .set_time       = rs5c372_rtc_set_time,
+        .read_alarm     = rs5c_read_alarm,
+        .set_alarm      = rs5c_set_alarm,
 };
 
+#if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
+
 static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
@@ -175,7 +452,7 @@ static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
         if (err)
                 return err;
 
-        return sprintf(buf, "0x%2x\n", trim);
+        return sprintf(buf, "%d\n", trim);
 }
 static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL);
 
@@ -192,29 +469,57 @@ static ssize_t rs5c372_sysfs_show_osc(struct device *dev,
 }
 static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
 
-static int rs5c372_attach(struct i2c_adapter *adapter)
+static int rs5c_sysfs_register(struct device *dev)
 {
-        return i2c_probe(adapter, &addr_data, rs5c372_probe);
+        int err;
+
+        err = device_create_file(dev, &dev_attr_trim);
+        if (err)
+                return err;
+        err = device_create_file(dev, &dev_attr_osc);
+        if (err)
+                device_remove_file(dev, &dev_attr_trim);
+
+        return err;
 }
 
+#else
+static int rs5c_sysfs_register(struct device *dev)
+{
+        return 0;
+}
+#endif  /* SYSFS */
+
+static struct i2c_driver rs5c372_driver;
+
 static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind)
 {
         int err = 0;
         struct i2c_client *client;
-        struct rtc_device *rtc;
+        struct rs5c372 *rs5c372;
+        struct rtc_time tm;
 
-        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        dev_dbg(adapter->class_dev.dev, "%s\n", __FUNCTION__);
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
                 err = -ENODEV;
                 goto exit;
         }
 
-        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
+        if (!(rs5c372 = kzalloc(sizeof(struct rs5c372), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto exit;
         }
 
+        /* we read registers 0x0f then 0x00-0x0f; skip the first one */
+        rs5c372->regs=&rs5c372->buf[1];
+
+        /* On conversion to a "new style" i2c driver, we'll be handed
+         * the i2c_client (we won't create it)
+         */
+        client = &rs5c372->dev;
+        rs5c372->client = client;
+
         /* I2C client */
         client->addr = address;
         client->driver = &rs5c372_driver;
@@ -222,53 +527,159 @@ static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind)
 
         strlcpy(client->name, rs5c372_driver.driver.name, I2C_NAME_SIZE);
 
+        i2c_set_clientdata(client, rs5c372);
+
         /* Inform the i2c layer */
         if ((err = i2c_attach_client(client)))
                 goto exit_kfree;
 
-        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+        err = rs5c_get_regs(rs5c372);
+        if (err < 0)
+                goto exit_detach;
 
-        rtc = rtc_device_register(rs5c372_driver.driver.name, &client->dev,
-                                &rs5c372_rtc_ops, THIS_MODULE);
+        /* For "new style" drivers, irq is in i2c_client and chip type
+         * info comes from i2c_client.dev.platform_data.  Meanwhile:
+         *
+         * STICK BOARD-SPECIFIC SETUP CODE RIGHT HERE
+         */
+        if (rs5c372->type == rtc_undef) {
+                rs5c372->type = rtc_rs5c372b;
+                dev_warn(&client->dev, "assuming rs5c372b\n");
+        }
 
-        if (IS_ERR(rtc)) {
-                err = PTR_ERR(rtc);
+        /* clock may be set for am/pm or 24 hr time */
+        switch (rs5c372->type) {
+        case rtc_rs5c372a:
+        case rtc_rs5c372b:
+                /* alarm uses ALARM_A; and nINTRA on 372a, nINTR on 372b.
+                 * so does periodic irq, except some 327a modes.
+                 */
+                if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C372_CTRL2_24)
+                        rs5c372->time24 = 1;
+                break;
+        case rtc_rv5c386:
+        case rtc_rv5c387a:
+                if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24)
+                        rs5c372->time24 = 1;
+                /* alarm uses ALARM_W; and nINTRB for alarm and periodic
+                 * irq, on both 386 and 387
+                 */
+                break;
+        default:
+                dev_err(&client->dev, "unknown RTC type\n");
                 goto exit_detach;
         }
 
-        i2c_set_clientdata(client, rtc);
+        /* if the oscillator lost power and no other software (like
+         * the bootloader) set it up, do it here.
+         */
+        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_detach;
+                }
+                rs5c372->regs[RS5C_REG_CTRL1] = buf[1];
+                rs5c372->regs[RS5C_REG_CTRL2] = buf[2];
+        }
+
+        if (rs5c372_get_datetime(client, &tm) < 0)
+                dev_warn(&client->dev, "clock needs to be set\n");
 
-        device_create_file(&client->dev, &dev_attr_trim);
-        device_create_file(&client->dev, &dev_attr_osc);
+        dev_info(&client->dev, "%s found, %s, driver version " DRV_VERSION "\n",
+                        ({ char *s; switch (rs5c372->type) {
+                        case rtc_rs5c372a:      s = "rs5c372a"; break;
+                        case rtc_rs5c372b:      s = "rs5c372b"; break;
+                        case rtc_rv5c386:       s = "rv5c386"; break;
+                        case rtc_rv5c387a:      s = "rv5c387a"; break;
+                        default:                s = "chip"; break;
+                        }; s;}),
+                        rs5c372->time24 ? "24hr" : "am/pm"
+                        );
+
+        /* FIXME when client->irq exists, use it to register alarm irq */
+
+        rs5c372->rtc = rtc_device_register(rs5c372_driver.driver.name,
+                                &client->dev, &rs5c372_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rs5c372->rtc)) {
+                err = PTR_ERR(rs5c372->rtc);
+                goto exit_detach;
+        }
+
+        err = rs5c_sysfs_register(&client->dev);
+        if (err)
+                goto exit_devreg;
 
         return 0;
 
+exit_devreg:
+        rtc_device_unregister(rs5c372->rtc);
+
 exit_detach:
         i2c_detach_client(client);
 
 exit_kfree:
-        kfree(client);
+        kfree(rs5c372);
 
 exit:
         return err;
 }
 
+static int rs5c372_attach(struct i2c_adapter *adapter)
+{
+        return i2c_probe(adapter, &addr_data, rs5c372_probe);
+}
+
 static int rs5c372_detach(struct i2c_client *client)
 {
         int err;
-        struct rtc_device *rtc = i2c_get_clientdata(client);
+        struct rs5c372 *rs5c372 = i2c_get_clientdata(client);
 
-        if (rtc)
-                rtc_device_unregister(rtc);
+        if (rs5c372->rtc)
+                rtc_device_unregister(rs5c372->rtc);
+
+        /* REVISIT properly destroy the sysfs files ... */
 
         if ((err = i2c_detach_client(client)))
                 return err;
 
-        kfree(client);
-
+        kfree(rs5c372);
         return 0;
 }
 
+static struct i2c_driver rs5c372_driver = {
+        .driver         = {
+                .name   = "rtc-rs5c372",
+        },
+        .attach_adapter = &rs5c372_attach,
+        .detach_client  = &rs5c372_detach,
+};
+
 static __init int rs5c372_init(void)
 {
         return i2c_add_driver(&rs5c372_driver);
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index e301dea57bb3..f406a2b55aea 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -191,6 +191,8 @@ static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         alm_en = readb(base + S3C2410_RTCALM);
 
+        alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;
+
         pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
                  alm_en,
                  alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
@@ -331,12 +333,8 @@ static int s3c_rtc_ioctl(struct device *dev,
 
 static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
 {
-        unsigned int rtcalm = readb(s3c_rtc_base + S3C2410_RTCALM);
         unsigned int ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
 
-        seq_printf(seq, "alarm_IRQ\t: %s\n",
-                   (rtcalm & S3C2410_RTCALM_ALMEN) ? "yes" : "no" );
-
         seq_printf(seq, "periodic_IRQ\t: %s\n",
                      (ticnt & S3C2410_TICNT_ENABLE) ? "yes" : "no" );
 
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index bd4d7d174ef4..9c8ead43a59c 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -289,9 +289,7 @@ static int sa1100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 
 static int sa1100_rtc_proc(struct device *dev, struct seq_file *seq)
 {
-        seq_printf(seq, "trim/divider\t: 0x%08lx\n", RTTR);
-        seq_printf(seq, "alarm_IRQ\t: %s\n",
-                        (RTSR & RTSR_ALE) ? "yes" : "no" );
+        seq_printf(seq, "trim/divider\t: 0x%08x\n", (u32) RTTR);
         seq_printf(seq, "update_IRQ\t: %s\n",
                         (RTSR & RTSR_HZE) ? "yes" : "no");
         seq_printf(seq, "periodic_IRQ\t: %s\n",
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 143302a8e79c..e9e0934380b8 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -2,6 +2,7 @@
  * SuperH On-Chip RTC Support
  *
  * Copyright (C) 2006  Paul Mundt
+ * Copyright (C) 2006  Jamie Lenehan
  *
  * Based on the old arch/sh/kernel/cpu/rtc.c by:
  *
@@ -21,7 +22,10 @@
 #include <linux/seq_file.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
-#include <asm/io.h>
+#include <linux/io.h>
+
+#define DRV_NAME        "sh-rtc"
+#define DRV_VERSION     "0.1.2"
 
 #ifdef CONFIG_CPU_SH3
 #define rtc_reg_size            sizeof(u16)
@@ -33,22 +37,26 @@
 
 #define RTC_REG(r)      ((r) * rtc_reg_size)
 
-#define R64CNT          RTC_REG(0)
-#define RSECCNT         RTC_REG(1)
-#define RMINCNT         RTC_REG(2)
-#define RHRCNT          RTC_REG(3)
-#define RWKCNT          RTC_REG(4)
-#define RDAYCNT         RTC_REG(5)
-#define RMONCNT         RTC_REG(6)
-#define RYRCNT          RTC_REG(7)
-#define RSECAR          RTC_REG(8)
-#define RMINAR          RTC_REG(9)
-#define RHRAR           RTC_REG(10)
-#define RWKAR           RTC_REG(11)
-#define RDAYAR          RTC_REG(12)
-#define RMONAR          RTC_REG(13)
-#define RCR1            RTC_REG(14)
-#define RCR2            RTC_REG(15)
+#define R64CNT          RTC_REG(0)
+
+#define RSECCNT         RTC_REG(1)      /* RTC sec */
+#define RMINCNT         RTC_REG(2)      /* RTC min */
+#define RHRCNT          RTC_REG(3)      /* RTC hour */
+#define RWKCNT          RTC_REG(4)      /* RTC week */
+#define RDAYCNT         RTC_REG(5)      /* RTC day */
+#define RMONCNT         RTC_REG(6)      /* RTC month */
+#define RYRCNT          RTC_REG(7)      /* RTC year */
+#define RSECAR          RTC_REG(8)      /* ALARM sec */
+#define RMINAR          RTC_REG(9)      /* ALARM min */
+#define RHRAR           RTC_REG(10)     /* ALARM hour */
+#define RWKAR           RTC_REG(11)     /* ALARM week */
+#define RDAYAR          RTC_REG(12)     /* ALARM day */
+#define RMONAR          RTC_REG(13)     /* ALARM month */
+#define RCR1            RTC_REG(14)     /* Control */
+#define RCR2            RTC_REG(15)     /* Control */
+
+/* ALARM Bits - or with BCD encoded value */
+#define AR_ENB          0x80    /* Enable for alarm cmp   */
 
 /* RCR1 Bits */
 #define RCR1_CF         0x80    /* Carry Flag             */
@@ -71,22 +79,28 @@ struct sh_rtc {
         unsigned int alarm_irq, periodic_irq, carry_irq;
         struct rtc_device *rtc_dev;
         spinlock_t lock;
+        int rearm_aie;
 };
 
-static irqreturn_t sh_rtc_interrupt(int irq, void *id)
+static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
 {
-        struct platform_device *pdev = id;
+        struct platform_device *pdev = to_platform_device(dev_id);
         struct sh_rtc *rtc = platform_get_drvdata(pdev);
         unsigned int tmp, events = 0;
 
         spin_lock(&rtc->lock);
 
         tmp = readb(rtc->regbase + RCR1);
+        tmp &= ~RCR1_CF;
 
-        if (tmp & RCR1_AF)
-                events |= RTC_AF | RTC_IRQF;
-
-        tmp &= ~(RCR1_CF | RCR1_AF);
+        if (rtc->rearm_aie) {
+                if (tmp & RCR1_AF)
+                        tmp &= ~RCR1_AF;        /* try to clear AF again */
+                else {
+                        tmp |= RCR1_AIE;        /* AF has cleared, rearm IRQ */
+                        rtc->rearm_aie = 0;
+                }
+        }
 
         writeb(tmp, rtc->regbase + RCR1);
 
@@ -97,9 +111,45 @@ static irqreturn_t sh_rtc_interrupt(int irq, void *id)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t sh_rtc_periodic(int irq, void *id)
+static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
 {
-        struct sh_rtc *rtc = dev_get_drvdata(id);
+        struct platform_device *pdev = to_platform_device(dev_id);
+        struct sh_rtc *rtc = platform_get_drvdata(pdev);
+        unsigned int tmp, events = 0;
+
+        spin_lock(&rtc->lock);
+
+        tmp = readb(rtc->regbase + RCR1);
+
+        /*
+         * If AF is set then the alarm has triggered. If we clear AF while
+         * the alarm time still matches the RTC time then AF will
+         * immediately be set again, and if AIE is enabled then the alarm
+         * interrupt will immediately be retrigger. So we clear AIE here
+         * and use rtc->rearm_aie so that the carry interrupt will keep
+         * trying to clear AF and once it stays cleared it'll re-enable
+         * AIE.
+         */
+        if (tmp & RCR1_AF) {
+                events |= RTC_AF | RTC_IRQF;
+
+                tmp &= ~(RCR1_AF|RCR1_AIE);
+
+                writeb(tmp, rtc->regbase + RCR1);
+
+                rtc->rearm_aie = 1;
+
+                rtc_update_irq(&rtc->rtc_dev->class_dev, 1, events);
+        }
+
+        spin_unlock(&rtc->lock);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
+{
+        struct platform_device *pdev = to_platform_device(dev_id);
+        struct sh_rtc *rtc = platform_get_drvdata(pdev);
 
         spin_lock(&rtc->lock);
 
@@ -139,10 +189,11 @@ static inline void sh_rtc_setaie(struct device *dev, unsigned int enable)
 
         tmp = readb(rtc->regbase + RCR1);
 
-        if (enable)
-                tmp |= RCR1_AIE;
-        else
+        if (!enable) {
                 tmp &= ~RCR1_AIE;
+                rtc->rearm_aie = 0;
+        } else if (rtc->rearm_aie == 0)
+                tmp |= RCR1_AIE;
 
         writeb(tmp, rtc->regbase + RCR1);
 
@@ -177,7 +228,7 @@ static int sh_rtc_open(struct device *dev)
                 goto err_bad_carry;
         }
 
-        ret = request_irq(rtc->alarm_irq, sh_rtc_interrupt, IRQF_DISABLED,
+        ret = request_irq(rtc->alarm_irq, sh_rtc_alarm, IRQF_DISABLED,
                           "sh-rtc alarm", dev);
         if (unlikely(ret)) {
                 dev_err(dev, "request alarm IRQ failed with %d, IRQ %d\n",
@@ -200,6 +251,7 @@ static void sh_rtc_release(struct device *dev)
         struct sh_rtc *rtc = dev_get_drvdata(dev);
 
         sh_rtc_setpie(dev, 0);
+        sh_rtc_setaie(dev, 0);
 
         free_irq(rtc->periodic_irq, dev);
         free_irq(rtc->carry_irq, dev);
@@ -212,8 +264,6 @@ static int sh_rtc_proc(struct device *dev, struct seq_file *seq)
         unsigned int tmp;
 
         tmp = readb(rtc->regbase + RCR1);
-        seq_printf(seq, "alarm_IRQ\t: %s\n",
-                   (tmp & RCR1_AIE) ? "yes" : "no");
         seq_printf(seq, "carry_IRQ\t: %s\n",
                    (tmp & RCR1_CIE) ? "yes" : "no");
 
@@ -267,7 +317,7 @@ static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 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));
+                tm->tm_mon      = BCD2BIN(readb(rtc->regbase + RMONCNT)) - 1;
 
 #if defined(CONFIG_CPU_SH4)
                 yr  = readw(rtc->regbase + RYRCNT);
@@ -295,7 +345,7 @@ static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 "mday=%d, mon=%d, year=%d, wday=%d\n",
                 __FUNCTION__,
                 tm->tm_sec, tm->tm_min, tm->tm_hour,
-                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+                tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
 
         if (rtc_valid_tm(tm) < 0)
                 dev_err(dev, "invalid date\n");
@@ -322,7 +372,7 @@ static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm)
         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),  rtc->regbase + RMONCNT);
+        writeb(BIN2BCD(tm->tm_mon + 1), rtc->regbase + RMONCNT);
 
 #ifdef CONFIG_CPU_SH3
         year = tm->tm_year % 100;
@@ -344,12 +394,138 @@ static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm)
         return 0;
 }
 
+static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)
+{
+        unsigned int byte;
+        int value = 0xff;       /* return 0xff for ignored values */
+
+        byte = readb(rtc->regbase + reg_off);
+        if (byte & AR_ENB) {
+                byte &= ~AR_ENB;        /* strip the enable bit */
+                value = BCD2BIN(byte);
+        }
+
+        return value;
+}
+
+static int sh_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_rtc *rtc = platform_get_drvdata(pdev);
+        struct rtc_time* tm = &wkalrm->time;
+
+        spin_lock_irq(&rtc->lock);
+
+        tm->tm_sec      = sh_rtc_read_alarm_value(rtc, RSECAR);
+        tm->tm_min      = sh_rtc_read_alarm_value(rtc, RMINAR);
+        tm->tm_hour     = sh_rtc_read_alarm_value(rtc, RHRAR);
+        tm->tm_wday     = sh_rtc_read_alarm_value(rtc, RWKAR);
+        tm->tm_mday     = sh_rtc_read_alarm_value(rtc, RDAYAR);
+        tm->tm_mon      = sh_rtc_read_alarm_value(rtc, RMONAR);
+        if (tm->tm_mon > 0)
+                tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
+        tm->tm_year     = 0xffff;
+
+        wkalrm->enabled = (readb(rtc->regbase + RCR1) & RCR1_AIE) ? 1 : 0;
+
+        spin_unlock_irq(&rtc->lock);
+
+        return 0;
+}
+
+static inline void sh_rtc_write_alarm_value(struct sh_rtc *rtc,
+                                            int value, int reg_off)
+{
+        /* < 0 for a value that is ignored */
+        if (value < 0)
+                writeb(0, rtc->regbase + reg_off);
+        else
+                writeb(BIN2BCD(value) | AR_ENB,  rtc->regbase + reg_off);
+}
+
+static int sh_rtc_check_alarm(struct rtc_time* tm)
+{
+        /*
+         * The original rtc says anything > 0xc0 is "don't care" or "match
+         * all" - most users use 0xff but rtc-dev uses -1 for the same thing.
+         * The original rtc doesn't support years - some things use -1 and
+         * some 0xffff. We use -1 to make out tests easier.
+         */
+        if (tm->tm_year == 0xffff)
+                tm->tm_year = -1;
+        if (tm->tm_mon >= 0xff)
+                tm->tm_mon = -1;
+        if (tm->tm_mday >= 0xff)
+                tm->tm_mday = -1;
+        if (tm->tm_wday >= 0xff)
+                tm->tm_wday = -1;
+        if (tm->tm_hour >= 0xff)
+                tm->tm_hour = -1;
+        if (tm->tm_min >= 0xff)
+                tm->tm_min = -1;
+        if (tm->tm_sec >= 0xff)
+                tm->tm_sec = -1;
+
+        if (tm->tm_year > 9999 ||
+                tm->tm_mon >= 12 ||
+                tm->tm_mday == 0 || tm->tm_mday >= 32 ||
+                tm->tm_wday >= 7 ||
+                tm->tm_hour >= 24 ||
+                tm->tm_min >= 60 ||
+                tm->tm_sec >= 60)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_rtc *rtc = platform_get_drvdata(pdev);
+        unsigned int rcr1;
+        struct rtc_time *tm = &wkalrm->time;
+        int mon, err;
+
+        err = sh_rtc_check_alarm(tm);
+        if (unlikely(err < 0))
+                return err;
+
+        spin_lock_irq(&rtc->lock);
+
+        /* disable alarm interrupt and clear flag */
+        rcr1 = readb(rtc->regbase + RCR1);
+        rcr1 &= ~RCR1_AF;
+        writeb(rcr1 & ~RCR1_AIE, rtc->regbase + RCR1);
+
+        rtc->rearm_aie = 0;
+
+        /* set alarm time */
+        sh_rtc_write_alarm_value(rtc, tm->tm_sec,  RSECAR);
+        sh_rtc_write_alarm_value(rtc, tm->tm_min,  RMINAR);
+        sh_rtc_write_alarm_value(rtc, tm->tm_hour, RHRAR);
+        sh_rtc_write_alarm_value(rtc, tm->tm_wday, RWKAR);
+        sh_rtc_write_alarm_value(rtc, tm->tm_mday, RDAYAR);
+        mon = tm->tm_mon;
+        if (mon >= 0)
+                mon += 1;
+        sh_rtc_write_alarm_value(rtc, mon, RMONAR);
+
+        /* Restore interrupt activation status */
+        writeb(rcr1, rtc->regbase + RCR1);
+
+        spin_unlock_irq(&rtc->lock);
+
+        return 0;
+}
+
 static struct rtc_class_ops sh_rtc_ops = {
         .open           = sh_rtc_open,
         .release        = sh_rtc_release,
         .ioctl          = sh_rtc_ioctl,
         .read_time      = sh_rtc_read_time,
         .set_time       = sh_rtc_set_time,
+        .read_alarm     = sh_rtc_read_alarm,
+        .set_alarm      = sh_rtc_set_alarm,
         .proc           = sh_rtc_proc,
 };
 
@@ -442,7 +618,7 @@ static int __devexit sh_rtc_remove(struct platform_device *pdev)
 }
 static struct platform_driver sh_rtc_platform_driver = {
         .driver         = {
-                .name   = "sh-rtc",
+                .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
         },
         .probe          = sh_rtc_probe,
@@ -463,5 +639,6 @@ module_init(sh_rtc_init);
 module_exit(sh_rtc_exit);
 
 MODULE_DESCRIPTION("SuperH on-chip RTC driver");
-MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, Jamie Lenehan <lenehan@twibble.org>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index 625637b84d33..9418a59fb368 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -83,7 +83,7 @@ static int __devinit rtc_sysfs_add_device(struct class_device *class_dev,
 {
         int err;
 
-        dev_info(class_dev->dev, "rtc intf: sysfs\n");
+        dev_dbg(class_dev->dev, "rtc intf: sysfs\n");
 
         err = sysfs_create_group(&class_dev->kobj, &rtc_attr_group);
         if (err)
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index 6ef9c62d5032..f50a1b8e1607 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -123,11 +123,18 @@ static int test_probe(struct platform_device *plat_dev)
                 err = PTR_ERR(rtc);
                 return err;
         }
-        device_create_file(&plat_dev->dev, &dev_attr_irq);
+
+        err = device_create_file(&plat_dev->dev, &dev_attr_irq);
+        if (err)
+                goto err;
 
         platform_set_drvdata(plat_dev, rtc);
 
         return 0;
+
+err:
+        rtc_device_unregister(rtc);
+        return err;
 }
 
 static int __devexit test_remove(struct platform_device *plat_dev)
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index 522c69753bbf..019ae255b0c8 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -372,7 +372,7 @@ static int x1205_validate_client(struct i2c_client *client)
                 };
 
                 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
-                        dev_err(&client->adapter->dev,
+                        dev_err(&client->dev,
                                 "%s: could not read register %x\n",
                                 __FUNCTION__, probe_zero_pattern[i]);
 
@@ -380,7 +380,7 @@ static int x1205_validate_client(struct i2c_client *client)
                 }
 
                 if ((buf & probe_zero_pattern[i+1]) != 0) {
-                        dev_err(&client->adapter->dev,
+                        dev_err(&client->dev,
                                 "%s: register=%02x, zero pattern=%d, value=%x\n",
                                 __FUNCTION__, probe_zero_pattern[i], i, buf);
 
@@ -400,7 +400,7 @@ static int x1205_validate_client(struct i2c_client *client)
                 };
 
                 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
-                        dev_err(&client->adapter->dev,
+                        dev_err(&client->dev,
                                 "%s: could not read register %x\n",
                                 __FUNCTION__, probe_limits_pattern[i].reg);
 
@@ -411,7 +411,7 @@ static int x1205_validate_client(struct i2c_client *client)
 
                 if (value > probe_limits_pattern[i].max ||
                         value < probe_limits_pattern[i].min) {
-                        dev_dbg(&client->adapter->dev,
+                        dev_dbg(&client->dev,
                                 "%s: register=%x, lim pattern=%d, value=%d\n",
                                 __FUNCTION__, probe_limits_pattern[i].reg,
                                 i, value);
@@ -506,7 +506,7 @@ static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
         struct i2c_client *client;
         struct rtc_device *rtc;
 
-        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        dev_dbg(adapter->class_dev.dev, "%s\n", __FUNCTION__);
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
                 err = -ENODEV;
@@ -562,11 +562,19 @@ static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
         else
                 dev_err(&client->dev, "couldn't read status\n");
 
-        device_create_file(&client->dev, &dev_attr_atrim);
-        device_create_file(&client->dev, &dev_attr_dtrim);
+        err = device_create_file(&client->dev, &dev_attr_atrim);
+        if (err) goto exit_devreg;
+        err = device_create_file(&client->dev, &dev_attr_dtrim);
+        if (err) goto exit_atrim;
 
         return 0;
 
+exit_atrim:
+        device_remove_file(&client->dev, &dev_attr_atrim);
+
+exit_devreg:
+        rtc_device_unregister(rtc);
+
 exit_detach:
         i2c_detach_client(client);