ARM: OMAP: Fix omap-rtc

[linux-2.6-omap-h63xx.git] / drivers / char / omap-rtc.c

diff --git a/drivers/char/omap-rtc.c b/drivers/char/omap-rtc.c
index 36eedffd3b94b09b18aa685f55e4c4c5abdece85..1ae41222bf7440b24e0c0d823d48f9c26dc18fe4 100644 (file)
--- a/drivers/char/omap-rtc.c
+++ b/drivers/char/omap-rtc.c
@@ -54,7 +54,7 @@
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
 #include <linux/spinlock.h>
-#include <linux/device.h>
+#include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
@@ -71,6 +71,9 @@
 
 extern spinlock_t rtc_lock;
 
+static int omap_rtc_alarm = NO_IRQ;
+static int omap_rtc_timer = NO_IRQ;
+
 
 /* OMAP RTC register access macros: */
 
@@ -118,7 +121,7 @@ static const unsigned char days_in_mo[] =
  *     A very tiny interrupt handler. It runs with SA_INTERRUPT set.
  */
 
-static irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
        /*
         *      Either an alarm interrupt or update complete interrupt.
@@ -436,11 +439,24 @@ static struct miscdevice rtc_dev = {
        .fops           = &rtc_fops,
 };
 
-static int __init omap_rtc_probe(struct device *dev)
+static int __init omap_rtc_probe(struct platform_device *pdev)
 {
-       struct platform_device  *pdev = to_platform_device(dev);
        struct resource         *res, *mem;
 
+       /* find the IRQs */
+
+       omap_rtc_timer = platform_get_irq(pdev, 0);
+       if (omap_rtc_timer <= 0) {
+               dev_err(&pdev->dev, "no irq for rtc timer\n");
+               return -ENOENT;
+       }
+
+       omap_rtc_alarm = platform_get_irq(pdev, 1);
+       if (omap_rtc_alarm <= 0) {
+               dev_err(&pdev->dev, "no irq for alarm\n");
+               return -ENOENT;
+       }
+
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (res)
                mem = request_mem_region(res->start,
@@ -453,7 +469,7 @@ static int __init omap_rtc_probe(struct device *dev)
                        pdev->name, OMAP_RTC_BASE);
                return -EBUSY;
        }
-       dev_set_drvdata(dev, mem);
+       platform_set_drvdata(pdev, mem);
 
        if (CMOS_READ(OMAP_RTC_STATUS_REG) & OMAP_RTC_STATUS_POWER_UP) {
                pr_info("%s: RTC power up reset detected.\n",
@@ -469,18 +485,18 @@ static int __init omap_rtc_probe(struct device *dev)
                CMOS_WRITE(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
        }
 
-       if (request_irq(INT_RTC_TIMER, rtc_interrupt, SA_INTERRUPT,
+       if (request_irq(omap_rtc_timer, rtc_interrupt, SA_INTERRUPT,
                        pdev->name, NULL)) {
                pr_debug("%s: RTC timer interrupt IRQ%d is not free.\n",
-                       pdev->name, INT_RTC_TIMER);
+                       pdev->name, omap_rtc_timer);
                goto fail;
        }
 
-       if (request_irq(INT_RTC_ALARM, rtc_interrupt, SA_INTERRUPT,
+       if (request_irq(omap_rtc_alarm, rtc_interrupt, SA_INTERRUPT,
                        pdev->name, NULL)) {
                pr_debug("%s: RTC alarm interrupt IRQ%d is not free.\n",
-                       pdev->name, INT_RTC_ALARM);
-               free_irq(INT_RTC_TIMER, NULL);
+                       pdev->name, omap_rtc_alarm);
+               free_irq(omap_rtc_timer, NULL);
                goto fail;
        }
 
@@ -502,15 +518,15 @@ fail:
        return -EIO;
 }
 
-static int __exit omap_rtc_remove(struct device *dev)
+static int omap_rtc_remove(struct platform_device *pdev)
 {
-       free_irq (INT_RTC_TIMER, NULL);
-       free_irq (INT_RTC_ALARM, NULL);
+       free_irq (omap_rtc_timer, NULL);
+       free_irq (omap_rtc_alarm, NULL);
 
        remove_proc_entry ("driver/rtc", NULL);
        misc_deregister(&rtc_dev);
 
-       release_resource(dev_get_drvdata(dev));
+       release_resource(platform_get_drvdata(pdev));
        return 0;
 }
 
@@ -709,61 +725,60 @@ static void set_rtc_irq_bit(unsigned char bit)
 #ifdef CONFIG_PM
 static struct timespec rtc_delta;
 
-static int rtc_suspend(struct device *dev, u32 state, u32 level)
+static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
        struct rtc_time rtc_tm;
        struct timespec time;
 
-       if (level == SUSPEND_POWER_DOWN)
-       {
-               time.tv_nsec = 0;
-               get_rtc_time(&rtc_tm);
-               rtc_tm_to_time(&rtc_tm, &time.tv_sec);
+       time.tv_nsec = 0;
+       get_rtc_time(&rtc_tm);
+       rtc_tm_to_time(&rtc_tm, &time.tv_sec);
 
-               save_time_delta(&rtc_delta, &time);
-       }
+       save_time_delta(&rtc_delta, &time);
 
        return 0;
 }
 
-static int rtc_resume(struct device *dev, u32 level)
+static int omap_rtc_resume(struct platform_device *pdev)
 {
        struct rtc_time rtc_tm;
        struct timespec time;
 
-       if (level == RESUME_POWER_ON)
-       {
-               time.tv_nsec = 0;
-               get_rtc_time(&rtc_tm);
-               rtc_tm_to_time(&rtc_tm, &time.tv_sec);
+       time.tv_nsec = 0;
+       get_rtc_time(&rtc_tm);
+       rtc_tm_to_time(&rtc_tm, &time.tv_sec);
 
-               restore_time_delta(&rtc_delta, &time);
-       }
+       restore_time_delta(&rtc_delta, &time);
 
        return 0;
 }
 #else
-#define rtc_suspend NULL
-#define rtc_resume  NULL
+#define omap_rtc_suspend NULL
+#define omap_rtc_resume  NULL
 #endif
 
-static struct device_driver omap_rtc_driver = {
-       .name           = "omap_rtc",
-       .bus            = &platform_bus_type,
+static struct platform_driver omap_rtc_driver = {
        .probe          = omap_rtc_probe,
-       .remove         = __exit_p(omap_rtc_remove),
-       .suspend        = rtc_suspend,
-       .resume         = rtc_resume,
+       .remove         = omap_rtc_remove,
+       .suspend        = omap_rtc_suspend,
+       .resume         = omap_rtc_resume,
+       .driver         = {
+               .name   = "omap_rtc",
+               .owner  = THIS_MODULE,
+       },
 };
 
+static char __initdata banner[] = KERN_INFO "OMAP RTC Driver\n";
+
 static int __init rtc_init(void)
 {
-       return driver_register(&omap_rtc_driver);
+       printk(banner);
+       return platform_driver_register(&omap_rtc_driver);
 }
 
 static void __exit rtc_exit(void)
 {
-       driver_unregister(&omap_rtc_driver);
+       platform_driver_unregister(&omap_rtc_driver);
 }
 
 module_init(rtc_init);