![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300|
Return to clock.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300 |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1982, 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution is only permitted until one year after the first shipment
11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
12: * binary forms are permitted provided that: (1) source distributions retain
13: * this entire copyright notice and comment, and (2) distributions including
14: * binaries display the following acknowledgement: This product includes
15: * software developed by the University of California, Berkeley and its
16: * contributors'' in the documentation or other materials provided with the
17: * distribution and in all advertising materials mentioning features or use
18: * of this software. Neither the name of the University nor the names of
19: * its contributors may be used to endorse or promote products derived from
20: * this software without specific prior written permission.
21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24: *
25: * from: Utah $Hdr: clock.c 1.17 89/11/30$
26: *
27: * @(#)clock.c 7.2 (Berkeley) 6/22/90
28: */
29:
30: #include "param.h"
31: #include "user.h"
32: #include "kernel.h"
33: #include "../hpdev/hilreg.h"
34: #include "clockreg.h"
35:
36: #include "machine/psl.h"
37: #include "machine/cpu.h"
38:
39: #if defined(GPROF) && defined(PROFTIMER)
40: #include "gprof.h"
41: #endif
42:
43: int clkstd[] = { IOV(0x5F8000) };
44:
45: static int month_days[12] = {
46: 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
47: };
48: struct bbc_tm *gmt_to_bbc();
49: u_char bbc_registers[13];
50: u_char write_bbc_reg(), read_bbc_reg();
51: struct hil_dev *bbcaddr = NULL;
52:
53: /*
54: * Machine-dependent clock routines.
55: *
56: * Startrtclock restarts the real-time clock, which provides
57: * hardclock interrupts to kern_clock.c.
58: *
59: * Inittodr initializes the time of day hardware which provides
60: * date functions.
61: *
62: * Resettodr restores the time of day hardware after a time change.
63: *
64: * A note on the real-time clock:
65: * We actually load the clock with CLK_INTERVAL-1 instead of CLK_INTERVAL.
66: * This is because the counter decrements to zero after N+1 enabled clock
67: * periods where N is the value loaded into the counter.
68: */
69:
70: /*
71: * Start the real-time clock.
72: */
73: startrtclock()
74: {
75: register struct clkreg *clk = (struct clkreg *)clkstd[0];
76:
77: clk->clk_cr2 = CLK_CR1;
78: clk->clk_cr1 = CLK_RESET;
79: clk->clk_cr2 = CLK_CR3;
80: clk->clk_cr3 = 0;
81: clk->clk_msb1 = (CLK_INTERVAL-1) >> 8 & 0xFF;
82: clk->clk_lsb1 = (CLK_INTERVAL-1) & 0xFF;
83: clk->clk_msb2 = 0;
84: clk->clk_lsb2 = 0;
85: clk->clk_msb3 = 0;
86: clk->clk_lsb3 = 0;
87: clk->clk_cr2 = CLK_CR1;
88: clk->clk_cr1 = CLK_IENAB;
89: }
90:
91: /*
92: * Returns number of usec since last recorded clock "tick"
93: * (i.e. clock interrupt).
94: */
95: clkread()
96: {
97: register struct clkreg *clk = (struct clkreg *) clkstd[0];
98: register int high, low;
99:
100: high = clk->clk_msb1;
101: low = clk->clk_lsb1;
102: if (high != clk->clk_msb1)
103: high = clk->clk_msb1;
104:
105: high = (CLK_INTERVAL-1) - ((high << 8) | low);
106: /*
107: * Pending interrupt indicates that the counter has wrapped
108: * since we went to splhigh(). Need to compensate.
109: */
110: if (clk->clk_sr & CLK_INT1)
111: high += CLK_INTERVAL;
112: return((high * tick) / CLK_INTERVAL);
113: }
114:
115: #include "clock.h"
116: #if NCLOCK > 0
117: /*
118: * /dev/clock: mappable high resolution timer.
119: *
120: * This code implements a 32-bit recycling counter (with a 4 usec period)
121: * using timers 2 & 3 on the 6840 clock chip. The counter can be mapped
122: * RO into a user's address space to achieve low overhead (no system calls),
123: * high-precision timing.
124: *
125: * Note that timer 3 is also used for the high precision profiling timer
126: * (PROFTIMER code above). Care should be taken when both uses are
127: * configured as only a token effort is made to avoid conflicting use.
128: */
129: #include "proc.h"
130: #include "ioctl.h"
131: #include "mapmem.h"
132: #include "malloc.h"
133: #include "clockioctl.h"
134:
135: int clockon = 0; /* non-zero if high-res timer enabled */
136: #ifdef PROFTIMER
137: int profprocs = 0; /* # of procs using profiling timer */
138: #endif
139: #ifdef DEBUG
140: int clockdebug = 0;
141: #endif
142:
143: /*ARGSUSED*/
144: clockopen(dev, flags)
145: dev_t dev;
146: {
147: #ifdef PROFTIMER
148: #ifdef GPROF
149: /*
150: * Kernel profiling enabled, give up.
151: */
152: if (profiling)
153: return(EBUSY);
154: #endif
155: /*
156: * If any user processes are profiling, give up.
157: */
158: if (profprocs)
159: return(EBUSY);
160: #endif
161: if (!clockon) {
162: startclock();
163: clockon++;
164: }
165: return(0);
166: }
167:
168: /*ARGSUSED*/
169: clockclose(dev, flags)
170: dev_t dev;
171: {
172: #ifdef MAPMEM
173: (void) clockunmmap(dev, (caddr_t)0);
174: #endif
175: stopclock();
176: clockon = 0;
177: return(0);
178: }
179:
180: /*ARGSUSED*/
181: clockioctl(dev, cmd, data, flag)
182: dev_t dev;
183: caddr_t data;
184: {
185: int error = 0;
186:
187: switch (cmd) {
188:
189: #ifdef MAPMEM
190: case CLOCKMAP:
191: error = clockmmap(dev, (caddr_t *)data);
192: break;
193:
194: case CLOCKUNMAP:
195: error = clockunmmap(dev, *(caddr_t *)data);
196: break;
197:
198: case CLOCKGETRES:
199: *(int *)data = CLK_RESOLUTION;
200: break;
201: #endif
202:
203: default:
204: error = EINVAL;
205: break;
206: }
207: return(error);
208: }
209:
210: /*ARGSUSED*/
211: clockmap(dev, off, prot)
212: dev_t dev;
213: {
214: #ifdef MMAP
215: return((off + (IOBASE+CLKSR-1)) >> PGSHIFT);
216: #endif
217: }
218:
219: #ifdef MAPMEM
220:
221: struct mapmemops clockops = {
222: (int (*)())0, (int (*)())0, (int (*)())0, (int (*)())0
223: };
224:
225: clockmmap(dev, addrp)
226: dev_t dev;
227: caddr_t *addrp;
228: {
229: struct proc *p = u.u_procp; /* XXX */
230: struct mapmem *mp;
231: int id, error, clockmapin();
232:
233: id = minor(dev); /* XXX */
234: error = mmalloc(p, id, addrp, NBPG, MM_RO|MM_CI|MM_NOCORE,
235: &clockops, &mp);
236: #ifdef DEBUG
237: if (clockdebug)
238: printf("clockmmap(%d): addr %x\n", p->p_pid, *addrp);
239: #endif
240: if (error == 0)
241: if (error = mmmapin(p, mp, clockmapin))
242: (void) mmfree(p, mp);
243: return(error);
244: }
245:
246: clockunmmap(dev, addr)
247: dev_t dev;
248: caddr_t addr;
249: {
250: struct proc *p = u.u_procp; /* XXX */
251: register struct mapmem *mp, **mpp;
252: int found, id;
253:
254: #ifdef DEBUG
255: if (clockdebug)
256: printf("clockunmmap(%d): addr %x\n", p->p_pid, addr);
257: #endif
258: id = minor(dev); /* XXX */
259: found = 0;
260: mpp = &u.u_mmap;
261: for (mp = *mpp; mp; mp = *mpp) {
262: if (mp->mm_id != id || mp->mm_ops != &clockops) {
263: mpp = &mp->mm_next;
264: continue;
265: }
266: if (addr &&
267: (addr < mp->mm_uva || addr >= mp->mm_uva+mp->mm_size)) {
268: mpp = &mp->mm_next;
269: continue;
270: }
271: mmmapout(p, mp);
272: (void) mmfree(p, mp);
273: found++;
274: }
275: return(found ? 0 : EINVAL);
276: }
277:
278: /*ARGSUSED*/
279: clockmapin(mp, off)
280: struct mapmem *mp;
281: {
282: return((off + (IOBASE+CLKSR-1)) >> PGSHIFT);
283: }
284: #endif
285:
286: startclock()
287: {
288: register struct clkreg *clk = (struct clkreg *)clkstd[0];
289:
290: clk->clk_msb2 = -1; clk->clk_lsb2 = -1;
291: clk->clk_msb3 = -1; clk->clk_lsb3 = -1;
292:
293: clk->clk_cr2 = CLK_CR3;
294: clk->clk_cr3 = CLK_OENAB|CLK_8BIT;
295: clk->clk_cr2 = CLK_CR1;
296: clk->clk_cr1 = CLK_IENAB;
297: }
298:
299: stopclock()
300: {
301: register struct clkreg *clk = (struct clkreg *)clkstd[0];
302:
303: clk->clk_cr2 = CLK_CR3;
304: clk->clk_cr3 = 0;
305: clk->clk_cr2 = CLK_CR1;
306: clk->clk_cr1 = CLK_IENAB;
307: }
308: #endif
309:
310: #ifdef PROFTIMER
311: /*
312: * This code allows the hp300 kernel to use one of the extra timers on
313: * the clock chip for profiling, instead of the regular system timer.
314: * The advantage of this is that the profiling timer can be turned up to
315: * a higher interrupt rate, giving finer resolution timing. The profclock
316: * routine is called from the lev6intr in locore, and is a specialized
317: * routine that calls addupc. The overhead then is far less than if
318: * hardclock/softclock was called. Further, the context switch code in
319: * locore has been changed to turn the profile clock on/off when switching
320: * into/out of a process that is profiling (startprofclock/stopprofclock).
321: * This reduces the impact of the profiling clock on other users, and might
322: * possibly increase the accuracy of the profiling.
323: */
324: int profint = PRF_INTERVAL; /* Clock ticks between interrupts */
325: int profscale = 0; /* Scale factor from sys clock to prof clock */
326: char profon = 0; /* Is profiling clock on? */
327:
328: /* profon values - do not change, locore.s assumes these values */
329: #define PRF_NONE 0x00
330: #define PRF_USER 0x01
331: #define PRF_KERNEL 0x80
332:
333: initprofclock()
334: {
335: #if NCLOCK > 0
336: /*
337: * If the high-res timer is running, force profiling off.
338: * Unfortunately, this gets reflected back to the user not as
339: * an error but as a lack of results.
340: */
341: if (clockon) {
342: u.u_prof.pr_scale = 0;
343: return;
344: }
345: /*
346: * Keep track of the number of user processes that are profiling
347: * by checking the scale value.
348: *
349: * XXX: this all assumes that the profiling code is well behaved;
350: * i.e. profil() is called once per process with pcscale non-zero
351: * to turn it on, and once with pcscale zero to turn it off.
352: * Also assumes you don't do any forks or execs. Oh well, there
353: * is always adb...
354: */
355: if (u.u_prof.pr_scale)
356: profprocs++;
357: else
358: profprocs--;
359: #endif
360: /*
361: * The profile interrupt interval must be an even divisor
362: * of the CLK_INTERVAL so that scaling from a system clock
363: * tick to a profile clock tick is possible using integer math.
364: */
365: if (profint > CLK_INTERVAL || (CLK_INTERVAL % profint) != 0)
366: profint = CLK_INTERVAL;
367: profscale = CLK_INTERVAL / profint;
368: }
369:
370: startprofclock()
371: {
372: register struct clkreg *clk = (struct clkreg *)clkstd[0];
373:
374: clk->clk_msb3 = (profint-1) >> 8 & 0xFF;
375: clk->clk_lsb3 = (profint-1) & 0xFF;
376:
377: clk->clk_cr2 = CLK_CR3;
378: clk->clk_cr3 = CLK_IENAB;
379: }
380:
381: stopprofclock()
382: {
383: register struct clkreg *clk = (struct clkreg *)clkstd[0];
384:
385: clk->clk_cr2 = CLK_CR3;
386: clk->clk_cr3 = 0;
387: }
388:
389: #ifdef GPROF
390: /*
391: * profclock() is expanded in line in lev6intr() unless profiling kernel.
392: * Assumes it is called with clock interrupts blocked.
393: */
394: profclock(pc, ps)
395: caddr_t pc;
396: int ps;
397: {
398: /*
399: * Came from user mode.
400: * If this process is being profiled record the tick.
401: */
402: if (USERMODE(ps)) {
403: if (u.u_prof.pr_scale)
404: addupc(pc, &u.u_prof, 1);
405: }
406: /*
407: * Came from kernel (supervisor) mode.
408: * If we are profiling the kernel, record the tick.
409: */
410: else if (profiling < 2) {
411: register int s = pc - s_lowpc;
412:
413: if (s < s_textsize)
414: kcount[s / (HISTFRACTION * sizeof (*kcount))]++;
415: }
416: /*
417: * Kernel profiling was on but has been disabled.
418: * Mark as no longer profiling kernel and if all profiling done,
419: * disable the clock.
420: */
421: if (profiling && (profon & PRF_KERNEL)) {
422: profon &= ~PRF_KERNEL;
423: if (profon == PRF_NONE)
424: stopprofclock();
425: }
426: }
427: #endif
428: #endif
429:
430: /*
431: * Initialize the time of day register, based on the time base which is, e.g.
432: * from a filesystem.
433: */
434: inittodr(base)
435: time_t base;
436: {
437: u_long timbuf = base; /* assume no battery clock exists */
438: static int bbcinited = 0;
439:
440: /* XXX */
441: if (!bbcinited) {
442: if (badbaddr(&BBCADDR->hil_stat))
443: printf("WARNING: no battery clock\n");
444: else
445: bbcaddr = BBCADDR;
446: bbcinited = 1;
447: }
448:
449: /*
450: * bbc_to_gmt converts and stores the gmt in timbuf.
451: * If an error is detected in bbc_to_gmt, or if the filesystem
452: * time is more recent than the gmt time in the clock,
453: * then use the filesystem time and warn the user.
454: */
455: if (!bbc_to_gmt(&timbuf) || timbuf < base) {
456: printf("WARNING: bad date in battery clock\n");
457: timbuf = base;
458: }
459: if (base < 5*SECYR) {
460: printf("WARNING: preposterous time in file system");
461: timbuf = 6*SECYR + 186*SECDAY + SECDAY/2;
462: printf(" -- CHECK AND RESET THE DATE!\n");
463: }
464:
465: /* Battery clock does not store usec's, so forget about it. */
466: time.tv_sec = timbuf;
467: }
468:
469: resettodr()
470: {
471: register int i;
472: register struct bbc_tm *tmptr;
473:
474: tmptr = gmt_to_bbc(time.tv_sec);
475:
476: decimal_to_bbc(0, 1, tmptr->tm_sec);
477: decimal_to_bbc(2, 3, tmptr->tm_min);
478: decimal_to_bbc(4, 5, tmptr->tm_hour);
479: decimal_to_bbc(7, 8, tmptr->tm_mday);
480: decimal_to_bbc(9, 10, tmptr->tm_mon);
481: decimal_to_bbc(11, 12, tmptr->tm_year);
482:
483: /* Some bogusness to deal with seemingly broken hardware. Nonsense */
484: bbc_registers[5] = ((tmptr->tm_hour / 10) & 0x03) + 8;
485:
486: write_bbc_reg(15, 13); /* reset prescalar */
487:
488: for (i = 0; i <= NUM_BBC_REGS; i++)
489: if (bbc_registers[i] != write_bbc_reg(i, bbc_registers[i])) {
490: printf("Cannot set battery backed clock\n");
491: break;
492: }
493: }
494:
495: struct bbc_tm *
496: gmt_to_bbc(tim)
497: long tim;
498: {
499: register int i;
500: register long hms, day;
501: static struct bbc_tm rt;
502:
503: day = tim / SECDAY;
504: hms = tim % SECDAY;
505:
506: /* Hours, minutes, seconds are easy */
507: rt.tm_hour = hms / 3600;
508: rt.tm_min = (hms % 3600) / 60;
509: rt.tm_sec = (hms % 3600) % 60;
510:
511: /* Number of years in days */
512: for (i = STARTOFTIME - 1900; day >= days_in_year(i); i++)
513: day -= days_in_year(i);
514: rt.tm_year = i;
515:
516: /* Number of months in days left */
517: if (leapyear(rt.tm_year))
518: days_in_month(FEBRUARY) = 29;
519: for (i = 1; day >= days_in_month(i); i++)
520: day -= days_in_month(i);
521: days_in_month(FEBRUARY) = 28;
522: rt.tm_mon = i;
523:
524: /* Days are what is left over (+1) from all that. */
525: rt.tm_mday = day + 1;
526:
527: return(&rt);
528: }
529:
530: bbc_to_gmt(timbuf)
531: u_long *timbuf;
532: {
533: register int i;
534: register u_long tmp;
535: int year, month, day, hour, min, sec;
536:
537: read_bbc();
538:
539: sec = bbc_to_decimal(1, 0);
540: min = bbc_to_decimal(3, 2);
541:
542: /*
543: * Hours are different for some reason. Makes no sense really.
544: */
545: hour = ((bbc_registers[5] & 0x03) * 10) + bbc_registers[4];
546: day = bbc_to_decimal(8, 7);
547: month = bbc_to_decimal(10, 9);
548: year = bbc_to_decimal(12, 11) + 1900;
549:
550: range_test(hour, 0, 23);
551: range_test(day, 1, 31);
552: range_test(month, 1, 12);
553: range_test(year, STARTOFTIME, 2000);
554:
555: tmp = 0;
556:
557: for (i = STARTOFTIME; i < year; i++)
558: tmp += days_in_year(i);
559: if (leapyear(year) && month > FEBRUARY)
560: tmp++;
561:
562: for (i = 1; i < month; i++)
563: tmp += days_in_month(i);
564:
565: tmp += (day - 1);
566: tmp = ((tmp * 24 + hour) * 60 + min) * 60 + sec;
567:
568: *timbuf = tmp;
569: return(1);
570: }
571:
572: read_bbc()
573: {
574: register int i, read_okay;
575:
576: read_okay = 0;
577: while (!read_okay) {
578: read_okay = 1;
579: for (i = 0; i <= NUM_BBC_REGS; i++)
580: bbc_registers[i] = read_bbc_reg(i);
581: for (i = 0; i <= NUM_BBC_REGS; i++)
582: if (bbc_registers[i] != read_bbc_reg(i))
583: read_okay = 0;
584: }
585: }
586:
587: u_char
588: read_bbc_reg(reg)
589: int reg;
590: {
591: u_char data = reg;
592:
593: if (bbcaddr) {
594: send_hil_cmd(bbcaddr, BBC_SET_REG, &data, 1, NULL);
595: send_hil_cmd(bbcaddr, BBC_READ_REG, NULL, 0, &data);
596: }
597: return(data);
598: }
599:
600: u_char
601: write_bbc_reg(reg, data)
602: u_int data;
603: {
604: u_char tmp;
605:
606: tmp = (u_char) ((data << HIL_SSHIFT) | reg);
607:
608: if (bbcaddr) {
609: send_hil_cmd(bbcaddr, BBC_SET_REG, &tmp, 1, NULL);
610: send_hil_cmd(bbcaddr, BBC_WRITE_REG, NULL, 0, NULL);
611: send_hil_cmd(bbcaddr, BBC_READ_REG, NULL, 0, &tmp);
612: }
613: return(tmp);
614: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.