1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2010-2013 Alexander Motin <mav@FreeBSD.org>
5 * All rights reserved.
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 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer,
12 *    without modification, immediately at the beginning of the file.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD$");
31
32/*
33 * Common routines to manage event timers hardware.
34 */
35
36#include "opt_device_polling.h"
37
38#include <sys/param.h>
39#include <sys/systm.h>
40#include <sys/bus.h>
41#include <sys/limits.h>
42#include <sys/lock.h>
43#include <sys/kdb.h>
44#include <sys/ktr.h>
45#include <sys/mutex.h>
46#include <sys/proc.h>
47#include <sys/kernel.h>
48#include <sys/sched.h>
49#include <sys/smp.h>
50#include <sys/sysctl.h>
51#include <sys/timeet.h>
52#include <sys/timetc.h>
53
54#include <machine/atomic.h>
55#include <machine/clock.h>
56#include <machine/cpu.h>
57#include <machine/smp.h>
58
59int			cpu_disable_c2_sleep = 0; /* Timer dies in C2. */
60int			cpu_disable_c3_sleep = 0; /* Timer dies in C3. */
61
62static void		setuptimer(void);
63static void		loadtimer(sbintime_t now, int first);
64static int		doconfigtimer(void);
65static void		configtimer(int start);
66static int		round_freq(struct eventtimer *et, int freq);
67
68static sbintime_t	getnextcpuevent(int idle);
69static sbintime_t	getnextevent(void);
70static int		handleevents(sbintime_t now, int fake);
71
72static struct mtx	et_hw_mtx;
73
74#define	ET_HW_LOCK(state)						\
75	{								\
76		if (timer->et_flags & ET_FLAGS_PERCPU)			\
77			mtx_lock_spin(&(state)->et_hw_mtx);		\
78		else							\
79			mtx_lock_spin(&et_hw_mtx);			\
80	}
81
82#define	ET_HW_UNLOCK(state)						\
83	{								\
84		if (timer->et_flags & ET_FLAGS_PERCPU)			\
85			mtx_unlock_spin(&(state)->et_hw_mtx);		\
86		else							\
87			mtx_unlock_spin(&et_hw_mtx);			\
88	}
89
90static struct eventtimer *timer = NULL;
91static sbintime_t	timerperiod;	/* Timer period for periodic mode. */
92static sbintime_t	statperiod;	/* statclock() events period. */
93static sbintime_t	profperiod;	/* profclock() events period. */
94static sbintime_t	nexttick;	/* Next global timer tick time. */
95static u_int		busy = 1;	/* Reconfiguration is in progress. */
96static int		profiling;	/* Profiling events enabled. */
97
98static char		timername[32];	/* Wanted timer. */
99TUNABLE_STR("kern.eventtimer.timer", timername, sizeof(timername));
100
101static int		singlemul;	/* Multiplier for periodic mode. */
102SYSCTL_INT(_kern_eventtimer, OID_AUTO, singlemul, CTLFLAG_RWTUN, &singlemul,
103    0, "Multiplier for periodic mode");
104
105static u_int		idletick;	/* Run periodic events when idle. */
106SYSCTL_UINT(_kern_eventtimer, OID_AUTO, idletick, CTLFLAG_RWTUN, &idletick,
107    0, "Run periodic events when idle");
108
109static int		periodic;	/* Periodic or one-shot mode. */
110static int		want_periodic;	/* What mode to prefer. */
111TUNABLE_INT("kern.eventtimer.periodic", &want_periodic);
112
113struct pcpu_state {
114	struct mtx	et_hw_mtx;	/* Per-CPU timer mutex. */
115	u_int		action;		/* Reconfiguration requests. */
116	u_int		handle;		/* Immediate handle resuests. */
117	sbintime_t	now;		/* Last tick time. */
118	sbintime_t	nextevent;	/* Next scheduled event on this CPU. */
119	sbintime_t	nexttick;	/* Next timer tick time. */
120	sbintime_t	nexthard;	/* Next hardclock() event. */
121	sbintime_t	nextstat;	/* Next statclock() event. */
122	sbintime_t	nextprof;	/* Next profclock() event. */
123	sbintime_t	nextcall;	/* Next callout event. */
124	sbintime_t	nextcallopt;	/* Next optional callout event. */
125	int		ipi;		/* This CPU needs IPI. */
126	int		idle;		/* This CPU is in idle mode. */
127};
128
129DPCPU_DEFINE_STATIC(struct pcpu_state, timerstate);
130DPCPU_DEFINE(sbintime_t, hardclocktime);
131
132/*
133 * Timer broadcast IPI handler.
134 */
135int
136hardclockintr(void)
137{
138	sbintime_t now;
139	struct pcpu_state *state;
140	int done;
141
142	if (doconfigtimer() || busy)
143		return (FILTER_HANDLED);
144	state = DPCPU_PTR(timerstate);
145	now = state->now;
146	CTR3(KTR_SPARE2, "ipi  at %d:    now  %d.%08x",
147	    curcpu, (int)(now >> 32), (u_int)(now & 0xffffffff));
148	done = handleevents(now, 0);
149	return (done ? FILTER_HANDLED : FILTER_STRAY);
150}
151
152/*
153 * Handle all events for specified time on this CPU
154 */
155static int
156handleevents(sbintime_t now, int fake)
157{
158	sbintime_t t, *hct;
159	struct trapframe *frame;
160	struct pcpu_state *state;
161	int usermode;
162	int done, runs;
163
164	CTR3(KTR_SPARE2, "handle at %d:  now  %d.%08x",
165	    curcpu, (int)(now >> 32), (u_int)(now & 0xffffffff));
166	done = 0;
167	if (fake) {
168		frame = NULL;
169		usermode = 0;
170	} else {
171		frame = curthread->td_intr_frame;
172		usermode = TRAPF_USERMODE(frame);
173	}
174
175	state = DPCPU_PTR(timerstate);
176
177	runs = 0;
178	while (now >= state->nexthard) {
179		state->nexthard += tick_sbt;
180		runs++;
181	}
182	if (runs) {
183		hct = DPCPU_PTR(hardclocktime);
184		*hct = state->nexthard - tick_sbt;
185		if (fake < 2) {
186			hardclock(runs, usermode);
187			done = 1;
188		}
189	}
190	runs = 0;
191	while (now >= state->nextstat) {
192		state->nextstat += statperiod;
193		runs++;
194	}
195	if (runs && fake < 2) {
196		statclock(runs, usermode);
197		done = 1;
198	}
199	if (profiling) {
200		runs = 0;
201		while (now >= state->nextprof) {
202			state->nextprof += profperiod;
203			runs++;
204		}
205		if (runs && !fake) {
206			profclock(runs, usermode, TRAPF_PC(frame));
207			done = 1;
208		}
209	} else
210		state->nextprof = state->nextstat;
211	if (now >= state->nextcallopt || now >= state->nextcall) {
212		state->nextcall = state->nextcallopt = SBT_MAX;
213		callout_process(now);
214	}
215
216	t = getnextcpuevent(0);
217	ET_HW_LOCK(state);
218	if (!busy) {
219		state->idle = 0;
220		state->nextevent = t;
221		loadtimer(now, (fake == 2) &&
222		    (timer->et_flags & ET_FLAGS_PERCPU));
223	}
224	ET_HW_UNLOCK(state);
225	return (done);
226}
227
228/*
229 * Schedule binuptime of the next event on current CPU.
230 */
231static sbintime_t
232getnextcpuevent(int idle)
233{
234	sbintime_t event;
235	struct pcpu_state *state;
236	u_int hardfreq;
237
238	state = DPCPU_PTR(timerstate);
239	/* Handle hardclock() events, skipping some if CPU is idle. */
240	event = state->nexthard;
241	if (idle) {
242		hardfreq = (u_int)hz / 2;
243		if (tc_min_ticktock_freq > 2
244#ifdef SMP
245		    && curcpu == CPU_FIRST()
246#endif
247		    )
248			hardfreq = hz / tc_min_ticktock_freq;
249		if (hardfreq > 1)
250			event += tick_sbt * (hardfreq - 1);
251	}
252	/* Handle callout events. */
253	if (event > state->nextcall)
254		event = state->nextcall;
255	if (!idle) { /* If CPU is active - handle other types of events. */
256		if (event > state->nextstat)
257			event = state->nextstat;
258		if (profiling && event > state->nextprof)
259			event = state->nextprof;
260	}
261	return (event);
262}
263
264/*
265 * Schedule binuptime of the next event on all CPUs.
266 */
267static sbintime_t
268getnextevent(void)
269{
270	struct pcpu_state *state;
271	sbintime_t event;
272#ifdef SMP
273	int	cpu;
274#endif
275#ifdef KTR
276	int	c;
277
278	c = -1;
279#endif
280	state = DPCPU_PTR(timerstate);
281	event = state->nextevent;
282#ifdef SMP
283	if ((timer->et_flags & ET_FLAGS_PERCPU) == 0) {
284		CPU_FOREACH(cpu) {
285			state = DPCPU_ID_PTR(cpu, timerstate);
286			if (event > state->nextevent) {
287				event = state->nextevent;
288#ifdef KTR
289				c = cpu;
290#endif
291			}
292		}
293	}
294#endif
295	CTR4(KTR_SPARE2, "next at %d:    next %d.%08x by %d",
296	    curcpu, (int)(event >> 32), (u_int)(event & 0xffffffff), c);
297	return (event);
298}
299
300/* Hardware timer callback function. */
301static void
302timercb(struct eventtimer *et, void *arg)
303{
304	sbintime_t now;
305	sbintime_t *next;
306	struct pcpu_state *state;
307#ifdef SMP
308	int cpu, bcast;
309#endif
310
311	/* Do not touch anything if somebody reconfiguring timers. */
312	if (busy)
313		return;
314	/* Update present and next tick times. */
315	state = DPCPU_PTR(timerstate);
316	if (et->et_flags & ET_FLAGS_PERCPU) {
317		next = &state->nexttick;
318	} else
319		next = &nexttick;
320	now = sbinuptime();
321	if (periodic)
322		*next = now + timerperiod;
323	else
324		*next = -1;	/* Next tick is not scheduled yet. */
325	state->now = now;
326	CTR3(KTR_SPARE2, "intr at %d:    now  %d.%08x",
327	    curcpu, (int)(now >> 32), (u_int)(now & 0xffffffff));
328
329#ifdef SMP
330#ifdef EARLY_AP_STARTUP
331	MPASS(mp_ncpus == 1 || smp_started);
332#endif
333	/* Prepare broadcasting to other CPUs for non-per-CPU timers. */
334	bcast = 0;
335#ifdef EARLY_AP_STARTUP
336	if ((et->et_flags & ET_FLAGS_PERCPU) == 0) {
337#else
338	if ((et->et_flags & ET_FLAGS_PERCPU) == 0 && smp_started) {
339#endif
340		CPU_FOREACH(cpu) {
341			state = DPCPU_ID_PTR(cpu, timerstate);
342			ET_HW_LOCK(state);
343			state->now = now;
344			if (now >= state->nextevent) {
345				state->nextevent += SBT_1S;
346				if (curcpu != cpu) {
347					state->ipi = 1;
348					bcast = 1;
349				}
350			}
351			ET_HW_UNLOCK(state);
352		}
353	}
354#endif
355
356	/* Handle events for this time on this CPU. */
357	handleevents(now, 0);
358
359#ifdef SMP
360	/* Broadcast interrupt to other CPUs for non-per-CPU timers. */
361	if (bcast) {
362		CPU_FOREACH(cpu) {
363			if (curcpu == cpu)
364				continue;
365			state = DPCPU_ID_PTR(cpu, timerstate);
366			if (state->ipi) {
367				state->ipi = 0;
368				ipi_cpu(cpu, IPI_HARDCLOCK);
369			}
370		}
371	}
372#endif
373}
374
375/*
376 * Load new value into hardware timer.
377 */
378static void
379loadtimer(sbintime_t now, int start)
380{
381	struct pcpu_state *state;
382	sbintime_t new;
383	sbintime_t *next;
384	uint64_t tmp;
385	int eq;
386
387	if (timer->et_flags & ET_FLAGS_PERCPU) {
388		state = DPCPU_PTR(timerstate);
389		next = &state->nexttick;
390	} else
391		next = &nexttick;
392	if (periodic) {
393		if (start) {
394			/*
395			 * Try to start all periodic timers aligned
396			 * to period to make events synchronous.
397			 */
398			tmp = now % timerperiod;
399			new = timerperiod - tmp;
400			if (new < tmp)		/* Left less then passed. */
401				new += timerperiod;
402			CTR5(KTR_SPARE2, "load p at %d:   now %d.%08x first in %d.%08x",
403			    curcpu, (int)(now >> 32), (u_int)(now & 0xffffffff),
404			    (int)(new >> 32), (u_int)(new & 0xffffffff));
405			*next = new + now;
406			et_start(timer, new, timerperiod);
407		}
408	} else {
409		new = getnextevent();
410		eq = (new == *next);
411		CTR4(KTR_SPARE2, "load at %d:    next %d.%08x eq %d",
412		    curcpu, (int)(new >> 32), (u_int)(new & 0xffffffff), eq);
413		if (!eq) {
414			*next = new;
415			et_start(timer, new - now, 0);
416		}
417	}
418}
419
420/*
421 * Prepare event timer parameters after configuration changes.
422 */
423static void
424setuptimer(void)
425{
426	int freq;
427
428	if (periodic && (timer->et_flags & ET_FLAGS_PERIODIC) == 0)
429		periodic = 0;
430	else if (!periodic && (timer->et_flags & ET_FLAGS_ONESHOT) == 0)
431		periodic = 1;
432	singlemul = MIN(MAX(singlemul, 1), 20);
433	freq = hz * singlemul;
434	while (freq < (profiling ? profhz : stathz))
435		freq += hz;
436	freq = round_freq(timer, freq);
437	timerperiod = SBT_1S / freq;
438}
439
440/*
441 * Reconfigure specified per-CPU timer on other CPU. Called from IPI handler.
442 */
443static int
444doconfigtimer(void)
445{
446	sbintime_t now;
447	struct pcpu_state *state;
448
449	state = DPCPU_PTR(timerstate);
450	switch (atomic_load_acq_int(&state->action)) {
451	case 1:
452		now = sbinuptime();
453		ET_HW_LOCK(state);
454		loadtimer(now, 1);
455		ET_HW_UNLOCK(state);
456		state->handle = 0;
457		atomic_store_rel_int(&state->action, 0);
458		return (1);
459	case 2:
460		ET_HW_LOCK(state);
461		et_stop(timer);
462		ET_HW_UNLOCK(state);
463		state->handle = 0;
464		atomic_store_rel_int(&state->action, 0);
465		return (1);
466	}
467	if (atomic_readandclear_int(&state->handle) && !busy) {
468		now = sbinuptime();
469		handleevents(now, 0);
470		return (1);
471	}
472	return (0);
473}
474
475/*
476 * Reconfigure specified timer.
477 * For per-CPU timers use IPI to make other CPUs to reconfigure.
478 */
479static void
480configtimer(int start)
481{
482	sbintime_t now, next;
483	struct pcpu_state *state;
484	int cpu;
485
486	if (start) {
487		setuptimer();
488		now = sbinuptime();
489	} else
490		now = 0;
491	critical_enter();
492	ET_HW_LOCK(DPCPU_PTR(timerstate));
493	if (start) {
494		/* Initialize time machine parameters. */
495		next = now + timerperiod;
496		if (periodic)
497			nexttick = next;
498		else
499			nexttick = -1;
500#ifdef EARLY_AP_STARTUP
501		MPASS(mp_ncpus == 1 || smp_started);
502#endif
503		CPU_FOREACH(cpu) {
504			state = DPCPU_ID_PTR(cpu, timerstate);
505			state->now = now;
506#ifndef EARLY_AP_STARTUP
507			if (!smp_started && cpu != CPU_FIRST())
508				state->nextevent = SBT_MAX;
509			else
510#endif
511				state->nextevent = next;
512			if (periodic)
513				state->nexttick = next;
514			else
515				state->nexttick = -1;
516			state->nexthard = next;
517			state->nextstat = next;
518			state->nextprof = next;
519			state->nextcall = next;
520			state->nextcallopt = next;
521			hardclock_sync(cpu);
522		}
523		busy = 0;
524		/* Start global timer or per-CPU timer of this CPU. */
525		loadtimer(now, 1);
526	} else {
527		busy = 1;
528		/* Stop global timer or per-CPU timer of this CPU. */
529		et_stop(timer);
530	}
531	ET_HW_UNLOCK(DPCPU_PTR(timerstate));
532#ifdef SMP
533#ifdef EARLY_AP_STARTUP
534	/* If timer is global we are done. */
535	if ((timer->et_flags & ET_FLAGS_PERCPU) == 0) {
536#else
537	/* If timer is global or there is no other CPUs yet - we are done. */
538	if ((timer->et_flags & ET_FLAGS_PERCPU) == 0 || !smp_started) {
539#endif
540		critical_exit();
541		return;
542	}
543	/* Set reconfigure flags for other CPUs. */
544	CPU_FOREACH(cpu) {
545		state = DPCPU_ID_PTR(cpu, timerstate);
546		atomic_store_rel_int(&state->action,
547		    (cpu == curcpu) ? 0 : ( start ? 1 : 2));
548	}
549	/* Broadcast reconfigure IPI. */
550	ipi_all_but_self(IPI_HARDCLOCK);
551	/* Wait for reconfiguration completed. */
552restart:
553	cpu_spinwait();
554	CPU_FOREACH(cpu) {
555		if (cpu == curcpu)
556			continue;
557		state = DPCPU_ID_PTR(cpu, timerstate);
558		if (atomic_load_acq_int(&state->action))
559			goto restart;
560	}
561#endif
562	critical_exit();
563}
564
565/*
566 * Calculate nearest frequency supported by hardware timer.
567 */
568static int
569round_freq(struct eventtimer *et, int freq)
570{
571	uint64_t div;
572
573	if (et->et_frequency != 0) {
574		div = lmax((et->et_frequency + freq / 2) / freq, 1);
575		if (et->et_flags & ET_FLAGS_POW2DIV)
576			div = 1 << (flsl(div + div / 2) - 1);
577		freq = (et->et_frequency + div / 2) / div;
578	}
579	if (et->et_min_period > SBT_1S)
580		panic("Event timer \"%s\" doesn't support sub-second periods!",
581		    et->et_name);
582	else if (et->et_min_period != 0)
583		freq = min(freq, SBT2FREQ(et->et_min_period));
584	if (et->et_max_period < SBT_1S && et->et_max_period != 0)
585		freq = max(freq, SBT2FREQ(et->et_max_period));
586	return (freq);
587}
588
589/*
590 * Configure and start event timers (BSP part).
591 */
592void
593cpu_initclocks_bsp(void)
594{
595	struct pcpu_state *state;
596	int base, div, cpu;
597
598	mtx_init(&et_hw_mtx, "et_hw_mtx", NULL, MTX_SPIN);
599	CPU_FOREACH(cpu) {
600		state = DPCPU_ID_PTR(cpu, timerstate);
601		mtx_init(&state->et_hw_mtx, "et_hw_mtx", NULL, MTX_SPIN);
602		state->nextcall = SBT_MAX;
603		state->nextcallopt = SBT_MAX;
604	}
605	periodic = want_periodic;
606	/* Grab requested timer or the best of present. */
607	if (timername[0])
608		timer = et_find(timername, 0, 0);
609	if (timer == NULL && periodic) {
610		timer = et_find(NULL,
611		    ET_FLAGS_PERIODIC, ET_FLAGS_PERIODIC);
612	}
613	if (timer == NULL) {
614		timer = et_find(NULL,
615		    ET_FLAGS_ONESHOT, ET_FLAGS_ONESHOT);
616	}
617	if (timer == NULL && !periodic) {
618		timer = et_find(NULL,
619		    ET_FLAGS_PERIODIC, ET_FLAGS_PERIODIC);
620	}
621	if (timer == NULL)
622		panic("No usable event timer found!");
623	et_init(timer, timercb, NULL, NULL);
624
625	/* Adapt to timer capabilities. */
626	if (periodic && (timer->et_flags & ET_FLAGS_PERIODIC) == 0)
627		periodic = 0;
628	else if (!periodic && (timer->et_flags & ET_FLAGS_ONESHOT) == 0)
629		periodic = 1;
630	if (timer->et_flags & ET_FLAGS_C3STOP)
631		cpu_disable_c3_sleep++;
632
633	/*
634	 * We honor the requested 'hz' value.
635	 * We want to run stathz in the neighborhood of 128hz.
636	 * We would like profhz to run as often as possible.
637	 */
638	if (singlemul <= 0 || singlemul > 20) {
639		if (hz >= 1500 || (hz % 128) == 0)
640			singlemul = 1;
641		else if (hz >= 750)
642			singlemul = 2;
643		else
644			singlemul = 4;
645	}
646	if (periodic) {
647		base = round_freq(timer, hz * singlemul);
648		singlemul = max((base + hz / 2) / hz, 1);
649		hz = (base + singlemul / 2) / singlemul;
650		if (base <= 128)
651			stathz = base;
652		else {
653			div = base / 128;
654			if (div >= singlemul && (div % singlemul) == 0)
655				div++;
656			stathz = base / div;
657		}
658		profhz = stathz;
659		while ((profhz + stathz) <= 128 * 64)
660			profhz += stathz;
661		profhz = round_freq(timer, profhz);
662	} else {
663		hz = round_freq(timer, hz);
664		stathz = round_freq(timer, 127);
665		profhz = round_freq(timer, stathz * 64);
666	}
667	tick = 1000000 / hz;
668	tick_sbt = SBT_1S / hz;
669	tick_bt = sbttobt(tick_sbt);
670	statperiod = SBT_1S / stathz;
671	profperiod = SBT_1S / profhz;
672	ET_LOCK();
673	configtimer(1);
674	ET_UNLOCK();
675}
676
677/*
678 * Start per-CPU event timers on APs.
679 */
680void
681cpu_initclocks_ap(void)
682{
683	sbintime_t now;
684	struct pcpu_state *state;
685	struct thread *td;
686
687	state = DPCPU_PTR(timerstate);
688	now = sbinuptime();
689	ET_HW_LOCK(state);
690	state->now = now;
691	hardclock_sync(curcpu);
692	spinlock_enter();
693	ET_HW_UNLOCK(state);
694	td = curthread;
695	td->td_intr_nesting_level++;
696	handleevents(state->now, 2);
697	td->td_intr_nesting_level--;
698	spinlock_exit();
699}
700
701void
702suspendclock(void)
703{
704	ET_LOCK();
705	configtimer(0);
706	ET_UNLOCK();
707}
708
709void
710resumeclock(void)
711{
712	ET_LOCK();
713	configtimer(1);
714	ET_UNLOCK();
715}
716
717/*
718 * Switch to profiling clock rates.
719 */
720void
721cpu_startprofclock(void)
722{
723
724	ET_LOCK();
725	if (profiling == 0) {
726		if (periodic) {
727			configtimer(0);
728			profiling = 1;
729			configtimer(1);
730		} else
731			profiling = 1;
732	} else
733		profiling++;
734	ET_UNLOCK();
735}
736
737/*
738 * Switch to regular clock rates.
739 */
740void
741cpu_stopprofclock(void)
742{
743
744	ET_LOCK();
745	if (profiling == 1) {
746		if (periodic) {
747			configtimer(0);
748			profiling = 0;
749			configtimer(1);
750		} else
751		profiling = 0;
752	} else
753		profiling--;
754	ET_UNLOCK();
755}
756
757/*
758 * Switch to idle mode (all ticks handled).
759 */
760sbintime_t
761cpu_idleclock(void)
762{
763	sbintime_t now, t;
764	struct pcpu_state *state;
765
766	if (idletick || busy ||
767	    (periodic && (timer->et_flags & ET_FLAGS_PERCPU))
768#ifdef DEVICE_POLLING
769	    || curcpu == CPU_FIRST()
770#endif
771	    )
772		return (-1);
773	state = DPCPU_PTR(timerstate);
774	if (periodic)
775		now = state->now;
776	else
777		now = sbinuptime();
778	CTR3(KTR_SPARE2, "idle at %d:    now  %d.%08x",
779	    curcpu, (int)(now >> 32), (u_int)(now & 0xffffffff));
780	t = getnextcpuevent(1);
781	ET_HW_LOCK(state);
782	state->idle = 1;
783	state->nextevent = t;
784	if (!periodic)
785		loadtimer(now, 0);
786	ET_HW_UNLOCK(state);
787	return (MAX(t - now, 0));
788}
789
790/*
791 * Switch to active mode (skip empty ticks).
792 */
793void
794cpu_activeclock(void)
795{
796	sbintime_t now;
797	struct pcpu_state *state;
798	struct thread *td;
799
800	state = DPCPU_PTR(timerstate);
801	if (state->idle == 0 || busy)
802		return;
803	if (periodic)
804		now = state->now;
805	else
806		now = sbinuptime();
807	CTR3(KTR_SPARE2, "active at %d:  now  %d.%08x",
808	    curcpu, (int)(now >> 32), (u_int)(now & 0xffffffff));
809	spinlock_enter();
810	td = curthread;
811	td->td_intr_nesting_level++;
812	handleevents(now, 1);
813	td->td_intr_nesting_level--;
814	spinlock_exit();
815}
816
817/*
818 * Change the frequency of the given timer.  This changes et->et_frequency and
819 * if et is the active timer it reconfigures the timer on all CPUs.  This is
820 * intended to be a private interface for the use of et_change_frequency() only.
821 */
822void
823cpu_et_frequency(struct eventtimer *et, uint64_t newfreq)
824{
825
826	ET_LOCK();
827	if (et == timer) {
828		configtimer(0);
829		et->et_frequency = newfreq;
830		configtimer(1);
831	} else
832		et->et_frequency = newfreq;
833	ET_UNLOCK();
834}
835
836void
837cpu_new_callout(int cpu, sbintime_t bt, sbintime_t bt_opt)
838{
839	struct pcpu_state *state;
840
841	/* Do not touch anything if somebody reconfiguring timers. */
842	if (busy)
843		return;
844	CTR6(KTR_SPARE2, "new co at %d:    on %d at %d.%08x - %d.%08x",
845	    curcpu, cpu, (int)(bt_opt >> 32), (u_int)(bt_opt & 0xffffffff),
846	    (int)(bt >> 32), (u_int)(bt & 0xffffffff));
847
848	KASSERT(!CPU_ABSENT(cpu), ("Absent CPU %d", cpu));
849	state = DPCPU_ID_PTR(cpu, timerstate);
850	ET_HW_LOCK(state);
851
852	/*
853	 * If there is callout time already set earlier -- do nothing.
854	 * This check may appear redundant because we check already in
855	 * callout_process() but this double check guarantees we're safe
856	 * with respect to race conditions between interrupts execution
857	 * and scheduling.
858	 */
859	state->nextcallopt = bt_opt;
860	if (bt >= state->nextcall)
861		goto done;
862	state->nextcall = bt;
863	/* If there is some other event set earlier -- do nothing. */
864	if (bt >= state->nextevent)
865		goto done;
866	state->nextevent = bt;
867	/* If timer is periodic -- there is nothing to reprogram. */
868	if (periodic)
869		goto done;
870	/* If timer is global or of the current CPU -- reprogram it. */
871	if ((timer->et_flags & ET_FLAGS_PERCPU) == 0 || cpu == curcpu) {
872		loadtimer(sbinuptime(), 0);
873done:
874		ET_HW_UNLOCK(state);
875		return;
876	}
877	/* Otherwise make other CPU to reprogram it. */
878	state->handle = 1;
879	ET_HW_UNLOCK(state);
880#ifdef SMP
881	ipi_cpu(cpu, IPI_HARDCLOCK);
882#endif
883}
884
885/*
886 * Report or change the active event timers hardware.
887 */
888static int
889sysctl_kern_eventtimer_timer(SYSCTL_HANDLER_ARGS)
890{
891	char buf[32];
892	struct eventtimer *et;
893	int error;
894
895	ET_LOCK();
896	et = timer;
897	snprintf(buf, sizeof(buf), "%s", et->et_name);
898	ET_UNLOCK();
899	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
900	ET_LOCK();
901	et = timer;
902	if (error != 0 || req->newptr == NULL ||
903	    strcasecmp(buf, et->et_name) == 0) {
904		ET_UNLOCK();
905		return (error);
906	}
907	et = et_find(buf, 0, 0);
908	if (et == NULL) {
909		ET_UNLOCK();
910		return (ENOENT);
911	}
912	configtimer(0);
913	et_free(timer);
914	if (et->et_flags & ET_FLAGS_C3STOP)
915		cpu_disable_c3_sleep++;
916	if (timer->et_flags & ET_FLAGS_C3STOP)
917		cpu_disable_c3_sleep--;
918	periodic = want_periodic;
919	timer = et;
920	et_init(timer, timercb, NULL, NULL);
921	configtimer(1);
922	ET_UNLOCK();
923	return (error);
924}
925SYSCTL_PROC(_kern_eventtimer, OID_AUTO, timer,
926    CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE,
927    0, 0, sysctl_kern_eventtimer_timer, "A", "Chosen event timer");
928
929/*
930 * Report or change the active event timer periodicity.
931 */
932static int
933sysctl_kern_eventtimer_periodic(SYSCTL_HANDLER_ARGS)
934{
935	int error, val;
936
937	val = periodic;
938	error = sysctl_handle_int(oidp, &val, 0, req);
939	if (error != 0 || req->newptr == NULL)
940		return (error);
941	ET_LOCK();
942	configtimer(0);
943	periodic = want_periodic = val;
944	configtimer(1);
945	ET_UNLOCK();
946	return (error);
947}
948SYSCTL_PROC(_kern_eventtimer, OID_AUTO, periodic,
949    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
950    0, 0, sysctl_kern_eventtimer_periodic, "I", "Enable event timer periodic mode");
951
952#include "opt_ddb.h"
953
954#ifdef DDB
955#include <ddb/ddb.h>
956
957DB_SHOW_COMMAND(clocksource, db_show_clocksource)
958{
959	struct pcpu_state *st;
960	int c;
961
962	CPU_FOREACH(c) {
963		st = DPCPU_ID_PTR(c, timerstate);
964		db_printf(
965		    "CPU %2d: action %d handle %d  ipi %d idle %d\n"
966		    "        now %#jx nevent %#jx (%jd)\n"
967		    "        ntick %#jx (%jd) nhard %#jx (%jd)\n"
968		    "        nstat %#jx (%jd) nprof %#jx (%jd)\n"
969		    "        ncall %#jx (%jd) ncallopt %#jx (%jd)\n",
970		    c, st->action, st->handle, st->ipi, st->idle,
971		    (uintmax_t)st->now,
972		    (uintmax_t)st->nextevent,
973		    (uintmax_t)(st->nextevent - st->now) / tick_sbt,
974		    (uintmax_t)st->nexttick,
975		    (uintmax_t)(st->nexttick - st->now) / tick_sbt,
976		    (uintmax_t)st->nexthard,
977		    (uintmax_t)(st->nexthard - st->now) / tick_sbt,
978		    (uintmax_t)st->nextstat,
979		    (uintmax_t)(st->nextstat - st->now) / tick_sbt,
980		    (uintmax_t)st->nextprof,
981		    (uintmax_t)(st->nextprof - st->now) / tick_sbt,
982		    (uintmax_t)st->nextcall,
983		    (uintmax_t)(st->nextcall - st->now) / tick_sbt,
984		    (uintmax_t)st->nextcallopt,
985		    (uintmax_t)(st->nextcallopt - st->now) / tick_sbt);
986	}
987}
988
989#endif
990