1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/errno.h>
18#include <linux/module.h>
19#include <linux/sched.h>
20#include <linux/kernel.h>
21#include <linux/param.h>
22#include <linux/string.h>
23#include <linux/mm.h>
24#include <linux/interrupt.h>
25#include <linux/time.h>
26#include <linux/rtc.h>
27#include <linux/rtc/m48t59.h>
28#include <linux/timex.h>
29#include <linux/init.h>
30#include <linux/pci.h>
31#include <linux/ioport.h>
32#include <linux/profile.h>
33#include <linux/of.h>
34#include <linux/of_device.h>
35#include <linux/platform_device.h>
36
37#include <asm/oplib.h>
38#include <asm/timer.h>
39#include <asm/system.h>
40#include <asm/irq.h>
41#include <asm/io.h>
42#include <asm/idprom.h>
43#include <asm/machines.h>
44#include <asm/page.h>
45#include <asm/pcic.h>
46#include <asm/irq_regs.h>
47
48#include "irq.h"
49
50DEFINE_SPINLOCK(rtc_lock);
51EXPORT_SYMBOL(rtc_lock);
52
53static int set_rtc_mmss(unsigned long);
54static int sbus_do_settimeofday(struct timespec *tv);
55
56unsigned long profile_pc(struct pt_regs *regs)
57{
58 extern char __copy_user_begin[], __copy_user_end[];
59 extern char __atomic_begin[], __atomic_end[];
60 extern char __bzero_begin[], __bzero_end[];
61
62 unsigned long pc = regs->pc;
63
64 if (in_lock_functions(pc) ||
65 (pc >= (unsigned long) __copy_user_begin &&
66 pc < (unsigned long) __copy_user_end) ||
67 (pc >= (unsigned long) __atomic_begin &&
68 pc < (unsigned long) __atomic_end) ||
69 (pc >= (unsigned long) __bzero_begin &&
70 pc < (unsigned long) __bzero_end))
71 pc = regs->u_regs[UREG_RETPC];
72 return pc;
73}
74
75EXPORT_SYMBOL(profile_pc);
76
77__volatile__ unsigned int *master_l10_counter;
78
79
80
81
82
83
84#define TICK_SIZE (tick_nsec / 1000)
85
86static irqreturn_t timer_interrupt(int dummy, void *dev_id)
87{
88
89 static long last_rtc_update;
90
91#ifndef CONFIG_SMP
92 profile_tick(CPU_PROFILING);
93#endif
94
95
96 write_seqlock(&xtime_lock);
97
98 clear_clock_irq();
99
100 do_timer(1);
101
102
103 if (ntp_synced() &&
104 xtime.tv_sec > last_rtc_update + 660 &&
105 (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
106 (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
107 if (set_rtc_mmss(xtime.tv_sec) == 0)
108 last_rtc_update = xtime.tv_sec;
109 else
110 last_rtc_update = xtime.tv_sec - 600;
111 }
112 write_sequnlock(&xtime_lock);
113
114#ifndef CONFIG_SMP
115 update_process_times(user_mode(get_irq_regs()));
116#endif
117 return IRQ_HANDLED;
118}
119
120static unsigned char mostek_read_byte(struct device *dev, u32 ofs)
121{
122 struct platform_device *pdev = to_platform_device(dev);
123 struct m48t59_plat_data *pdata = pdev->dev.platform_data;
124
125 return readb(pdata->ioaddr + ofs);
126}
127
128static void mostek_write_byte(struct device *dev, u32 ofs, u8 val)
129{
130 struct platform_device *pdev = to_platform_device(dev);
131 struct m48t59_plat_data *pdata = pdev->dev.platform_data;
132
133 writeb(val, pdata->ioaddr + ofs);
134}
135
136static struct m48t59_plat_data m48t59_data = {
137 .read_byte = mostek_read_byte,
138 .write_byte = mostek_write_byte,
139};
140
141
142static struct platform_device m48t59_rtc = {
143 .name = "rtc-m48t59",
144 .id = 0,
145 .num_resources = 1,
146 .dev = {
147 .platform_data = &m48t59_data,
148 },
149};
150
151static int __devinit clock_probe(struct of_device *op, const struct of_device_id *match)
152{
153 struct device_node *dp = op->node;
154 const char *model = of_get_property(dp, "model", NULL);
155
156 if (!model)
157 return -ENODEV;
158
159 m48t59_rtc.resource = &op->resource[0];
160 if (!strcmp(model, "mk48t02")) {
161
162 m48t59_data.ioaddr = of_ioremap(&op->resource[0], 0,
163 2048, "rtc-m48t59");
164 m48t59_data.type = M48T59RTC_TYPE_M48T02;
165 } else if (!strcmp(model, "mk48t08")) {
166 m48t59_data.ioaddr = of_ioremap(&op->resource[0], 0,
167 8192, "rtc-m48t59");
168 m48t59_data.type = M48T59RTC_TYPE_M48T08;
169 } else
170 return -ENODEV;
171
172 if (platform_device_register(&m48t59_rtc) < 0)
173 printk(KERN_ERR "Registering RTC device failed\n");
174
175 return 0;
176}
177
178static struct of_device_id __initdata clock_match[] = {
179 {
180 .name = "eeprom",
181 },
182 {},
183};
184
185static struct of_platform_driver clock_driver = {
186 .match_table = clock_match,
187 .probe = clock_probe,
188 .driver = {
189 .name = "rtc",
190 },
191};
192
193
194
195static int __init clock_init(void)
196{
197 return of_register_driver(&clock_driver, &of_platform_bus_type);
198}
199
200
201
202
203
204fs_initcall(clock_init);
205
206static void __init sbus_time_init(void)
207{
208
209 BTFIXUPSET_CALL(bus_do_settimeofday, sbus_do_settimeofday, BTFIXUPCALL_NORM);
210 btfixup();
211
212 sparc_init_timers(timer_interrupt);
213
214
215 local_irq_enable();
216}
217
218void __init time_init(void)
219{
220#ifdef CONFIG_PCI
221 extern void pci_time_init(void);
222 if (pcic_present()) {
223 pci_time_init();
224 return;
225 }
226#endif
227 sbus_time_init();
228}
229
230static inline unsigned long do_gettimeoffset(void)
231{
232 unsigned long val = *master_l10_counter;
233 unsigned long usec = (val >> 10) & 0x1fffff;
234
235
236 if (val & 0x80000000)
237 usec += 1000000 / HZ;
238
239 return usec;
240}
241
242
243
244
245
246void do_gettimeofday(struct timeval *tv)
247{
248 unsigned long flags;
249 unsigned long seq;
250 unsigned long usec, sec;
251 unsigned long max_ntp_tick = tick_usec - tickadj;
252
253 do {
254 seq = read_seqbegin_irqsave(&xtime_lock, flags);
255 usec = do_gettimeoffset();
256
257
258
259
260
261
262 if (unlikely(time_adjust < 0))
263 usec = min(usec, max_ntp_tick);
264
265 sec = xtime.tv_sec;
266 usec += (xtime.tv_nsec / 1000);
267 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
268
269 while (usec >= 1000000) {
270 usec -= 1000000;
271 sec++;
272 }
273
274 tv->tv_sec = sec;
275 tv->tv_usec = usec;
276}
277
278EXPORT_SYMBOL(do_gettimeofday);
279
280int do_settimeofday(struct timespec *tv)
281{
282 int ret;
283
284 write_seqlock_irq(&xtime_lock);
285 ret = bus_do_settimeofday(tv);
286 write_sequnlock_irq(&xtime_lock);
287 clock_was_set();
288 return ret;
289}
290
291EXPORT_SYMBOL(do_settimeofday);
292
293static int sbus_do_settimeofday(struct timespec *tv)
294{
295 time_t wtm_sec, sec = tv->tv_sec;
296 long wtm_nsec, nsec = tv->tv_nsec;
297
298 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
299 return -EINVAL;
300
301
302
303
304
305
306
307 nsec -= 1000 * do_gettimeoffset();
308
309 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
310 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
311
312 set_normalized_timespec(&xtime, sec, nsec);
313 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
314
315 ntp_clear();
316 return 0;
317}
318
319static int set_rtc_mmss(unsigned long secs)
320{
321 struct rtc_device *rtc = rtc_class_open("rtc0");
322 int err = -1;
323
324 if (rtc) {
325 err = rtc_set_mmss(rtc, secs);
326 rtc_class_close(rtc);
327 }
328
329 return err;
330}
331