git.oblomov.eu Git - linux-2.6/blob - arch/arm/mach-integrator/time.c

   1 /*
   2  *  linux/arch/arm/mach-integrator/time.c
   3  *
   4  *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/time.h>
  13 #include <linux/mc146818rtc.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/init.h>
  16 #include <linux/device.h>
  17 #include <linux/amba/bus.h>
  18
  19 #include <asm/hardware.h>
  20 #include <asm/io.h>
  21 #include <asm/uaccess.h>
  22 #include <asm/rtc.h>
  23
  24 #include <asm/mach/time.h>
  25
  26 #define RTC_DR          (0)
  27 #define RTC_MR          (4)
  28 #define RTC_STAT        (8)
  29 #define RTC_EOI         (8)
  30 #define RTC_LR          (12)
  31 #define RTC_CR          (16)
  32 #define RTC_CR_MIE      (1 << 0)
  33
  34 extern int (*set_rtc)(void);
  35 static void __iomem *rtc_base;
  36
  37 static int integrator_set_rtc(void)
  38 {
  39         __raw_writel(xtime.tv_sec, rtc_base + RTC_LR);
  40         return 1;
  41 }
  42
  43 static int rtc_read_alarm(struct rtc_wkalrm *alrm)
  44 {
  45         rtc_time_to_tm(readl(rtc_base + RTC_MR), &alrm->time);
  46         return 0;
  47 }
  48
  49 static inline int rtc_set_alarm(struct rtc_wkalrm *alrm)
  50 {
  51         unsigned long time;
  52         int ret;
  53
  54         /*
  55          * At the moment, we can only deal with non-wildcarded alarm times.
  56          */
  57         ret = rtc_valid_tm(&alrm->time);
  58         if (ret == 0)
  59                 ret = rtc_tm_to_time(&alrm->time, &time);
  60         if (ret == 0)
  61                 writel(time, rtc_base + RTC_MR);
  62         return ret;
  63 }
  64
  65 static int rtc_read_time(struct rtc_time *tm)
  66 {
  67         rtc_time_to_tm(readl(rtc_base + RTC_DR), tm);
  68         return 0;
  69 }
  70
  71 /*
  72  * Set the RTC time.  Unfortunately, we can't accurately set
  73  * the point at which the counter updates.
  74  *
  75  * Also, since RTC_LR is transferred to RTC_CR on next rising
  76  * edge of the 1Hz clock, we must write the time one second
  77  * in advance.
  78  */
  79 static inline int rtc_set_time(struct rtc_time *tm)
  80 {
  81         unsigned long time;
  82         int ret;
  83
  84         ret = rtc_tm_to_time(tm, &time);
  85         if (ret == 0)
  86                 writel(time + 1, rtc_base + RTC_LR);
  87
  88         return ret;
  89 }
  90
  91 static struct rtc_ops rtc_ops = {
  92         .owner          = THIS_MODULE,
  93         .read_time      = rtc_read_time,
  94         .set_time       = rtc_set_time,
  95         .read_alarm     = rtc_read_alarm,
  96         .set_alarm      = rtc_set_alarm,
  97 };
  98
  99 static irqreturn_t arm_rtc_interrupt(int irq, void *dev_id,
 100                                      struct pt_regs *regs)
 101 {
 102         writel(0, rtc_base + RTC_EOI);
 103         return IRQ_HANDLED;
 104 }
 105
 106 static int rtc_probe(struct amba_device *dev, void *id)
 107 {
 108         int ret;
 109
 110         if (rtc_base)
 111                 return -EBUSY;
 112
 113         ret = amba_request_regions(dev, NULL);
 114         if (ret)
 115                 goto out;
 116
 117         rtc_base = ioremap(dev->res.start, SZ_4K);
 118         if (!rtc_base) {
 119                 ret = -ENOMEM;
 120                 goto res_out;
 121         }
 122
 123         __raw_writel(0, rtc_base + RTC_CR);
 124         __raw_writel(0, rtc_base + RTC_EOI);
 125
 126         xtime.tv_sec = __raw_readl(rtc_base + RTC_DR);
 127
 128         ret = request_irq(dev->irq[0], arm_rtc_interrupt, SA_INTERRUPT,
 129                           "rtc-pl030", dev);
 130         if (ret)
 131                 goto map_out;
 132
 133         ret = register_rtc(&rtc_ops);
 134         if (ret)
 135                 goto irq_out;
 136
 137         set_rtc = integrator_set_rtc;
 138         return 0;
 139
 140  irq_out:
 141         free_irq(dev->irq[0], dev);
 142  map_out:
 143         iounmap(rtc_base);
 144         rtc_base = NULL;
 145  res_out:
 146         amba_release_regions(dev);
 147  out:
 148         return ret;
 149 }
 150
 151 static int rtc_remove(struct amba_device *dev)
 152 {
 153         set_rtc = NULL;
 154
 155         writel(0, rtc_base + RTC_CR);
 156
 157         free_irq(dev->irq[0], dev);
 158         unregister_rtc(&rtc_ops);
 159
 160         iounmap(rtc_base);
 161         rtc_base = NULL;
 162         amba_release_regions(dev);
 163
 164         return 0;
 165 }
 166
 167 static struct timespec rtc_delta;
 168
 169 static int rtc_suspend(struct amba_device *dev, pm_message_t state)
 170 {
 171         struct timespec rtc;
 172
 173         rtc.tv_sec = readl(rtc_base + RTC_DR);
 174         rtc.tv_nsec = 0;
 175         save_time_delta(&rtc_delta, &rtc);
 176
 177         return 0;
 178 }
 179
 180 static int rtc_resume(struct amba_device *dev)
 181 {
 182         struct timespec rtc;
 183
 184         rtc.tv_sec = readl(rtc_base + RTC_DR);
 185         rtc.tv_nsec = 0;
 186         restore_time_delta(&rtc_delta, &rtc);
 187
 188         return 0;
 189 }
 190
 191 static struct amba_id rtc_ids[] = {
 192         {
 193                 .id     = 0x00041030,
 194                 .mask   = 0x000fffff,
 195         },
 196         { 0, 0 },
 197 };
 198
 199 static struct amba_driver rtc_driver = {
 200         .drv            = {
 201                 .name   = "rtc-pl030",
 202         },
 203         .probe          = rtc_probe,
 204         .remove         = rtc_remove,
 205         .suspend        = rtc_suspend,
 206         .resume         = rtc_resume,
 207         .id_table       = rtc_ids,
 208 };
 209
 210 static int __init integrator_rtc_init(void)
 211 {
 212         return amba_driver_register(&rtc_driver);
 213 }
 214
 215 static void __exit integrator_rtc_exit(void)
 216 {
 217         amba_driver_unregister(&rtc_driver);
 218 }
 219
 220 module_init(integrator_rtc_init);
 221 module_exit(integrator_rtc_exit);