Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 1 | /* |
| 2 | * linux/kernel/time/tick-common.c |
| 3 | * |
| 4 | * This file contains the base functions to manage periodic tick |
| 5 | * related events. |
| 6 | * |
| 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 |
| 10 | * |
| 11 | * This code is licenced under the GPL version 2. For details see |
| 12 | * kernel-base/COPYING. |
| 13 | */ |
| 14 | #include <linux/cpu.h> |
| 15 | #include <linux/err.h> |
| 16 | #include <linux/hrtimer.h> |
Russell King | d7b9068 | 2008-04-17 07:46:24 +0200 | [diff] [blame] | 17 | #include <linux/interrupt.h> |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 18 | #include <linux/percpu.h> |
| 19 | #include <linux/profile.h> |
| 20 | #include <linux/sched.h> |
| 21 | #include <linux/tick.h> |
| 22 | |
Russell King | d7b9068 | 2008-04-17 07:46:24 +0200 | [diff] [blame] | 23 | #include <asm/irq_regs.h> |
| 24 | |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 25 | #include "tick-internal.h" |
| 26 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 27 | /* |
| 28 | * Tick devices |
| 29 | */ |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 30 | DEFINE_PER_CPU(struct tick_device, tick_cpu_device); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 31 | /* |
| 32 | * Tick next event: keeps track of the tick time |
| 33 | */ |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 34 | ktime_t tick_next_period; |
| 35 | ktime_t tick_period; |
Thomas Gleixner | 6441402 | 2008-09-22 18:46:37 +0200 | [diff] [blame] | 36 | int tick_do_timer_cpu __read_mostly = TICK_DO_TIMER_BOOT; |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 37 | DEFINE_SPINLOCK(tick_device_lock); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 38 | |
Ingo Molnar | 289f480 | 2007-02-16 01:28:15 -0800 | [diff] [blame] | 39 | /* |
| 40 | * Debugging: see timer_list.c |
| 41 | */ |
| 42 | struct tick_device *tick_get_device(int cpu) |
| 43 | { |
| 44 | return &per_cpu(tick_cpu_device, cpu); |
| 45 | } |
| 46 | |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 47 | /** |
| 48 | * tick_is_oneshot_available - check for a oneshot capable event device |
| 49 | */ |
| 50 | int tick_is_oneshot_available(void) |
| 51 | { |
| 52 | struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev; |
| 53 | |
| 54 | return dev && (dev->features & CLOCK_EVT_FEAT_ONESHOT); |
| 55 | } |
| 56 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 57 | /* |
| 58 | * Periodic tick |
| 59 | */ |
| 60 | static void tick_periodic(int cpu) |
| 61 | { |
| 62 | if (tick_do_timer_cpu == cpu) { |
| 63 | write_seqlock(&xtime_lock); |
| 64 | |
| 65 | /* Keep track of the next tick event */ |
| 66 | tick_next_period = ktime_add(tick_next_period, tick_period); |
| 67 | |
| 68 | do_timer(1); |
| 69 | write_sequnlock(&xtime_lock); |
| 70 | } |
| 71 | |
| 72 | update_process_times(user_mode(get_irq_regs())); |
| 73 | profile_tick(CPU_PROFILING); |
| 74 | } |
| 75 | |
| 76 | /* |
| 77 | * Event handler for periodic ticks |
| 78 | */ |
| 79 | void tick_handle_periodic(struct clock_event_device *dev) |
| 80 | { |
| 81 | int cpu = smp_processor_id(); |
David S. Miller | 3494c16 | 2007-02-24 22:11:42 -0800 | [diff] [blame] | 82 | ktime_t next; |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 83 | |
| 84 | tick_periodic(cpu); |
| 85 | |
| 86 | if (dev->mode != CLOCK_EVT_MODE_ONESHOT) |
| 87 | return; |
| 88 | /* |
| 89 | * Setup the next period for devices, which do not have |
| 90 | * periodic mode: |
| 91 | */ |
David S. Miller | 3494c16 | 2007-02-24 22:11:42 -0800 | [diff] [blame] | 92 | next = ktime_add(dev->next_event, tick_period); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 93 | for (;;) { |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 94 | if (!clockevents_program_event(dev, next, ktime_get())) |
| 95 | return; |
| 96 | tick_periodic(cpu); |
David S. Miller | 3494c16 | 2007-02-24 22:11:42 -0800 | [diff] [blame] | 97 | next = ktime_add(next, tick_period); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 98 | } |
| 99 | } |
| 100 | |
| 101 | /* |
| 102 | * Setup the device for a periodic tick |
| 103 | */ |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 104 | void tick_setup_periodic(struct clock_event_device *dev, int broadcast) |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 105 | { |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 106 | tick_set_periodic_handler(dev, broadcast); |
| 107 | |
| 108 | /* Broadcast setup ? */ |
| 109 | if (!tick_device_is_functional(dev)) |
| 110 | return; |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 111 | |
Thomas Gleixner | 27ce4cb | 2008-09-22 19:04:02 +0200 | [diff] [blame] | 112 | if ((dev->features & CLOCK_EVT_FEAT_PERIODIC) && |
| 113 | !tick_broadcast_oneshot_active()) { |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 114 | clockevents_set_mode(dev, CLOCK_EVT_MODE_PERIODIC); |
| 115 | } else { |
| 116 | unsigned long seq; |
| 117 | ktime_t next; |
| 118 | |
| 119 | do { |
| 120 | seq = read_seqbegin(&xtime_lock); |
| 121 | next = tick_next_period; |
| 122 | } while (read_seqretry(&xtime_lock, seq)); |
| 123 | |
| 124 | clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT); |
| 125 | |
| 126 | for (;;) { |
| 127 | if (!clockevents_program_event(dev, next, ktime_get())) |
| 128 | return; |
| 129 | next = ktime_add(next, tick_period); |
| 130 | } |
| 131 | } |
| 132 | } |
| 133 | |
| 134 | /* |
| 135 | * Setup the tick device |
| 136 | */ |
| 137 | static void tick_setup_device(struct tick_device *td, |
| 138 | struct clock_event_device *newdev, int cpu, |
Mike Travis | c18a41f | 2008-07-15 14:14:34 -0700 | [diff] [blame] | 139 | const cpumask_t *cpumask) |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 140 | { |
| 141 | ktime_t next_event; |
| 142 | void (*handler)(struct clock_event_device *) = NULL; |
| 143 | |
| 144 | /* |
| 145 | * First device setup ? |
| 146 | */ |
| 147 | if (!td->evtdev) { |
| 148 | /* |
| 149 | * If no cpu took the do_timer update, assign it to |
| 150 | * this cpu: |
| 151 | */ |
Thomas Gleixner | 6441402 | 2008-09-22 18:46:37 +0200 | [diff] [blame] | 152 | if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) { |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 153 | tick_do_timer_cpu = cpu; |
| 154 | tick_next_period = ktime_get(); |
| 155 | tick_period = ktime_set(0, NSEC_PER_SEC / HZ); |
| 156 | } |
| 157 | |
| 158 | /* |
| 159 | * Startup in periodic mode first. |
| 160 | */ |
| 161 | td->mode = TICKDEV_MODE_PERIODIC; |
| 162 | } else { |
| 163 | handler = td->evtdev->event_handler; |
| 164 | next_event = td->evtdev->next_event; |
Venkatesh Pallipadi | 7c1e768 | 2008-09-03 21:36:50 +0000 | [diff] [blame] | 165 | td->evtdev->event_handler = clockevents_handle_noop; |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | td->evtdev = newdev; |
| 169 | |
| 170 | /* |
| 171 | * When the device is not per cpu, pin the interrupt to the |
| 172 | * current cpu: |
| 173 | */ |
Mike Travis | c18a41f | 2008-07-15 14:14:34 -0700 | [diff] [blame] | 174 | if (!cpus_equal(newdev->cpumask, *cpumask)) |
| 175 | irq_set_affinity(newdev->irq, *cpumask); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 176 | |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 177 | /* |
| 178 | * When global broadcasting is active, check if the current |
| 179 | * device is registered as a placeholder for broadcast mode. |
| 180 | * This allows us to handle this x86 misfeature in a generic |
| 181 | * way. |
| 182 | */ |
| 183 | if (tick_device_uses_broadcast(newdev, cpu)) |
| 184 | return; |
| 185 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 186 | if (td->mode == TICKDEV_MODE_PERIODIC) |
| 187 | tick_setup_periodic(newdev, 0); |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 188 | else |
| 189 | tick_setup_oneshot(newdev, handler, next_event); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | /* |
| 193 | * Check, if the new registered device should be used. |
| 194 | */ |
| 195 | static int tick_check_new_device(struct clock_event_device *newdev) |
| 196 | { |
| 197 | struct clock_event_device *curdev; |
| 198 | struct tick_device *td; |
| 199 | int cpu, ret = NOTIFY_OK; |
| 200 | unsigned long flags; |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 201 | |
| 202 | spin_lock_irqsave(&tick_device_lock, flags); |
| 203 | |
| 204 | cpu = smp_processor_id(); |
| 205 | if (!cpu_isset(cpu, newdev->cpumask)) |
Venki Pallipadi | 4a93232 | 2007-10-12 23:04:23 +0200 | [diff] [blame] | 206 | goto out_bc; |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 207 | |
| 208 | td = &per_cpu(tick_cpu_device, cpu); |
| 209 | curdev = td->evtdev; |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 210 | |
| 211 | /* cpu local device ? */ |
Mike Travis | 0bc3cc0 | 2008-07-24 18:21:31 -0700 | [diff] [blame] | 212 | if (!cpus_equal(newdev->cpumask, cpumask_of_cpu(cpu))) { |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 213 | |
| 214 | /* |
| 215 | * If the cpu affinity of the device interrupt can not |
| 216 | * be set, ignore it. |
| 217 | */ |
| 218 | if (!irq_can_set_affinity(newdev->irq)) |
| 219 | goto out_bc; |
| 220 | |
| 221 | /* |
| 222 | * If we have a cpu local device already, do not replace it |
| 223 | * by a non cpu local device |
| 224 | */ |
Mike Travis | 0bc3cc0 | 2008-07-24 18:21:31 -0700 | [diff] [blame] | 225 | if (curdev && cpus_equal(curdev->cpumask, cpumask_of_cpu(cpu))) |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 226 | goto out_bc; |
| 227 | } |
| 228 | |
| 229 | /* |
| 230 | * If we have an active device, then check the rating and the oneshot |
| 231 | * feature. |
| 232 | */ |
| 233 | if (curdev) { |
| 234 | /* |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 235 | * Prefer one shot capable devices ! |
| 236 | */ |
| 237 | if ((curdev->features & CLOCK_EVT_FEAT_ONESHOT) && |
| 238 | !(newdev->features & CLOCK_EVT_FEAT_ONESHOT)) |
| 239 | goto out_bc; |
| 240 | /* |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 241 | * Check the rating |
| 242 | */ |
| 243 | if (curdev->rating >= newdev->rating) |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 244 | goto out_bc; |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 245 | } |
| 246 | |
| 247 | /* |
| 248 | * Replace the eventually existing device by the new |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 249 | * device. If the current device is the broadcast device, do |
| 250 | * not give it back to the clockevents layer ! |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 251 | */ |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 252 | if (tick_is_broadcast_device(curdev)) { |
Thomas Gleixner | 2344abb | 2008-09-16 11:32:50 -0700 | [diff] [blame] | 253 | clockevents_shutdown(curdev); |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 254 | curdev = NULL; |
| 255 | } |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 256 | clockevents_exchange_device(curdev, newdev); |
Mike Travis | 0bc3cc0 | 2008-07-24 18:21:31 -0700 | [diff] [blame] | 257 | tick_setup_device(td, newdev, cpu, &cpumask_of_cpu(cpu)); |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 258 | if (newdev->features & CLOCK_EVT_FEAT_ONESHOT) |
| 259 | tick_oneshot_notify(); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 260 | |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 261 | spin_unlock_irqrestore(&tick_device_lock, flags); |
| 262 | return NOTIFY_STOP; |
| 263 | |
| 264 | out_bc: |
| 265 | /* |
| 266 | * Can the new device be used as a broadcast device ? |
| 267 | */ |
| 268 | if (tick_check_broadcast_device(newdev)) |
| 269 | ret = NOTIFY_STOP; |
Venki Pallipadi | 4a93232 | 2007-10-12 23:04:23 +0200 | [diff] [blame] | 270 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 271 | spin_unlock_irqrestore(&tick_device_lock, flags); |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 272 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 273 | return ret; |
| 274 | } |
| 275 | |
| 276 | /* |
| 277 | * Shutdown an event device on a given cpu: |
| 278 | * |
| 279 | * This is called on a life CPU, when a CPU is dead. So we cannot |
| 280 | * access the hardware device itself. |
| 281 | * We just set the mode and remove it from the lists. |
| 282 | */ |
| 283 | static void tick_shutdown(unsigned int *cpup) |
| 284 | { |
| 285 | struct tick_device *td = &per_cpu(tick_cpu_device, *cpup); |
| 286 | struct clock_event_device *dev = td->evtdev; |
| 287 | unsigned long flags; |
| 288 | |
| 289 | spin_lock_irqsave(&tick_device_lock, flags); |
| 290 | td->mode = TICKDEV_MODE_PERIODIC; |
| 291 | if (dev) { |
| 292 | /* |
| 293 | * Prevent that the clock events layer tries to call |
| 294 | * the set mode function! |
| 295 | */ |
| 296 | dev->mode = CLOCK_EVT_MODE_UNUSED; |
| 297 | clockevents_exchange_device(dev, NULL); |
| 298 | td->evtdev = NULL; |
| 299 | } |
Thomas Gleixner | d3ed782 | 2007-05-08 00:30:03 -0700 | [diff] [blame] | 300 | /* Transfer the do_timer job away from this cpu */ |
| 301 | if (*cpup == tick_do_timer_cpu) { |
| 302 | int cpu = first_cpu(cpu_online_map); |
| 303 | |
Thomas Gleixner | 6441402 | 2008-09-22 18:46:37 +0200 | [diff] [blame] | 304 | tick_do_timer_cpu = (cpu != NR_CPUS) ? cpu : |
| 305 | TICK_DO_TIMER_NONE; |
Thomas Gleixner | d3ed782 | 2007-05-08 00:30:03 -0700 | [diff] [blame] | 306 | } |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 307 | spin_unlock_irqrestore(&tick_device_lock, flags); |
| 308 | } |
| 309 | |
Thomas Gleixner | cd05a1f | 2007-03-17 00:25:52 +0100 | [diff] [blame] | 310 | static void tick_suspend(void) |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 311 | { |
| 312 | struct tick_device *td = &__get_cpu_var(tick_cpu_device); |
| 313 | unsigned long flags; |
| 314 | |
| 315 | spin_lock_irqsave(&tick_device_lock, flags); |
Thomas Gleixner | 2344abb | 2008-09-16 11:32:50 -0700 | [diff] [blame] | 316 | clockevents_shutdown(td->evtdev); |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 317 | spin_unlock_irqrestore(&tick_device_lock, flags); |
| 318 | } |
| 319 | |
Thomas Gleixner | cd05a1f | 2007-03-17 00:25:52 +0100 | [diff] [blame] | 320 | static void tick_resume(void) |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 321 | { |
| 322 | struct tick_device *td = &__get_cpu_var(tick_cpu_device); |
| 323 | unsigned long flags; |
Thomas Gleixner | 18de5bc | 2007-07-21 04:37:34 -0700 | [diff] [blame] | 324 | int broadcast = tick_resume_broadcast(); |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 325 | |
| 326 | spin_lock_irqsave(&tick_device_lock, flags); |
Thomas Gleixner | 18de5bc | 2007-07-21 04:37:34 -0700 | [diff] [blame] | 327 | clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_RESUME); |
| 328 | |
| 329 | if (!broadcast) { |
| 330 | if (td->mode == TICKDEV_MODE_PERIODIC) |
| 331 | tick_setup_periodic(td->evtdev, 0); |
| 332 | else |
| 333 | tick_resume_oneshot(); |
| 334 | } |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 335 | spin_unlock_irqrestore(&tick_device_lock, flags); |
| 336 | } |
| 337 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 338 | /* |
| 339 | * Notification about clock event devices |
| 340 | */ |
| 341 | static int tick_notify(struct notifier_block *nb, unsigned long reason, |
| 342 | void *dev) |
| 343 | { |
| 344 | switch (reason) { |
| 345 | |
| 346 | case CLOCK_EVT_NOTIFY_ADD: |
| 347 | return tick_check_new_device(dev); |
| 348 | |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 349 | case CLOCK_EVT_NOTIFY_BROADCAST_ON: |
| 350 | case CLOCK_EVT_NOTIFY_BROADCAST_OFF: |
Thomas Gleixner | 1595f45 | 2007-10-14 22:57:45 +0200 | [diff] [blame] | 351 | case CLOCK_EVT_NOTIFY_BROADCAST_FORCE: |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 352 | tick_broadcast_on_off(reason, dev); |
| 353 | break; |
| 354 | |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 355 | case CLOCK_EVT_NOTIFY_BROADCAST_ENTER: |
| 356 | case CLOCK_EVT_NOTIFY_BROADCAST_EXIT: |
| 357 | tick_broadcast_oneshot_control(reason); |
| 358 | break; |
| 359 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 360 | case CLOCK_EVT_NOTIFY_CPU_DEAD: |
Thomas Gleixner | 79bf2bb | 2007-02-16 01:28:03 -0800 | [diff] [blame] | 361 | tick_shutdown_broadcast_oneshot(dev); |
Thomas Gleixner | f8381cb | 2007-02-16 01:28:02 -0800 | [diff] [blame] | 362 | tick_shutdown_broadcast(dev); |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 363 | tick_shutdown(dev); |
| 364 | break; |
| 365 | |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 366 | case CLOCK_EVT_NOTIFY_SUSPEND: |
Thomas Gleixner | cd05a1f | 2007-03-17 00:25:52 +0100 | [diff] [blame] | 367 | tick_suspend(); |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 368 | tick_suspend_broadcast(); |
| 369 | break; |
| 370 | |
| 371 | case CLOCK_EVT_NOTIFY_RESUME: |
Thomas Gleixner | 18de5bc | 2007-07-21 04:37:34 -0700 | [diff] [blame] | 372 | tick_resume(); |
Thomas Gleixner | 6321dd6 | 2007-03-06 08:25:42 +0100 | [diff] [blame] | 373 | break; |
| 374 | |
Thomas Gleixner | 906568c | 2007-02-16 01:28:01 -0800 | [diff] [blame] | 375 | default: |
| 376 | break; |
| 377 | } |
| 378 | |
| 379 | return NOTIFY_OK; |
| 380 | } |
| 381 | |
| 382 | static struct notifier_block tick_notifier = { |
| 383 | .notifier_call = tick_notify, |
| 384 | }; |
| 385 | |
| 386 | /** |
| 387 | * tick_init - initialize the tick control |
| 388 | * |
| 389 | * Register the notifier with the clockevents framework |
| 390 | */ |
| 391 | void __init tick_init(void) |
| 392 | { |
| 393 | clockevents_register_notifier(&tick_notifier); |
| 394 | } |