2 * linux/kernel/time/tick-broadcast.c
4 * This file contains functions which emulate a local clock-event
5 * device via a broadcast event source.
7 * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
8 * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
9 * Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
11 * This code is licenced under the GPL version 2. For details see
12 * kernel-base/COPYING.
14 #include <linux/cpu.h>
15 #include <linux/err.h>
16 #include <linux/hrtimer.h>
17 #include <linux/interrupt.h>
18 #include <linux/percpu.h>
19 #include <linux/profile.h>
20 #include <linux/sched.h>
21 #include <linux/smp.h>
22 #include <linux/module.h>
24 #include "tick-internal.h"
27 * Broadcast support for broken x86 hardware, where the local apic
28 * timer stops in C3 state.
31 static struct tick_device tick_broadcast_device
;
32 static cpumask_var_t tick_broadcast_mask
;
33 static cpumask_var_t tick_broadcast_on
;
34 static cpumask_var_t tmpmask
;
35 static DEFINE_RAW_SPINLOCK(tick_broadcast_lock
);
36 static int tick_broadcast_forced
;
38 #ifdef CONFIG_TICK_ONESHOT
39 static void tick_broadcast_clear_oneshot(int cpu
);
40 static void tick_resume_broadcast_oneshot(struct clock_event_device
*bc
);
42 static inline void tick_broadcast_clear_oneshot(int cpu
) { }
43 static inline void tick_resume_broadcast_oneshot(struct clock_event_device
*bc
) { }
47 * Debugging: see timer_list.c
49 struct tick_device
*tick_get_broadcast_device(void)
51 return &tick_broadcast_device
;
54 struct cpumask
*tick_get_broadcast_mask(void)
56 return tick_broadcast_mask
;
60 * Start the device in periodic mode
62 static void tick_broadcast_start_periodic(struct clock_event_device
*bc
)
65 tick_setup_periodic(bc
, 1);
69 * Check, if the device can be utilized as broadcast device:
71 static bool tick_check_broadcast_device(struct clock_event_device
*curdev
,
72 struct clock_event_device
*newdev
)
74 if ((newdev
->features
& CLOCK_EVT_FEAT_DUMMY
) ||
75 (newdev
->features
& CLOCK_EVT_FEAT_PERCPU
) ||
76 (newdev
->features
& CLOCK_EVT_FEAT_C3STOP
))
79 if (tick_broadcast_device
.mode
== TICKDEV_MODE_ONESHOT
&&
80 !(newdev
->features
& CLOCK_EVT_FEAT_ONESHOT
))
83 return !curdev
|| newdev
->rating
> curdev
->rating
;
87 * Conditionally install/replace broadcast device
89 void tick_install_broadcast_device(struct clock_event_device
*dev
)
91 struct clock_event_device
*cur
= tick_broadcast_device
.evtdev
;
93 if (!tick_check_broadcast_device(cur
, dev
))
96 if (!try_module_get(dev
->owner
))
99 clockevents_exchange_device(cur
, dev
);
101 cur
->event_handler
= clockevents_handle_noop
;
102 tick_broadcast_device
.evtdev
= dev
;
103 if (!cpumask_empty(tick_broadcast_mask
))
104 tick_broadcast_start_periodic(dev
);
106 * Inform all cpus about this. We might be in a situation
107 * where we did not switch to oneshot mode because the per cpu
108 * devices are affected by CLOCK_EVT_FEAT_C3STOP and the lack
109 * of a oneshot capable broadcast device. Without that
110 * notification the systems stays stuck in periodic mode
113 if (dev
->features
& CLOCK_EVT_FEAT_ONESHOT
)
118 * Check, if the device is the broadcast device
120 int tick_is_broadcast_device(struct clock_event_device
*dev
)
122 return (dev
&& tick_broadcast_device
.evtdev
== dev
);
125 int tick_broadcast_update_freq(struct clock_event_device
*dev
, u32 freq
)
129 if (tick_is_broadcast_device(dev
)) {
130 raw_spin_lock(&tick_broadcast_lock
);
131 ret
= __clockevents_update_freq(dev
, freq
);
132 raw_spin_unlock(&tick_broadcast_lock
);
138 static void err_broadcast(const struct cpumask
*mask
)
140 pr_crit_once("Failed to broadcast timer tick. Some CPUs may be unresponsive.\n");
143 static void tick_device_setup_broadcast_func(struct clock_event_device
*dev
)
146 dev
->broadcast
= tick_broadcast
;
147 if (!dev
->broadcast
) {
148 pr_warn_once("%s depends on broadcast, but no broadcast function available\n",
150 dev
->broadcast
= err_broadcast
;
155 * Check, if the device is disfunctional and a place holder, which
156 * needs to be handled by the broadcast device.
158 int tick_device_uses_broadcast(struct clock_event_device
*dev
, int cpu
)
160 struct clock_event_device
*bc
= tick_broadcast_device
.evtdev
;
164 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
167 * Devices might be registered with both periodic and oneshot
168 * mode disabled. This signals, that the device needs to be
169 * operated from the broadcast device and is a placeholder for
170 * the cpu local device.
172 if (!tick_device_is_functional(dev
)) {
173 dev
->event_handler
= tick_handle_periodic
;
174 tick_device_setup_broadcast_func(dev
);
175 cpumask_set_cpu(cpu
, tick_broadcast_mask
);
176 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
177 tick_broadcast_start_periodic(bc
);
179 tick_broadcast_setup_oneshot(bc
);
183 * Clear the broadcast bit for this cpu if the
184 * device is not power state affected.
186 if (!(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
187 cpumask_clear_cpu(cpu
, tick_broadcast_mask
);
189 tick_device_setup_broadcast_func(dev
);
192 * Clear the broadcast bit if the CPU is not in
193 * periodic broadcast on state.
195 if (!cpumask_test_cpu(cpu
, tick_broadcast_on
))
196 cpumask_clear_cpu(cpu
, tick_broadcast_mask
);
198 switch (tick_broadcast_device
.mode
) {
199 case TICKDEV_MODE_ONESHOT
:
201 * If the system is in oneshot mode we can
202 * unconditionally clear the oneshot mask bit,
203 * because the CPU is running and therefore
204 * not in an idle state which causes the power
205 * state affected device to stop. Let the
206 * caller initialize the device.
208 tick_broadcast_clear_oneshot(cpu
);
212 case TICKDEV_MODE_PERIODIC
:
214 * If the system is in periodic mode, check
215 * whether the broadcast device can be
218 if (cpumask_empty(tick_broadcast_mask
) && bc
)
219 clockevents_shutdown(bc
);
221 * If we kept the cpu in the broadcast mask,
222 * tell the caller to leave the per cpu device
223 * in shutdown state. The periodic interrupt
224 * is delivered by the broadcast device.
226 ret
= cpumask_test_cpu(cpu
, tick_broadcast_mask
);
234 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
238 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
239 int tick_receive_broadcast(void)
241 struct tick_device
*td
= this_cpu_ptr(&tick_cpu_device
);
242 struct clock_event_device
*evt
= td
->evtdev
;
247 if (!evt
->event_handler
)
250 evt
->event_handler(evt
);
256 * Broadcast the event to the cpus, which are set in the mask (mangled).
258 static bool tick_do_broadcast(struct cpumask
*mask
)
260 int cpu
= smp_processor_id();
261 struct tick_device
*td
;
265 * Check, if the current cpu is in the mask
267 if (cpumask_test_cpu(cpu
, mask
)) {
268 cpumask_clear_cpu(cpu
, mask
);
272 if (!cpumask_empty(mask
)) {
274 * It might be necessary to actually check whether the devices
275 * have different broadcast functions. For now, just use the
276 * one of the first device. This works as long as we have this
277 * misfeature only on x86 (lapic)
279 td
= &per_cpu(tick_cpu_device
, cpumask_first(mask
));
280 td
->evtdev
->broadcast(mask
);
286 * Periodic broadcast:
287 * - invoke the broadcast handlers
289 static bool tick_do_periodic_broadcast(void)
291 cpumask_and(tmpmask
, cpu_online_mask
, tick_broadcast_mask
);
292 return tick_do_broadcast(tmpmask
);
296 * Event handler for periodic broadcast ticks
298 static void tick_handle_periodic_broadcast(struct clock_event_device
*dev
)
300 struct tick_device
*td
= this_cpu_ptr(&tick_cpu_device
);
303 raw_spin_lock(&tick_broadcast_lock
);
304 bc_local
= tick_do_periodic_broadcast();
306 if (clockevent_state_oneshot(dev
)) {
307 ktime_t next
= ktime_add(dev
->next_event
, tick_period
);
309 clockevents_program_event(dev
, next
, true);
311 raw_spin_unlock(&tick_broadcast_lock
);
314 * We run the handler of the local cpu after dropping
315 * tick_broadcast_lock because the handler might deadlock when
316 * trying to switch to oneshot mode.
319 td
->evtdev
->event_handler(td
->evtdev
);
323 * tick_broadcast_control - Enable/disable or force broadcast mode
324 * @mode: The selected broadcast mode
326 * Called when the system enters a state where affected tick devices
327 * might stop. Note: TICK_BROADCAST_FORCE cannot be undone.
329 * Called with interrupts disabled, so clockevents_lock is not
330 * required here because the local clock event device cannot go away
333 void tick_broadcast_control(enum tick_broadcast_mode mode
)
335 struct clock_event_device
*bc
, *dev
;
336 struct tick_device
*td
;
339 td
= this_cpu_ptr(&tick_cpu_device
);
343 * Is the device not affected by the powerstate ?
345 if (!dev
|| !(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
348 if (!tick_device_is_functional(dev
))
351 raw_spin_lock(&tick_broadcast_lock
);
352 cpu
= smp_processor_id();
353 bc
= tick_broadcast_device
.evtdev
;
354 bc_stopped
= cpumask_empty(tick_broadcast_mask
);
357 case TICK_BROADCAST_FORCE
:
358 tick_broadcast_forced
= 1;
359 case TICK_BROADCAST_ON
:
360 cpumask_set_cpu(cpu
, tick_broadcast_on
);
361 if (!cpumask_test_and_set_cpu(cpu
, tick_broadcast_mask
)) {
362 if (tick_broadcast_device
.mode
==
363 TICKDEV_MODE_PERIODIC
)
364 clockevents_shutdown(dev
);
368 case TICK_BROADCAST_OFF
:
369 if (tick_broadcast_forced
)
371 cpumask_clear_cpu(cpu
, tick_broadcast_on
);
372 if (!tick_device_is_functional(dev
))
374 if (cpumask_test_and_clear_cpu(cpu
, tick_broadcast_mask
)) {
375 if (tick_broadcast_device
.mode
==
376 TICKDEV_MODE_PERIODIC
)
377 tick_setup_periodic(dev
, 0);
382 if (cpumask_empty(tick_broadcast_mask
)) {
384 clockevents_shutdown(bc
);
385 } else if (bc_stopped
) {
386 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
387 tick_broadcast_start_periodic(bc
);
389 tick_broadcast_setup_oneshot(bc
);
391 raw_spin_unlock(&tick_broadcast_lock
);
393 EXPORT_SYMBOL_GPL(tick_broadcast_control
);
396 * Set the periodic handler depending on broadcast on/off
398 void tick_set_periodic_handler(struct clock_event_device
*dev
, int broadcast
)
401 dev
->event_handler
= tick_handle_periodic
;
403 dev
->event_handler
= tick_handle_periodic_broadcast
;
406 #ifdef CONFIG_HOTPLUG_CPU
408 * Remove a CPU from broadcasting
410 void tick_shutdown_broadcast(unsigned int cpu
)
412 struct clock_event_device
*bc
;
415 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
417 bc
= tick_broadcast_device
.evtdev
;
418 cpumask_clear_cpu(cpu
, tick_broadcast_mask
);
419 cpumask_clear_cpu(cpu
, tick_broadcast_on
);
421 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
) {
422 if (bc
&& cpumask_empty(tick_broadcast_mask
))
423 clockevents_shutdown(bc
);
426 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
430 void tick_suspend_broadcast(void)
432 struct clock_event_device
*bc
;
435 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
437 bc
= tick_broadcast_device
.evtdev
;
439 clockevents_shutdown(bc
);
441 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
445 * This is called from tick_resume_local() on a resuming CPU. That's
446 * called from the core resume function, tick_unfreeze() and the magic XEN
449 * In none of these cases the broadcast device mode can change and the
450 * bit of the resuming CPU in the broadcast mask is safe as well.
452 bool tick_resume_check_broadcast(void)
454 if (tick_broadcast_device
.mode
== TICKDEV_MODE_ONESHOT
)
457 return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask
);
460 void tick_resume_broadcast(void)
462 struct clock_event_device
*bc
;
465 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
467 bc
= tick_broadcast_device
.evtdev
;
470 clockevents_tick_resume(bc
);
472 switch (tick_broadcast_device
.mode
) {
473 case TICKDEV_MODE_PERIODIC
:
474 if (!cpumask_empty(tick_broadcast_mask
))
475 tick_broadcast_start_periodic(bc
);
477 case TICKDEV_MODE_ONESHOT
:
478 if (!cpumask_empty(tick_broadcast_mask
))
479 tick_resume_broadcast_oneshot(bc
);
483 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
486 #ifdef CONFIG_TICK_ONESHOT
488 static cpumask_var_t tick_broadcast_oneshot_mask
;
489 static cpumask_var_t tick_broadcast_pending_mask
;
490 static cpumask_var_t tick_broadcast_force_mask
;
493 * Exposed for debugging: see timer_list.c
495 struct cpumask
*tick_get_broadcast_oneshot_mask(void)
497 return tick_broadcast_oneshot_mask
;
501 * Called before going idle with interrupts disabled. Checks whether a
502 * broadcast event from the other core is about to happen. We detected
503 * that in tick_broadcast_oneshot_control(). The callsite can use this
504 * to avoid a deep idle transition as we are about to get the
505 * broadcast IPI right away.
507 int tick_check_broadcast_expired(void)
509 return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask
);
513 * Set broadcast interrupt affinity
515 static void tick_broadcast_set_affinity(struct clock_event_device
*bc
,
516 const struct cpumask
*cpumask
)
518 if (!(bc
->features
& CLOCK_EVT_FEAT_DYNIRQ
))
521 if (cpumask_equal(bc
->cpumask
, cpumask
))
524 bc
->cpumask
= cpumask
;
525 irq_set_affinity(bc
->irq
, bc
->cpumask
);
528 static void tick_broadcast_set_event(struct clock_event_device
*bc
, int cpu
,
531 if (!clockevent_state_oneshot(bc
))
532 clockevents_set_state(bc
, CLOCK_EVT_STATE_ONESHOT
);
534 clockevents_program_event(bc
, expires
, 1);
535 tick_broadcast_set_affinity(bc
, cpumask_of(cpu
));
538 static void tick_resume_broadcast_oneshot(struct clock_event_device
*bc
)
540 clockevents_set_state(bc
, CLOCK_EVT_STATE_ONESHOT
);
544 * Called from irq_enter() when idle was interrupted to reenable the
547 void tick_check_oneshot_broadcast_this_cpu(void)
549 if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask
)) {
550 struct tick_device
*td
= this_cpu_ptr(&tick_cpu_device
);
553 * We might be in the middle of switching over from
554 * periodic to oneshot. If the CPU has not yet
555 * switched over, leave the device alone.
557 if (td
->mode
== TICKDEV_MODE_ONESHOT
) {
558 clockevents_set_state(td
->evtdev
,
559 CLOCK_EVT_STATE_ONESHOT
);
565 * Handle oneshot mode broadcasting
567 static void tick_handle_oneshot_broadcast(struct clock_event_device
*dev
)
569 struct tick_device
*td
;
570 ktime_t now
, next_event
;
571 int cpu
, next_cpu
= 0;
574 raw_spin_lock(&tick_broadcast_lock
);
575 dev
->next_event
.tv64
= KTIME_MAX
;
576 next_event
.tv64
= KTIME_MAX
;
577 cpumask_clear(tmpmask
);
579 /* Find all expired events */
580 for_each_cpu(cpu
, tick_broadcast_oneshot_mask
) {
581 td
= &per_cpu(tick_cpu_device
, cpu
);
582 if (td
->evtdev
->next_event
.tv64
<= now
.tv64
) {
583 cpumask_set_cpu(cpu
, tmpmask
);
585 * Mark the remote cpu in the pending mask, so
586 * it can avoid reprogramming the cpu local
587 * timer in tick_broadcast_oneshot_control().
589 cpumask_set_cpu(cpu
, tick_broadcast_pending_mask
);
590 } else if (td
->evtdev
->next_event
.tv64
< next_event
.tv64
) {
591 next_event
.tv64
= td
->evtdev
->next_event
.tv64
;
597 * Remove the current cpu from the pending mask. The event is
598 * delivered immediately in tick_do_broadcast() !
600 cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask
);
602 /* Take care of enforced broadcast requests */
603 cpumask_or(tmpmask
, tmpmask
, tick_broadcast_force_mask
);
604 cpumask_clear(tick_broadcast_force_mask
);
607 * Sanity check. Catch the case where we try to broadcast to
610 if (WARN_ON_ONCE(!cpumask_subset(tmpmask
, cpu_online_mask
)))
611 cpumask_and(tmpmask
, tmpmask
, cpu_online_mask
);
614 * Wakeup the cpus which have an expired event.
616 bc_local
= tick_do_broadcast(tmpmask
);
619 * Two reasons for reprogram:
621 * - The global event did not expire any CPU local
622 * events. This happens in dyntick mode, as the maximum PIT
623 * delta is quite small.
625 * - There are pending events on sleeping CPUs which were not
628 if (next_event
.tv64
!= KTIME_MAX
)
629 tick_broadcast_set_event(dev
, next_cpu
, next_event
);
631 raw_spin_unlock(&tick_broadcast_lock
);
634 td
= this_cpu_ptr(&tick_cpu_device
);
635 td
->evtdev
->event_handler(td
->evtdev
);
639 static int broadcast_needs_cpu(struct clock_event_device
*bc
, int cpu
)
641 if (!(bc
->features
& CLOCK_EVT_FEAT_HRTIMER
))
643 if (bc
->next_event
.tv64
== KTIME_MAX
)
645 return bc
->bound_on
== cpu
? -EBUSY
: 0;
648 static void broadcast_shutdown_local(struct clock_event_device
*bc
,
649 struct clock_event_device
*dev
)
652 * For hrtimer based broadcasting we cannot shutdown the cpu
653 * local device if our own event is the first one to expire or
654 * if we own the broadcast timer.
656 if (bc
->features
& CLOCK_EVT_FEAT_HRTIMER
) {
657 if (broadcast_needs_cpu(bc
, smp_processor_id()))
659 if (dev
->next_event
.tv64
< bc
->next_event
.tv64
)
662 clockevents_set_state(dev
, CLOCK_EVT_STATE_SHUTDOWN
);
666 * tick_broadcast_oneshot_control - Enter/exit broadcast oneshot mode
667 * @state: The target state (enter/exit)
669 * The system enters/leaves a state, where affected devices might stop
670 * Returns 0 on success, -EBUSY if the cpu is used to broadcast wakeups.
672 * Called with interrupts disabled, so clockevents_lock is not
673 * required here because the local clock event device cannot go away
676 int tick_broadcast_oneshot_control(enum tick_broadcast_state state
)
678 struct clock_event_device
*bc
, *dev
;
679 struct tick_device
*td
;
684 * Periodic mode does not care about the enter/exit of power
687 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
691 * We are called with preemtion disabled from the depth of the
692 * idle code, so we can't be moved away.
694 td
= this_cpu_ptr(&tick_cpu_device
);
697 if (!(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
700 raw_spin_lock(&tick_broadcast_lock
);
701 bc
= tick_broadcast_device
.evtdev
;
702 cpu
= smp_processor_id();
704 if (state
== TICK_BROADCAST_ENTER
) {
705 if (!cpumask_test_and_set_cpu(cpu
, tick_broadcast_oneshot_mask
)) {
706 WARN_ON_ONCE(cpumask_test_cpu(cpu
, tick_broadcast_pending_mask
));
707 broadcast_shutdown_local(bc
, dev
);
709 * We only reprogram the broadcast timer if we
710 * did not mark ourself in the force mask and
711 * if the cpu local event is earlier than the
712 * broadcast event. If the current CPU is in
713 * the force mask, then we are going to be
714 * woken by the IPI right away.
716 if (!cpumask_test_cpu(cpu
, tick_broadcast_force_mask
) &&
717 dev
->next_event
.tv64
< bc
->next_event
.tv64
)
718 tick_broadcast_set_event(bc
, cpu
, dev
->next_event
);
721 * If the current CPU owns the hrtimer broadcast
722 * mechanism, it cannot go deep idle and we remove the
723 * CPU from the broadcast mask. We don't have to go
724 * through the EXIT path as the local timer is not
727 ret
= broadcast_needs_cpu(bc
, cpu
);
729 cpumask_clear_cpu(cpu
, tick_broadcast_oneshot_mask
);
731 if (cpumask_test_and_clear_cpu(cpu
, tick_broadcast_oneshot_mask
)) {
732 clockevents_set_state(dev
, CLOCK_EVT_STATE_ONESHOT
);
734 * The cpu which was handling the broadcast
735 * timer marked this cpu in the broadcast
736 * pending mask and fired the broadcast
737 * IPI. So we are going to handle the expired
738 * event anyway via the broadcast IPI
739 * handler. No need to reprogram the timer
740 * with an already expired event.
742 if (cpumask_test_and_clear_cpu(cpu
,
743 tick_broadcast_pending_mask
))
747 * Bail out if there is no next event.
749 if (dev
->next_event
.tv64
== KTIME_MAX
)
752 * If the pending bit is not set, then we are
753 * either the CPU handling the broadcast
754 * interrupt or we got woken by something else.
756 * We are not longer in the broadcast mask, so
757 * if the cpu local expiry time is already
758 * reached, we would reprogram the cpu local
759 * timer with an already expired event.
761 * This can lead to a ping-pong when we return
762 * to idle and therefor rearm the broadcast
763 * timer before the cpu local timer was able
764 * to fire. This happens because the forced
765 * reprogramming makes sure that the event
766 * will happen in the future and depending on
767 * the min_delta setting this might be far
768 * enough out that the ping-pong starts.
770 * If the cpu local next_event has expired
771 * then we know that the broadcast timer
772 * next_event has expired as well and
773 * broadcast is about to be handled. So we
774 * avoid reprogramming and enforce that the
775 * broadcast handler, which did not run yet,
776 * will invoke the cpu local handler.
778 * We cannot call the handler directly from
779 * here, because we might be in a NOHZ phase
780 * and we did not go through the irq_enter()
784 if (dev
->next_event
.tv64
<= now
.tv64
) {
785 cpumask_set_cpu(cpu
, tick_broadcast_force_mask
);
789 * We got woken by something else. Reprogram
790 * the cpu local timer device.
792 tick_program_event(dev
->next_event
, 1);
796 raw_spin_unlock(&tick_broadcast_lock
);
799 EXPORT_SYMBOL_GPL(tick_broadcast_oneshot_control
);
802 * Reset the one shot broadcast for a cpu
804 * Called with tick_broadcast_lock held
806 static void tick_broadcast_clear_oneshot(int cpu
)
808 cpumask_clear_cpu(cpu
, tick_broadcast_oneshot_mask
);
809 cpumask_clear_cpu(cpu
, tick_broadcast_pending_mask
);
812 static void tick_broadcast_init_next_event(struct cpumask
*mask
,
815 struct tick_device
*td
;
818 for_each_cpu(cpu
, mask
) {
819 td
= &per_cpu(tick_cpu_device
, cpu
);
821 td
->evtdev
->next_event
= expires
;
826 * tick_broadcast_setup_oneshot - setup the broadcast device
828 void tick_broadcast_setup_oneshot(struct clock_event_device
*bc
)
830 int cpu
= smp_processor_id();
832 /* Set it up only once ! */
833 if (bc
->event_handler
!= tick_handle_oneshot_broadcast
) {
834 int was_periodic
= clockevent_state_periodic(bc
);
836 bc
->event_handler
= tick_handle_oneshot_broadcast
;
839 * We must be careful here. There might be other CPUs
840 * waiting for periodic broadcast. We need to set the
841 * oneshot_mask bits for those and program the
842 * broadcast device to fire.
844 cpumask_copy(tmpmask
, tick_broadcast_mask
);
845 cpumask_clear_cpu(cpu
, tmpmask
);
846 cpumask_or(tick_broadcast_oneshot_mask
,
847 tick_broadcast_oneshot_mask
, tmpmask
);
849 if (was_periodic
&& !cpumask_empty(tmpmask
)) {
850 clockevents_set_state(bc
, CLOCK_EVT_STATE_ONESHOT
);
851 tick_broadcast_init_next_event(tmpmask
,
853 tick_broadcast_set_event(bc
, cpu
, tick_next_period
);
855 bc
->next_event
.tv64
= KTIME_MAX
;
858 * The first cpu which switches to oneshot mode sets
859 * the bit for all other cpus which are in the general
860 * (periodic) broadcast mask. So the bit is set and
861 * would prevent the first broadcast enter after this
862 * to program the bc device.
864 tick_broadcast_clear_oneshot(cpu
);
869 * Select oneshot operating mode for the broadcast device
871 void tick_broadcast_switch_to_oneshot(void)
873 struct clock_event_device
*bc
;
876 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
878 tick_broadcast_device
.mode
= TICKDEV_MODE_ONESHOT
;
879 bc
= tick_broadcast_device
.evtdev
;
881 tick_broadcast_setup_oneshot(bc
);
883 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
886 #ifdef CONFIG_HOTPLUG_CPU
887 void hotplug_cpu__broadcast_tick_pull(int deadcpu
)
889 struct clock_event_device
*bc
;
892 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
893 bc
= tick_broadcast_device
.evtdev
;
895 if (bc
&& broadcast_needs_cpu(bc
, deadcpu
)) {
896 /* This moves the broadcast assignment to this CPU: */
897 clockevents_program_event(bc
, bc
->next_event
, 1);
899 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
903 * Remove a dead CPU from broadcasting
905 void tick_shutdown_broadcast_oneshot(unsigned int cpu
)
909 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
912 * Clear the broadcast masks for the dead cpu, but do not stop
913 * the broadcast device!
915 cpumask_clear_cpu(cpu
, tick_broadcast_oneshot_mask
);
916 cpumask_clear_cpu(cpu
, tick_broadcast_pending_mask
);
917 cpumask_clear_cpu(cpu
, tick_broadcast_force_mask
);
919 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
924 * Check, whether the broadcast device is in one shot mode
926 int tick_broadcast_oneshot_active(void)
928 return tick_broadcast_device
.mode
== TICKDEV_MODE_ONESHOT
;
932 * Check whether the broadcast device supports oneshot.
934 bool tick_broadcast_oneshot_available(void)
936 struct clock_event_device
*bc
= tick_broadcast_device
.evtdev
;
938 return bc
? bc
->features
& CLOCK_EVT_FEAT_ONESHOT
: false;
943 void __init
tick_broadcast_init(void)
945 zalloc_cpumask_var(&tick_broadcast_mask
, GFP_NOWAIT
);
946 zalloc_cpumask_var(&tick_broadcast_on
, GFP_NOWAIT
);
947 zalloc_cpumask_var(&tmpmask
, GFP_NOWAIT
);
948 #ifdef CONFIG_TICK_ONESHOT
949 zalloc_cpumask_var(&tick_broadcast_oneshot_mask
, GFP_NOWAIT
);
950 zalloc_cpumask_var(&tick_broadcast_pending_mask
, GFP_NOWAIT
);
951 zalloc_cpumask_var(&tick_broadcast_force_mask
, GFP_NOWAIT
);