2007-02-16 02:28:01 -07:00
|
|
|
/*
|
|
|
|
* linux/kernel/time/tick-common.c
|
|
|
|
*
|
|
|
|
* This file contains the base functions to manage periodic tick
|
|
|
|
* related events.
|
|
|
|
*
|
|
|
|
* Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
|
|
|
|
* Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
|
|
|
|
* Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
|
|
|
|
*
|
|
|
|
* This code is licenced under the GPL version 2. For details see
|
|
|
|
* kernel-base/COPYING.
|
|
|
|
*/
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/hrtimer.h>
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/profile.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/tick.h>
|
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
#include "tick-internal.h"
|
|
|
|
|
2007-02-16 02:28:01 -07:00
|
|
|
/*
|
|
|
|
* Tick devices
|
|
|
|
*/
|
2007-02-16 02:28:02 -07:00
|
|
|
DEFINE_PER_CPU(struct tick_device, tick_cpu_device);
|
2007-02-16 02:28:01 -07:00
|
|
|
/*
|
|
|
|
* Tick next event: keeps track of the tick time
|
|
|
|
*/
|
2007-02-16 02:28:02 -07:00
|
|
|
ktime_t tick_next_period;
|
|
|
|
ktime_t tick_period;
|
2007-05-08 01:30:03 -06:00
|
|
|
int tick_do_timer_cpu __read_mostly = -1;
|
2007-02-16 02:28:02 -07:00
|
|
|
DEFINE_SPINLOCK(tick_device_lock);
|
2007-02-16 02:28:01 -07:00
|
|
|
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
/*
|
|
|
|
* Debugging: see timer_list.c
|
|
|
|
*/
|
|
|
|
struct tick_device *tick_get_device(int cpu)
|
|
|
|
{
|
|
|
|
return &per_cpu(tick_cpu_device, cpu);
|
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:03 -07:00
|
|
|
/**
|
|
|
|
* tick_is_oneshot_available - check for a oneshot capable event device
|
|
|
|
*/
|
|
|
|
int tick_is_oneshot_available(void)
|
|
|
|
{
|
|
|
|
struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
|
|
|
|
|
|
|
|
return dev && (dev->features & CLOCK_EVT_FEAT_ONESHOT);
|
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:01 -07:00
|
|
|
/*
|
|
|
|
* Periodic tick
|
|
|
|
*/
|
|
|
|
static void tick_periodic(int cpu)
|
|
|
|
{
|
|
|
|
if (tick_do_timer_cpu == cpu) {
|
|
|
|
write_seqlock(&xtime_lock);
|
|
|
|
|
|
|
|
/* Keep track of the next tick event */
|
|
|
|
tick_next_period = ktime_add(tick_next_period, tick_period);
|
|
|
|
|
|
|
|
do_timer(1);
|
|
|
|
write_sequnlock(&xtime_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
update_process_times(user_mode(get_irq_regs()));
|
|
|
|
profile_tick(CPU_PROFILING);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Event handler for periodic ticks
|
|
|
|
*/
|
|
|
|
void tick_handle_periodic(struct clock_event_device *dev)
|
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
2007-02-24 23:11:42 -07:00
|
|
|
ktime_t next;
|
2007-02-16 02:28:01 -07:00
|
|
|
|
|
|
|
tick_periodic(cpu);
|
|
|
|
|
|
|
|
if (dev->mode != CLOCK_EVT_MODE_ONESHOT)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Setup the next period for devices, which do not have
|
|
|
|
* periodic mode:
|
|
|
|
*/
|
2007-02-24 23:11:42 -07:00
|
|
|
next = ktime_add(dev->next_event, tick_period);
|
2007-02-16 02:28:01 -07:00
|
|
|
for (;;) {
|
|
|
|
if (!clockevents_program_event(dev, next, ktime_get()))
|
|
|
|
return;
|
|
|
|
tick_periodic(cpu);
|
2007-02-24 23:11:42 -07:00
|
|
|
next = ktime_add(next, tick_period);
|
2007-02-16 02:28:01 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup the device for a periodic tick
|
|
|
|
*/
|
2007-02-16 02:28:02 -07:00
|
|
|
void tick_setup_periodic(struct clock_event_device *dev, int broadcast)
|
2007-02-16 02:28:01 -07:00
|
|
|
{
|
2007-02-16 02:28:02 -07:00
|
|
|
tick_set_periodic_handler(dev, broadcast);
|
|
|
|
|
|
|
|
/* Broadcast setup ? */
|
|
|
|
if (!tick_device_is_functional(dev))
|
|
|
|
return;
|
2007-02-16 02:28:01 -07:00
|
|
|
|
|
|
|
if (dev->features & CLOCK_EVT_FEAT_PERIODIC) {
|
|
|
|
clockevents_set_mode(dev, CLOCK_EVT_MODE_PERIODIC);
|
|
|
|
} else {
|
|
|
|
unsigned long seq;
|
|
|
|
ktime_t next;
|
|
|
|
|
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&xtime_lock);
|
|
|
|
next = tick_next_period;
|
|
|
|
} while (read_seqretry(&xtime_lock, seq));
|
|
|
|
|
|
|
|
clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
if (!clockevents_program_event(dev, next, ktime_get()))
|
|
|
|
return;
|
|
|
|
next = ktime_add(next, tick_period);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup the tick device
|
|
|
|
*/
|
|
|
|
static void tick_setup_device(struct tick_device *td,
|
|
|
|
struct clock_event_device *newdev, int cpu,
|
|
|
|
cpumask_t cpumask)
|
|
|
|
{
|
|
|
|
ktime_t next_event;
|
|
|
|
void (*handler)(struct clock_event_device *) = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First device setup ?
|
|
|
|
*/
|
|
|
|
if (!td->evtdev) {
|
|
|
|
/*
|
|
|
|
* If no cpu took the do_timer update, assign it to
|
|
|
|
* this cpu:
|
|
|
|
*/
|
|
|
|
if (tick_do_timer_cpu == -1) {
|
|
|
|
tick_do_timer_cpu = cpu;
|
|
|
|
tick_next_period = ktime_get();
|
|
|
|
tick_period = ktime_set(0, NSEC_PER_SEC / HZ);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Startup in periodic mode first.
|
|
|
|
*/
|
|
|
|
td->mode = TICKDEV_MODE_PERIODIC;
|
|
|
|
} else {
|
|
|
|
handler = td->evtdev->event_handler;
|
|
|
|
next_event = td->evtdev->next_event;
|
|
|
|
}
|
|
|
|
|
|
|
|
td->evtdev = newdev;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When the device is not per cpu, pin the interrupt to the
|
|
|
|
* current cpu:
|
|
|
|
*/
|
|
|
|
if (!cpus_equal(newdev->cpumask, cpumask))
|
|
|
|
irq_set_affinity(newdev->irq, cpumask);
|
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
/*
|
|
|
|
* When global broadcasting is active, check if the current
|
|
|
|
* device is registered as a placeholder for broadcast mode.
|
|
|
|
* This allows us to handle this x86 misfeature in a generic
|
|
|
|
* way.
|
|
|
|
*/
|
|
|
|
if (tick_device_uses_broadcast(newdev, cpu))
|
|
|
|
return;
|
|
|
|
|
2007-02-16 02:28:01 -07:00
|
|
|
if (td->mode == TICKDEV_MODE_PERIODIC)
|
|
|
|
tick_setup_periodic(newdev, 0);
|
2007-02-16 02:28:03 -07:00
|
|
|
else
|
|
|
|
tick_setup_oneshot(newdev, handler, next_event);
|
2007-02-16 02:28:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check, if the new registered device should be used.
|
|
|
|
*/
|
|
|
|
static int tick_check_new_device(struct clock_event_device *newdev)
|
|
|
|
{
|
|
|
|
struct clock_event_device *curdev;
|
|
|
|
struct tick_device *td;
|
|
|
|
int cpu, ret = NOTIFY_OK;
|
|
|
|
unsigned long flags;
|
|
|
|
cpumask_t cpumask;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tick_device_lock, flags);
|
|
|
|
|
|
|
|
cpu = smp_processor_id();
|
|
|
|
if (!cpu_isset(cpu, newdev->cpumask))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
td = &per_cpu(tick_cpu_device, cpu);
|
|
|
|
curdev = td->evtdev;
|
|
|
|
cpumask = cpumask_of_cpu(cpu);
|
|
|
|
|
|
|
|
/* cpu local device ? */
|
|
|
|
if (!cpus_equal(newdev->cpumask, cpumask)) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the cpu affinity of the device interrupt can not
|
|
|
|
* be set, ignore it.
|
|
|
|
*/
|
|
|
|
if (!irq_can_set_affinity(newdev->irq))
|
|
|
|
goto out_bc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have a cpu local device already, do not replace it
|
|
|
|
* by a non cpu local device
|
|
|
|
*/
|
|
|
|
if (curdev && cpus_equal(curdev->cpumask, cpumask))
|
|
|
|
goto out_bc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have an active device, then check the rating and the oneshot
|
|
|
|
* feature.
|
|
|
|
*/
|
|
|
|
if (curdev) {
|
2007-02-16 02:28:03 -07:00
|
|
|
/*
|
|
|
|
* Prefer one shot capable devices !
|
|
|
|
*/
|
|
|
|
if ((curdev->features & CLOCK_EVT_FEAT_ONESHOT) &&
|
|
|
|
!(newdev->features & CLOCK_EVT_FEAT_ONESHOT))
|
|
|
|
goto out_bc;
|
2007-02-16 02:28:01 -07:00
|
|
|
/*
|
|
|
|
* Check the rating
|
|
|
|
*/
|
|
|
|
if (curdev->rating >= newdev->rating)
|
2007-02-16 02:28:02 -07:00
|
|
|
goto out_bc;
|
2007-02-16 02:28:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Replace the eventually existing device by the new
|
2007-02-16 02:28:02 -07:00
|
|
|
* device. If the current device is the broadcast device, do
|
|
|
|
* not give it back to the clockevents layer !
|
2007-02-16 02:28:01 -07:00
|
|
|
*/
|
2007-02-16 02:28:02 -07:00
|
|
|
if (tick_is_broadcast_device(curdev)) {
|
|
|
|
clockevents_set_mode(curdev, CLOCK_EVT_MODE_SHUTDOWN);
|
|
|
|
curdev = NULL;
|
|
|
|
}
|
2007-02-16 02:28:01 -07:00
|
|
|
clockevents_exchange_device(curdev, newdev);
|
|
|
|
tick_setup_device(td, newdev, cpu, cpumask);
|
2007-02-16 02:28:03 -07:00
|
|
|
if (newdev->features & CLOCK_EVT_FEAT_ONESHOT)
|
|
|
|
tick_oneshot_notify();
|
2007-02-16 02:28:01 -07:00
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
spin_unlock_irqrestore(&tick_device_lock, flags);
|
|
|
|
return NOTIFY_STOP;
|
|
|
|
|
|
|
|
out_bc:
|
|
|
|
/*
|
|
|
|
* Can the new device be used as a broadcast device ?
|
|
|
|
*/
|
|
|
|
if (tick_check_broadcast_device(newdev))
|
|
|
|
ret = NOTIFY_STOP;
|
2007-02-16 02:28:01 -07:00
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&tick_device_lock, flags);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2007-02-16 02:28:01 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shutdown an event device on a given cpu:
|
|
|
|
*
|
|
|
|
* This is called on a life CPU, when a CPU is dead. So we cannot
|
|
|
|
* access the hardware device itself.
|
|
|
|
* We just set the mode and remove it from the lists.
|
|
|
|
*/
|
|
|
|
static void tick_shutdown(unsigned int *cpup)
|
|
|
|
{
|
|
|
|
struct tick_device *td = &per_cpu(tick_cpu_device, *cpup);
|
|
|
|
struct clock_event_device *dev = td->evtdev;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tick_device_lock, flags);
|
|
|
|
td->mode = TICKDEV_MODE_PERIODIC;
|
|
|
|
if (dev) {
|
|
|
|
/*
|
|
|
|
* Prevent that the clock events layer tries to call
|
|
|
|
* the set mode function!
|
|
|
|
*/
|
|
|
|
dev->mode = CLOCK_EVT_MODE_UNUSED;
|
|
|
|
clockevents_exchange_device(dev, NULL);
|
|
|
|
td->evtdev = NULL;
|
|
|
|
}
|
2007-05-08 01:30:03 -06:00
|
|
|
/* Transfer the do_timer job away from this cpu */
|
|
|
|
if (*cpup == tick_do_timer_cpu) {
|
|
|
|
int cpu = first_cpu(cpu_online_map);
|
|
|
|
|
|
|
|
tick_do_timer_cpu = (cpu != NR_CPUS) ? cpu : -1;
|
|
|
|
}
|
2007-02-16 02:28:01 -07:00
|
|
|
spin_unlock_irqrestore(&tick_device_lock, flags);
|
|
|
|
}
|
|
|
|
|
2007-03-16 17:25:52 -06:00
|
|
|
static void tick_suspend(void)
|
2007-03-06 00:25:42 -07:00
|
|
|
{
|
|
|
|
struct tick_device *td = &__get_cpu_var(tick_cpu_device);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tick_device_lock, flags);
|
2007-03-16 17:25:52 -06:00
|
|
|
clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_SHUTDOWN);
|
2007-03-06 00:25:42 -07:00
|
|
|
spin_unlock_irqrestore(&tick_device_lock, flags);
|
|
|
|
}
|
|
|
|
|
2007-03-16 17:25:52 -06:00
|
|
|
static void tick_resume(void)
|
2007-03-06 00:25:42 -07:00
|
|
|
{
|
|
|
|
struct tick_device *td = &__get_cpu_var(tick_cpu_device);
|
|
|
|
unsigned long flags;
|
2007-07-21 05:37:34 -06:00
|
|
|
int broadcast = tick_resume_broadcast();
|
2007-03-06 00:25:42 -07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&tick_device_lock, flags);
|
2007-07-21 05:37:34 -06:00
|
|
|
clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_RESUME);
|
|
|
|
|
|
|
|
if (!broadcast) {
|
|
|
|
if (td->mode == TICKDEV_MODE_PERIODIC)
|
|
|
|
tick_setup_periodic(td->evtdev, 0);
|
|
|
|
else
|
|
|
|
tick_resume_oneshot();
|
|
|
|
}
|
2007-03-06 00:25:42 -07:00
|
|
|
spin_unlock_irqrestore(&tick_device_lock, flags);
|
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:01 -07:00
|
|
|
/*
|
|
|
|
* Notification about clock event devices
|
|
|
|
*/
|
|
|
|
static int tick_notify(struct notifier_block *nb, unsigned long reason,
|
|
|
|
void *dev)
|
|
|
|
{
|
|
|
|
switch (reason) {
|
|
|
|
|
|
|
|
case CLOCK_EVT_NOTIFY_ADD:
|
|
|
|
return tick_check_new_device(dev);
|
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_ON:
|
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
|
|
|
|
tick_broadcast_on_off(reason, dev);
|
|
|
|
break;
|
|
|
|
|
2007-02-16 02:28:03 -07:00
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:
|
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:
|
|
|
|
tick_broadcast_oneshot_control(reason);
|
|
|
|
break;
|
|
|
|
|
2007-02-16 02:28:01 -07:00
|
|
|
case CLOCK_EVT_NOTIFY_CPU_DEAD:
|
2007-02-16 02:28:03 -07:00
|
|
|
tick_shutdown_broadcast_oneshot(dev);
|
2007-02-16 02:28:02 -07:00
|
|
|
tick_shutdown_broadcast(dev);
|
2007-02-16 02:28:01 -07:00
|
|
|
tick_shutdown(dev);
|
|
|
|
break;
|
|
|
|
|
2007-03-06 00:25:42 -07:00
|
|
|
case CLOCK_EVT_NOTIFY_SUSPEND:
|
2007-03-16 17:25:52 -06:00
|
|
|
tick_suspend();
|
2007-03-06 00:25:42 -07:00
|
|
|
tick_suspend_broadcast();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CLOCK_EVT_NOTIFY_RESUME:
|
2007-07-21 05:37:34 -06:00
|
|
|
tick_resume();
|
2007-03-06 00:25:42 -07:00
|
|
|
break;
|
|
|
|
|
2007-02-16 02:28:01 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block tick_notifier = {
|
|
|
|
.notifier_call = tick_notify,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tick_init - initialize the tick control
|
|
|
|
*
|
|
|
|
* Register the notifier with the clockevents framework
|
|
|
|
*/
|
|
|
|
void __init tick_init(void)
|
|
|
|
{
|
|
|
|
clockevents_register_notifier(&tick_notifier);
|
|
|
|
}
|