forked from Minki/linux
timers: Introduce in-kernel alarm-timer interface
This provides the in kernel interface and infrastructure for alarm-timers. Alarm-timers are a hybrid style timer, similar to hrtimers, but when the system is suspended, the RTC device is set to fire and wake the system for when the soonest alarm-timer expires. The concept for Alarm-timers was inspired by the Android Alarm driver (by Arve Hjønnevåg) found in the Android kernel tree. See: http://android.git.kernel.org/?p=kernel/common.git;a=blob;f=drivers/rtc/alarm.c;h=1250edfbdf3302f5e4ea6194847c6ef4bb7beb1c;hb=android-2.6.36 This in-kernel interface should be fairly compatible with the Android alarm driver in-kernel interface, but has the advantage of utilizing the new RTC timerqueue code instead of doing direct RTC manipulation. CC: Arve Hjønnevåg <arve@android.com> CC: Thomas Gleixner <tglx@linutronix.de> CC: Alessandro Zummo <a.zummo@towertech.it> Acked-by: Arnd Bergmann <arnd@arndb.de> Signed-off-by: John Stultz <john.stultz@linaro.org>
This commit is contained in:
John Stultz
parent
88d19cf379
commit
ff3ead96d1
30
include/linux/alarmtimer.h
Normal file
30
include/linux/alarmtimer.h
Normal file
@ -0,0 +1,30 @@
|
||||
#ifndef _LINUX_ALARMTIMER_H
|
||||
#define _LINUX_ALARMTIMER_H
|
||||
|
||||
#include <linux/time.h>
|
||||
#include <linux/hrtimer.h>
|
||||
#include <linux/timerqueue.h>
|
||||
#include <linux/rtc.h>
|
||||
|
||||
enum alarmtimer_type {
|
||||
ALARM_REALTIME,
|
||||
ALARM_BOOTTIME,
|
||||
|
||||
ALARM_NUMTYPE,
|
||||
};
|
||||
|
||||
struct alarm {
|
||||
struct timerqueue_node node;
|
||||
ktime_t period;
|
||||
void (*function)(struct alarm *);
|
||||
enum alarmtimer_type type;
|
||||
char enabled;
|
||||
void *data;
|
||||
};
|
||||
|
||||
void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
|
||||
void (*function)(struct alarm *));
|
||||
void alarm_start(struct alarm *alarm, ktime_t start, ktime_t period);
|
||||
void alarm_cancel(struct alarm *alarm);
|
||||
|
||||
#endif
|
||||
@ -1,5 +1,5 @@
|
||||
obj-y += timekeeping.o ntp.o clocksource.o jiffies.o timer_list.o timecompare.o
|
||||
obj-y += timeconv.o posix-clock.o
|
||||
obj-y += timeconv.o posix-clock.o alarmtimer.o
|
||||
|
||||
obj-$(CONFIG_GENERIC_CLOCKEVENTS_BUILD) += clockevents.o
|
||||
obj-$(CONFIG_GENERIC_CLOCKEVENTS) += tick-common.o
|
||||
|
||||
375
kernel/time/alarmtimer.c
Normal file
375
kernel/time/alarmtimer.c
Normal file
@ -0,0 +1,375 @@
|
||||
/*
|
||||
* Alarmtimer interface
|
||||
*
|
||||
* This interface provides a timer which is similarto hrtimers,
|
||||
* but triggers a RTC alarm if the box is suspend.
|
||||
*
|
||||
* This interface is influenced by the Android RTC Alarm timer
|
||||
* interface.
|
||||
*
|
||||
* Copyright (C) 2010 IBM Corperation
|
||||
*
|
||||
* Author: John Stultz <john.stultz@linaro.org>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
#include <linux/time.h>
|
||||
#include <linux/hrtimer.h>
|
||||
#include <linux/timerqueue.h>
|
||||
#include <linux/rtc.h>
|
||||
#include <linux/alarmtimer.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/posix-timers.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/freezer.h>
|
||||
|
||||
|
||||
static struct alarm_base {
|
||||
spinlock_t lock;
|
||||
struct timerqueue_head timerqueue;
|
||||
struct hrtimer timer;
|
||||
ktime_t (*gettime)(void);
|
||||
clockid_t base_clockid;
|
||||
struct work_struct irqwork;
|
||||
} alarm_bases[ALARM_NUMTYPE];
|
||||
|
||||
static struct rtc_timer rtctimer;
|
||||
static struct rtc_device *rtcdev;
|
||||
|
||||
static ktime_t freezer_delta;
|
||||
static DEFINE_SPINLOCK(freezer_delta_lock);
|
||||
|
||||
|
||||
/**************************************************************************
|
||||
* alarmtimer management code
|
||||
*/
|
||||
|
||||
/*
|
||||
* alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
|
||||
* @base: pointer to the base where the timer is being run
|
||||
* @alarm: pointer to alarm being enqueued.
|
||||
*
|
||||
* Adds alarm to a alarm_base timerqueue and if necessary sets
|
||||
* an hrtimer to run.
|
||||
*
|
||||
* Must hold base->lock when calling.
|
||||
*/
|
||||
static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
|
||||
{
|
||||
timerqueue_add(&base->timerqueue, &alarm->node);
|
||||
if (&alarm->node == timerqueue_getnext(&base->timerqueue)) {
|
||||
hrtimer_try_to_cancel(&base->timer);
|
||||
hrtimer_start(&base->timer, alarm->node.expires,
|
||||
HRTIMER_MODE_ABS);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* alarmtimer_remove - Removes an alarm timer from an alarm_base timerqueue
|
||||
* @base: pointer to the base where the timer is running
|
||||
* @alarm: pointer to alarm being removed
|
||||
*
|
||||
* Removes alarm to a alarm_base timerqueue and if necessary sets
|
||||
* a new timer to run.
|
||||
*
|
||||
* Must hold base->lock when calling.
|
||||
*/
|
||||
static void alarmtimer_remove(struct alarm_base *base, struct alarm *alarm)
|
||||
{
|
||||
struct timerqueue_node *next = timerqueue_getnext(&base->timerqueue);
|
||||
|
||||
timerqueue_del(&base->timerqueue, &alarm->node);
|
||||
if (next == &alarm->node) {
|
||||
hrtimer_try_to_cancel(&base->timer);
|
||||
next = timerqueue_getnext(&base->timerqueue);
|
||||
if (!next)
|
||||
return;
|
||||
hrtimer_start(&base->timer, next->expires, HRTIMER_MODE_ABS);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* alarmtimer_do_work - Handles alarm being fired.
|
||||
* @work: pointer to workqueue being run
|
||||
*
|
||||
* When a timer fires, this runs through the timerqueue to see
|
||||
* which alarm timers, and run those that expired. If there are
|
||||
* more alarm timers queued, we set the hrtimer to fire in the
|
||||
* future.
|
||||
*/
|
||||
void alarmtimer_do_work(struct work_struct *work)
|
||||
{
|
||||
struct alarm_base *base = container_of(work, struct alarm_base,
|
||||
irqwork);
|
||||
struct timerqueue_node *next;
|
||||
unsigned long flags;
|
||||
ktime_t now;
|
||||
|
||||
spin_lock_irqsave(&base->lock, flags);
|
||||
now = base->gettime();
|
||||
while ((next = timerqueue_getnext(&base->timerqueue))) {
|
||||
struct alarm *alarm;
|
||||
ktime_t expired = next->expires;
|
||||
|
||||
if (expired.tv64 >= now.tv64)
|
||||
break;
|
||||
|
||||
alarm = container_of(next, struct alarm, node);
|
||||
|
||||
timerqueue_del(&base->timerqueue, &alarm->node);
|
||||
alarm->enabled = 0;
|
||||
/* Re-add periodic timers */
|
||||
if (alarm->period.tv64) {
|
||||
alarm->node.expires = ktime_add(expired, alarm->period);
|
||||
timerqueue_add(&base->timerqueue, &alarm->node);
|
||||
alarm->enabled = 1;
|
||||
}
|
||||
spin_unlock_irqrestore(&base->lock, flags);
|
||||
if (alarm->function)
|
||||
alarm->function(alarm);
|
||||
spin_lock_irqsave(&base->lock, flags);
|
||||
}
|
||||
|
||||
if (next) {
|
||||
hrtimer_start(&base->timer, next->expires,
|
||||
HRTIMER_MODE_ABS);
|
||||
}
|
||||
spin_unlock_irqrestore(&base->lock, flags);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* alarmtimer_fired - Handles alarm hrtimer being fired.
|
||||
* @timer: pointer to hrtimer being run
|
||||
*
|
||||
* When a timer fires, this schedules the do_work function to
|
||||
* be run.
|
||||
*/
|
||||
static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
|
||||
{
|
||||
struct alarm_base *base = container_of(timer, struct alarm_base, timer);
|
||||
schedule_work(&base->irqwork);
|
||||
return HRTIMER_NORESTART;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* alarmtimer_suspend - Suspend time callback
|
||||
* @dev: unused
|
||||
* @state: unused
|
||||
*
|
||||
* When we are going into suspend, we look through the bases
|
||||
* to see which is the soonest timer to expire. We then
|
||||
* set an rtc timer to fire that far into the future, which
|
||||
* will wake us from suspend.
|
||||
*/
|
||||
static int alarmtimer_suspend(struct device *dev)
|
||||
{
|
||||
struct rtc_time tm;
|
||||
ktime_t min, now;
|
||||
unsigned long flags;
|
||||
int i;
|
||||
|
||||
spin_lock_irqsave(&freezer_delta_lock, flags);
|
||||
min = freezer_delta;
|
||||
freezer_delta = ktime_set(0, 0);
|
||||
spin_unlock_irqrestore(&freezer_delta_lock, flags);
|
||||
|
||||
/* If we have no rtcdev, just return */
|
||||
if (!rtcdev)
|
||||
return 0;
|
||||
|
||||
/* Find the soonest timer to expire*/
|
||||
for (i = 0; i < ALARM_NUMTYPE; i++) {
|
||||
struct alarm_base *base = &alarm_bases[i];
|
||||
struct timerqueue_node *next;
|
||||
ktime_t delta;
|
||||
|
||||
spin_lock_irqsave(&base->lock, flags);
|
||||
next = timerqueue_getnext(&base->timerqueue);
|
||||
spin_unlock_irqrestore(&base->lock, flags);
|
||||
if (!next)
|
||||
continue;
|
||||
delta = ktime_sub(next->expires, base->gettime());
|
||||
if (!min.tv64 || (delta.tv64 < min.tv64))
|
||||
min = delta;
|
||||
}
|
||||
if (min.tv64 == 0)
|
||||
return 0;
|
||||
|
||||
/* XXX - Should we enforce a minimum sleep time? */
|
||||
WARN_ON(min.tv64 < NSEC_PER_SEC);
|
||||
|
||||
/* Setup an rtc timer to fire that far in the future */
|
||||
rtc_timer_cancel(rtcdev, &rtctimer);
|
||||
rtc_read_time(rtcdev, &tm);
|
||||
now = rtc_tm_to_ktime(tm);
|
||||
now = ktime_add(now, min);
|
||||
|
||||
rtc_timer_start(rtcdev, &rtctimer, now, ktime_set(0, 0));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**************************************************************************
|
||||
* alarm kernel interface code
|
||||
*/
|
||||
|
||||
/*
|
||||
* alarm_init - Initialize an alarm structure
|
||||
* @alarm: ptr to alarm to be initialized
|
||||
* @type: the type of the alarm
|
||||
* @function: callback that is run when the alarm fires
|
||||
*
|
||||
* In-kernel interface to initializes the alarm structure.
|
||||
*/
|
||||
void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
|
||||
void (*function)(struct alarm *))
|
||||
{
|
||||
timerqueue_init(&alarm->node);
|
||||
alarm->period = ktime_set(0, 0);
|
||||
alarm->function = function;
|
||||
alarm->type = type;
|
||||
alarm->enabled = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* alarm_start - Sets an alarm to fire
|
||||
* @alarm: ptr to alarm to set
|
||||
* @start: time to run the alarm
|
||||
* @period: period at which the alarm will recur
|
||||
*
|
||||
* In-kernel interface set an alarm timer.
|
||||
*/
|
||||
void alarm_start(struct alarm *alarm, ktime_t start, ktime_t period)
|
||||
{
|
||||
struct alarm_base *base = &alarm_bases[alarm->type];
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&base->lock, flags);
|
||||
if (alarm->enabled)
|
||||
alarmtimer_remove(base, alarm);
|
||||
alarm->node.expires = start;
|
||||
alarm->period = period;
|
||||
alarmtimer_enqueue(base, alarm);
|
||||
alarm->enabled = 1;
|
||||
spin_unlock_irqrestore(&base->lock, flags);
|
||||
}
|
||||
|
||||
/*
|
||||
* alarm_cancel - Tries to cancel an alarm timer
|
||||
* @alarm: ptr to alarm to be canceled
|
||||
*
|
||||
* In-kernel interface to cancel an alarm timer.
|
||||
*/
|
||||
void alarm_cancel(struct alarm *alarm)
|
||||
{
|
||||
struct alarm_base *base = &alarm_bases[alarm->type];
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&base->lock, flags);
|
||||
if (alarm->enabled)
|
||||
alarmtimer_remove(base, alarm);
|
||||
alarm->enabled = 0;
|
||||
spin_unlock_irqrestore(&base->lock, flags);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**************************************************************************
|
||||
* alarmtimer initialization code
|
||||
*/
|
||||
|
||||
/* Suspend hook structures */
|
||||
static const struct dev_pm_ops alarmtimer_pm_ops = {
|
||||
.suspend = alarmtimer_suspend,
|
||||
};
|
||||
|
||||
static struct platform_driver alarmtimer_driver = {
|
||||
.driver = {
|
||||
.name = "alarmtimer",
|
||||
.pm = &alarmtimer_pm_ops,
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* alarmtimer_init - Initialize alarm timer code
|
||||
*
|
||||
* This function initializes the alarm bases and registers
|
||||
* the posix clock ids.
|
||||
*/
|
||||
static int __init alarmtimer_init(void)
|
||||
{
|
||||
int error = 0;
|
||||
int i;
|
||||
|
||||
/* Initialize alarm bases */
|
||||
alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
|
||||
alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
|
||||
alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
|
||||
alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
|
||||
for (i = 0; i < ALARM_NUMTYPE; i++) {
|
||||
timerqueue_init_head(&alarm_bases[i].timerqueue);
|
||||
spin_lock_init(&alarm_bases[i].lock);
|
||||
hrtimer_init(&alarm_bases[i].timer,
|
||||
alarm_bases[i].base_clockid,
|
||||
HRTIMER_MODE_ABS);
|
||||
alarm_bases[i].timer.function = alarmtimer_fired;
|
||||
INIT_WORK(&alarm_bases[i].irqwork, alarmtimer_do_work);
|
||||
}
|
||||
error = platform_driver_register(&alarmtimer_driver);
|
||||
platform_device_register_simple("alarmtimer", -1, NULL, 0);
|
||||
|
||||
return error;
|
||||
}
|
||||
device_initcall(alarmtimer_init);
|
||||
|
||||
/**
|
||||
* has_wakealarm - check rtc device has wakealarm ability
|
||||
* @dev: current device
|
||||
* @name_ptr: name to be returned
|
||||
*
|
||||
* This helper function checks to see if the rtc device can wake
|
||||
* from suspend.
|
||||
*/
|
||||
static int __init has_wakealarm(struct device *dev, void *name_ptr)
|
||||
{
|
||||
struct rtc_device *candidate = to_rtc_device(dev);
|
||||
|
||||
if (!candidate->ops->set_alarm)
|
||||
return 0;
|
||||
if (!device_may_wakeup(candidate->dev.parent))
|
||||
return 0;
|
||||
|
||||
*(const char **)name_ptr = dev_name(dev);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* alarmtimer_init_late - Late initializing of alarmtimer code
|
||||
*
|
||||
* This function locates a rtc device to use for wakealarms.
|
||||
* Run as late_initcall to make sure rtc devices have been
|
||||
* registered.
|
||||
*/
|
||||
static int __init alarmtimer_init_late(void)
|
||||
{
|
||||
char *str;
|
||||
|
||||
/* Find an rtc device and init the rtc_timer */
|
||||
class_find_device(rtc_class, NULL, &str, has_wakealarm);
|
||||
if (str)
|
||||
rtcdev = rtc_class_open(str);
|
||||
if (!rtcdev) {
|
||||
printk(KERN_WARNING "No RTC device found, ALARM timers will"
|
||||
" not wake from suspend");
|
||||
}
|
||||
rtc_timer_init(&rtctimer, NULL, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
late_initcall(alarmtimer_init_late);
|
||||
Loading…
Reference in New Issue
Block a user