Annotation of sys/arch/mips64/mips64/clock.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: clock.c,v 1.18 2007/04/29 17:35:27 kettenis Exp $ */
2:
3: /*
4: * Copyright (c) 2001-2004 Opsycon AB (www.opsycon.se / www.opsycon.com)
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: *
15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
16: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
19: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25: * SUCH DAMAGE.
26: *
27: */
28:
29: #include <sys/param.h>
30: #include <sys/kernel.h>
31: #include <sys/systm.h>
32: #include <sys/device.h>
33: #include <sys/evcount.h>
34: #include <sys/timetc.h>
35:
36: #include <machine/autoconf.h>
37: #include <machine/cpu.h>
38: #include <mips64/dev/clockvar.h>
39: #include <mips64/archtype.h>
40:
41: static struct evcount clk_count;
42: static int clk_irq = 5;
43:
44: /* Definition of the driver for autoconfig. */
45: int clockmatch(struct device *, void *, void *);
46: void clockattach(struct device *, struct device *, void *);
47: intrmask_t clock_int5_dummy(intrmask_t, struct trap_frame *);
48: intrmask_t clock_int5(intrmask_t, struct trap_frame *);
49: void clock_int5_init(struct clock_softc *);
50:
51: struct cfdriver clock_cd = {
52: NULL, "clock", DV_DULL, NULL, 0
53: };
54:
55: struct cfattach clock_ca = {
56: sizeof(struct clock_softc), clockmatch, clockattach
57: };
58:
59: int clock_started = 0;
60: u_int32_t cpu_counter_last;
61: u_int32_t cpu_counter_interval;
62: u_int32_t pendingticks;
63: u_int32_t ticktime;
64:
65: u_int cp0_get_timecount(struct timecounter *);
66:
67: struct timecounter cp0_timecounter = {
68: cp0_get_timecount, /* get_timecount */
69: 0, /* no poll_pps */
70: 0xffffffff, /* counter_mask */
71: 0, /* frequency */
72: "CP0", /* name */
73: 0 /* quality */
74: };
75:
76: #define SECMIN (60) /* seconds per minute */
77: #define SECHOUR (60*SECMIN) /* seconds per hour */
78:
79: #define YEARDAYS(year) (((((year) + 1900) % 4) == 0 && \
80: ((((year) + 1900) % 100) != 0 || \
81: (((year) + 1900) % 400) == 0)) ? 366 : 365)
82:
83: int
84: clockmatch(struct device *parent, void *cfdata, void *aux)
85: {
86: struct confargs *ca = aux;
87: struct cfdata *cf = cfdata;
88:
89: /* Make sure that we're looking for a clock. */
90: if (strcmp(ca->ca_name, clock_cd.cd_name) != 0)
91: return (0);
92:
93: if (cf->cf_unit >= 1)
94: return 0;
95: return 10; /* Try to get clock early */
96: }
97:
98: void
99: clockattach(struct device *parent, struct device *self, void *aux)
100: {
101: struct clock_softc *sc;
102:
103: md_clk_attach(parent, self, aux);
104: sc = (struct clock_softc *)self;
105:
106: switch (sys_config.system_type) {
107: case ALGOR_P4032:
108: case ALGOR_P5064:
109: case MOMENTUM_CP7000:
110: case MOMENTUM_CP7000G:
111: case MOMENTUM_JAGUAR:
112: case GALILEO_EV64240:
113: case SGI_INDY:
114: case SGI_O2:
115: case SGI_O200:
116: printf(" ticker on int5 using count register");
117: set_intr(INTPRI_CLOCK, CR_INT_5, clock_int5);
118: ticktime = sys_config.cpu[0].clock / 2000;
119: break;
120:
121: default:
122: panic("clockattach: it didn't get here. really.");
123: }
124:
125: printf("\n");
126: }
127:
128: /*
129: * Clock interrupt code for machines using the on cpu chip
130: * counter register. This register counts at half the pipeline
131: * frequency so the frequency must be known and the options
132: * register wired to allow it's use.
133: *
134: * The code is enabled by setting 'cpu_counter_interval'.
135: */
136: void
137: clock_int5_init(struct clock_softc *sc)
138: {
139: int s;
140:
141: s = splclock();
142: cpu_counter_interval = sys_config.cpu[0].clock / (hz * 2);
143: cpu_counter_last = cp0_get_count() + cpu_counter_interval * 4;
144: cp0_set_compare(cpu_counter_last);
145: splx(s);
146: }
147:
148: /*
149: * Dummy count register interrupt handler used on some targets.
150: * Just resets the compare register and acknowledge the interrupt.
151: */
152: intrmask_t
153: clock_int5_dummy(intrmask_t mask, struct trap_frame *tf)
154: {
155: cp0_set_compare(0); /* Shut up counter int's for a while */
156: return CR_INT_5; /* Clock is always on 5 */
157: }
158:
159: /*
160: * Interrupt handler for targets using the internal count register
161: * as interval clock. Normally the system is run with the clock
162: * interrupt always enabled. Masking is done here and if the clock
163: * can not be run the tick is just counted and handled later when
164: * the clock is unmasked again.
165: */
166: intrmask_t
167: clock_int5(intrmask_t mask, struct trap_frame *tf)
168: {
169: u_int32_t clkdiff;
170:
171: /*
172: * If clock is started count the tick, else just arm for a new.
173: */
174: if (clock_started && cpu_counter_interval != 0) {
175: clkdiff = cp0_get_count() - cpu_counter_last;
176: while (clkdiff >= cpu_counter_interval) {
177: cpu_counter_last += cpu_counter_interval;
178: clkdiff = cp0_get_count() - cpu_counter_last;
179: pendingticks++;
180: }
181: cpu_counter_last += cpu_counter_interval;
182: pendingticks++;
183: } else {
184: cpu_counter_last = cpu_counter_interval + cp0_get_count();
185: }
186:
187: cp0_set_compare(cpu_counter_last);
188: /* Make sure that next clock tick has not passed */
189: clkdiff = cp0_get_count() - cpu_counter_last;
190: if (clkdiff > 0) {
191: cpu_counter_last += cpu_counter_interval;
192: pendingticks++;
193: cp0_set_compare(cpu_counter_last);
194: }
195:
196: if ((tf->cpl & SPL_CLOCKMASK) == 0) {
197: while (pendingticks) {
198: clk_count.ec_count++;
199: hardclock(tf);
200: pendingticks--;
201: }
202: }
203:
204: return CR_INT_5; /* Clock is always on 5 */
205: }
206:
207: /*
208: * Wait "n" microseconds.
209: */
210: void
211: delay(int n)
212: {
213: int dly;
214: int p, c;
215:
216: p = cp0_get_count();
217: dly = (sys_config.cpu[0].clock / 1000000) * n / 2;
218: while (dly > 0) {
219: c = cp0_get_count();
220: dly -= c - p;
221: p = c;
222: }
223: }
224:
225: /*
226: * Wait "n" nanoseconds.
227: */
228: void
229: nanodelay(int n)
230: {
231: int dly;
232: int p, c;
233:
234: p = cp0_get_count();
235: dly = ((sys_config.cpu[0].clock * n) / 1000000000) / 2;
236: while (dly > 0) {
237: c = cp0_get_count();
238: dly -= c - p;
239: p = c;
240: }
241: }
242:
243: /*
244: * Mips machine independent clock routines.
245: */
246:
247: /*
248: * Start the real-time and statistics clocks. Leave stathz 0 since there
249: * are no other timers available.
250: */
251: void
252: cpu_initclocks()
253: {
254: struct clock_softc *sc = (struct clock_softc *)clock_cd.cd_devs[0];
255: struct tod_time ct;
256: u_int first_cp0, second_cp0, cycles_per_sec;
257: int first_sec;
258:
259: hz = sc->sc_clock.clk_hz;
260: stathz = sc->sc_clock.clk_stathz;
261: profhz = sc->sc_clock.clk_profhz;
262:
263: evcount_attach(&clk_count, "clock", (void *)&clk_irq, &evcount_intr);
264:
265: /* Start the clock. */
266: if (sc->sc_clock.clk_init != NULL)
267: (*sc->sc_clock.clk_init)(sc);
268:
269: /*
270: * Calibrate the cycle counter frequency.
271: */
272: if (sc->sc_clock.clk_get != NULL) {
273: (*sc->sc_clock.clk_get)(sc, 0, &ct);
274: first_sec = ct.sec;
275:
276: /* Let the clock tick one second. */
277: do {
278: first_cp0 = cp0_get_count();
279: (*sc->sc_clock.clk_get)(sc, 0, &ct);
280: } while (ct.sec == first_sec);
281: first_sec = ct.sec;
282: /* Let the clock tick one more second. */
283: do {
284: second_cp0 = cp0_get_count();
285: (*sc->sc_clock.clk_get)(sc, 0, &ct);
286: } while (ct.sec == first_sec);
287:
288: cycles_per_sec = second_cp0 - first_cp0;
289: sys_config.cpu[0].clock = cycles_per_sec * 2;
290: }
291:
292: tick = 1000000 / hz; /* number of micro-seconds between interrupts */
293: tickadj = 240000 / (60 * hz); /* can adjust 240ms in 60s */
294:
295: cp0_timecounter.tc_frequency = sys_config.cpu[0].clock / 2;
296: tc_init(&cp0_timecounter);
297:
298: clock_started++;
299: }
300:
301: /*
302: * We assume newhz is either stathz or profhz, and that neither will
303: * change after being set up above. Could recalculate intervals here
304: * but that would be a drag.
305: */
306: void
307: setstatclockrate(newhz)
308: int newhz;
309: {
310: }
311:
312: /*
313: * This code is defunct after 2099. Will Unix still be here then??
314: */
315: static short dayyr[12] = {
316: 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
317: };
318:
319: /*
320: * Initialize the time of day register, based on the time base which
321: * is, e.g. from a filesystem.
322: */
323: void
324: inittodr(time_t base)
325: {
326: struct timespec ts;
327: struct tod_time c;
328: struct clock_softc *sc = (struct clock_softc *)clock_cd.cd_devs[0];
329: int days, yr;
330:
331: ts.tv_nsec = 0;
332:
333: if (base < 15*SECYR) {
334: printf("WARNING: preposterous time in file system");
335: /* read the system clock anyway */
336: base = 17*SECYR + 186*SECDAY + SECDAY/2;
337: }
338:
339: /*
340: * Read RTC chip registers NOTE: Read routines are responsible
341: * for sanity checking clock. Dates after 19991231 should be
342: * returned as year >= 100.
343: */
344: if (sc->sc_clock.clk_get) {
345: (*sc->sc_clock.clk_get)(sc, base, &c);
346: } else {
347: printf("WARNING: No TOD clock, believing file system.\n");
348: goto bad;
349: }
350:
351: days = 0;
352: for (yr = 70; yr < c.year; yr++) {
353: days += YEARDAYS(yr);
354: }
355:
356: days += dayyr[c.mon - 1] + c.day - 1;
357: if (YEARDAYS(c.year) == 366 && c.mon > 2) {
358: days++;
359: }
360:
361: /* now have days since Jan 1, 1970; the rest is easy... */
362: ts.tv_sec = days * SECDAY + c.hour * 3600 + c.min * 60 + c.sec;
363: tc_setclock(&ts);
364: sc->sc_initted = 1;
365:
366: /*
367: * See if we gained/lost time.
368: */
369: if (base < ts.tv_sec - 5*SECYR) {
370: printf("WARNING: file system time much less than clock time\n");
371: } else if (base > ts.tv_sec + 5*SECYR) {
372: printf("WARNING: clock time much less than file system time\n");
373: printf("WARNING: using file system time\n");
374: } else {
375: return;
376: }
377:
378: bad:
379: ts.tv_sec = base;
380: tc_setclock(&ts);
381: sc->sc_initted = 1;
382: printf("WARNING: CHECK AND RESET THE DATE!\n");
383: }
384:
385: /*
386: * Reset the TOD clock. This is done when the system is halted or
387: * when the time is reset by the stime system call.
388: */
389: void
390: resettodr()
391: {
392: struct tod_time c;
393: struct clock_softc *sc = (struct clock_softc *)clock_cd.cd_devs[0];
394: register int t, t2;
395:
396: /*
397: * Don't reset clock if time has not been set!
398: */
399: if (!sc->sc_initted) {
400: return;
401: }
402:
403: /* compute the day of week. 1 is Sunday*/
404: t2 = time_second / SECDAY;
405: c.dow = (t2 + 5) % 7 + 1; /* 1/1/1970 was thursday */
406:
407: /* compute the year */
408: t2 = time_second / SECDAY;
409: c.year = 69;
410: while (t2 >= 0) { /* whittle off years */
411: t = t2;
412: c.year++;
413: t2 -= YEARDAYS(c.year);
414: }
415:
416: /* t = month + day; separate */
417: t2 = YEARDAYS(c.year);
418: for (c.mon = 1; c.mon < 12; c.mon++) {
419: if (t < dayyr[c.mon] + (t2 == 366 && c.mon > 1))
420: break;
421: }
422:
423: c.day = t - dayyr[c.mon - 1] + 1;
424: if (t2 == 366 && c.mon > 2) {
425: c.day--;
426: }
427:
428: t = time_second % SECDAY;
429: c.hour = t / 3600;
430: t %= 3600;
431: c.min = t / 60;
432: c.sec = t % 60;
433:
434: if (sc->sc_clock.clk_set) {
435: (*sc->sc_clock.clk_set)(sc, &c);
436: }
437: }
438:
439: u_int
440: cp0_get_timecount(struct timecounter *tc)
441: {
442: return (cp0_get_count());
443: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to clock.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mips64 / mips64