[PATCH] RTC: Remove some duplicate BCD definitions
[linux-2.6.git] / arch / sh64 / kernel / time.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * arch/sh64/kernel/time.c
7  *
8  * Copyright (C) 2000, 2001  Paolo Alberelli
9  * Copyright (C) 2003, 2004  Paul Mundt
10  * Copyright (C) 2003  Richard Curnow
11  *
12  *    Original TMU/RTC code taken from sh version.
13  *    Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
14  *      Some code taken from i386 version.
15  *      Copyright (C) 1991, 1992, 1995  Linus Torvalds
16  */
17
18 #include <linux/config.h>
19 #include <linux/errno.h>
20 #include <linux/rwsem.h>
21 #include <linux/sched.h>
22 #include <linux/kernel.h>
23 #include <linux/param.h>
24 #include <linux/string.h>
25 #include <linux/mm.h>
26 #include <linux/interrupt.h>
27 #include <linux/time.h>
28 #include <linux/delay.h>
29 #include <linux/init.h>
30 #include <linux/profile.h>
31 #include <linux/smp.h>
32 #include <linux/module.h>
33 #include <linux/bcd.h>
34
35 #include <asm/registers.h>       /* required by inline __asm__ stmt. */
36
37 #include <asm/processor.h>
38 #include <asm/uaccess.h>
39 #include <asm/io.h>
40 #include <asm/irq.h>
41 #include <asm/delay.h>
42
43 #include <linux/timex.h>
44 #include <linux/irq.h>
45 #include <asm/hardware.h>
46
47 #define TMU_TOCR_INIT   0x00
48 #define TMU0_TCR_INIT   0x0020
49 #define TMU_TSTR_INIT   1
50 #define TMU_TSTR_OFF    0
51
52 /* RCR1 Bits */
53 #define RCR1_CF         0x80    /* Carry Flag             */
54 #define RCR1_CIE        0x10    /* Carry Interrupt Enable */
55 #define RCR1_AIE        0x08    /* Alarm Interrupt Enable */
56 #define RCR1_AF         0x01    /* Alarm Flag             */
57
58 /* RCR2 Bits */
59 #define RCR2_PEF        0x80    /* PEriodic interrupt Flag */
60 #define RCR2_PESMASK    0x70    /* Periodic interrupt Set  */
61 #define RCR2_RTCEN      0x08    /* ENable RTC              */
62 #define RCR2_ADJ        0x04    /* ADJustment (30-second)  */
63 #define RCR2_RESET      0x02    /* Reset bit               */
64 #define RCR2_START      0x01    /* Start bit               */
65
66 /* Clock, Power and Reset Controller */
67 #define CPRC_BLOCK_OFF  0x01010000
68 #define CPRC_BASE       PHYS_PERIPHERAL_BLOCK + CPRC_BLOCK_OFF
69
70 #define FRQCR           (cprc_base+0x0)
71 #define WTCSR           (cprc_base+0x0018)
72 #define STBCR           (cprc_base+0x0030)
73
74 /* Time Management Unit */
75 #define TMU_BLOCK_OFF   0x01020000
76 #define TMU_BASE        PHYS_PERIPHERAL_BLOCK + TMU_BLOCK_OFF
77 #define TMU0_BASE       tmu_base + 0x8 + (0xc * 0x0)
78 #define TMU1_BASE       tmu_base + 0x8 + (0xc * 0x1)
79 #define TMU2_BASE       tmu_base + 0x8 + (0xc * 0x2)
80
81 #define TMU_TOCR        tmu_base+0x0    /* Byte access */
82 #define TMU_TSTR        tmu_base+0x4    /* Byte access */
83
84 #define TMU0_TCOR       TMU0_BASE+0x0   /* Long access */
85 #define TMU0_TCNT       TMU0_BASE+0x4   /* Long access */
86 #define TMU0_TCR        TMU0_BASE+0x8   /* Word access */
87
88 /* Real Time Clock */
89 #define RTC_BLOCK_OFF   0x01040000
90 #define RTC_BASE        PHYS_PERIPHERAL_BLOCK + RTC_BLOCK_OFF
91
92 #define R64CNT          rtc_base+0x00
93 #define RSECCNT         rtc_base+0x04
94 #define RMINCNT         rtc_base+0x08
95 #define RHRCNT          rtc_base+0x0c
96 #define RWKCNT          rtc_base+0x10
97 #define RDAYCNT         rtc_base+0x14
98 #define RMONCNT         rtc_base+0x18
99 #define RYRCNT          rtc_base+0x1c   /* 16bit */
100 #define RSECAR          rtc_base+0x20
101 #define RMINAR          rtc_base+0x24
102 #define RHRAR           rtc_base+0x28
103 #define RWKAR           rtc_base+0x2c
104 #define RDAYAR          rtc_base+0x30
105 #define RMONAR          rtc_base+0x34
106 #define RCR1            rtc_base+0x38
107 #define RCR2            rtc_base+0x3c
108
109 #define TICK_SIZE (tick_nsec / 1000)
110
111 extern unsigned long wall_jiffies;
112
113 static unsigned long tmu_base, rtc_base;
114 unsigned long cprc_base;
115
116 /* Variables to allow interpolation of time of day to resolution better than a
117  * jiffy. */
118
119 /* This is effectively protected by xtime_lock */
120 static unsigned long ctc_last_interrupt;
121 static unsigned long long usecs_per_jiffy = 1000000/HZ; /* Approximation */
122
123 #define CTC_JIFFY_SCALE_SHIFT 40
124
125 /* 2**CTC_JIFFY_SCALE_SHIFT / ctc_ticks_per_jiffy */
126 static unsigned long long scaled_recip_ctc_ticks_per_jiffy;
127
128 /* Estimate number of microseconds that have elapsed since the last timer tick,
129    by scaling the delta that has occured in the CTC register.
130
131    WARNING WARNING WARNING : This algorithm relies on the CTC decrementing at
132    the CPU clock rate.  If the CPU sleeps, the CTC stops counting.  Bear this
133    in mind if enabling SLEEP_WORKS in process.c.  In that case, this algorithm
134    probably needs to use TMU.TCNT0 instead.  This will work even if the CPU is
135    sleeping, though will be coarser.
136
137    FIXME : What if usecs_per_tick is moving around too much, e.g. if an adjtime
138    is running or if the freq or tick arguments of adjtimex are modified after
139    we have calibrated the scaling factor?  This will result in either a jump at
140    the end of a tick period, or a wrap backwards at the start of the next one,
141    if the application is reading the time of day often enough.  I think we
142    ought to do better than this.  For this reason, usecs_per_jiffy is left
143    separated out in the calculation below.  This allows some future hook into
144    the adjtime-related stuff in kernel/timer.c to remove this hazard.
145
146 */
147
148 static unsigned long usecs_since_tick(void)
149 {
150         unsigned long long current_ctc;
151         long ctc_ticks_since_interrupt;
152         unsigned long long ull_ctc_ticks_since_interrupt;
153         unsigned long result;
154
155         unsigned long long mul1_out;
156         unsigned long long mul1_out_high;
157         unsigned long long mul2_out_low, mul2_out_high;
158
159         /* Read CTC register */
160         asm ("getcon cr62, %0" : "=r" (current_ctc));
161         /* Note, the CTC counts down on each CPU clock, not up.
162            Note(2), use long type to get correct wraparound arithmetic when
163            the counter crosses zero. */
164         ctc_ticks_since_interrupt = (long) ctc_last_interrupt - (long) current_ctc;
165         ull_ctc_ticks_since_interrupt = (unsigned long long) ctc_ticks_since_interrupt;
166
167         /* Inline assembly to do 32x32x32->64 multiplier */
168         asm volatile ("mulu.l %1, %2, %0" :
169              "=r" (mul1_out) :
170              "r" (ull_ctc_ticks_since_interrupt), "r" (usecs_per_jiffy));
171
172         mul1_out_high = mul1_out >> 32;
173
174         asm volatile ("mulu.l %1, %2, %0" :
175              "=r" (mul2_out_low) :
176              "r" (mul1_out), "r" (scaled_recip_ctc_ticks_per_jiffy));
177
178 #if 1
179         asm volatile ("mulu.l %1, %2, %0" :
180              "=r" (mul2_out_high) :
181              "r" (mul1_out_high), "r" (scaled_recip_ctc_ticks_per_jiffy));
182 #endif
183
184         result = (unsigned long) (((mul2_out_high << 32) + mul2_out_low) >> CTC_JIFFY_SCALE_SHIFT);
185
186         return result;
187 }
188
189 void do_gettimeofday(struct timeval *tv)
190 {
191         unsigned long flags;
192         unsigned long seq;
193         unsigned long usec, sec;
194
195         do {
196                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
197                 usec = usecs_since_tick();
198                 {
199                         unsigned long lost = jiffies - wall_jiffies;
200
201                         if (lost)
202                                 usec += lost * (1000000 / HZ);
203                 }
204
205                 sec = xtime.tv_sec;
206                 usec += xtime.tv_nsec / 1000;
207         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
208
209         while (usec >= 1000000) {
210                 usec -= 1000000;
211                 sec++;
212         }
213
214         tv->tv_sec = sec;
215         tv->tv_usec = usec;
216 }
217
218 int do_settimeofday(struct timespec *tv)
219 {
220         time_t wtm_sec, sec = tv->tv_sec;
221         long wtm_nsec, nsec = tv->tv_nsec;
222
223         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
224                 return -EINVAL;
225
226         write_seqlock_irq(&xtime_lock);
227         /*
228          * This is revolting. We need to set "xtime" correctly. However, the
229          * value in this location is the value at the most recent update of
230          * wall time.  Discover what correction gettimeofday() would have
231          * made, and then undo it!
232          */
233         nsec -= 1000 * (usecs_since_tick() +
234                                 (jiffies - wall_jiffies) * (1000000 / HZ));
235
236         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
237         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
238
239         set_normalized_timespec(&xtime, sec, nsec);
240         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
241
242         ntp_clear();
243         write_sequnlock_irq(&xtime_lock);
244         clock_was_set();
245
246         return 0;
247 }
248 EXPORT_SYMBOL(do_settimeofday);
249
250 static int set_rtc_time(unsigned long nowtime)
251 {
252         int retval = 0;
253         int real_seconds, real_minutes, cmos_minutes;
254
255         ctrl_outb(RCR2_RESET, RCR2);  /* Reset pre-scaler & stop RTC */
256
257         cmos_minutes = ctrl_inb(RMINCNT);
258         BCD_TO_BIN(cmos_minutes);
259
260         /*
261          * since we're only adjusting minutes and seconds,
262          * don't interfere with hour overflow. This avoids
263          * messing with unknown time zones but requires your
264          * RTC not to be off by more than 15 minutes
265          */
266         real_seconds = nowtime % 60;
267         real_minutes = nowtime / 60;
268         if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1)
269                 real_minutes += 30;     /* correct for half hour time zone */
270         real_minutes %= 60;
271
272         if (abs(real_minutes - cmos_minutes) < 30) {
273                 BIN_TO_BCD(real_seconds);
274                 BIN_TO_BCD(real_minutes);
275                 ctrl_outb(real_seconds, RSECCNT);
276                 ctrl_outb(real_minutes, RMINCNT);
277         } else {
278                 printk(KERN_WARNING
279                        "set_rtc_time: can't update from %d to %d\n",
280                        cmos_minutes, real_minutes);
281                 retval = -1;
282         }
283
284         ctrl_outb(RCR2_RTCEN|RCR2_START, RCR2);  /* Start RTC */
285
286         return retval;
287 }
288
289 /* last time the RTC clock got updated */
290 static long last_rtc_update = 0;
291
292 /*
293  * timer_interrupt() needs to keep up the real-time clock,
294  * as well as call the "do_timer()" routine every clocktick
295  */
296 static inline void do_timer_interrupt(int irq, struct pt_regs *regs)
297 {
298         unsigned long long current_ctc;
299         asm ("getcon cr62, %0" : "=r" (current_ctc));
300         ctc_last_interrupt = (unsigned long) current_ctc;
301
302         do_timer(regs);
303 #ifndef CONFIG_SMP
304         update_process_times(user_mode(regs));
305 #endif
306         profile_tick(CPU_PROFILING, regs);
307
308 #ifdef CONFIG_HEARTBEAT
309         {
310                 extern void heartbeat(void);
311
312                 heartbeat();
313         }
314 #endif
315
316         /*
317          * If we have an externally synchronized Linux clock, then update
318          * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
319          * called as close as possible to 500 ms before the new second starts.
320          */
321         if (ntp_synced() &&
322             xtime.tv_sec > last_rtc_update + 660 &&
323             (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
324             (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
325                 if (set_rtc_time(xtime.tv_sec) == 0)
326                         last_rtc_update = xtime.tv_sec;
327                 else
328                         last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
329         }
330 }
331
332 /*
333  * This is the same as the above, except we _also_ save the current
334  * Time Stamp Counter value at the time of the timer interrupt, so that
335  * we later on can estimate the time of day more exactly.
336  */
337 static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
338 {
339         unsigned long timer_status;
340
341         /* Clear UNF bit */
342         timer_status = ctrl_inw(TMU0_TCR);
343         timer_status &= ~0x100;
344         ctrl_outw(timer_status, TMU0_TCR);
345
346         /*
347          * Here we are in the timer irq handler. We just have irqs locally
348          * disabled but we don't know if the timer_bh is running on the other
349          * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
350          * the irq version of write_lock because as just said we have irq
351          * locally disabled. -arca
352          */
353         write_lock(&xtime_lock);
354         do_timer_interrupt(irq, regs);
355         write_unlock(&xtime_lock);
356
357         return IRQ_HANDLED;
358 }
359
360 static unsigned long get_rtc_time(void)
361 {
362         unsigned int sec, min, hr, wk, day, mon, yr, yr100;
363
364  again:
365         do {
366                 ctrl_outb(0, RCR1);  /* Clear CF-bit */
367                 sec = ctrl_inb(RSECCNT);
368                 min = ctrl_inb(RMINCNT);
369                 hr  = ctrl_inb(RHRCNT);
370                 wk  = ctrl_inb(RWKCNT);
371                 day = ctrl_inb(RDAYCNT);
372                 mon = ctrl_inb(RMONCNT);
373                 yr  = ctrl_inw(RYRCNT);
374                 yr100 = (yr >> 8);
375                 yr &= 0xff;
376         } while ((ctrl_inb(RCR1) & RCR1_CF) != 0);
377
378         BCD_TO_BIN(yr100);
379         BCD_TO_BIN(yr);
380         BCD_TO_BIN(mon);
381         BCD_TO_BIN(day);
382         BCD_TO_BIN(hr);
383         BCD_TO_BIN(min);
384         BCD_TO_BIN(sec);
385
386         if (yr > 99 || mon < 1 || mon > 12 || day > 31 || day < 1 ||
387             hr > 23 || min > 59 || sec > 59) {
388                 printk(KERN_ERR
389                        "SH RTC: invalid value, resetting to 1 Jan 2000\n");
390                 ctrl_outb(RCR2_RESET, RCR2);  /* Reset & Stop */
391                 ctrl_outb(0, RSECCNT);
392                 ctrl_outb(0, RMINCNT);
393                 ctrl_outb(0, RHRCNT);
394                 ctrl_outb(6, RWKCNT);
395                 ctrl_outb(1, RDAYCNT);
396                 ctrl_outb(1, RMONCNT);
397                 ctrl_outw(0x2000, RYRCNT);
398                 ctrl_outb(RCR2_RTCEN|RCR2_START, RCR2);  /* Start */
399                 goto again;
400         }
401
402         return mktime(yr100 * 100 + yr, mon, day, hr, min, sec);
403 }
404
405 static __init unsigned int get_cpu_hz(void)
406 {
407         unsigned int count;
408         unsigned long __dummy;
409         unsigned long ctc_val_init, ctc_val;
410
411         /*
412         ** Regardless the toolchain, force the compiler to use the
413         ** arbitrary register r3 as a clock tick counter.
414         ** NOTE: r3 must be in accordance with sh64_rtc_interrupt()
415         */
416         register unsigned long long  __rtc_irq_flag __asm__ ("r3");
417
418         local_irq_enable();
419         do {} while (ctrl_inb(R64CNT) != 0);
420         ctrl_outb(RCR1_CIE, RCR1); /* Enable carry interrupt */
421
422         /*
423          * r3 is arbitrary. CDC does not support "=z".
424          */
425         ctc_val_init = 0xffffffff;
426         ctc_val = ctc_val_init;
427
428         asm volatile("gettr     tr0, %1\n\t"
429                      "putcon    %0, " __CTC "\n\t"
430                      "and       %2, r63, %2\n\t"
431                      "pta       $+4, tr0\n\t"
432                      "beq/l     %2, r63, tr0\n\t"
433                      "ptabs     %1, tr0\n\t"
434                      "getcon    " __CTC ", %0\n\t"
435                 : "=r"(ctc_val), "=r" (__dummy), "=r" (__rtc_irq_flag)
436                 : "0" (0));
437         local_irq_disable();
438         /*
439          * SH-3:
440          * CPU clock = 4 stages * loop
441          * tst    rm,rm      if id ex
442          * bt/s   1b            if id ex
443          * add    #1,rd            if id ex
444          *                            (if) pipe line stole
445          * tst    rm,rm                  if id ex
446          * ....
447          *
448          *
449          * SH-4:
450          * CPU clock = 6 stages * loop
451          * I don't know why.
452          * ....
453          *
454          * SH-5:
455          * Use CTC register to count.  This approach returns the right value
456          * even if the I-cache is disabled (e.g. whilst debugging.)
457          *
458          */
459
460         count = ctc_val_init - ctc_val; /* CTC counts down */
461
462 #if defined (CONFIG_SH_SIMULATOR)
463         /*
464          * Let's pretend we are a 5MHz SH-5 to avoid a too
465          * little timer interval. Also to keep delay
466          * calibration within a reasonable time.
467          */
468         return 5000000;
469 #else
470         /*
471          * This really is count by the number of clock cycles
472          * by the ratio between a complete R64CNT
473          * wrap-around (128) and CUI interrupt being raised (64).
474          */
475         return count*2;
476 #endif
477 }
478
479 static irqreturn_t sh64_rtc_interrupt(int irq, void *dev_id,
480                                       struct pt_regs *regs)
481 {
482         ctrl_outb(0, RCR1);     /* Disable Carry Interrupts */
483         regs->regs[3] = 1;      /* Using r3 */
484
485         return IRQ_HANDLED;
486 }
487
488 static struct irqaction irq0  = { timer_interrupt, SA_INTERRUPT, CPU_MASK_NONE, "timer", NULL, NULL};
489 static struct irqaction irq1  = { sh64_rtc_interrupt, SA_INTERRUPT, CPU_MASK_NONE, "rtc", NULL, NULL};
490
491 void __init time_init(void)
492 {
493         unsigned int cpu_clock, master_clock, bus_clock, module_clock;
494         unsigned long interval;
495         unsigned long frqcr, ifc, pfc;
496         static int ifc_table[] = { 2, 4, 6, 8, 10, 12, 16, 24 };
497 #define bfc_table ifc_table     /* Same */
498 #define pfc_table ifc_table     /* Same */
499
500         tmu_base = onchip_remap(TMU_BASE, 1024, "TMU");
501         if (!tmu_base) {
502                 panic("Unable to remap TMU\n");
503         }
504
505         rtc_base = onchip_remap(RTC_BASE, 1024, "RTC");
506         if (!rtc_base) {
507                 panic("Unable to remap RTC\n");
508         }
509
510         cprc_base = onchip_remap(CPRC_BASE, 1024, "CPRC");
511         if (!cprc_base) {
512                 panic("Unable to remap CPRC\n");
513         }
514
515         xtime.tv_sec = get_rtc_time();
516         xtime.tv_nsec = 0;
517
518         setup_irq(TIMER_IRQ, &irq0);
519         setup_irq(RTC_IRQ, &irq1);
520
521         /* Check how fast it is.. */
522         cpu_clock = get_cpu_hz();
523
524         /* Note careful order of operations to maintain reasonable precision and avoid overflow. */
525         scaled_recip_ctc_ticks_per_jiffy = ((1ULL << CTC_JIFFY_SCALE_SHIFT) / (unsigned long long)(cpu_clock / HZ));
526
527         disable_irq(RTC_IRQ);
528
529         printk("CPU clock: %d.%02dMHz\n",
530                (cpu_clock / 1000000), (cpu_clock % 1000000)/10000);
531         {
532                 unsigned short bfc;
533                 frqcr = ctrl_inl(FRQCR);
534                 ifc  = ifc_table[(frqcr>> 6) & 0x0007];
535                 bfc  = bfc_table[(frqcr>> 3) & 0x0007];
536                 pfc  = pfc_table[(frqcr>> 12) & 0x0007];
537                 master_clock = cpu_clock * ifc;
538                 bus_clock = master_clock/bfc;
539         }
540
541         printk("Bus clock: %d.%02dMHz\n",
542                (bus_clock/1000000), (bus_clock % 1000000)/10000);
543         module_clock = master_clock/pfc;
544         printk("Module clock: %d.%02dMHz\n",
545                (module_clock/1000000), (module_clock % 1000000)/10000);
546         interval = (module_clock/(HZ*4));
547
548         printk("Interval = %ld\n", interval);
549
550         current_cpu_data.cpu_clock    = cpu_clock;
551         current_cpu_data.master_clock = master_clock;
552         current_cpu_data.bus_clock    = bus_clock;
553         current_cpu_data.module_clock = module_clock;
554
555         /* Start TMU0 */
556         ctrl_outb(TMU_TSTR_OFF, TMU_TSTR);
557         ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
558         ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
559         ctrl_outl(interval, TMU0_TCOR);
560         ctrl_outl(interval, TMU0_TCNT);
561         ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
562 }
563
564 void enter_deep_standby(void)
565 {
566         /* Disable watchdog timer */
567         ctrl_outl(0xa5000000, WTCSR);
568         /* Configure deep standby on sleep */
569         ctrl_outl(0x03, STBCR);
570
571 #ifdef CONFIG_SH_ALPHANUMERIC
572         {
573                 extern void mach_alphanum(int position, unsigned char value);
574                 extern void mach_alphanum_brightness(int setting);
575                 char halted[] = "Halted. ";
576                 int i;
577                 mach_alphanum_brightness(6); /* dimmest setting above off */
578                 for (i=0; i<8; i++) {
579                         mach_alphanum(i, halted[i]);
580                 }
581                 asm __volatile__ ("synco");
582         }
583 #endif
584
585         asm __volatile__ ("sleep");
586         asm __volatile__ ("synci");
587         asm __volatile__ ("nop");
588         asm __volatile__ ("nop");
589         asm __volatile__ ("nop");
590         asm __volatile__ ("nop");
591         panic("Unexpected wakeup!\n");
592 }
593
594 /*
595  * Scheduler clock - returns current time in nanosec units.
596  */
597 unsigned long long sched_clock(void)
598 {
599         return (unsigned long long)jiffies * (1000000000 / HZ);
600 }
601