1 /* 2 * Copyright (c) 2003,2004 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 /* 36 * WARNING! THE SYSTIMER MODULE DOES NOT OPERATE OR DISPATCH WITH THE 37 * MP LOCK HELD. ALL CODE USING THIS MODULE MUST BE MP-SAFE. 38 * 39 * This code implements a fine-grained per-cpu system timer which is 40 * ultimately based on a hardware timer. The hardware timer abstraction 41 * is sufficiently disconnected from this code to support both per-cpu 42 * hardware timers or a single system-wide hardware timer. 43 * 44 * WARNING! During early boot if a new system timer is selected, existing 45 * timeouts will not be effected and will thus occur slower or faster. 46 * periodic timers will be adjusted at the next periodic load. 47 * 48 * Notes on machine-dependant code (in arch/arch/systimer.c) 49 * 50 * cputimer_intr_reload() Reload the one-shot (per-cpu basis) 51 */ 52 53 #include <sys/param.h> 54 #include <sys/kernel.h> 55 #include <sys/systm.h> 56 #include <sys/thread.h> 57 #include <sys/globaldata.h> 58 #include <sys/systimer.h> 59 #include <sys/thread2.h> 60 61 /* 62 * Execute ready systimers. Called directly from the platform-specific 63 * one-shot timer clock interrupt (e.g. clkintr()) or via an IPI. May 64 * be called simultaniously on multiple cpus and always operations on 65 * the current cpu's queue. Systimer functions are responsible for calling 66 * hardclock, statclock, and other finely-timed routines. 67 */ 68 void 69 systimer_intr(sysclock_t *timep, int in_ipi, struct intrframe *frame) 70 { 71 globaldata_t gd = mycpu; 72 sysclock_t time = *timep; 73 systimer_t info; 74 75 if (gd->gd_syst_nest) 76 return; 77 78 crit_enter(); 79 ++gd->gd_syst_nest; 80 while ((info = TAILQ_FIRST(&gd->gd_systimerq)) != NULL) { 81 /* 82 * If we haven't reached the requested time, tell the cputimer 83 * how much is left and break out. 84 */ 85 if ((int)(info->time - time) > 0) { 86 cputimer_intr_reload(info->time - time); 87 break; 88 } 89 90 /* 91 * Dequeue and execute, detect a loss of the systimer. Note 92 * that the in-progress systimer pointer can only be used to 93 * detect a loss of the systimer, it is only useful within 94 * this code sequence and becomes stale otherwise. 95 */ 96 info->flags &= ~SYSTF_ONQUEUE; 97 TAILQ_REMOVE(info->queue, info, node); 98 gd->gd_systimer_inprog = info; 99 crit_exit(); 100 info->func(info, in_ipi, frame); 101 crit_enter(); 102 103 /* 104 * The caller may deleted or even re-queue the systimer itself 105 * with a delete/add sequence. If the caller does not mess with 106 * the systimer we will requeue the periodic interval automatically. 107 * 108 * If this is a non-queued periodic interrupt, do not allow multiple 109 * events to build up (used for things like the callout timer to 110 * prevent premature timeouts due to long interrupt disablements, 111 * BIOS 8254 glitching, and so forth). However, we still want to 112 * keep things synchronized between cpus for efficient handling of 113 * the timer interrupt so jump in multiples of the periodic rate. 114 */ 115 if (gd->gd_systimer_inprog == info && info->periodic) { 116 if (info->which != sys_cputimer) { 117 info->periodic = sys_cputimer->fromhz(info->freq); 118 info->which = sys_cputimer; 119 } 120 info->time += info->periodic; 121 if ((info->flags & SYSTF_NONQUEUED) && 122 (int)(info->time - time) <= 0 123 ) { 124 info->time += roundup(time - info->time, info->periodic); 125 } 126 systimer_add(info); 127 } 128 gd->gd_systimer_inprog = NULL; 129 } 130 --gd->gd_syst_nest; 131 crit_exit(); 132 } 133 134 void 135 systimer_intr_enable(void) 136 { 137 cputimer_intr_enable(); 138 } 139 140 /* 141 * MPSAFE 142 */ 143 void 144 systimer_add(systimer_t info) 145 { 146 struct globaldata *gd = mycpu; 147 148 KKASSERT((info->flags & SYSTF_ONQUEUE) == 0); 149 crit_enter(); 150 if (info->gd == gd) { 151 systimer_t scan1; 152 systimer_t scan2; 153 scan1 = TAILQ_FIRST(&gd->gd_systimerq); 154 if (scan1 == NULL || (int)(scan1->time - info->time) > 0) { 155 cputimer_intr_reload(info->time - sys_cputimer->count()); 156 TAILQ_INSERT_HEAD(&gd->gd_systimerq, info, node); 157 } else { 158 scan2 = TAILQ_LAST(&gd->gd_systimerq, systimerq); 159 for (;;) { 160 if (scan1 == NULL) { 161 TAILQ_INSERT_TAIL(&gd->gd_systimerq, info, node); 162 break; 163 } 164 if (info->flags & SYSTF_FIRST) { 165 /* 166 * When coincident events occur, the event being 167 * added wants to be placed before the others. 168 */ 169 if ((int)(scan1->time - info->time) >= 0) { 170 TAILQ_INSERT_BEFORE(scan1, info, node); 171 break; 172 } 173 if ((int)(scan2->time - info->time) < 0) { 174 TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, 175 info, node); 176 break; 177 } 178 } else { 179 /* 180 * When coincident events occur, the event being 181 * added should be placed after the others. This 182 * is the default. 183 */ 184 if ((int)(scan1->time - info->time) > 0) { 185 TAILQ_INSERT_BEFORE(scan1, info, node); 186 break; 187 } 188 if ((int)(scan2->time - info->time) <= 0) { 189 TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, 190 info, node); 191 break; 192 } 193 } 194 scan1 = TAILQ_NEXT(scan1, node); 195 scan2 = TAILQ_PREV(scan2, systimerq, node); 196 } 197 } 198 info->flags = (info->flags | SYSTF_ONQUEUE) & ~SYSTF_IPIRUNNING; 199 info->queue = &gd->gd_systimerq; 200 } else { 201 KKASSERT((info->flags & SYSTF_IPIRUNNING) == 0); 202 info->flags |= SYSTF_IPIRUNNING; 203 lwkt_send_ipiq(info->gd, (ipifunc1_t)systimer_add, info); 204 } 205 crit_exit(); 206 } 207 208 /* 209 * systimer_del() 210 * 211 * Delete a system timer. Only the owning cpu can delete a timer. 212 * 213 * MPSAFE 214 */ 215 void 216 systimer_del(systimer_t info) 217 { 218 struct globaldata *gd = info->gd; 219 220 KKASSERT(gd == mycpu && (info->flags & SYSTF_IPIRUNNING) == 0); 221 222 crit_enter(); 223 224 if (info->flags & SYSTF_ONQUEUE) { 225 TAILQ_REMOVE(info->queue, info, node); 226 info->flags &= ~SYSTF_ONQUEUE; 227 } 228 229 /* 230 * Deal with dispatch races by clearing the in-progress systimer 231 * pointer. Only a direct pointer comparison can be used, the 232 * actual contents of the structure gd_systimer_inprog points to, 233 * if not equal to info, may be stale. 234 */ 235 if (gd->gd_systimer_inprog == info) 236 gd->gd_systimer_inprog = NULL; 237 238 crit_exit(); 239 } 240 241 /* 242 * systimer_init_periodic*() 243 * 244 * Initialize a periodic timer at the specified frequency and add 245 * it to the system. The frequency is uncompensated and approximate. 246 * 247 * Try to synchronize multiple registrations of the same or similar 248 * frequencies so the hardware interrupt is able to dispatch several 249 * together. We do this by adjusting the phase of the initial timeout. 250 * This helps SMP. Note that we are not attempting to synchronize to 251 * the realtime clock. 252 * 253 * This synchronization is also depended upon for statclock, hardclock, 254 * and schedclock. 255 */ 256 static __inline 257 void 258 _systimer_init_periodic(systimer_t info, systimer_func_t func, void *data, 259 int freq, int flags) 260 { 261 sysclock_t base_count; 262 263 if (sys_cputimer->sync_base == 0) 264 sys_cputimer->sync_base = sys_cputimer->count(); 265 266 bzero(info, sizeof(struct systimer)); 267 268 if ((flags & SYSTF_100KHZSYNC) && freq <= 100000) 269 info->periodic = sys_cputimer->fromhz(100000) * (100000 / freq); 270 if ((flags & SYSTF_MSSYNC) && freq <= 1000) 271 info->periodic = sys_cputimer->fromhz(1000) * (1000 / freq); 272 else 273 info->periodic = sys_cputimer->fromhz(freq); 274 275 base_count = sys_cputimer->count(); 276 base_count = base_count - 277 (base_count - sys_cputimer->sync_base) % info->periodic; 278 info->time = base_count + info->periodic; 279 info->func = func; 280 info->data = data; 281 info->freq = freq; 282 info->which = sys_cputimer; 283 info->gd = mycpu; 284 info->flags |= flags; 285 systimer_add(info); 286 } 287 288 void 289 systimer_init_periodic(systimer_t info, systimer_func_t func, void *data, 290 int freq) 291 { 292 _systimer_init_periodic(info, func, data, freq, 0); 293 } 294 295 void 296 systimer_init_periodic_nq(systimer_t info, systimer_func_t func, void *data, 297 int freq) 298 { 299 _systimer_init_periodic(info, func, data, freq, SYSTF_NONQUEUED); 300 } 301 302 /* 303 * These provide systimers whos periods are in perfect multiples of 1ms 304 * or 0.1uS. This is used in situations where the caller wants to gang 305 * multiple systimers together whos periods may have some coincident events, 306 * in order for those coincident events to generate only one interrupt. 307 * 308 * This also allows the caller to make event ordering assumptions for 309 * said coincident events. 310 */ 311 void 312 systimer_init_periodic_nq1khz(systimer_t info, systimer_func_t func, 313 void *data, int freq) 314 { 315 _systimer_init_periodic(info, func, data, freq, 316 SYSTF_NONQUEUED | SYSTF_MSSYNC); 317 } 318 319 void 320 systimer_init_periodic_nq100khz(systimer_t info, systimer_func_t func, 321 void *data, int freq) 322 { 323 _systimer_init_periodic(info, func, data, freq, 324 SYSTF_NONQUEUED | SYSTF_100KHZSYNC); 325 } 326 327 void 328 systimer_init_periodic_flags(systimer_t info, systimer_func_t func, 329 void *data, int freq, int flags) 330 { 331 _systimer_init_periodic(info, func, data, freq, flags); 332 } 333 334 335 /* 336 * Adjust the periodic interval for a periodic timer which is already 337 * running. The current timeout is not effected. 338 */ 339 void 340 systimer_adjust_periodic(systimer_t info, int freq) 341 { 342 crit_enter(); 343 info->periodic = sys_cputimer->fromhz(freq); 344 info->freq = freq; 345 info->which = sys_cputimer; 346 crit_exit(); 347 } 348 349 /* 350 * systimer_init_oneshot() 351 * 352 * Initialize a periodic timer at the specified frequency and add 353 * it to the system. The frequency is uncompensated and approximate. 354 */ 355 void 356 systimer_init_oneshot(systimer_t info, systimer_func_t func, void *data, int us) 357 { 358 bzero(info, sizeof(struct systimer)); 359 info->time = sys_cputimer->count() + sys_cputimer->fromus(us); 360 info->func = func; 361 info->data = data; 362 info->which = sys_cputimer; 363 info->gd = mycpu; 364 systimer_add(info); 365 } 366