7 files changed, 185 insertions, 100 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 50ac047cd136..f1598324344c 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -640,7 +640,7 @@ config RTC_DRV_OMAP
 
 config RTC_DRV_S3C
         tristate "Samsung S3C series SoC RTC"
-        depends on ARCH_S3C2410
+        depends on ARCH_S3C2410 || ARCH_S3C64XX
         help
           RTC (Realtime Clock) driver for the clock inbuilt into the
           Samsung S3C24XX series of SoCs. This can provide periodic
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 96e8e70fbf1e..11b8ea29d2b7 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -719,6 +719,9 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                 }
         }
 
+        cmos_rtc.dev = dev;
+        dev_set_drvdata(dev, &cmos_rtc);
+
         cmos_rtc.rtc = rtc_device_register(driver_name, dev,
                                 &cmos_rtc_ops, THIS_MODULE);
         if (IS_ERR(cmos_rtc.rtc)) {
@@ -726,8 +729,6 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                 goto cleanup0;
         }
 
-        cmos_rtc.dev = dev;
-        dev_set_drvdata(dev, &cmos_rtc);
         rename_region(ports, dev_name(&cmos_rtc.rtc->dev));
 
         spin_lock_irq(&rtc_lock);
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index 532acf9b05d8..359d1e04626c 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -16,7 +16,6 @@
 #include <linux/rtc.h>
 #include <linux/io.h>
 #include <linux/bcd.h>
-#include <asm/rtc.h>
 
 #define DRV_NAME        "rtc-ds1302"
 #define DRV_VERSION     "0.1.1"
@@ -34,14 +33,55 @@
 #define RTC_ADDR_MIN    0x01            /* Address of minute register */
 #define RTC_ADDR_SEC    0x00            /* Address of second register */
 
+#ifdef CONFIG_SH_SECUREEDGE5410
+#include <asm/rtc.h>
+#include <mach/snapgear.h>
+
 #define RTC_RESET       0x1000
 #define RTC_IODATA      0x0800
 #define RTC_SCLK        0x0400
 
-#ifdef CONFIG_SH_SECUREEDGE5410
-#include <mach/snapgear.h>
 #define set_dp(x)       SECUREEDGE_WRITE_IOPORT(x, 0x1c00)
 #define get_dp()        SECUREEDGE_READ_IOPORT()
+#define ds1302_set_tx()
+#define ds1302_set_rx()
+
+static inline int ds1302_hw_init(void)
+{
+        return 0;
+}
+
+static inline void ds1302_reset(void)
+{
+        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
+}
+
+static inline void ds1302_clock(void)
+{
+        set_dp(get_dp() | RTC_SCLK);    /* clock high */
+        set_dp(get_dp() & ~RTC_SCLK);   /* clock low */
+}
+
+static inline void ds1302_start(void)
+{
+        set_dp(get_dp() | RTC_RESET);
+}
+
+static inline void ds1302_stop(void)
+{
+        set_dp(get_dp() & ~RTC_RESET);
+}
+
+static inline void ds1302_txbit(int bit)
+{
+        set_dp((get_dp() & ~RTC_IODATA) | (bit ? RTC_IODATA : 0));
+}
+
+static inline int ds1302_rxbit(void)
+{
+        return !!(get_dp() & RTC_IODATA);
+}
+
 #else
 #error "Add support for your platform"
 #endif
@@ -50,11 +90,11 @@ static void ds1302_sendbits(unsigned int val)
 {
         int i;
 
+        ds1302_set_tx();
+
         for (i = 8; (i); i--, val >>= 1) {
-                set_dp((get_dp() & ~RTC_IODATA) | ((val & 0x1) ?
-                        RTC_IODATA : 0));
-                set_dp(get_dp() | RTC_SCLK);    /* clock high */
-                set_dp(get_dp() & ~RTC_SCLK);   /* clock low */
+                ds1302_txbit(val & 0x1);
+                ds1302_clock();
         }
 }
 
