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 integrator_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 integrator_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 integrator_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 integrator_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      = integrator_rtc_read_time,
  94         .set_time       = integrator_rtc_set_time,
  95         .read_alarm     = integrator_rtc_read_alarm,
  96         .set_alarm      = integrator_rtc_set_alarm,
  97 };
  98
  99 static irqreturn_t arm_rtc_interrupt(int irq, void *dev_id)
 100 {
 101         writel(0, rtc_base + RTC_EOI);
 102         return IRQ_HANDLED;
 103 }
 104
 105 static int rtc_probe(struct amba_device *dev, void *id)
 106 {
 107         int ret;
 108
 109         if (rtc_base)
 110                 return -EBUSY;
 111
 112         ret = amba_request_regions(dev, NULL);
 113         if (ret)
 114                 goto out;
 115
 116         rtc_base = ioremap(dev->res.start, SZ_4K);
 117         if (!rtc_base) {
 118                 ret = -ENOMEM;
 119                 goto res_out;
 120         }
 121
 122         __raw_writel(0, rtc_base + RTC_CR);
 123         __raw_writel(0, rtc_base + RTC_EOI);
 124
 125         xtime.tv_sec = __raw_readl(rtc_base + RTC_DR);
 126
 127         /* note that 'dev' is merely used for irq disambiguation;
 128          * it is not actually referenced in the irq handler
 129          */
 130         ret = request_irq(dev->irq[0], arm_rtc_interrupt, IRQF_DISABLED,
 131                           "rtc-pl030", dev);
 132         if (ret)
 133                 goto map_out;
 134
 135         ret = register_rtc(&rtc_ops);
 136         if (ret)
 137                 goto irq_out;
 138
 139         set_rtc = integrator_set_rtc;
 140         return 0;
 141
 142  irq_out:
 143         free_irq(dev->irq[0], dev);
 144  map_out:
 145         iounmap(rtc_base);
 146         rtc_base = NULL;
 147  res_out:
 148         amba_release_regions(dev);
 149  out:
 150         return ret;
 151 }
 152
 153 static int rtc_remove(struct amba_device *dev)
 154 {
 155         set_rtc = NULL;
 156
 157         writel(0, rtc_base + RTC_CR);
 158
 159         free_irq(dev->irq[0], dev);
 160         unregister_rtc(&rtc_ops);
 161
 162         iounmap(rtc_base);
 163         rtc_base = NULL;
 164         amba_release_regions(dev);
 165
 166         return 0;
 167 }
 168
 169 static struct timespec rtc_delta;
 170
 171 static int rtc_suspend(struct amba_device *dev, pm_message_t state)
 172 {
 173         struct timespec rtc;
 174
 175         rtc.tv_sec = readl(rtc_base + RTC_DR);
 176         rtc.tv_nsec = 0;
 177         save_time_delta(&rtc_delta, &rtc);
 178
 179         return 0;
 180 }
 181
 182 static int rtc_resume(struct amba_device *dev)
 183 {
 184         struct timespec rtc;
 185
 186         rtc.tv_sec = readl(rtc_base + RTC_DR);
 187         rtc.tv_nsec = 0;
 188         restore_time_delta(&rtc_delta, &rtc);
 189
 190         return 0;
 191 }
 192
 193 static struct amba_id rtc_ids[] = {
 194         {
 195                 .id     = 0x00041030,
 196                 .mask   = 0x000fffff,
 197         },
 198         { 0, 0 },
 199 };
 200
 201 static struct amba_driver rtc_driver = {
 202         .drv            = {
 203                 .name   = "rtc-pl030",
 204         },
 205         .probe          = rtc_probe,
 206         .remove         = rtc_remove,
 207         .suspend        = rtc_suspend,
 208         .resume         = rtc_resume,
 209         .id_table       = rtc_ids,
 210 };
 211
 212 static int __init integrator_rtc_init(void)
 213 {
 214         return amba_driver_register(&rtc_driver);
 215 }
 216
 217 static void __exit integrator_rtc_exit(void)
 218 {
 219         amba_driver_unregister(&rtc_driver);
 220 }
 221
 222 module_init(integrator_rtc_init);
 223 module_exit(integrator_rtc_exit);