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
timer_intr(__unused int inuser,__unused uint64_t iaddr)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 KDBG_RELEASE(DECR_PM_DEADLINE | DBG_FUNC_START);
84 cpu_data_ptr->idle_timer_notify(cpu_data_ptr->idle_timer_refcon, &new_idle_timeout_ticks);
85 KDBG_RELEASE(DECR_PM_DEADLINE | DBG_FUNC_END);
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
timer_set_deadline(uint64_t deadline)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
timer_resync_deadlines(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 KDBG_RELEASE(DECR_SET_DEADLINE | DBG_FUNC_NONE, decr, 2);
183 }
184 splx(s);
185 }
186
187 void
timer_queue_expire_local(__unused void * arg)188 timer_queue_expire_local(
189 __unused void *arg)
190 {
191 rtclock_timer_t *mytimer = &getCpuDatap()->rtclock_timer;
192 uint64_t abstime;
193
194 abstime = mach_absolute_time();
195 mytimer->has_expired = TRUE;
196 mytimer->deadline = timer_queue_expire(&mytimer->queue, abstime);
197 mytimer->has_expired = FALSE;
198
199 timer_resync_deadlines();
200 }
201
202 boolean_t
timer_resort_threshold(__unused uint64_t skew)203 timer_resort_threshold(__unused uint64_t skew)
204 {
205 return FALSE;
206 }
207
208 mpqueue_head_t *
timer_queue_assign(uint64_t deadline)209 timer_queue_assign(
210 uint64_t deadline)
211 {
212 cpu_data_t *cpu_data_ptr = getCpuDatap();
213 mpqueue_head_t *queue;
214
215 if (cpu_data_ptr->cpu_running) {
216 queue = &cpu_data_ptr->rtclock_timer.queue;
217
218 if (deadline < cpu_data_ptr->rtclock_timer.deadline) {
219 timer_set_deadline(deadline);
220 }
221 } else {
222 queue = &cpu_datap(master_cpu)->rtclock_timer.queue;
223 }
224
225 return queue;
226 }
227
228 void
timer_queue_cancel(mpqueue_head_t * queue,uint64_t deadline,uint64_t new_deadline)229 timer_queue_cancel(
230 mpqueue_head_t *queue,
231 uint64_t deadline,
232 uint64_t new_deadline)
233 {
234 if (queue == &getCpuDatap()->rtclock_timer.queue) {
235 if (deadline < new_deadline) {
236 timer_set_deadline(new_deadline);
237 }
238 }
239 }
240
241 mpqueue_head_t *
timer_queue_cpu(int cpu)242 timer_queue_cpu(int cpu)
243 {
244 return &cpu_datap(cpu)->rtclock_timer.queue;
245 }
246
247 void
timer_call_cpu(int cpu,void (* fn)(void *),void * arg)248 timer_call_cpu(int cpu, void (*fn)(void *), void *arg)
249 {
250 cpu_signal(cpu_datap(cpu), SIGPxcall, (void *) fn, arg);
251 }
252
253 void
timer_call_nosync_cpu(int cpu,void (* fn)(void *),void * arg)254 timer_call_nosync_cpu(int cpu, void (*fn)(void *), void *arg)
255 {
256 /* XXX Needs error checking and retry */
257 cpu_signal(cpu_datap(cpu), SIGPxcall, (void *) fn, arg);
258 }
259
260
261 static timer_coalescing_priority_params_ns_t tcoal_prio_params_init =
262 {
263 .idle_entry_timer_processing_hdeadline_threshold_ns = 5000ULL * NSEC_PER_USEC,
264 .interrupt_timer_coalescing_ilat_threshold_ns = 30ULL * NSEC_PER_USEC,
265 .timer_resort_threshold_ns = 50 * NSEC_PER_MSEC,
266 .timer_coalesce_rt_shift = 0,
267 .timer_coalesce_bg_shift = -5,
268 .timer_coalesce_kt_shift = 3,
269 .timer_coalesce_fp_shift = 3,
270 .timer_coalesce_ts_shift = 3,
271 .timer_coalesce_rt_ns_max = 0ULL,
272 .timer_coalesce_bg_ns_max = 100 * NSEC_PER_MSEC,
273 .timer_coalesce_kt_ns_max = 1 * NSEC_PER_MSEC,
274 .timer_coalesce_fp_ns_max = 1 * NSEC_PER_MSEC,
275 .timer_coalesce_ts_ns_max = 1 * NSEC_PER_MSEC,
276 #if XNU_TARGET_OS_OSX
277 .latency_qos_scale = {3, 2, 1, -2, 3, 3},
278 .latency_qos_ns_max = {1 * NSEC_PER_MSEC, 5 * NSEC_PER_MSEC, 20 * NSEC_PER_MSEC,
279 75 * NSEC_PER_MSEC, 1 * NSEC_PER_MSEC, 1 * NSEC_PER_MSEC},
280 .latency_tier_rate_limited = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
281 #else /* XNU_TARGET_OS_OSX */
282 .latency_qos_scale = {3, 2, 1, -2, -15, -15},
283 .latency_qos_ns_max = {1 * NSEC_PER_MSEC, 5 * NSEC_PER_MSEC, 20 * NSEC_PER_MSEC,
284 75 * NSEC_PER_MSEC, 10000 * NSEC_PER_MSEC, 10000 * NSEC_PER_MSEC},
285 .latency_tier_rate_limited = {FALSE, FALSE, FALSE, FALSE, TRUE, TRUE},
286 #endif /* XNU_TARGET_OS_OSX */
287 };
288 timer_coalescing_priority_params_ns_t *
timer_call_get_priority_params(void)289 timer_call_get_priority_params(void)
290 {
291 return &tcoal_prio_params_init;
292 }
293