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/irq.h>
18 #include <linux/percpu.h>
19 #include <linux/profile.h>
20 #include <linux/sched.h>
21 #include <linux/tick.h>
23 #include "tick-internal.h"
26 * Broadcast support for broken x86 hardware, where the local apic
27 * timer stops in C3 state.
30 struct tick_device tick_broadcast_device
;
31 static cpumask_t tick_broadcast_mask
;
32 DEFINE_SPINLOCK(tick_broadcast_lock
);
35 * Start the device in periodic mode
37 static void tick_broadcast_start_periodic(struct clock_event_device
*bc
)
39 if (bc
&& bc
->mode
== CLOCK_EVT_MODE_SHUTDOWN
)
40 tick_setup_periodic(bc
, 1);
44 * Check, if the device can be utilized as broadcast device:
46 int tick_check_broadcast_device(struct clock_event_device
*dev
)
48 if (tick_broadcast_device
.evtdev
||
49 (dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
52 clockevents_exchange_device(NULL
, dev
);
53 tick_broadcast_device
.evtdev
= dev
;
54 if (!cpus_empty(tick_broadcast_mask
))
55 tick_broadcast_start_periodic(dev
);
60 * Check, if the device is the broadcast device
62 int tick_is_broadcast_device(struct clock_event_device
*dev
)
64 return (dev
&& tick_broadcast_device
.evtdev
== dev
);
68 * Check, if the device is disfunctional and a place holder, which
69 * needs to be handled by the broadcast device.
71 int tick_device_uses_broadcast(struct clock_event_device
*dev
, int cpu
)
76 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
79 * Devices might be registered with both periodic and oneshot
80 * mode disabled. This signals, that the device needs to be
81 * operated from the broadcast device and is a placeholder for
82 * the cpu local device.
84 if (!tick_device_is_functional(dev
)) {
85 dev
->event_handler
= tick_handle_periodic
;
86 cpu_set(cpu
, tick_broadcast_mask
);
87 tick_broadcast_start_periodic(tick_broadcast_device
.evtdev
);
91 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
96 * Broadcast the event to the cpus, which are set in the mask
98 int tick_do_broadcast(cpumask_t mask
)
100 int ret
= 0, cpu
= smp_processor_id();
101 struct tick_device
*td
;
104 * Check, if the current cpu is in the mask
106 if (cpu_isset(cpu
, mask
)) {
107 cpu_clear(cpu
, mask
);
108 td
= &per_cpu(tick_cpu_device
, cpu
);
109 td
->evtdev
->event_handler(td
->evtdev
);
113 if (!cpus_empty(mask
)) {
115 * It might be necessary to actually check whether the devices
116 * have different broadcast functions. For now, just use the
117 * one of the first device. This works as long as we have this
118 * misfeature only on x86 (lapic)
120 cpu
= first_cpu(mask
);
121 td
= &per_cpu(tick_cpu_device
, cpu
);
122 td
->evtdev
->broadcast(mask
);
129 * Periodic broadcast:
130 * - invoke the broadcast handlers
132 static void tick_do_periodic_broadcast(void)
136 spin_lock(&tick_broadcast_lock
);
138 cpus_and(mask
, cpu_online_map
, tick_broadcast_mask
);
139 tick_do_broadcast(mask
);
141 spin_unlock(&tick_broadcast_lock
);
145 * Event handler for periodic broadcast ticks
147 static void tick_handle_periodic_broadcast(struct clock_event_device
*dev
)
149 dev
->next_event
.tv64
= KTIME_MAX
;
151 tick_do_periodic_broadcast();
154 * The device is in periodic mode. No reprogramming necessary:
156 if (dev
->mode
== CLOCK_EVT_MODE_PERIODIC
)
160 * Setup the next period for devices, which do not have
164 ktime_t next
= ktime_add(dev
->next_event
, tick_period
);
166 if (!clockevents_program_event(dev
, next
, ktime_get()))
168 tick_do_periodic_broadcast();
173 * Powerstate information: The system enters/leaves a state, where
174 * affected devices might stop
176 static void tick_do_broadcast_on_off(void *why
)
178 struct clock_event_device
*bc
, *dev
;
179 struct tick_device
*td
;
180 unsigned long flags
, *reason
= why
;
183 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
185 cpu
= smp_processor_id();
186 td
= &per_cpu(tick_cpu_device
, cpu
);
188 bc
= tick_broadcast_device
.evtdev
;
191 * Is the device in broadcast mode forever or is it not
192 * affected by the powerstate ?
194 if (!dev
|| !tick_device_is_functional(dev
) ||
195 !(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
198 if (*reason
== CLOCK_EVT_NOTIFY_BROADCAST_ON
) {
199 if (!cpu_isset(cpu
, tick_broadcast_mask
)) {
200 cpu_set(cpu
, tick_broadcast_mask
);
201 if (td
->mode
== TICKDEV_MODE_PERIODIC
)
202 clockevents_set_mode(dev
,
203 CLOCK_EVT_MODE_SHUTDOWN
);
206 if (cpu_isset(cpu
, tick_broadcast_mask
)) {
207 cpu_clear(cpu
, tick_broadcast_mask
);
208 if (td
->mode
== TICKDEV_MODE_PERIODIC
)
209 tick_setup_periodic(dev
, 0);
213 if (cpus_empty(tick_broadcast_mask
))
214 clockevents_set_mode(bc
, CLOCK_EVT_MODE_SHUTDOWN
);
216 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
217 tick_broadcast_start_periodic(bc
);
220 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
224 * Powerstate information: The system enters/leaves a state, where
225 * affected devices might stop.
227 void tick_broadcast_on_off(unsigned long reason
, int *oncpu
)
232 tick_do_broadcast_on_off(&reason
);
234 smp_call_function_single(*oncpu
, tick_do_broadcast_on_off
,
240 * Set the periodic handler depending on broadcast on/off
242 void tick_set_periodic_handler(struct clock_event_device
*dev
, int broadcast
)
245 dev
->event_handler
= tick_handle_periodic
;
247 dev
->event_handler
= tick_handle_periodic_broadcast
;
251 * Remove a CPU from broadcasting
253 void tick_shutdown_broadcast(unsigned int *cpup
)
255 struct clock_event_device
*bc
;
257 unsigned int cpu
= *cpup
;
259 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
261 bc
= tick_broadcast_device
.evtdev
;
262 cpu_clear(cpu
, tick_broadcast_mask
);
264 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
) {
265 if (bc
&& cpus_empty(tick_broadcast_mask
))
266 clockevents_set_mode(bc
, CLOCK_EVT_MODE_SHUTDOWN
);
269 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);