@@ -63,10 +103,11 @@ static unsigned int ds1302_recvbits(void)
         unsigned int val;
         int i;
 
+        ds1302_set_rx();
+
         for (i = 0, val = 0; (i < 8); i++) {
-                val |= (((get_dp() & RTC_IODATA) ? 1 : 0) << i);
-                set_dp(get_dp() | RTC_SCLK);    /* clock high */
-                set_dp(get_dp() & ~RTC_SCLK);   /* clock low */
+                val |= (ds1302_rxbit() << i);
+                ds1302_clock();
         }
 
         return val;
@@ -76,23 +117,24 @@ static unsigned int ds1302_readbyte(unsigned int addr)
 {
         unsigned int val;
 
-        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
+        ds1302_reset();
 
-        set_dp(get_dp() | RTC_RESET);
+        ds1302_start();
         ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_READ);
         val = ds1302_recvbits();
-        set_dp(get_dp() & ~RTC_RESET);
+        ds1302_stop();
 
         return val;
 }
 
 static void ds1302_writebyte(unsigned int addr, unsigned int val)
 {
-        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
-        set_dp(get_dp() | RTC_RESET);
+        ds1302_reset();
+
+        ds1302_start();
         ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_WRITE);
         ds1302_sendbits(val);
-        set_dp(get_dp() & ~RTC_RESET);
+        ds1302_stop();
 }
 
 static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
@@ -167,13 +209,20 @@ static int __init ds1302_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
 
+        if (ds1302_hw_init()) {
+                dev_err(&pdev->dev, "Failed to init communication channel");
+                return -EINVAL;
+        }
+
         /* Reset */
-        set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
+        ds1302_reset();
 
         /* Write a magic value to the DS1302 RAM, and see if it sticks. */
         ds1302_writebyte(RTC_ADDR_RAM0, 0x42);
-        if (ds1302_readbyte(RTC_ADDR_RAM0) != 0x42)
+        if (ds1302_readbyte(RTC_ADDR_RAM0) != 0x42) {
+                dev_err(&pdev->dev, "Failed to probe");
                 return -ENODEV;
+        }
 
         rtc = rtc_device_register("ds1302", &pdev->dev,
                                            &ds1302_rtc_ops, THIS_MODULE);
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index 054e05294af8..468200c38ecb 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -462,39 +462,16 @@ isl1208_sysfs_store_usr(struct device *dev,
 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
                    isl1208_sysfs_store_usr);
 
-static int
-isl1208_sysfs_register(struct device *dev)
-{
-        int err;
-
-        err = device_create_file(dev, &dev_attr_atrim);
-        if (err)
-                return err;
-
-        err = device_create_file(dev, &dev_attr_dtrim);
-        if (err) {
-                device_remove_file(dev, &dev_attr_atrim);
-                return err;
-        }
-
-        err = device_create_file(dev, &dev_attr_usr);
-        if (err) {
-                device_remove_file(dev, &dev_attr_atrim);
-                device_remove_file(dev, &dev_attr_dtrim);
-        }
-
-        return 0;
-}
-
-static int
-isl1208_sysfs_unregister(struct device *dev)
-{
-        device_remove_file(dev, &dev_attr_dtrim);
-        device_remove_file(dev, &dev_attr_atrim);
-        device_remove_file(dev, &dev_attr_usr);
+static struct attribute *isl1208_rtc_attrs[] = {
+        &dev_attr_atrim.attr,
+        &dev_attr_dtrim.attr,
+        &dev_attr_usr.attr,
+        NULL
+};
 
-        return 0;
-}
+static const struct attribute_group isl1208_rtc_sysfs_files = {
+        .attrs  = isl1208_rtc_attrs,
+};
 
 static int
 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
@@ -529,7 +506,7 @@ isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 dev_warn(&client->dev, "rtc power failure detected, "
                          "please set clock.\n");
 
-        rc = isl1208_sysfs_register(&client->dev);
+        rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
         if (rc)
                 goto exit_unregister;
 
