![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to machine_clock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / i386|
Return to machine_clock.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1992, 1993, 1994, 1995 NeXT Computer, Inc.
27: *
28: * Machine dependent clock and timer routines
29: * for i386 architecture.
30: *
31: * HISTORY
32: *
33: * 11 June 1995 ? at NeXT
34: * Major rewrite for new clock API - banished
35: * all occurrances of ns_time_t in favor of
36: * tvalspec_t.
37: *
38: * 24 March 1992 ? at NeXT
39: * Created from m68k version.
40: */
41:
42: #import <mach/mach_types.h>
43:
44: #import <bsd/sys/param.h>
45: #import <bsd/sys/time.h>
46:
47: #import <kern/clock.h>
48: #import <vm/vm_kern.h>
49:
50: #import <machdep/i386/timer.h>
51: #import <machdep/i386/timer_inline.h>
52: #import <machdep/i386/intr_exported.h>
53:
54: static tvalspec_t time_of_boot; /* rel to 1/1/70 (UNIX T[0]) */
55:
56: /*
57: * Nanosecond event counter ;-)
58: */
59:
60: static struct _system_clock {
61: tvalspec_t counter;
62: timer_cnt_val_t last_timer_count;
63: mapped_tvalspec_t *mapped_counter;
64: timer_cnt_val_t timer_const;
65: } system_clock;
66:
67: static tvalspec_t system_time_stamp(void);
68:
69: static struct _system_timer {
70: boolean_t is_set;
71: tvalspec_t expire_time;
72: timer_func_t expire_func;
73: } system_timer;
74:
75: struct _interrupt_location {
76: unsigned int eip;
77: int rpl;
78: int ipl;
79: };
80:
81: static void machine_hardclock(
82: struct _interrupt_location *loc);
83:
84: static boolean_t hardclock_enabled;
85:
86: void
87: system_timer_dispatch(
88: unsigned int irq,
89: void *_state,
90: int ipl
91: )
92: {
93: thread_saved_state_t *state = (thread_saved_state_t *)_state;
94: tvalspec_t now;
95: struct _interrupt_location loc;
96:
97: ADD_TVALSPEC_NSEC(&system_clock.counter, NSEC_PER_TICK);
98: system_clock.last_timer_count = system_clock.timer_const;
99:
100: if (state) {
101: loc.eip = state->frame.eip;
102:
103: if (!(state->frame.eflags & EFL_VM))
104: loc.rpl = state->frame.cs.rpl;
105: else
106: loc.rpl = USER_PRIV;
107:
108: loc.ipl = ipl;
109: }
110: else {
111: loc.eip = 0x00000000;
112: loc.rpl = KERN_PRIV;
113: loc.ipl = ipl;
114: }
115:
116: if (hardclock_enabled)
117: machine_hardclock(&loc);
118:
119: now = system_time_stamp();
120:
121: if (system_timer.is_set &&
122: CMP_TVALSPEC(&system_timer.expire_time, &now) <= 0) {
123: system_timer.is_set = FALSE;
124: (*system_timer.expire_func)(now);
125: }
126: }
127:
128: void
129: hardclock_init(void)
130: {
131: hardclock_enabled = TRUE;
132: }
133:
134: static void
135: machine_hardclock(
136: struct _interrupt_location *loc
137: )
138: {
139: clock_interrupt(tick, (loc->rpl == USER_PRIV), (loc->ipl == 0));
140:
141: hardclock(loc->eip, STATUS_WORD(loc->rpl, loc->ipl));
142: }
143:
144: static unsigned int us_spin_us_const = 0x2000;
145:
146: void
147: us_spin(
148: unsigned int us
149: )
150: {
151: unsigned int constant;
152:
153: while (us-- > 0) {
154: constant = us_spin_us_const;
155:
156: while (constant-- > 0)
157: continue;
158: }
159: }
160:
161: void
162: us_spin_calibrate(void)
163: {
164: timer_ctl_reg_t reg;
165: timer_cnt_val_t leftover;
166: int s;
167:
168: reg = (timer_ctl_reg_t) { 0 };
169:
170: reg.mode = TIMER_EVENTMODE;
171: reg.rw = TIMER_CTL_RW_BOTH;
172: timer_set_ctl(reg);
173:
174: s = splclock();
175: timer_write(TIMER_CNT0_SEL, TIMER_COUNT_MAX);
176:
177: us_spin(1);
178:
179: timer_latch(TIMER_CNT0_SEL); leftover = timer_read(TIMER_CNT0_SEL);
180: splx(s);
181:
182: /*
183: * Formula for spin constant is :
184: * (loopcount * timer clock speed)/ counter ticks
185: */
186: us_spin_us_const =
187: (us_spin_us_const *
188: (TIMER_CONSTANT / (TIMER_COUNT_MAX - leftover))) / 1000000;
189: }
190:
191: static timer_cnt_val_t
192: system_timer_constant(void)
193: {
194: unsigned int constant;
195:
196: constant = TIMER_CONSTANT / TICKS_PER_SEC;
197: if ((TIMER_CONSTANT % TICKS_PER_SEC) >= (TICKS_PER_SEC / 2))
198: constant++;
199:
200: return ((timer_cnt_val_t)constant);
201: }
202:
203: /*
204: * Initialize the clock and timer interface.
205: */
206: void
207: machine_clock_init(void)
208: {
209: timer_ctl_reg_t reg;
210: int s;
211: extern void readtodc(unsigned int *);
212:
213: (void) intr_register_irq(0, system_timer_dispatch, 0, INTR_IPL6);
214: (void) intr_enable_irq(0);
215:
216: /*
217: * Initialize the RTC, and set the system's idea of time.
218: */
219: readtodc(&time_of_boot.tv_sec);
220:
221: /*
222: * Set up the timer.
223: */
224: s = splclock();
225:
226: reg = (timer_ctl_reg_t){ 0 };
227:
228: reg.mode = TIMER_NDIVMODE;
229: reg.rw = TIMER_CTL_RW_BOTH;
230: timer_set_ctl(reg);
231:
232: // save constant for later use
233: system_clock.timer_const = system_timer_constant();
234:
235: timer_write(TIMER_CNT0_SEL, system_clock.timer_const);
236: system_clock.last_timer_count = system_clock.timer_const;
237:
238: splx(s);
239: }
240:
241: /*
242: * Clock functions
243: */
244: tvalspec_t
245: clock_get_counter(
246: clock_type_t which_clock
247: )
248: {
249: tvalspec_t result = system_time_stamp();
250:
251: switch (which_clock) {
252:
253: case System:
254: break;
255:
256: case Calendar: {
257: int s = splclock();
258:
259: ADD_TVALSPEC(&result, &time_of_boot);
260: splx(s);
261: break;
262: }
263:
264: default:
265: result = TVALSPEC_ZERO;
266: break;
267: }
268:
269: return (result);
270: }
271:
272: void
273: clock_set_counter(
274: clock_type_t which_clock,
275: tvalspec_t value
276: )
277: {
278: tvalspec_t counter = system_time_stamp();
279:
280: switch (which_clock) {
281:
282: case Calendar: {
283: int s = splclock();
284:
285: time_of_boot = value;
286: SUB_TVALSPEC(&time_of_boot, &counter);
287: splx(s);
288:
289: writetodc(&value.tv_sec);
290: break;
291: }
292:
293: default:
294: /* Can only set the calendar */
295: break;
296: }
297: }
298:
299: void
300: clock_adjust_counter(
301: clock_type_t which_clock,
302: clock_res_t nsec
303: )
304: {
305: switch (which_clock) {
306:
307: case Calendar: {
308: int s = splclock();
309:
310: ADD_TVALSPEC_NSEC(&time_of_boot, nsec);
311: splx(s);
312: break;
313: }
314:
315: default:
316: /* Can only adjust the calendar */
317: break;
318: }
319: }
320:
321: mapped_tvalspec_t *
322: clock_map_counter(
323: clock_type_t which_clock
324: )
325: {
326: mapped_tvalspec_t *mapped_clock;
327:
328: switch (which_clock) {
329:
330: case System:
331: if (!(mapped_clock = system_clock.mapped_counter)) {
332: int s;
333:
334: if (kmem_alloc_wired(kernel_map,
335: (vm_offset_t *)&mapped_clock,
336: PAGE_SIZE) != KERN_SUCCESS) {
337: mapped_clock = 0;
338: break;
339: }
340: s = splclock();
341: system_clock.mapped_counter = mapped_clock;
342: splx(s);
343: }
344: break;
345:
346: default:
347: mapped_clock = 0;
348: break;
349: }
350:
351: return (mapped_clock);
352: }
353:
354: void
355: timer_set_expire_func(
356: timer_type_t which_timer,
357: timer_func_t expire_func
358: )
359: {
360: switch (which_timer) {
361:
362: case SystemWide:
363: if (!expire_func || !system_timer.expire_func) {
364: int s = splclock();
365:
366: system_timer.expire_func = expire_func;
367: system_timer.is_set = FALSE;
368: splx(s);
369: }
370: break;
371:
372: default:
373: break;
374: }
375: }
376:
377: void
378: timer_set_deadline(
379: timer_type_t which_timer,
380: tvalspec_t deadline
381: )
382: {
383: switch (which_timer) {
384:
385: case SystemWide:
386: if (system_timer.expire_func) {
387: int s = splclock();
388:
389: system_timer.expire_time = deadline;
390: system_timer.is_set = TRUE;
391: splx(s);
392: }
393: break;
394:
395: default:
396: break;
397: }
398: }
399:
400: /*
401: * Get current clock value plus fraction of a tick.
402: */
403: static tvalspec_t
404: system_time_stamp(void)
405: {
406: timer_cnt_val_t current_timer_count, last_timer_count;
407: clock_res_t fraction;
408: tvalspec_t result;
409: int s = splclock();
410:
411: // take a snapshot of the whole counter state
412: result = system_clock.counter;
413: last_timer_count = system_clock.last_timer_count;
414: timer_latch(TIMER_CNT0_SEL);
415: current_timer_count = timer_read(TIMER_CNT0_SEL);
416: system_clock.last_timer_count = current_timer_count;
417: splx(s);
418:
419: // check for tick overflow
420: if (current_timer_count > last_timer_count) {
421: // we missed a tick
422: ADD_TVALSPEC_NSEC(&result, NSEC_PER_TICK);
423: }
424:
425: // convert fraction to ns
426: fraction = (system_clock.timer_const - current_timer_count);
427: fraction = fraction * (NSEC_PER_SEC / TIMER_CONSTANT);
428:
429: ADD_TVALSPEC_NSEC(&result, fraction);
430:
431: return (result);
432: }
433:
434: unsigned int
435: event_get(void)
436: {
437: return (system_time_stamp().tv_nsec);
438: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.