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 */
66void
67timer_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
73 cpu_data_ptr = getCpuDatap();
74 mytimer = &cpu_data_ptr->rtclock_timer; /* Point to the event timer */
75 abstime = mach_absolute_time(); /* Get the time now */
76
77 /* is it time for an idle timer event? */
78 if ((cpu_data_ptr->idle_timer_deadline > 0) && (cpu_data_ptr->idle_timer_deadline <= abstime)) {
79 cpu_data_ptr->idle_timer_deadline = 0x0ULL;
80 new_idle_timeout_ticks = 0x0ULL;
81
82 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_COMMON, MACHDBG_CODE(DBG_MACH_EXCP_DECI, 3) | DBG_FUNC_START, 0, 0, 0, 0, 0);
83 ((idle_timer_t)cpu_data_ptr->idle_timer_notify)(cpu_data_ptr->idle_timer_refcon, &new_idle_timeout_ticks);
84 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_COMMON, MACHDBG_CODE(DBG_MACH_EXCP_DECI, 3) | DBG_FUNC_END, 0, 0, 0, 0, 0);
85
86 /* if a new idle timeout was requested set the new idle timer deadline */
87 if (new_idle_timeout_ticks != 0x0ULL) {
88 clock_absolutetime_interval_to_deadline(new_idle_timeout_ticks, &cpu_data_ptr->idle_timer_deadline);
89 }
90
91 abstime = mach_absolute_time(); /* Get the time again since we ran a bit */
92 }
93
94 /* has a pending clock timer expired? */
95 if (mytimer->deadline <= abstime) { /* Have we expired the
96 * deadline? */
97 mytimer->has_expired = TRUE; /* Remember that we popped */
98 mytimer->deadline = EndOfAllTime; /* Set timer request to
99 * the end of all time
100 * in case we have no
101 * more events */
102 mytimer->deadline = timer_queue_expire(&mytimer->queue, abstime);
103 mytimer->has_expired = FALSE;
104 abstime = mach_absolute_time(); /* Get the time again since we ran a bit */
105 }
106
107 uint64_t quantum_deadline = cpu_data_ptr->quantum_timer_deadline;
108 /* is it the quantum timer expiration? */
109 if ((quantum_deadline <= abstime) && (quantum_deadline > 0)) {
110 cpu_data_ptr->quantum_timer_deadline = 0;
111 quantum_timer_expire(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 */
123void
124timer_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
141void
142quantum_timer_set_deadline(uint64_t deadline)
143{
144 cpu_data_t *cpu_data_ptr;
145
146 /* We should've only come into this path with interrupts disabled */
147 assert(ml_get_interrupts_enabled() == FALSE);
148
149 cpu_data_ptr = getCpuDatap();
150 cpu_data_ptr->quantum_timer_deadline = deadline;
151 timer_resync_deadlines();
152}
153
154/*
155 * Re-evaluate the outstanding deadlines and select the most proximate.
156 *
157 * Should be called at splclock.
158 */
159void
160timer_resync_deadlines(void)
161{
162 uint64_t deadline;
163 rtclock_timer_t *mytimer;
164 spl_t s = splclock(); /* No interruptions please */
165 cpu_data_t *cpu_data_ptr;
166
167 cpu_data_ptr = getCpuDatap();
168
169 deadline = 0;
170
171 /* if we have a clock timer set sooner, pop on that */
172 mytimer = &cpu_data_ptr->rtclock_timer; /* Point to the timer itself */
173 if ((!mytimer->has_expired) && (mytimer->deadline > 0))
174 deadline = mytimer->deadline;
175
176 /* if we have a idle timer event coming up, how about that? */
177 if ((cpu_data_ptr->idle_timer_deadline > 0)
178 && (cpu_data_ptr->idle_timer_deadline < deadline))
179 deadline = cpu_data_ptr->idle_timer_deadline;
180
181 /* If we have the quantum timer setup, check that */
182 if ((cpu_data_ptr->quantum_timer_deadline > 0)
183 && (cpu_data_ptr->quantum_timer_deadline < deadline))
184 deadline = cpu_data_ptr->quantum_timer_deadline;
185
186 if ((deadline == EndOfAllTime)
187 || ((deadline > 0) && (cpu_data_ptr->rtcPop != deadline))) {
188 int decr;
189
190 decr = setPop(deadline);
191
192 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE,
193 MACHDBG_CODE(DBG_MACH_EXCP_DECI, 1) | DBG_FUNC_NONE,
194 decr, 2, 0, 0, 0);
195 }
196 splx(s);
197}
198
199
200boolean_t
201timer_resort_threshold(__unused uint64_t skew) {
202 return FALSE;
203}
204
205mpqueue_head_t *
206timer_queue_assign(
207 uint64_t deadline)
208{
209 cpu_data_t *cpu_data_ptr = getCpuDatap();
210 mpqueue_head_t *queue;
211
212 if (cpu_data_ptr->cpu_running) {
213 queue = &cpu_data_ptr->rtclock_timer.queue;
214
215 if (deadline < cpu_data_ptr->rtclock_timer.deadline)
216 timer_set_deadline(deadline);
217 }
218 else
219 queue = &cpu_datap(master_cpu)->rtclock_timer.queue;
220
221 return (queue);
222}
223
224void
225timer_queue_cancel(
226 mpqueue_head_t *queue,
227 uint64_t deadline,
228 uint64_t new_deadline)
229{
230 if (queue == &getCpuDatap()->rtclock_timer.queue) {
231 if (deadline < new_deadline)
232 timer_set_deadline(new_deadline);
233 }
234}
235
236mpqueue_head_t *
237timer_queue_cpu(int cpu)
238{
239 return &cpu_datap(cpu)->rtclock_timer.queue;
240}
241
242void
243timer_call_cpu(int cpu, void (*fn)(void *), void *arg)
244{
245 cpu_signal(cpu_datap(cpu), SIGPxcall, (void *) fn, arg);
246}
247
248void
249timer_call_nosync_cpu(int cpu, void (*fn)(void *), void *arg)
250{
251 /* XXX Needs error checking and retry */
252 cpu_signal(cpu_datap(cpu), SIGPxcall, (void *) fn, arg);
253}
254
255
256static timer_coalescing_priority_params_ns_t tcoal_prio_params_init =
257{
258 .idle_entry_timer_processing_hdeadline_threshold_ns = 5000ULL * NSEC_PER_USEC,
259 .interrupt_timer_coalescing_ilat_threshold_ns = 30ULL * NSEC_PER_USEC,
260 .timer_resort_threshold_ns = 50 * NSEC_PER_MSEC,
261 .timer_coalesce_rt_shift = 0,
262 .timer_coalesce_bg_shift = -5,
263 .timer_coalesce_kt_shift = 3,
264 .timer_coalesce_fp_shift = 3,
265 .timer_coalesce_ts_shift = 3,
266 .timer_coalesce_rt_ns_max = 0ULL,
267 .timer_coalesce_bg_ns_max = 100 * NSEC_PER_MSEC,
268 .timer_coalesce_kt_ns_max = 1 * NSEC_PER_MSEC,
269 .timer_coalesce_fp_ns_max = 1 * NSEC_PER_MSEC,
270 .timer_coalesce_ts_ns_max = 1 * NSEC_PER_MSEC,
271 .latency_qos_scale = {3, 2, 1, -2, -15, -15},
272 .latency_qos_ns_max ={1 * NSEC_PER_MSEC, 5 * NSEC_PER_MSEC, 20 * NSEC_PER_MSEC,
273 75 * NSEC_PER_MSEC, 10000 * NSEC_PER_MSEC, 10000 * NSEC_PER_MSEC},
274 .latency_tier_rate_limited = {FALSE, FALSE, FALSE, FALSE, TRUE, TRUE},
275};
276timer_coalescing_priority_params_ns_t * timer_call_get_priority_params(void)
277{
278 return &tcoal_prio_params_init;
279}
280