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