![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun4-timer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / machine / sun4|
Return to sun4-timer.c CVS log | Up to [The Machine Emulator] / tme / machine / sun4 |
1.1 root 1: /* $Id: sun4-timer.c,v 1.2 2006/11/16 02:42:16 fredette Exp $ */
2:
3: /* machine/sun4/sun4-timer.c - implementation of Sun 4 timer emulation: */
4:
5: /*
6: * Copyright (c) 2006 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: sun4-timer.c,v 1.2 2006/11/16 02:42:16 fredette Exp $");
38:
39: /* includes: */
40: #include <tme/generic/bus-device.h>
41: #include "sun4-impl.h"
42:
43: /* macros: */
44:
45: /* real sun4/4c timer bits: */
46: #define TME_SUN4_32_TIMER_LIMIT TME_BIT(31)
47: #define TME_SUN44C_TIMER_MASK (0x7ffffc00)
48: #define TME_SUN4M_TIMER_MASK (0x7ffffe00)
49:
50: /* define this to track interrupt rates, reporting once every N
51: seconds: */
52: #if 1
53: #define TME_SUN4_TIMER_TRACK_INT_RATE (10)
54: #endif
55:
56: /* this makes timer callouts. it must be called with the mutex held: */
57: static void
58: _tme_sun4_timer_callout(struct tme_sun4 *sun4)
59: {
60: struct tme_bus_connection *conn_bus;
61: struct tme_sun4_timer *timer;
62: unsigned int int_asserted;
63: int again;
64: int rc;
65:
66: /* if this function is already running in another thread, return
67: now. the other thread will do our work: */
68: if (sun4->tme_sun4_timer_callouts_running) {
69: return;
70: }
71:
72: /* callouts are now running: */
73: sun4->tme_sun4_timer_callouts_running = TRUE;
74:
75: /* get our bus connection: */
76: conn_bus = sun4->tme_sun4_buses[TME_SUN4_32_CONN_REG_TIMER];
77:
78: /* loop forever: */
79: for (again = TRUE; again;) {
80: again = FALSE;
81:
82: /* check all of the timers for changes: */
83: timer = &sun4->tme_sun4_timers[0];
84: do {
85:
86: /* if this timer needs an interrupt callout: */
87: int_asserted = (timer->tme_sun4_timer_counter & TME_SUN4_32_TIMER_LIMIT) != 0;
88: if (!int_asserted
89: != !timer->tme_sun4_timer_int_asserted) {
90:
91: /* unlock our mutex: */
92: tme_mutex_unlock(&sun4->tme_sun4_mutex);
93:
94: /* call out the bus interrupt signal edge: */
95: rc = (*conn_bus->tme_bus_signal)
96: (conn_bus,
97: ((timer == &sun4->tme_sun4_timers[0]
98: ? TME_BUS_SIGNAL_INT(10)
99: : TME_BUS_SIGNAL_INT(14))
100: | (int_asserted
101: ? TME_BUS_SIGNAL_LEVEL_ASSERTED
102: : TME_BUS_SIGNAL_LEVEL_NEGATED)));
103:
104: /* lock our mutex: */
105: tme_mutex_lock(&sun4->tme_sun4_mutex);
106:
107: /* if this callout was successful, note the new state of the
108: interrupt signal: */
109: if (rc == TME_OK) {
110: timer->tme_sun4_timer_int_asserted = int_asserted;
111: again = TRUE;
112: }
113:
114: /* otherwise, abort: */
115: else {
116: abort();
117: }
118: }
119: } while (++timer != (&sun4->tme_sun4_timers[0] + TME_ARRAY_ELS(sun4->tme_sun4_timers)));
120:
121: }
122:
123: /* there are no more callouts to make: */
124: sun4->tme_sun4_timer_callouts_running = FALSE;
125: }
126:
127: /* this can be called to force an immediate timer interrupt: */
128: void
129: _tme_sun4_timer_int_force(struct tme_sun4 *sun4,
130: struct tme_sun4_timer *timer)
131: {
132:
133: /* lock our mutex: */
134: tme_mutex_lock(&sun4->tme_sun4_mutex);
135:
136: /* force an immediate timer interrupt: */
137: timer->tme_sun4_timer_counter = TME_SUN4_32_TIMER_LIMIT;
138: timer->tme_sun4_timer_limit |= TME_SUN4_32_TIMER_LIMIT;
139:
140: /* call out any interrupts: */
141: _tme_sun4_timer_callout(sun4);
142:
143: /* unlock our mutex: */
144: tme_mutex_unlock(&sun4->tme_sun4_mutex);
145: }
146:
147: /* the sun4 timer update function. it must be called with the mutex
148: locked: */
149: static void
150: _tme_sun4_timer_update(struct tme_sun4_timer *timer, struct timeval *now, struct timeval *sleep)
151: {
152:
153: /* get the current time: */
154: gettimeofday(now, NULL);
155:
156: #ifdef TME_SUN4_TIMER_TRACK_INT_RATE
157:
158: /* if the sample time has finished: */
159: if (timer->tme_sun4_timer_track_sample.tv_sec < now->tv_sec
160: || (timer->tme_sun4_timer_track_sample.tv_sec == now->tv_sec
161: && timer->tme_sun4_timer_track_sample.tv_usec <= now->tv_usec)) {
162:
163: /* if the timer has made any interrupts during the sample time: */
164: if (timer->tme_sun4_timer_track_ints > 0) {
165:
166: /* log the interrupt rate: */
167: tme_log(TME_SUN4_LOG_HANDLE(timer->tme_sun4_timer_sun4),
168: 0, TME_OK,
169: (TME_SUN4_LOG_HANDLE(timer->tme_sun4_timer_sun4),
170: "level %d timer interrupt rate: %ld/sec",
171: (timer == &timer->tme_sun4_timer_sun4->tme_sun4_timers[0]
172: ? 10
173: : 14),
174: (timer->tme_sun4_timer_track_ints
175: / (now->tv_sec
176: - (timer->tme_sun4_timer_track_sample.tv_sec
177: - TME_SUN4_TIMER_TRACK_INT_RATE)))));
178: }
179:
180: /* reset the sampling: */
181: timer->tme_sun4_timer_track_ints = 0;
182: timer->tme_sun4_timer_track_sample = *now;
183: timer->tme_sun4_timer_track_sample.tv_sec += TME_SUN4_TIMER_TRACK_INT_RATE;
184: }
185:
186: #endif /* TME_SUN4_TIMER_TRACK_INT_RATE */
187:
188: /* if this timer has not reached its next limit: */
189: if (__tme_predict_false(timer->tme_sun4_timer_limit_next.tv_sec > now->tv_sec
190: || (timer->tme_sun4_timer_limit_next.tv_sec == now->tv_sec
191: && timer->tme_sun4_timer_limit_next.tv_usec > now->tv_usec))) {
192:
193: /* sleep until this timer reaches its next limit: */
194: sleep->tv_sec = timer->tme_sun4_timer_limit_next.tv_sec - now->tv_sec;
195: sleep->tv_usec = timer->tme_sun4_timer_limit_next.tv_usec - now->tv_usec;
196: if (timer->tme_sun4_timer_limit_next.tv_usec < now->tv_usec) {
197: sleep->tv_sec--;
198: sleep->tv_usec += 1000000;
199: }
200: return;
201: }
202:
203: /* set this timer's next limit time: */
204: do {
205: timer->tme_sun4_timer_limit_next.tv_sec += timer->tme_sun4_timer_period.tv_sec;
206: timer->tme_sun4_timer_limit_next.tv_usec += timer->tme_sun4_timer_period.tv_usec;
207: if (__tme_predict_false(timer->tme_sun4_timer_limit_next.tv_usec >= 1000000)) {
208: timer->tme_sun4_timer_limit_next.tv_usec -= 1000000;
209: timer->tme_sun4_timer_limit_next.tv_sec += 1;
210: }
211: } while (timer->tme_sun4_timer_limit_next.tv_sec < now->tv_sec
212: || (timer->tme_sun4_timer_limit_next.tv_sec == now->tv_sec
213: && timer->tme_sun4_timer_limit_next.tv_usec <= now->tv_usec));
214:
215: /* mark this timer as having reached its limit: */
216: #ifdef TME_SUN4_TIMER_TRACK_INT_RATE
217: if (!(timer->tme_sun4_timer_counter
218: & TME_SUN4_32_TIMER_LIMIT)) {
219: timer->tme_sun4_timer_track_ints++;
220: }
221: #endif /* TME_SUN4_TIMER_TRACK_INT_RATE */
222: timer->tme_sun4_timer_counter = TME_SUN4_32_TIMER_LIMIT;
223: timer->tme_sun4_timer_limit |= TME_SUN4_32_TIMER_LIMIT;
224:
225: /* sleep for the normal period: */
226: *sleep = timer->tme_sun4_timer_period;
227: }
228:
229: /* this resets a timer: */
230: static void
231: _tme_sun4_timer_reset(struct tme_sun4_timer *timer)
232: {
233: tme_uint32_t counter_one;
234: tme_uint32_t ticks;
235: tme_uint32_t ticks_max;
236: tme_uint32_t usecs;
237:
238: /* to keep things simpler, we always use the sun4m 500ns tick: */
239: counter_one = TME_SUN4_IS_SUN44C(timer->tme_sun4_timer_sun4) ? 2 : 1;
240: ticks_max = (TME_SUN4M_TIMER_MASK / _TME_FIELD_MASK_FACTOR(TME_SUN4M_TIMER_MASK)) + 1;
241:
242: /* get this timer's period, in 500ns ticks. NB that we account for
243: the fact that timers count from [1..limit), and not [0..limit): */
244: /* XXX FIXME - we assume that the limit value of one gives the
245: longest possible period. is this right? */
246: ticks = TME_FIELD_MASK_EXTRACTU(timer->tme_sun4_timer_limit, TME_SUN4M_TIMER_MASK);
247: ticks = (ticks - counter_one) & (ticks_max - counter_one);
248: if (__tme_predict_false(ticks == 0)) {
249: ticks = ticks_max;
250: }
251:
252: /* convert the timer's period from 500ns ticks to a struct timeval
253: and save it: */
254: usecs = ticks / 2;
255: timer->tme_sun4_timer_period.tv_sec = 0;
256: if (__tme_predict_false(usecs >= 1000000)) {
257: timer->tme_sun4_timer_period.tv_sec = usecs / 1000000;
258: usecs %= 1000000;
259: }
260: timer->tme_sun4_timer_period.tv_usec = usecs;
261:
262: /* set the next limit time for this timer: */
263: gettimeofday(&timer->tme_sun4_timer_limit_next, NULL);
264: timer->tme_sun4_timer_limit_next.tv_sec += timer->tme_sun4_timer_period.tv_sec;
265: timer->tme_sun4_timer_limit_next.tv_usec += timer->tme_sun4_timer_period.tv_usec;
266: if (timer->tme_sun4_timer_limit_next.tv_usec >= 1000000) {
267: timer->tme_sun4_timer_limit_next.tv_usec -= 1000000;
268: timer->tme_sun4_timer_limit_next.tv_sec += 1;
269: }
270: }
271:
272: /* the sun4 timer thread: */
273: static void
274: _tme_sun4_timer_th(struct tme_sun4_timer *timer)
275: {
276: struct tme_sun4 *sun4;
277: struct timeval now;
278: struct timeval sleep;
279:
280: /* recover our sun4: */
281: sun4 = timer->tme_sun4_timer_sun4;
282:
283: /* lock our mutex: */
284: tme_mutex_lock(&sun4->tme_sun4_mutex);
285:
286: /* loop forever: */
287: for (;;) {
288:
289: /* update this timer: */
290: _tme_sun4_timer_update(timer, &now, &sleep);
291:
292: /* call out any interrupts: */
293: _tme_sun4_timer_callout(sun4);
294:
295: /* sleep, but wake up if our timer configuration changes: */
296: tme_cond_sleep_yield(&timer->tme_sun4_timer_cond,
297: &sun4->tme_sun4_mutex,
298: &sleep);
299: }
300: /* NOTREACHED */
301: }
302:
303: /* the sun4 timer control bus cycle handler: */
304: int
305: _tme_sun4_timer_cycle_control(void *_sun4, struct tme_bus_cycle *cycle_init)
306: {
307: struct tme_sun4 *sun4;
308: unsigned int timer_i;
309: struct tme_sun4_timer *timer;
310: tme_uint32_t reg;
311: tme_uint32_t value32;
312: struct tme_bus_cycle cycle_resp;
313: struct timeval now;
314: struct timeval last_reset;
315: tme_uint32_t counter_one;
316: tme_uint32_t usecs;
317: tme_uint32_t ticks;
318:
319: /* recover our sun4: */
320: sun4 = (struct tme_sun4 *) _sun4;
321:
322: /* this must be a full 32-bit register access: */
323: if ((cycle_init->tme_bus_cycle_address % sizeof(tme_uint32_t)) != 0
324: || cycle_init->tme_bus_cycle_size != sizeof(tme_uint32_t)) {
325: abort();
326: }
327:
328: /* get the timer and register accessed: */
329: if (TME_SUN4_IS_SUN44C(sun4)) {
330: timer_i = cycle_init->tme_bus_cycle_address / TME_SUN44C_TIMER_SIZ_REG;
331: reg = cycle_init->tme_bus_cycle_address & TME_SUN4_32_TIMER_SIZ_COUNTER;
332: }
333: else {
334: abort();
335: }
336: timer = &sun4->tme_sun4_timers[timer_i];
337:
338: /* lock our mutex: */
339: tme_mutex_lock(&sun4->tme_sun4_mutex);
340:
341: /* if this is a read: */
342: if (cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_READ) {
343:
344: /* dispatch on the register: */
345: switch (reg) {
346: default: assert(FALSE);
347: case TME_SUN4_32_TIMER_REG_COUNTER:
348:
349: /* update the timers: */
350: _tme_sun4_timer_update(timer, &now, &last_reset);
351:
352: /* get the time of the last reset: */
353: last_reset = timer->tme_sun4_timer_limit_next;
354: if (last_reset.tv_usec < timer->tme_sun4_timer_period.tv_usec) {
355: last_reset.tv_sec -= 1;
356: last_reset.tv_usec += 1000000;
357: }
358: last_reset.tv_sec -= timer->tme_sun4_timer_period.tv_sec;
359: last_reset.tv_usec -= timer->tme_sun4_timer_period.tv_usec;
360:
361: /* get the number of microseconds since the last reset: */
362: usecs = now.tv_sec - last_reset.tv_sec;
363: usecs *= 1000000;
364: usecs
365: += (((tme_int32_t) now.tv_usec)
366: - ((tme_int32_t) last_reset.tv_usec));
367:
368: /* to keep things simpler, we always use the sun4m 500ns tick: */
369: counter_one = TME_SUN4_IS_SUN44C(sun4) ? 2 : 1;
370:
371: /* convert the number of microseconds until this timer resets again,
372: to the 500ns tick counter value for the timer. NB that we
373: account for the fact that timers count from [1..limit), and not
374: [0..limit): */
375: ticks = (usecs * 2) + counter_one;
376: TME_FIELD_MASK_DEPOSITU(timer->tme_sun4_timer_counter,
377: TME_SUN4M_TIMER_MASK,
378: ticks);
379:
380: /* read this timer's counter register: */
381: value32 = timer->tme_sun4_timer_counter;
382: break;
383:
384: case TME_SUN4_32_TIMER_REG_LIMIT:
385:
386: /* read this timer's limit register: */
387: value32 = timer->tme_sun4_timer_limit;
388:
389: /* a read of the limit register is used to acknowledge an
390: interrupt, which probably means clearing the limit bit on the
391: counter register: */
392: timer->tme_sun4_timer_counter = 0;
393: timer->tme_sun4_timer_limit &= ~TME_SUN4_32_TIMER_LIMIT;
394: break;
395: }
396:
397: tme_log(TME_SUN4_LOG_HANDLE(sun4), 2000, TME_OK,
398: (TME_SUN4_LOG_HANDLE(sun4),
399: _("timer #%d %s -> 0x%08x"),
400: timer_i,
401: (reg == TME_SUN4_32_TIMER_REG_COUNTER
402: ? "counter"
403: : "limit"),
404: value32));
405:
406: /* byteswap the register value: */
407: value32 = tme_htobe_u32(value32);
408: }
409:
410: /* run the bus cycle: */
411: cycle_resp.tme_bus_cycle_buffer = (tme_uint8_t *) &value32;
412: cycle_resp.tme_bus_cycle_buffer_increment = 1;
413: cycle_resp.tme_bus_cycle_lane_routing = cycle_init->tme_bus_cycle_lane_routing;
414: cycle_resp.tme_bus_cycle_address = 0;
415: cycle_resp.tme_bus_cycle_type = (cycle_init->tme_bus_cycle_type
416: ^ (TME_BUS_CYCLE_WRITE
417: | TME_BUS_CYCLE_READ));
418: cycle_resp.tme_bus_cycle_port = TME_BUS_CYCLE_PORT(0, TME_BUS32_LOG2);
419: tme_bus_cycle_xfer(cycle_init, &cycle_resp);
420:
421: /* if this is a write: */
422: if (cycle_init->tme_bus_cycle_type == TME_BUS_CYCLE_WRITE) {
423:
424: /* byteswap the register value: */
425: value32 = tme_htobe_u32(value32);
426:
427: tme_log(TME_SUN4_LOG_HANDLE(sun4), 2000, TME_OK,
428: (TME_SUN4_LOG_HANDLE(sun4),
429: _("timer #%d %s <- 0x%08x"),
430: timer_i,
431: (reg == TME_SUN4_32_TIMER_REG_COUNTER
432: ? "counter"
433: : "limit"),
434: value32));
435:
436: /* dispatch on the register: */
437: switch (reg) {
438: default: assert(FALSE);
439: case TME_SUN4_32_TIMER_REG_COUNTER:
440: abort();
441:
442: case TME_SUN4_32_TIMER_REG_LIMIT:
443:
444: /* write the timer's limit register: */
445: timer->tme_sun4_timer_limit = value32;
446:
447: /* reset this timer: */
448: _tme_sun4_timer_reset(timer);
449:
450: /* wake up the thread for this timer: */
451: tme_cond_notify(&timer->tme_sun4_timer_cond, FALSE);
452: break;
453: }
454: }
455:
456: /* make any callouts: */
457: _tme_sun4_timer_callout(sun4);
458:
459: /* unlock the mutex: */
460: tme_mutex_unlock(&sun4->tme_sun4_mutex);
461:
462: /* no faults: */
463: return (TME_OK);
464: }
465:
466: /* this creates the sun4 timers: */
467: void
468: _tme_sun4_timer_new(struct tme_sun4 *sun4)
469: {
470: struct tme_sun4_timer *timer;
471:
472: /* loop over the timers: */
473: timer = &sun4->tme_sun4_timers[0];
474: do {
475:
476: /* initialize and reset the timer: */
477: timer->tme_sun4_timer_sun4 = sun4;
478: tme_cond_init(&timer->tme_sun4_timer_cond);
479: _tme_sun4_timer_reset(timer);
480:
481: /* start the thread for this timer: */
482: tme_thread_create((tme_thread_t) _tme_sun4_timer_th, timer);
483:
484: } while (++timer != (&sun4->tme_sun4_timers[0] + TME_ARRAY_ELS(sun4->tme_sun4_timers)));
485: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.