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/timex.h>
27#include <linux/init.h>
28#include <linux/pci.h>
29#include <linux/ioport.h>
30#include <linux/profile.h>
31
32#include <asm/oplib.h>
33#include <asm/timer.h>
34#include <asm/mostek.h>
35#include <asm/system.h>
36#include <asm/irq.h>
37#include <asm/io.h>
38#include <asm/idprom.h>
39#include <asm/machines.h>
40#include <asm/sun4paddr.h>
41#include <asm/page.h>
42#include <asm/pcic.h>
43#include <asm/of_device.h>
44#include <asm/irq_regs.h>
45
46#include "irq.h"
47
48DEFINE_SPINLOCK(rtc_lock);
49enum sparc_clock_type sp_clock_typ;
50DEFINE_SPINLOCK(mostek_lock);
51void __iomem *mstk48t02_regs = NULL;
52static struct mostek48t08 __iomem *mstk48t08_regs = NULL;
53static int set_rtc_mmss(unsigned long);
54static int sbus_do_settimeofday(struct timespec *tv);
55
56#ifdef CONFIG_SUN4
57struct intersil *intersil_clock;
58#define intersil_cmd(intersil_reg, intsil_cmd) intersil_reg->int_cmd_reg = \
59 (intsil_cmd)
60
61#define intersil_intr(intersil_reg, intsil_cmd) intersil_reg->int_intr_reg = \
62 (intsil_cmd)
63
64#define intersil_start(intersil_reg) intersil_cmd(intersil_reg, \
65 ( INTERSIL_START | INTERSIL_32K | INTERSIL_NORMAL | INTERSIL_24H |\
66 INTERSIL_INTR_ENABLE))
67
68#define intersil_stop(intersil_reg) intersil_cmd(intersil_reg, \
69 ( INTERSIL_STOP | INTERSIL_32K | INTERSIL_NORMAL | INTERSIL_24H |\
70 INTERSIL_INTR_ENABLE))
71
72#define intersil_read_intr(intersil_reg, towhere) towhere = \
73 intersil_reg->int_intr_reg
74
75#endif
76
77unsigned long profile_pc(struct pt_regs *regs)
78{
79 extern char __copy_user_begin[], __copy_user_end[];
80 extern char __atomic_begin[], __atomic_end[];
81 extern char __bzero_begin[], __bzero_end[];
82
83 unsigned long pc = regs->pc;
84
85 if (in_lock_functions(pc) ||
86 (pc >= (unsigned long) __copy_user_begin &&
87 pc < (unsigned long) __copy_user_end) ||
88 (pc >= (unsigned long) __atomic_begin &&
89 pc < (unsigned long) __atomic_end) ||
90 (pc >= (unsigned long) __bzero_begin &&
91 pc < (unsigned long) __bzero_end))
92 pc = regs->u_regs[UREG_RETPC];
93 return pc;
94}
95
96EXPORT_SYMBOL(profile_pc);
97
98__volatile__ unsigned int *master_l10_counter;
99__volatile__ unsigned int *master_l10_limit;
100
101
102
103
104
105
106#define TICK_SIZE (tick_nsec / 1000)
107
108irqreturn_t timer_interrupt(int irq, void *dev_id)
109{
110
111 static long last_rtc_update;
112
113#ifndef CONFIG_SMP
114 profile_tick(CPU_PROFILING);
115#endif
116
117
118 write_seqlock(&xtime_lock);
119#ifdef CONFIG_SUN4
120 if((idprom->id_machtype == (SM_SUN4 | SM_4_260)) ||
121 (idprom->id_machtype == (SM_SUN4 | SM_4_110))) {
122 int temp;
123 intersil_read_intr(intersil_clock, temp);
124
125 enable_pil_irq(10);
126 }
127#endif
128 clear_clock_irq();
129
130 do_timer(1);
131#ifndef CONFIG_SMP
132 update_process_times(user_mode(get_irq_regs()));
133#endif
134
135
136
137 if (ntp_synced() &&
138 xtime.tv_sec > last_rtc_update + 660 &&
139 (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
140 (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
141 if (set_rtc_mmss(xtime.tv_sec) == 0)
142 last_rtc_update = xtime.tv_sec;
143 else
144 last_rtc_update = xtime.tv_sec - 600;
145 }
146 write_sequnlock(&xtime_lock);
147
148 return IRQ_HANDLED;
149}
150
151
152static void __devinit kick_start_clock(void)
153{
154 struct mostek48t02 *regs = (struct mostek48t02 *)mstk48t02_regs;
155 unsigned char sec;
156 int i, count;
157
158 prom_printf("CLOCK: Clock was stopped. Kick start ");
159
160 spin_lock_irq(&mostek_lock);
161
162
163 regs->creg |= MSTK_CREG_WRITE;
164 regs->sec &= ~MSTK_STOP;
165 regs->hour |= MSTK_KICK_START;
166 regs->creg &= ~MSTK_CREG_WRITE;
167
168 spin_unlock_irq(&mostek_lock);
169
170
171 sec = MSTK_REG_SEC(regs);
172 for (i = 0; i < 3; i++) {
173 while (sec == MSTK_REG_SEC(regs))
174 for (count = 0; count < 100000; count++)
175 ;
176 prom_printf(".");
177 sec = regs->sec;
178 }
179 prom_printf("\n");
180
181 spin_lock_irq(&mostek_lock);
182
183
184 regs->creg |= MSTK_CREG_WRITE;
185 regs->hour &= ~MSTK_KICK_START;
186 MSTK_SET_REG_SEC(regs,0);
187 MSTK_SET_REG_MIN(regs,0);
188 MSTK_SET_REG_HOUR(regs,0);
189 MSTK_SET_REG_DOW(regs,5);
190 MSTK_SET_REG_DOM(regs,1);
191 MSTK_SET_REG_MONTH(regs,8);
192 MSTK_SET_REG_YEAR(regs,1996 - MSTK_YEAR_ZERO);
193 regs->creg &= ~MSTK_CREG_WRITE;
194
195 spin_unlock_irq(&mostek_lock);
196
197
198 while (regs->hour & MSTK_KICK_START) {
199 prom_printf("CLOCK: Kick start still on!\n");
200
201 spin_lock_irq(&mostek_lock);
202 regs->creg |= MSTK_CREG_WRITE;
203 regs->hour &= ~MSTK_KICK_START;
204 regs->creg &= ~MSTK_CREG_WRITE;
205 spin_unlock_irq(&mostek_lock);
206 }
207
208 prom_printf("CLOCK: Kick start procedure successful.\n");
209}
210
211
212static inline int has_low_battery(void)
213{
214 struct mostek48t02 *regs = (struct mostek48t02 *)mstk48t02_regs;
215 unsigned char data1, data2;
216
217 spin_lock_irq(&mostek_lock);
218 data1 = regs->eeprom[0];
219 regs->eeprom[0] = ~data1;
220 data2 = regs->eeprom[0];
221 regs->eeprom[0] = data1;
222 spin_unlock_irq(&mostek_lock);
223
224 return (data1 == data2);
225}
226
227static void __devinit mostek_set_system_time(void)
228{
229 unsigned int year, mon, day, hour, min, sec;
230 struct mostek48t02 *mregs;
231
232 mregs = (struct mostek48t02 *)mstk48t02_regs;
233 if(!mregs) {
234 prom_printf("Something wrong, clock regs not mapped yet.\n");
235 prom_halt();
236 }
237 spin_lock_irq(&mostek_lock);
238 mregs->creg |= MSTK_CREG_READ;
239 sec = MSTK_REG_SEC(mregs);
240 min = MSTK_REG_MIN(mregs);
241 hour = MSTK_REG_HOUR(mregs);
242 day = MSTK_REG_DOM(mregs);
243 mon = MSTK_REG_MONTH(mregs);
244 year = MSTK_CVT_YEAR( MSTK_REG_YEAR(mregs) );
245 xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
246 xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
247 set_normalized_timespec(&wall_to_monotonic,
248 -xtime.tv_sec, -xtime.tv_nsec);
249 mregs->creg &= ~MSTK_CREG_READ;
250 spin_unlock_irq(&mostek_lock);
251}
252
253
254static inline void sun4_clock_probe(void)
255{
256#ifdef CONFIG_SUN4
257 int temp;
258 struct resource r;
259
260 memset(&r, 0, sizeof(r));
261 if( idprom->id_machtype == (SM_SUN4 | SM_4_330) ) {
262 sp_clock_typ = MSTK48T02;
263 r.start = sun4_clock_physaddr;
264 mstk48t02_regs = sbus_ioremap(&r, 0,
265 sizeof(struct mostek48t02), NULL);
266 mstk48t08_regs = NULL;
267 intersil_clock = NULL;
268
269
270 if (mostek_read(mstk48t02_regs + MOSTEK_SEC) & MSTK_STOP)
271 kick_start_clock();
272 } else if( idprom->id_machtype == (SM_SUN4 | SM_4_260)) {
273
274 printk("Clock: INTERSIL at %8x ",sun4_clock_physaddr);
275 sp_clock_typ = INTERSIL;
276 r.start = sun4_clock_physaddr;
277 intersil_clock = (struct intersil *)
278 sbus_ioremap(&r, 0, sizeof(*intersil_clock), "intersil");
279 mstk48t02_regs = 0;
280 mstk48t08_regs = NULL;
281
282
283 intersil_intr(intersil_clock,INTERSIL_INT_100HZ);
284
285 intersil_start(intersil_clock);
286
287 intersil_read_intr(intersil_clock, temp);
288 while (!(temp & 0x80))
289 intersil_read_intr(intersil_clock, temp);
290
291 intersil_read_intr(intersil_clock, temp);
292 while (!(temp & 0x80))
293 intersil_read_intr(intersil_clock, temp);
294
295 intersil_stop(intersil_clock);
296
297 }
298#endif
299}
300
301#ifndef CONFIG_SUN4
302static int __devinit clock_probe(struct of_device *op, const struct of_device_id *match)
303{
304 struct device_node *dp = op->node;
305 const char *model = of_get_property(dp, "model", NULL);
306
307 if (!model)
308 return -ENODEV;
309
310 if (!strcmp(model, "mk48t02")) {
311 sp_clock_typ = MSTK48T02;
312
313
314 mstk48t02_regs = of_ioremap(&op->resource[0], 0,
315 sizeof(struct mostek48t02),
316 "mk48t02");
317 mstk48t08_regs = NULL;
318 } else if (!strcmp(model, "mk48t08")) {
319 sp_clock_typ = MSTK48T08;
320 mstk48t08_regs = of_ioremap(&op->resource[0], 0,
321 sizeof(struct mostek48t08),
322 "mk48t08");
323
324 mstk48t02_regs = &mstk48t08_regs->regs;
325 } else
326 return -ENODEV;
327
328
329 if (has_low_battery())
330 printk(KERN_CRIT "NVRAM: Low battery voltage!\n");
331
332
333 if (mostek_read(mstk48t02_regs + MOSTEK_SEC) & MSTK_STOP)
334 kick_start_clock();
335
336 mostek_set_system_time();
337
338 return 0;
339}
340
341static struct of_device_id clock_match[] = {
342 {
343 .name = "eeprom",
344 },
345 {},
346};
347
348static struct of_platform_driver clock_driver = {
349 .match_table = clock_match,
350 .probe = clock_probe,
351 .driver = {
352 .name = "clock",
353 },
354};
355
356
357
358static int __init clock_init(void)
359{
360 return of_register_driver(&clock_driver, &of_platform_bus_type);
361}
362
363
364
365
366
367fs_initcall(clock_init);
368#endif
369
370void __init sbus_time_init(void)
371{
372
373 BTFIXUPSET_CALL(bus_do_settimeofday, sbus_do_settimeofday, BTFIXUPCALL_NORM);
374 btfixup();
375
376 if (ARCH_SUN4)
377 sun4_clock_probe();
378
379 sparc_init_timers(timer_interrupt);
380
381#ifdef CONFIG_SUN4
382 if(idprom->id_machtype == (SM_SUN4 | SM_4_330)) {
383 mostek_set_system_time();
384 } else if(idprom->id_machtype == (SM_SUN4 | SM_4_260) ) {
385
386 unsigned int year, mon, day, hour, min, sec;
387 int temp;
388 struct intersil *iregs;
389
390 iregs=intersil_clock;
391 if(!iregs) {
392 prom_printf("Something wrong, clock regs not mapped yet.\n");
393 prom_halt();
394 }
395
396 intersil_intr(intersil_clock,INTERSIL_INT_100HZ);
397 disable_pil_irq(10);
398 intersil_stop(iregs);
399 intersil_read_intr(intersil_clock, temp);
400
401 temp = iregs->clk.int_csec;
402
403 sec = iregs->clk.int_sec;
404 min = iregs->clk.int_min;
405 hour = iregs->clk.int_hour;
406 day = iregs->clk.int_day;
407 mon = iregs->clk.int_month;
408 year = MSTK_CVT_YEAR(iregs->clk.int_year);
409
410 enable_pil_irq(10);
411 intersil_start(iregs);
412
413 xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
414 xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
415 set_normalized_timespec(&wall_to_monotonic,
416 -xtime.tv_sec, -xtime.tv_nsec);
417 printk("%u/%u/%u %u:%u:%u\n",day,mon,year,hour,min,sec);
418 }
419#endif
420
421
422 local_irq_enable();
423}
424
425void __init time_init(void)
426{
427#ifdef CONFIG_PCI
428 extern void pci_time_init(void);
429 if (pcic_present()) {
430 pci_time_init();
431 return;
432 }
433#endif
434 sbus_time_init();
435}
436
437static inline unsigned long do_gettimeoffset(void)
438{
439 unsigned long val = *master_l10_counter;
440 unsigned long usec = (val >> 10) & 0x1fffff;
441
442
443 if (val & 0x80000000)
444 usec += 1000000 / HZ;
445
446 return usec;
447}
448
449
450
451
452
453void do_gettimeofday(struct timeval *tv)
454{
455 unsigned long flags;
456 unsigned long seq;
457 unsigned long usec, sec;
458 unsigned long max_ntp_tick = tick_usec - tickadj;
459
460 do {
461 seq = read_seqbegin_irqsave(&xtime_lock, flags);
462 usec = do_gettimeoffset();
463
464
465
466
467
468
469 if (unlikely(time_adjust < 0))
470 usec = min(usec, max_ntp_tick);
471
472 sec = xtime.tv_sec;
473 usec += (xtime.tv_nsec / 1000);
474 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
475
476 while (usec >= 1000000) {
477 usec -= 1000000;
478 sec++;
479 }
480
481 tv->tv_sec = sec;
482 tv->tv_usec = usec;
483}
484
485EXPORT_SYMBOL(do_gettimeofday);
486
487int do_settimeofday(struct timespec *tv)
488{
489 int ret;
490
491 write_seqlock_irq(&xtime_lock);
492 ret = bus_do_settimeofday(tv);
493 write_sequnlock_irq(&xtime_lock);
494 clock_was_set();
495 return ret;
496}
497
498EXPORT_SYMBOL(do_settimeofday);
499
500static int sbus_do_settimeofday(struct timespec *tv)
501{
502 time_t wtm_sec, sec = tv->tv_sec;
503 long wtm_nsec, nsec = tv->tv_nsec;
504
505 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
506 return -EINVAL;
507
508
509
510
511
512
513
514 nsec -= 1000 * do_gettimeoffset();
515
516 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
517 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
518
519 set_normalized_timespec(&xtime, sec, nsec);
520 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
521
522 ntp_clear();
523 return 0;
524}
525
526
527
528
529
530static int set_rtc_mmss(unsigned long nowtime)
531{
532 int real_seconds, real_minutes, mostek_minutes;
533 struct mostek48t02 *regs = (struct mostek48t02 *)mstk48t02_regs;
534 unsigned long flags;
535#ifdef CONFIG_SUN4
536 struct intersil *iregs = intersil_clock;
537 int temp;
538#endif
539
540
541 if (!regs) {
542#ifdef CONFIG_SUN4
543 if(!iregs)
544 return -1;
545 else {
546 temp = iregs->clk.int_csec;
547
548 mostek_minutes = iregs->clk.int_min;
549
550 real_seconds = nowtime % 60;
551 real_minutes = nowtime / 60;
552 if (((abs(real_minutes - mostek_minutes) + 15)/30) & 1)
553 real_minutes += 30;
554 real_minutes %= 60;
555
556 if (abs(real_minutes - mostek_minutes) < 30) {
557 intersil_stop(iregs);
558 iregs->clk.int_sec=real_seconds;
559 iregs->clk.int_min=real_minutes;
560 intersil_start(iregs);
561 } else {
562 printk(KERN_WARNING
563 "set_rtc_mmss: can't update from %d to %d\n",
564 mostek_minutes, real_minutes);
565 return -1;
566 }
567
568 return 0;
569 }
570#endif
571 }
572
573 spin_lock_irqsave(&mostek_lock, flags);
574
575 regs->creg |= MSTK_CREG_READ;
576 mostek_minutes = MSTK_REG_MIN(regs);
577 regs->creg &= ~MSTK_CREG_READ;
578
579
580
581
582
583
584
585 real_seconds = nowtime % 60;
586 real_minutes = nowtime / 60;
587 if (((abs(real_minutes - mostek_minutes) + 15)/30) & 1)
588 real_minutes += 30;
589 real_minutes %= 60;
590
591 if (abs(real_minutes - mostek_minutes) < 30) {
592 regs->creg |= MSTK_CREG_WRITE;
593 MSTK_SET_REG_SEC(regs,real_seconds);
594 MSTK_SET_REG_MIN(regs,real_minutes);
595 regs->creg &= ~MSTK_CREG_WRITE;
596 spin_unlock_irqrestore(&mostek_lock, flags);
597 return 0;
598 } else {
599 spin_unlock_irqrestore(&mostek_lock, flags);
600 return -1;
601 }
602}
603