2 * Copyright (c) 2006 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 #include <sys/types.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/systimer.h>
40 #include <sys/sysctl.h>
41 #include <sys/signal.h>
42 #include <sys/interrupt.h>
45 #include <machine/cpu.h>
46 #include <machine/clock.h>
47 #include <machine/globaldata.h>
48 #include <machine/md_var.h>
49 #include <machine/cothread.h>
51 #include <sys/thread2.h>
59 SYSCTL_INT(_machdep
, CPU_DISRTCSET
, disable_rtc_set
,
60 CTLFLAG_RW
, &disable_rtc_set
, 0, "");
61 SYSCTL_INT(_hw
, OID_AUTO
, tsc_present
, CTLFLAG_RD
,
62 &tsc_present
, 0, "TSC Available");
63 SYSCTL_INT(_hw
, OID_AUTO
, tsc_invariant
, CTLFLAG_RD
,
64 &tsc_invariant
, 0, "Invariant TSC");
65 SYSCTL_INT(_hw
, OID_AUTO
, tsc_mpsync
, CTLFLAG_RD
,
66 &tsc_mpsync
, 0, "TSC is synchronized across CPUs");
67 SYSCTL_QUAD(_hw
, OID_AUTO
, tsc_frequency
, CTLFLAG_RD
,
68 &tsc_frequency
, 0, "TSC Frequency");
71 int wall_cmos_clock
= 0;
72 SYSCTL_INT(_machdep
, CPU_WALLCLOCK
, wall_cmos_clock
,
73 CTLFLAG_RD
, &wall_cmos_clock
, 0, "");
75 static cothread_t vktimer_cotd
;
76 static int vktimer_running
;
77 static sysclock_t vktimer_target
;
78 static struct timespec vktimer_ts
;
79 static sysclock_t vktimer_reload
[MAXCPU
];
81 extern int use_precise_timer
;
84 * SYSTIMER IMPLEMENTATION
86 static sysclock_t
vkernel_timer_get_timecount(void);
87 static void vkernel_timer_construct(struct cputimer
*timer
, sysclock_t oclock
);
88 static void vktimer_thread(cothread_t cotd
);
90 static struct cputimer vkernel_cputimer
= {
91 .next
= SLIST_ENTRY_INITIALIZER
,
93 .pri
= CPUTIMER_PRI_VKERNEL
,
94 .type
= CPUTIMER_VKERNEL
,
95 .count
= vkernel_timer_get_timecount
,
96 .fromhz
= cputimer_default_fromhz
,
97 .fromus
= cputimer_default_fromus
,
98 .construct
= vkernel_timer_construct
,
99 .destruct
= cputimer_default_destruct
,
103 static void vktimer_intr_reload(struct cputimer_intr
*, sysclock_t
);
104 static void vktimer_intr_initclock(struct cputimer_intr
*, boolean_t
);
106 static struct cputimer_intr vkernel_cputimer_intr
= {
108 .reload
= vktimer_intr_reload
,
109 .enable
= cputimer_intr_default_enable
,
110 .config
= cputimer_intr_default_config
,
111 .restart
= cputimer_intr_default_restart
,
112 .pmfixup
= cputimer_intr_default_pmfixup
,
113 .initclock
= vktimer_intr_initclock
,
115 .next
= SLIST_ENTRY_INITIALIZER
,
117 .type
= CPUTIMER_INTR_VKERNEL
,
118 .prio
= CPUTIMER_INTR_PRIO_VKERNEL
,
119 .caps
= CPUTIMER_INTR_CAP_NONE
,
124 * Initialize the systimer subsystem, called from MI code in early boot.
127 cpu_initclocks(void *arg __unused
)
129 kprintf("initclocks\n");
130 cputimer_intr_register(&vkernel_cputimer_intr
);
131 cputimer_intr_select(&vkernel_cputimer_intr
, 0);
133 cputimer_register(&vkernel_cputimer
);
134 cputimer_select(&vkernel_cputimer
, 0);
136 SYSINIT(clocksvk
, SI_BOOT2_CLOCKREG
, SI_ORDER_FIRST
, cpu_initclocks
, NULL
);
139 * Constructor to initialize timer->base and get an initial count.
142 vkernel_timer_construct(struct cputimer
*timer
, sysclock_t oclock
)
145 timer
->base
= oclock
- vkernel_timer_get_timecount();
149 * Get the current counter, with 2's complement rollover.
151 * NOTE! MPSAFE, possibly no critical section
154 vkernel_timer_get_timecount(void)
159 if (use_precise_timer
)
160 clock_gettime(CLOCK_MONOTONIC_PRECISE
, &ts
);
162 clock_gettime(CLOCK_MONOTONIC_FAST
, &ts
);
163 count
= ts
.tv_nsec
/ 1000;
164 count
+= ts
.tv_sec
* 1000000;
170 * Initialize the interrupt for our core systimer. Use the kqueue timer
174 vktimer_intr_initclock(struct cputimer_intr
*cti __unused
,
175 boolean_t selected __unused
)
177 vktimer_target
= vkernel_timer_get_timecount();
179 vktimer_ts
.tv_nsec
= 1000000000 / 20;
180 vktimer_cotd
= cothread_create(vktimer_thread
, NULL
, NULL
, "vktimer");
181 while (vktimer_running
== 0)
182 usleep(1000000 / 10);
184 KKASSERT(kqueue_timer_info
== NULL
);
185 kqueue_timer_info
= kqueue_add_timer(vktimer_intr
, NULL
);
193 vktimer_sigint(int signo
)
195 /* do nothing, just interrupt */
199 vktimer_gettick_us(void)
201 struct clockinfo info
;
202 int mib
[] = { CTL_KERN
, KERN_CLOCKRATE
};
203 size_t len
= sizeof(info
);
205 if (sysctl(mib
, NELEM(mib
), &info
, &len
, NULL
, 0) != 0 ||
206 len
!= sizeof(info
)) {
207 /* Assume 10 milliseconds (== 100hz) */
208 return 1000000 / 100;
209 } else if (info
.tick
< 999999) {
212 /* Assume 10 milliseconds (== 100hz) */
213 return 1000000 / 100;
218 vktimer_thread(cothread_t cotd
)
222 sysclock_t ticklength_us
;
224 bzero(&sa
, sizeof(sa
));
225 sa
.sa_handler
= vktimer_sigint
;
226 sa
.sa_flags
|= SA_NODEFER
;
227 sigemptyset(&sa
.sa_mask
);
228 sigaction(SIGINT
, &sa
, NULL
);
230 ticklength_us
= vktimer_gettick_us();
232 while (vktimer_cotd
== NULL
)
233 usleep(1000000 / 10);
244 cothread_sleep(cotd
, &vktimer_ts
);
247 curtime
= vkernel_timer_get_timecount();
253 for (n
= 0; n
< ncpus
; ++n
) {
254 gscan
= globaldata_find(n
);
255 delta
= vktimer_reload
[n
] - curtime
;
256 if (delta
<= 0 && TAILQ_FIRST(&gscan
->gd_systimerq
))
257 pthread_kill(ap_tids
[n
], SIGURG
);
258 if (delta
> 0 && reload
> delta
)
262 vktimer_target
= reload
;
268 for (n
= 0; n
< ncpus
; ++n
) {
269 gscan
= globaldata_find(n
);
270 delta
= vktimer_reload
[n
] - curtime
;
271 if (delta
> 0 && reload
> delta
)
274 if (!use_precise_timer
&& reload
< ticklength_us
/ 10) {
276 * Avoid pointless short sleeps, when we only measure
277 * the current time at tick precision.
279 reload
= ticklength_us
/ 10;
281 vktimer_ts
.tv_nsec
= reload
* 1000;
286 * Reload the interrupt for our core systimer. Because the caller's
287 * reload calculation can be negatively indexed, we need a minimal
288 * check to ensure that a reasonable reload value is selected.
291 vktimer_intr_reload(struct cputimer_intr
*cti __unused
, sysclock_t reload
)
293 if (reload
>= 1000000) /* uS */
295 reload
+= vkernel_timer_get_timecount();
296 vktimer_reload
[mycpu
->gd_cpuid
] = reload
;
297 if (vktimer_cotd
&& (ssysclock_t
)(reload
- vktimer_target
) < 0) {
298 while ((sysclock_t
)(reload
- vktimer_target
) < 0)
299 reload
= atomic_swap_int(&vktimer_target
, reload
);
300 cothread_wakeup(vktimer_cotd
, &vktimer_ts
);
305 * pcpu clock interrupt (hard interrupt)
308 vktimer_intr(struct intrframe
*frame
)
310 struct globaldata
*gd
= mycpu
;
311 sysclock_t sysclock_count
;
313 sysclock_count
= sys_cputimer
->count();
314 ++gd
->gd_cnt
.v_timer
;
315 systimer_intr(&sysclock_count
, 0, frame
);
319 * Initialize the time of day register, based on the time base which is, e.g.
323 inittodr(time_t base
)
328 gettimeofday(&tv
, NULL
);
329 ts
.tv_sec
= tv
.tv_sec
;
330 ts
.tv_nsec
= tv
.tv_usec
* 1000;
335 * Write system time back to the RTC
343 * We need to enter a critical section to prevent signals from recursing
355 DRIVERSLEEP(int usec
)
357 if (mycpu
->gd_intr_nesting_level
)
359 else if (1000000 / usec
>= hz
)
360 tsleep(DRIVERSLEEP
, 0, "DELAY", 1000000 / usec
/ hz
+ 1);