| 1 | /* |
| 2 | * Copyright (c) 2006 The DragonFly Project. All rights reserved. |
| 3 | * |
| 4 | * This code is derived from software contributed to The DragonFly Project |
| 5 | * by Matthew Dillon <dillon@backplane.com> |
| 6 | * |
| 7 | * Redistribution and use in source and binary forms, with or without |
| 8 | * modification, are permitted provided that the following conditions |
| 9 | * are met: |
| 10 | * |
| 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 |
| 16 | * distribution. |
| 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. |
| 20 | * |
| 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 |
| 32 | * SUCH DAMAGE. |
| 33 | */ |
| 34 | |
| 35 | #include <sys/types.h> |
| 36 | #include <sys/systm.h> |
| 37 | #include <sys/kernel.h> |
| 38 | #include <sys/systimer.h> |
| 39 | #include <sys/sysctl.h> |
| 40 | #include <sys/signal.h> |
| 41 | #include <sys/interrupt.h> |
| 42 | #include <sys/bus.h> |
| 43 | #include <sys/time.h> |
| 44 | #include <machine/cpu.h> |
| 45 | #include <machine/clock.h> |
| 46 | #include <machine/globaldata.h> |
| 47 | #include <machine/md_var.h> |
| 48 | |
| 49 | #include <sys/thread2.h> |
| 50 | |
| 51 | #include <unistd.h> |
| 52 | #include <signal.h> |
| 53 | |
| 54 | #define VKTIMER_FREQ 1000000 /* 1us granularity */ |
| 55 | |
| 56 | static void vktimer_intr(void *dummy, struct intrframe *frame); |
| 57 | |
| 58 | int disable_rtc_set; |
| 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_QUAD(_hw, OID_AUTO, tsc_frequency, CTLFLAG_RD, |
| 64 | &tsc_frequency, 0, "TSC Frequency"); |
| 65 | |
| 66 | int adjkerntz; |
| 67 | int wall_cmos_clock = 0; |
| 68 | SYSCTL_INT(_machdep, CPU_WALLCLOCK, wall_cmos_clock, |
| 69 | CTLFLAG_RD, &wall_cmos_clock, 0, ""); |
| 70 | |
| 71 | static struct kqueue_info *kqueue_timer_info; |
| 72 | |
| 73 | static int cputimer_mib[16]; |
| 74 | static int cputimer_miblen; |
| 75 | |
| 76 | /* |
| 77 | * SYSTIMER IMPLEMENTATION |
| 78 | */ |
| 79 | static sysclock_t vkernel_timer_get_timecount(void); |
| 80 | static void vkernel_timer_construct(struct cputimer *timer, sysclock_t oclock); |
| 81 | |
| 82 | static struct cputimer vkernel_cputimer = { |
| 83 | SLIST_ENTRY_INITIALIZER, |
| 84 | "VKERNEL", |
| 85 | CPUTIMER_PRI_VKERNEL, |
| 86 | CPUTIMER_VKERNEL, |
| 87 | vkernel_timer_get_timecount, |
| 88 | cputimer_default_fromhz, |
| 89 | cputimer_default_fromus, |
| 90 | vkernel_timer_construct, |
| 91 | cputimer_default_destruct, |
| 92 | VKTIMER_FREQ, |
| 93 | 0, 0, 0 |
| 94 | }; |
| 95 | |
| 96 | static void vktimer_intr_reload(struct cputimer_intr *, sysclock_t); |
| 97 | static void vktimer_intr_initclock(struct cputimer_intr *, boolean_t); |
| 98 | |
| 99 | static struct cputimer_intr vkernel_cputimer_intr = { |
| 100 | .freq = VKTIMER_FREQ, |
| 101 | .reload = vktimer_intr_reload, |
| 102 | .enable = cputimer_intr_default_enable, |
| 103 | .config = cputimer_intr_default_config, |
| 104 | .restart = cputimer_intr_default_restart, |
| 105 | .pmfixup = cputimer_intr_default_pmfixup, |
| 106 | .initclock = vktimer_intr_initclock, |
| 107 | .next = SLIST_ENTRY_INITIALIZER, |
| 108 | .name = "vkernel", |
| 109 | .type = CPUTIMER_INTR_VKERNEL, |
| 110 | .prio = CPUTIMER_INTR_PRIO_VKERNEL, |
| 111 | .caps = CPUTIMER_INTR_CAP_NONE |
| 112 | }; |
| 113 | |
| 114 | /* |
| 115 | * Initialize the systimer subsystem, called from MI code in early boot. |
| 116 | */ |
| 117 | static void |
| 118 | cpu_initclocks(void *arg __unused) |
| 119 | { |
| 120 | int len; |
| 121 | |
| 122 | kprintf("initclocks\n"); |
| 123 | len = sizeof(vkernel_cputimer.freq); |
| 124 | if (sysctlbyname("kern.cputimer.freq", &vkernel_cputimer.freq, &len, |
| 125 | NULL, 0) < 0) { |
| 126 | panic("cpu_initclocks: can't get kern.cputimer.freq!"); |
| 127 | } |
| 128 | len = NELEM(cputimer_mib); |
| 129 | if (sysctlnametomib("kern.cputimer.clock", cputimer_mib, &len) < 0) |
| 130 | panic("cpu_initclocks: can't get kern.cputimer.clock!"); |
| 131 | cputimer_miblen = len; |
| 132 | |
| 133 | cputimer_intr_register(&vkernel_cputimer_intr); |
| 134 | cputimer_intr_select(&vkernel_cputimer_intr, 0); |
| 135 | |
| 136 | cputimer_register(&vkernel_cputimer); |
| 137 | cputimer_select(&vkernel_cputimer, 0); |
| 138 | } |
| 139 | SYSINIT(clocksvk, SI_BOOT2_CLOCKREG, SI_ORDER_FIRST, cpu_initclocks, NULL) |
| 140 | |
| 141 | /* |
| 142 | * Constructor to initialize timer->base and get an initial count. |
| 143 | */ |
| 144 | static void |
| 145 | vkernel_timer_construct(struct cputimer *timer, sysclock_t oclock) |
| 146 | { |
| 147 | timer->base = 0; |
| 148 | timer->base = oclock - vkernel_timer_get_timecount(); |
| 149 | } |
| 150 | |
| 151 | /* |
| 152 | * Get the current counter, with 2's complement rollover. |
| 153 | * |
| 154 | * NOTE! MPSAFE, possibly no critical section |
| 155 | */ |
| 156 | static sysclock_t |
| 157 | vkernel_timer_get_timecount(void) |
| 158 | { |
| 159 | sysclock_t counter; |
| 160 | size_t len; |
| 161 | |
| 162 | len = sizeof(counter); |
| 163 | if (sysctl(cputimer_mib, cputimer_miblen, &counter, &len, |
| 164 | NULL, 0) < 0) { |
| 165 | panic("vkernel_timer_get_timecount: sysctl failed!"); |
| 166 | } |
| 167 | return(counter); |
| 168 | } |
| 169 | |
| 170 | /* |
| 171 | * Initialize the interrupt for our core systimer. Use the kqueue timer |
| 172 | * support functions. |
| 173 | */ |
| 174 | static void |
| 175 | vktimer_intr_initclock(struct cputimer_intr *cti __unused, |
| 176 | boolean_t selected __unused) |
| 177 | { |
| 178 | KKASSERT(kqueue_timer_info == NULL); |
| 179 | kqueue_timer_info = kqueue_add_timer(vktimer_intr, NULL); |
| 180 | } |
| 181 | |
| 182 | /* |
| 183 | * Reload the interrupt for our core systimer. Because the caller's |
| 184 | * reload calculation can be negatively indexed, we need a minimal |
| 185 | * check to ensure that a reasonable reload value is selected. |
| 186 | */ |
| 187 | static void |
| 188 | vktimer_intr_reload(struct cputimer_intr *cti __unused, sysclock_t reload) |
| 189 | { |
| 190 | if (kqueue_timer_info) { |
| 191 | if ((int)reload < 1) |
| 192 | reload = 1; |
| 193 | kqueue_reload_timer(kqueue_timer_info, (reload + 999) / 1000); |
| 194 | } |
| 195 | } |
| 196 | |
| 197 | /* |
| 198 | * clock interrupt. |
| 199 | * |
| 200 | * NOTE: frame is a struct intrframe pointer. |
| 201 | */ |
| 202 | static void |
| 203 | vktimer_intr(void *dummy, struct intrframe *frame) |
| 204 | { |
| 205 | static sysclock_t sysclock_count; |
| 206 | struct globaldata *gd = mycpu; |
| 207 | struct globaldata *gscan; |
| 208 | int n; |
| 209 | |
| 210 | sysclock_count = sys_cputimer->count(); |
| 211 | for (n = 0; n < ncpus; ++n) { |
| 212 | gscan = globaldata_find(n); |
| 213 | if (TAILQ_FIRST(&gscan->gd_systimerq) == NULL) |
| 214 | continue; |
| 215 | if (gscan != gd) { |
| 216 | lwkt_send_ipiq3(gscan, (ipifunc3_t)systimer_intr, |
| 217 | &sysclock_count, 0); |
| 218 | } else { |
| 219 | systimer_intr(&sysclock_count, 0, frame); |
| 220 | } |
| 221 | } |
| 222 | } |
| 223 | |
| 224 | /* |
| 225 | * Initialize the time of day register, based on the time base which is, e.g. |
| 226 | * from a filesystem. |
| 227 | */ |
| 228 | void |
| 229 | inittodr(time_t base) |
| 230 | { |
| 231 | struct timespec ts; |
| 232 | struct timeval tv; |
| 233 | |
| 234 | gettimeofday(&tv, NULL); |
| 235 | ts.tv_sec = tv.tv_sec; |
| 236 | ts.tv_nsec = tv.tv_usec * 1000; |
| 237 | set_timeofday(&ts); |
| 238 | } |
| 239 | |
| 240 | /* |
| 241 | * Write system time back to the RTC |
| 242 | */ |
| 243 | void |
| 244 | resettodr(void) |
| 245 | { |
| 246 | } |
| 247 | |
| 248 | /* |
| 249 | * We need to enter a critical section to prevent signals from recursing |
| 250 | * into pthreads. |
| 251 | */ |
| 252 | void |
| 253 | DELAY(int usec) |
| 254 | { |
| 255 | crit_enter(); |
| 256 | usleep(usec); |
| 257 | crit_exit(); |
| 258 | } |
| 259 | |
| 260 | void |
| 261 | DRIVERSLEEP(int usec) |
| 262 | { |
| 263 | if (mycpu->gd_intr_nesting_level) |
| 264 | DELAY(usec); |
| 265 | else if (1000000 / usec >= hz) |
| 266 | tsleep(DRIVERSLEEP, 0, "DELAY", 1000000 / usec / hz + 1); |
| 267 | else |
| 268 | DELAY(usec); |
| 269 | } |
| 270 | |