sys/platform/vkernel/platform/systimer.c

   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  * $DragonFly: src/sys/platform/vkernel/platform/systimer.c,v 1.8 2007/01/14 20:07:15 dillon Exp $
  35  */
  36
  37 #include <sys/types.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/systimer.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/signal.h>
  43 #include <sys/interrupt.h>
  44 #include <sys/bus.h>
  45 #include <sys/time.h>
  46 #include <machine/cpu.h>
  47 #include <machine/globaldata.h>
  48 #include <machine/md_var.h>
  49
  50 #include <sys/thread2.h>
  51
  52 #include <unistd.h>
  53 #include <signal.h>
  54
  55 int disable_rtc_set;
  56 SYSCTL_INT(_machdep, CPU_DISRTCSET, disable_rtc_set,
  57            CTLFLAG_RW, &disable_rtc_set, 0, "");
  58
  59 int adjkerntz;
  60 int wall_cmos_clock = 0;
  61
  62 /*
  63  * SYSTIMER IMPLEMENTATION
  64  */
  65 static sysclock_t vkernel_timer_get_timecount(void);
  66 static void vkernel_timer_construct(struct cputimer *timer, sysclock_t oclock);
  67 /*static void cputimer_intr_hard(int signo);*/
  68 static void cputimer_intr(void *dummy, void *frame);
  69
  70 static struct cputimer vkernel_cputimer = {
  71         SLIST_ENTRY_INITIALIZER,
  72         "VKERNEL",
  73         CPUTIMER_PRI_VKERNEL,
  74         CPUTIMER_VKERNEL,
  75         vkernel_timer_get_timecount,
  76         cputimer_default_fromhz,
  77         cputimer_default_fromus,
  78         vkernel_timer_construct,
  79         cputimer_default_destruct,
  80         1000000,                        /* 1us granularity */
  81         0, 0, 0
  82 };
  83
  84 /*
  85  * Initialize the systimer subsystem, called from MI code in early boot.
  86  */
  87 void
  88 cpu_initclocks(void)
  89 {
  90         kprintf("initclocks\n");
  91         cputimer_register(&vkernel_cputimer);
  92         cputimer_select(&vkernel_cputimer, 0);
  93 }
  94
  95 /*
  96  * Constructor to initialize timer->base and get an initial count.
  97  */
  98 static void
  99 vkernel_timer_construct(struct cputimer *timer, sysclock_t oclock)
 100 {
 101         timer->base = 0;
 102         timer->base = oclock - vkernel_timer_get_timecount();
 103 }
 104
 105 /*
 106  * Get the current counter, with 2's complement rollover.
 107  */
 108 static sysclock_t
 109 vkernel_timer_get_timecount(void)
 110 {
 111         static sysclock_t vkernel_last_counter;
 112         struct timeval tv;
 113         sysclock_t counter;
 114
 115         /* XXX NO PROTECTION FROM INTERRUPT */
 116         gettimeofday(&tv, NULL);
 117         counter = (sysclock_t)tv.tv_usec;
 118         if (counter < vkernel_last_counter)
 119                 vkernel_cputimer.base += 1000000;
 120         vkernel_last_counter = counter;
 121         counter += vkernel_cputimer.base;
 122         return(counter);
 123 }
 124
 125 /*
 126  * Configure the interrupt for our core systimer
 127  */
 128 void
 129 cputimer_intr_config(struct cputimer *timer)
 130 {
 131         struct sigaction sa;
 132
 133         kprintf("cputimer_intr_config\n");
 134         bzero(&sa, sizeof(sa));
 135         sa.sa_mailbox = &mdcpu->gd_mailbox;
 136         sa.sa_flags = SA_MAILBOX;
 137         sigemptyset(&sa.sa_mask);
 138         sigaddset(&sa.sa_mask, SIGIO);
 139         sigaction(SIGALRM, &sa, NULL);
 140         register_int(0, cputimer_intr, NULL, "timer",
 141                      NULL, INTR_FAST|INTR_MPSAFE);
 142 }
 143
 144 /*
 145  * Reload the interrupt for our core systimer.
 146  */
 147 void
 148 cputimer_intr_reload(sysclock_t reload)
 149 {
 150         struct itimerval it;
 151
 152         it.it_interval.tv_usec = 0;
 153         it.it_interval.tv_sec = 0;
 154         it.it_value.tv_usec = reload;
 155         it.it_value.tv_sec = 0;
 156
 157         setitimer(ITIMER_REAL, &it, NULL);
 158 }
 159
 160 void
 161 signalmailbox(struct intrframe *frame)
 162 {
 163         struct mdglobaldata *gd = mdcpu;
 164
 165         if (gd->gd_mailbox) {
 166                 gd->gd_mailbox = 0;
 167                 crit_enter();
 168                 cputimer_intr(NULL, frame);
 169                 crit_exit();
 170         }
 171 }
 172
 173 #if 0
 174 /*
 175  * Clock interrupt (SIGALRM)
 176  *
 177  * Upon a clock interrupt, dispatch to the systimer subsystem
 178  *
 179  * XXX NO FRAME PROVIDED
 180  */
 181 static
 182 void
 183 cputimer_intr_hard(int signo)
 184 {
 185         struct mdglobaldata *gd = mdcpu;
 186
 187         /*
 188          * XXX check critical section hack
 189          */
 190         if (curthread->td_pri >= TDPRI_CRIT) {
 191                 atomic_set_int(&gd->gd_fpending, 1);
 192                 atomic_set_int(&gd->mi.gd_reqflags, RQF_INTPEND);
 193         } else {
 194                 crit_enter();
 195                 cputimer_intr(NULL, NULL);
 196                 crit_exit();
 197         }
 198 }
 199
 200 #endif
 201
 202 /*
 203  * clock interrupt.
 204  *
 205  * NOTE: frame is a struct intrframe pointer.
 206  */
 207 static
 208 void
 209 cputimer_intr(void *dummy, void *frame)
 210 {
 211         static sysclock_t sysclock_count;
 212         struct globaldata *gd = mycpu;
 213 #ifdef SMP
 214         struct globaldata *gscan;
 215         int n;
 216 #endif
 217         sysclock_count = sys_cputimer->count();
 218 #ifdef SMP
 219         for (n = 0; n < ncpus; ++n) {
 220                 gscan = globaldata_find(n);
 221                 if (TAILQ_FIRST(&gscan->gd_systimerq) == NULL)
 222                         continue;
 223                 if (gscan != gd) {
 224                         lwkt_send_ipiq3(gscan, (ipifunc3_t)systimer_intr,
 225                                         &sysclock_count, 0);
 226                 } else {
 227                         systimer_intr(&sysclock_count, 0, frame);
 228                 }
 229         }
 230 #else
 231         if (TAILQ_FIRST(&gd->gd_systimerq) != NULL)
 232                 systimer_intr(&sysclock_count, 0, frame);
 233 #endif
 234 }
 235
 236 /*
 237  * Initialize the time of day register, based on the time base which is, e.g.
 238  * from a filesystem.
 239  */
 240 void
 241 inittodr(time_t base)
 242 {
 243         struct timespec ts;
 244         struct timeval tv;
 245
 246         gettimeofday(&tv, NULL);
 247         ts.tv_sec = tv.tv_sec;
 248         ts.tv_nsec = tv.tv_usec * 1000;
 249         set_timeofday(&ts);
 250 }
 251
 252 /*
 253  * Write system time back to the RTC
 254  */
 255 void
 256 resettodr(void)
 257 {
 258 }
 259
 260 void
 261 DELAY(int usec)
 262 {
 263         usleep(usec);
 264 }
 265
 266