x86, VisWS: turn into generic arch, clean up
[linux-2.6] / 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);