osfmk/arm/arm_timer.c

   1 /*
   2  * Copyright (c) 2007 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_COPYRIGHT@
  30  */
  31 /*
  32  * @APPLE_FREE_COPYRIGHT@
  33  */
  34 /*
  35  *      File:           etimer.c
  36  *      Purpose:        Routines for handling the machine independent
  37  *                              event timer.
  38  */
  39
  40 #include <mach/mach_types.h>
  41
  42 #include <kern/clock.h>
  43 #include <kern/thread.h>
  44 #include <kern/processor.h>
  45 #include <kern/macro_help.h>
  46 #include <kern/spl.h>
  47 #include <kern/timer_queue.h>
  48 #include <kern/timer_call.h>
  49
  50 #include <machine/commpage.h>
  51 #include <machine/machine_routines.h>
  52
  53 #include <sys/kdebug.h>
  54 #include <arm/cpu_data.h>
  55 #include <arm/cpu_data_internal.h>
  56 #include <arm/cpu_internal.h>
  57
  58 /*
  59  *      Event timer interrupt.
  60  *
  61  * XXX a drawback of this implementation is that events serviced earlier must not set deadlines
  62  *     that occur before the entire chain completes.
  63  *
  64  * XXX a better implementation would use a set of generic callouts and iterate over them
  65  */
  66 void
  67 timer_intr(__unused int inuser, __unused uint64_t iaddr)
  68 {
  69         uint64_t        abstime, new_idle_timeout_ticks;
  70         rtclock_timer_t *mytimer;
  71         cpu_data_t     *cpu_data_ptr;
  72         processor_t     processor;
  73
  74         cpu_data_ptr = getCpuDatap();
  75         mytimer = &cpu_data_ptr->rtclock_timer; /* Point to the event timer */
  76         abstime = mach_absolute_time(); /* Get the time now */
  77
  78         /* is it time for an idle timer event? */
  79         if ((cpu_data_ptr->idle_timer_deadline > 0) && (cpu_data_ptr->idle_timer_deadline <= abstime)) {
  80                 cpu_data_ptr->idle_timer_deadline = 0x0ULL;
  81                 new_idle_timeout_ticks = 0x0ULL;
  82
  83                 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_COMMON, MACHDBG_CODE(DBG_MACH_EXCP_DECI, 3) | DBG_FUNC_START, 0, 0, 0, 0, 0);
  84                 cpu_data_ptr->idle_timer_notify(cpu_data_ptr->idle_timer_refcon, &new_idle_timeout_ticks);
  85                 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_COMMON, MACHDBG_CODE(DBG_MACH_EXCP_DECI, 3) | DBG_FUNC_END, 0, 0, 0, 0, 0);
  86
  87                 /* if a new idle timeout was requested set the new idle timer deadline */
  88                 if (new_idle_timeout_ticks != 0x0ULL) {
  89                         clock_absolutetime_interval_to_deadline(new_idle_timeout_ticks, &cpu_data_ptr->idle_timer_deadline);
  90                 }
  91
  92                 abstime = mach_absolute_time(); /* Get the time again since we ran a bit */
  93         }
  94
  95         /* has a pending clock timer expired? */
  96         if (mytimer->deadline <= abstime) {     /* Have we expired the
  97                                                  * deadline? */
  98                 mytimer->has_expired = TRUE;    /* Remember that we popped */
  99                 mytimer->deadline = EndOfAllTime;       /* Set timer request to
 100                                                          * the end of all time
 101                                                          * in case we have no
 102                                                          * more events */
 103                 mytimer->deadline = timer_queue_expire(&mytimer->queue, abstime);
 104                 mytimer->has_expired = FALSE;
 105                 abstime = mach_absolute_time(); /* Get the time again since we ran a bit */
 106         }
 107
 108         processor = PERCPU_GET_RELATIVE(processor, cpu_data, cpu_data_ptr);
 109         (void)running_timers_expire(processor, abstime);
 110         /*
 111          * No need to update abstime.
 112          */
 113
 114         /* Force reload our next deadline */
 115         cpu_data_ptr->rtcPop = EndOfAllTime;
 116         /* schedule our next deadline */
 117         timer_resync_deadlines();
 118 }
 119
 120 /*
 121  * Set the clock deadline
 122  */
 123 void
 124 timer_set_deadline(uint64_t deadline)
 125 {
 126         rtclock_timer_t *mytimer;
 127         spl_t           s;
 128         cpu_data_t     *cpu_data_ptr;
 129
 130         s = splclock();         /* no interruptions */
 131         cpu_data_ptr = getCpuDatap();
 132
 133         mytimer = &cpu_data_ptr->rtclock_timer; /* Point to the timer itself */
 134         mytimer->deadline = deadline;   /* Set the new expiration time */
 135
 136         timer_resync_deadlines();
 137
 138         splx(s);
 139 }
 140
 141 /*
 142  * Re-evaluate the outstanding deadlines and select the most proximate.
 143  *
 144  * Should be called at splclock.
 145  */
 146 void
 147 timer_resync_deadlines(void)
 148 {
 149         uint64_t        deadline;
 150         rtclock_timer_t *mytimer;
 151         spl_t           s = splclock(); /* No interruptions please */
 152         cpu_data_t     *cpu_data_ptr;
 153
 154         cpu_data_ptr = getCpuDatap();
 155
 156         deadline = 0;
 157
 158         /* if we have a clock timer set sooner, pop on that */
 159         mytimer = &cpu_data_ptr->rtclock_timer; /* Point to the timer itself */
 160         if ((!mytimer->has_expired) && (mytimer->deadline > 0)) {
 161                 deadline = mytimer->deadline;
 162         }
 163
 164         /* if we have a idle timer event coming up, how about that? */
 165         if ((cpu_data_ptr->idle_timer_deadline > 0)
 166             && (cpu_data_ptr->idle_timer_deadline < deadline)) {
 167                 deadline = cpu_data_ptr->idle_timer_deadline;
 168         }
 169
 170         uint64_t run_deadline = running_timers_deadline(
 171                 PERCPU_GET_RELATIVE(processor, cpu_data, cpu_data_ptr));
 172         if (run_deadline < deadline) {
 173                 deadline = run_deadline;
 174         }
 175
 176         if ((deadline == EndOfAllTime)
 177             || ((deadline > 0) && (cpu_data_ptr->rtcPop != deadline))) {
 178                 int             decr;
 179
 180                 decr = setPop(deadline);
 181
 182                 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE,
 183                     MACHDBG_CODE(DBG_MACH_EXCP_DECI, 1) | DBG_FUNC_NONE,
 184                     decr, 2, 0, 0, 0);
 185         }
 186         splx(s);
 187 }
 188
 189 void
 190 timer_queue_expire_local(
 191         __unused void                   *arg)
 192 {
 193         rtclock_timer_t         *mytimer = &getCpuDatap()->rtclock_timer;
 194         uint64_t                abstime;
 195
 196         abstime = mach_absolute_time();
 197         mytimer->has_expired = TRUE;
 198         mytimer->deadline = timer_queue_expire(&mytimer->queue, abstime);
 199         mytimer->has_expired = FALSE;
 200
 201         timer_resync_deadlines();
 202 }
 203
 204 boolean_t
 205 timer_resort_threshold(__unused uint64_t skew)
 206 {
 207         return FALSE;
 208 }
 209
 210 mpqueue_head_t *
 211 timer_queue_assign(
 212         uint64_t                deadline)
 213 {
 214         cpu_data_t                              *cpu_data_ptr = getCpuDatap();
 215         mpqueue_head_t          *queue;
 216
 217         if (cpu_data_ptr->cpu_running) {
 218                 queue = &cpu_data_ptr->rtclock_timer.queue;
 219
 220                 if (deadline < cpu_data_ptr->rtclock_timer.deadline) {
 221                         timer_set_deadline(deadline);
 222                 }
 223         } else {
 224                 queue = &cpu_datap(master_cpu)->rtclock_timer.queue;
 225         }
 226
 227         return queue;
 228 }
 229
 230 void
 231 timer_queue_cancel(
 232         mpqueue_head_t          *queue,
 233         uint64_t                deadline,
 234         uint64_t                new_deadline)
 235 {
 236         if (queue == &getCpuDatap()->rtclock_timer.queue) {
 237                 if (deadline < new_deadline) {
 238                         timer_set_deadline(new_deadline);
 239                 }
 240         }
 241 }
 242
 243 mpqueue_head_t *
 244 timer_queue_cpu(int cpu)
 245 {
 246         return &cpu_datap(cpu)->rtclock_timer.queue;
 247 }
 248
 249 void
 250 timer_call_cpu(int cpu, void (*fn)(void *), void *arg)
 251 {
 252         cpu_signal(cpu_datap(cpu), SIGPxcall, (void *) fn, arg);
 253 }
 254
 255 void
 256 timer_call_nosync_cpu(int cpu, void (*fn)(void *), void *arg)
 257 {
 258         /* XXX Needs error checking and retry */
 259         cpu_signal(cpu_datap(cpu), SIGPxcall, (void *) fn, arg);
 260 }
 261
 262
 263 static timer_coalescing_priority_params_ns_t tcoal_prio_params_init =
 264 {
 265         .idle_entry_timer_processing_hdeadline_threshold_ns = 5000ULL * NSEC_PER_USEC,
 266         .interrupt_timer_coalescing_ilat_threshold_ns = 30ULL * NSEC_PER_USEC,
 267         .timer_resort_threshold_ns = 50 * NSEC_PER_MSEC,
 268         .timer_coalesce_rt_shift = 0,
 269         .timer_coalesce_bg_shift = -5,
 270         .timer_coalesce_kt_shift = 3,
 271         .timer_coalesce_fp_shift = 3,
 272         .timer_coalesce_ts_shift = 3,
 273         .timer_coalesce_rt_ns_max = 0ULL,
 274         .timer_coalesce_bg_ns_max = 100 * NSEC_PER_MSEC,
 275         .timer_coalesce_kt_ns_max = 1 * NSEC_PER_MSEC,
 276         .timer_coalesce_fp_ns_max = 1 * NSEC_PER_MSEC,
 277         .timer_coalesce_ts_ns_max = 1 * NSEC_PER_MSEC,
 278 #if XNU_TARGET_OS_OSX
 279         .latency_qos_scale = {3, 2, 1, -2, 3, 3},
 280         .latency_qos_ns_max = {1 * NSEC_PER_MSEC, 5 * NSEC_PER_MSEC, 20 * NSEC_PER_MSEC,
 281                                75 * NSEC_PER_MSEC, 1 * NSEC_PER_MSEC, 1 * NSEC_PER_MSEC},
 282         .latency_tier_rate_limited = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
 283 #else /* XNU_TARGET_OS_OSX */
 284         .latency_qos_scale = {3, 2, 1, -2, -15, -15},
 285         .latency_qos_ns_max = {1 * NSEC_PER_MSEC, 5 * NSEC_PER_MSEC, 20 * NSEC_PER_MSEC,
 286                                75 * NSEC_PER_MSEC, 10000 * NSEC_PER_MSEC, 10000 * NSEC_PER_MSEC},
 287         .latency_tier_rate_limited = {FALSE, FALSE, FALSE, FALSE, TRUE, TRUE},
 288 #endif /* XNU_TARGET_OS_OSX */
 289 };
 290 timer_coalescing_priority_params_ns_t *
 291 timer_call_get_priority_params(void)
 292 {
 293         return &tcoal_prio_params_init;
 294 }