@@ -546,7 +523,7 @@ isl1208_remove(struct i2c_client *client)
 {
         struct rtc_device *rtc = i2c_get_clientdata(client);
 
-        isl1208_sysfs_unregister(&client->dev);
+        sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
         rtc_device_unregister(rtc);
 
         return 0;
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index d71fe61db1d6..25ec921db07c 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -379,7 +379,6 @@ static struct rtc_class_ops mxc_rtc_ops = {
 
 static int __init mxc_rtc_probe(struct platform_device *pdev)
 {
-        struct clk *clk;
         struct resource *res;
         struct rtc_device *rtc;
         struct rtc_plat_data *pdata = NULL;
@@ -402,14 +401,15 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
         pdata->ioaddr = devm_ioremap(&pdev->dev, res->start,
                                      resource_size(res));
 
-        clk = clk_get(&pdev->dev, "ckil");
-        if (IS_ERR(clk)) {
-                ret = PTR_ERR(clk);
+        pdata->clk = clk_get(&pdev->dev, "rtc");
+        if (IS_ERR(pdata->clk)) {
+                dev_err(&pdev->dev, "unable to get clock!\n");
+                ret = PTR_ERR(pdata->clk);
                 goto exit_free_pdata;
         }
 
-        rate = clk_get_rate(clk);
-        clk_put(clk);
+        clk_enable(pdata->clk);
+        rate = clk_get_rate(pdata->clk);
 
         if (rate == 32768)
                 reg = RTC_INPUT_CLK_32768HZ;
@@ -420,7 +420,7 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
         else {
                 dev_err(&pdev->dev, "rtc clock is not valid (%lu)\n", rate);
                 ret = -EINVAL;
-                goto exit_free_pdata;
+                goto exit_put_clk;
         }
 
         reg |= RTC_ENABLE_BIT;
@@ -428,18 +428,9 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
         if (((readw(pdata->ioaddr + RTC_RTCCTL)) & RTC_ENABLE_BIT) == 0) {
                 dev_err(&pdev->dev, "hardware module can't be enabled!\n");
                 ret = -EIO;
-                goto exit_free_pdata;
-        }
-
-        pdata->clk = clk_get(&pdev->dev, "rtc");
-        if (IS_ERR(pdata->clk)) {
-                dev_err(&pdev->dev, "unable to get clock!\n");
-                ret = PTR_ERR(pdata->clk);
-                goto exit_free_pdata;
+                goto exit_put_clk;
         }
 
-        clk_enable(pdata->clk);
-
         rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
                                   THIS_MODULE);
         if (IS_ERR(rtc)) {
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index 4969b6059c89..e5972b2c17b7 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -29,6 +29,11 @@
 #include <asm/irq.h>
 #include <plat/regs-rtc.h>
 
+enum s3c_cpu_type {
+        TYPE_S3C2410,
+        TYPE_S3C64XX,
+};
+
 /* I have yet to find an S3C implementation with more than one
  * of these rtc blocks in */
 
@@ -37,6 +42,7 @@ 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 enum s3c_cpu_type s3c_rtc_cpu_type;
 
 static DEFINE_SPINLOCK(s3c_rtc_pie_lock);
 
@@ -80,12 +86,25 @@ static int s3c_rtc_setpie(struct device *dev, int enabled)
         pr_debug("%s: pie=%d\n", __func__, enabled);
 
         spin_lock_irq(&s3c_rtc_pie_lock);
-        tmp = readb(s3c_rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;
 
-        if (enabled)
-                tmp |= S3C2410_TICNT_ENABLE;
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
+                tmp = readb(s3c_rtc_base + S3C2410_RTCCON);
+                tmp &= ~S3C64XX_RTCCON_TICEN;
+
+                if (enabled)
+                        tmp |= S3C64XX_RTCCON_TICEN;
+
+                writeb(tmp, s3c_rtc_base + S3C2410_RTCCON);
+        } else {
+                tmp = readb(s3c_rtc_base + S3C2410_TICNT);
+                tmp &= ~S3C2410_TICNT_ENABLE;
+
+                if (enabled)
+                        tmp |= S3C2410_TICNT_ENABLE;
+
+                writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
+        }
 
-        writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
         spin_unlock_irq(&s3c_rtc_pie_lock);
 
         return 0;
@@ -93,15 +112,21 @@ static int s3c_rtc_setpie(struct device *dev, int enabled)
 
 static int s3c_rtc_setfreq(struct device *dev, int freq)
 {
-        unsigned int tmp;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
+        unsigned int tmp = 0;
 
         if (!is_power_of_2(freq))
                 return -EINVAL;
 
         spin_lock_irq(&s3c_rtc_pie_lock);
 
-        tmp = readb(s3c_rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
-        tmp |= (128 / freq)-1;
+        if (s3c_rtc_cpu_type == TYPE_S3C2410) {
+                tmp = readb(s3c_rtc_base + S3C2410_TICNT);
+                tmp &= S3C2410_TICNT_ENABLE;
+        }
+
+        tmp |= (rtc_dev->max_user_freq / freq)-1;
 
         writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
         spin_unlock_irq(&s3c_rtc_pie_lock);
@@ -283,10 +308,17 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 
 static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
 {
-        unsigned int ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
+        unsigned int ticnt;
 
-        seq_printf(seq, "periodic_IRQ\t: %s\n",
-                     (ticnt & S3C2410_TICNT_ENABLE) ? "yes" : "no" );
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
+                ticnt = readb(s3c_rtc_base + S3C2410_RTCCON);
+                ticnt &= S3C64XX_RTCCON_TICEN;
+        } else {
+                ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
+                ticnt &= S3C2410_TICNT_ENABLE;
+        }
+
+        seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt  ? "yes" : "no");
         return 0;
 }
 
@@ -353,10 +385,16 @@ static void s3c_rtc_enable(struct platform_device *pdev, int en)
 
         if (!en) {
                 tmp = readb(base + S3C2410_RTCCON);
-                writeb(tmp & ~S3C2410_RTCCON_RTCEN, base + S3C2410_RTCCON);
-
-                tmp = readb(base + S3C2410_TICNT);
-                writeb(tmp & ~S3C2410_TICNT_ENABLE, base + S3C2410_TICNT);
+                if (s3c_rtc_cpu_type == TYPE_S3C64XX)
+                        tmp &= ~S3C64XX_RTCCON_TICEN;
+                tmp &= ~S3C2410_RTCCON_RTCEN;
+                writeb(tmp, base + S3C2410_RTCCON);
+
+                if (s3c_rtc_cpu_type == TYPE_S3C2410) {
+                        tmp = readb(base + S3C2410_TICNT);
+                        tmp &= ~S3C2410_TICNT_ENABLE;
+                        writeb(tmp, base + S3C2410_TICNT);
+                }
         } else {
                 /* re-enable the device, and check it is ok */
 
@@ -472,7 +510,12 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
                 goto err_nortc;
         }
 
-        rtc->max_user_freq = 128;
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX)
+                rtc->max_user_freq = 32768;
+        else
+                rtc->max_user_freq = 128;
+
+        s3c_rtc_cpu_type = platform_get_device_id(pdev)->driver_data;
 
         platform_set_drvdata(pdev, rtc);
         return 0;
@@ -492,20 +535,30 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 
 /* RTC Power management control */
 
-static int ticnt_save;
+static int ticnt_save, ticnt_en_save;
 
 static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
         /* save TICNT for anyone using periodic interrupts */
         ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT);
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX) {
+                ticnt_en_save = readb(s3c_rtc_base + S3C2410_RTCCON);
+                ticnt_en_save &= S3C64XX_RTCCON_TICEN;
+        }
         s3c_rtc_enable(pdev, 0);
         return 0;
 }
 
 static int s3c_rtc_resume(struct platform_device *pdev)
 {
+        unsigned int tmp;
+
         s3c_rtc_enable(pdev, 1);
         writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
+        if (s3c_rtc_cpu_type == TYPE_S3C64XX && ticnt_en_save) {
+                tmp = readb(s3c_rtc_base + S3C2410_RTCCON);
+                writeb(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON);
+        }
         return 0;
 }
 #else
@@ -513,13 +566,27 @@ static int s3c_rtc_resume(struct platform_device *pdev)
 #define s3c_rtc_resume  NULL
 #endif
 
-static struct platform_driver s3c2410_rtc_driver = {
+static struct platform_device_id s3c_rtc_driver_ids[] = {
+        {
+                .name           = "s3c2410-rtc",
+                .driver_data    = TYPE_S3C2410,
+        }, {
+                .name           = "s3c64xx-rtc",
+                .driver_data    = TYPE_S3C64XX,
+        },
+        { }
+};
+
+MODULE_DEVICE_TABLE(platform, s3c_rtc_driver_ids);
+
+static struct platform_driver s3c_rtc_driver = {
         .probe          = s3c_rtc_probe,
         .remove         = __devexit_p(s3c_rtc_remove),
         .suspend        = s3c_rtc_suspend,
         .resume         = s3c_rtc_resume,
+        .id_table       = s3c_rtc_driver_ids,
         .driver         = {
-                .name   = "s3c2410-rtc",
+                .name   = "s3c-rtc",
                 .owner  = THIS_MODULE,
         },
 };
@@ -529,12 +596,12 @@ static char __initdata banner[] = "S3C24XX RTC, (c) 2004,2006 Simtec Electronics
 static int __init s3c_rtc_init(void)
 {
         printk(banner);
-        return platform_driver_register(&s3c2410_rtc_driver);
+        return platform_driver_register(&s3c_rtc_driver);
 }
 
 static void __exit s3c_rtc_exit(void)
 {
-        platform_driver_unregister(&s3c2410_rtc_driver);
+        platform_driver_unregister(&s3c_rtc_driver);
 }
 
 module_init(s3c_rtc_init);
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
index b16cfe57a484..82931dc65c0b 100644
--- a/drivers/rtc/rtc-wm831x.c
+++ b/drivers/rtc/rtc-wm831x.c
@@ -449,17 +449,17 @@ static int wm831x_rtc_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        ret = wm831x_request_irq(wm831x, per_irq, wm831x_per_irq,
-                                 IRQF_TRIGGER_RISING, "wm831x_rtc_per",
-                                 wm831x_rtc);
+        ret = request_threaded_irq(per_irq, NULL, wm831x_per_irq,
+                                   IRQF_TRIGGER_RISING, "RTC period",
+                                   wm831x_rtc);
         if (ret != 0) {
                 dev_err(&pdev->dev, "Failed to request periodic IRQ %d: %d\n",
                         per_irq, ret);
         }
 
-        ret = wm831x_request_irq(wm831x, alm_irq, wm831x_alm_irq,
-                                 IRQF_TRIGGER_RISING, "wm831x_rtc_alm",
-                                 wm831x_rtc);
+        ret = request_threaded_irq(alm_irq, NULL, wm831x_alm_irq,
+                                   IRQF_TRIGGER_RISING, "RTC alarm",
+                                   wm831x_rtc);
         if (ret != 0) {
                 dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
                         alm_irq, ret);
@@ -478,8 +478,8 @@ static int __devexit wm831x_rtc_remove(struct platform_device *pdev)
         int per_irq = platform_get_irq_byname(pdev, "PER");
         int alm_irq = platform_get_irq_byname(pdev, "ALM");
 
-        wm831x_free_irq(wm831x_rtc->wm831x, alm_irq, wm831x_rtc);
-        wm831x_free_irq(wm831x_rtc->wm831x, per_irq, wm831x_rtc);
+        free_irq(alm_irq, wm831x_rtc);
+        free_irq(per_irq, wm831x_rtc);
         rtc_device_unregister(wm831x_rtc->rtc);
         kfree(wm831x_rtc);