/* * 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> /** * struct alarm_base - Alarm timer bases * @lock:		Lock for syncrhonized access to the base * @timerqueue:		Timerqueue head managing the list of events * @timer: 		hrtimer used to schedule events while running * @gettime:		Function to read the time correlating to the base * @base_clockid:	clockid for the base */static struct alarm_base {	spinlock_t		lock;	struct timerqueue_head	timerqueue;	struct hrtimer		timer;	ktime_t			(*gettime)(void);	clockid_t		base_clockid;} alarm_bases[ALARM_NUMTYPE]; /* freezer delta & lock used to handle clock_nanosleep triggered wakeups */static ktime_t freezer_delta;static DEFINE_SPINLOCK(freezer_delta_lock); #ifdef CONFIG_RTC_CLASS/* rtc timer and device for setting alarm wakeups at suspend */static struct rtc_timer		rtctimer;static struct rtc_device	*rtcdev;static DEFINE_SPINLOCK(rtcdev_lock); /** * alarmtimer_get_rtcdev - Return selected rtcdevice * * This function returns the rtc device to use for wakealarms. * If one has not already been chosen, it checks to see if a * functional rtc device is available. */static struct rtc_device *alarmtimer_get_rtcdev(void){	unsigned long flags;	struct rtc_device *ret; 	spin_lock_irqsave(&rtcdev_lock, flags);	ret = rtcdev;	spin_unlock_irqrestore(&rtcdev_lock, flags); 	return ret;}  static int alarmtimer_rtc_add_device(struct device *dev,				struct class_interface *class_intf){	unsigned long flags;	struct rtc_device *rtc = to_rtc_device(dev); 	if (rtcdev)		return -EBUSY; 	if (!rtc->ops->set_alarm)		return -1;	if (!device_may_wakeup(rtc->dev.parent))		return -1; 	spin_lock_irqsave(&rtcdev_lock, flags);	if (!rtcdev) {		rtcdev = rtc;		/* hold a reference so it doesn't go away */		get_device(dev);	}	spin_unlock_irqrestore(&rtcdev_lock, flags);	return 0;} static inline void alarmtimer_rtc_timer_init(void){	rtc_timer_init(&rtctimer, NULL, NULL);} static struct class_interface alarmtimer_rtc_interface = {	.add_dev = &alarmtimer_rtc_add_device,}; static int alarmtimer_rtc_interface_setup(void){	alarmtimer_rtc_interface.class = rtc_class;	return class_interface_register(&alarmtimer_rtc_interface);}static void alarmtimer_rtc_interface_remove(void){	class_interface_unregister(&alarmtimer_rtc_interface);}#elsestatic inline struct rtc_device *alarmtimer_get_rtcdev(void){	return NULL;}#define rtcdev (NULL)static inline int alarmtimer_rtc_interface_setup(void) { return 0; }static inline void alarmtimer_rtc_interface_remove(void) { }static inline void alarmtimer_rtc_timer_init(void) { }#endif /** * 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);	alarm->state |= ALARMTIMER_STATE_ENQUEUED; 	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); 	if (!(alarm->state & ALARMTIMER_STATE_ENQUEUED))		return; 	timerqueue_del(&base->timerqueue, &alarm->node);	alarm->state &= ~ALARMTIMER_STATE_ENQUEUED; 	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_fired - Handles alarm hrtimer being fired. * @timer: pointer to hrtimer being run * * When a alarm timer fires, this runs through the timerqueue to * see which alarms expired, and runs those. If there are more alarm * timers queued for the future, we set the hrtimer to fire when * when the next future alarm timer expires. */static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer){	struct alarm_base *base = container_of(timer, struct alarm_base, timer);	struct timerqueue_node *next;	unsigned long flags;	ktime_t now;	int ret = HRTIMER_NORESTART;	int restart = ALARMTIMER_NORESTART; 	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->state &= ~ALARMTIMER_STATE_ENQUEUED; 		alarm->state |= ALARMTIMER_STATE_CALLBACK;		spin_unlock_irqrestore(&base->lock, flags);		if (alarm->function)			restart = alarm->function(alarm, now);		spin_lock_irqsave(&base->lock, flags);		alarm->state &= ~ALARMTIMER_STATE_CALLBACK; 		if (restart != ALARMTIMER_NORESTART) {			timerqueue_add(&base->timerqueue, &alarm->node);			alarm->state |= ALARMTIMER_STATE_ENQUEUED;		}	} 	if (next) {		hrtimer_set_expires(&base->timer, next->expires);		ret = HRTIMER_RESTART;	}	spin_unlock_irqrestore(&base->lock, flags); 	return ret; } #ifdef CONFIG_RTC_CLASS/** * 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;	struct rtc_device *rtc;	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); 	rtc = alarmtimer_get_rtcdev();	/* If we have no rtcdev, just return */	if (!rtc)		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(rtc, &rtctimer);	rtc_read_time(rtc, &tm);	now = rtc_tm_to_ktime(tm);	now = ktime_add(now, min); 	rtc_timer_start(rtc, &rtctimer, now, ktime_set(0, 0)); 	return 0;}#elsestatic int alarmtimer_suspend(struct device *dev){	return 0;}#endif static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type){	ktime_t delta;	unsigned long flags;	struct alarm_base *base = &alarm_bases[type]; 	delta = ktime_sub(absexp, base->gettime()); 	spin_lock_irqsave(&freezer_delta_lock, flags);	if (!freezer_delta.tv64 || (delta.tv64 < freezer_delta.tv64))		freezer_delta = delta;	spin_unlock_irqrestore(&freezer_delta_lock, flags);}  /** * 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 */void alarm_init(struct alarm *alarm, enum alarmtimer_type type,		enum alarmtimer_restart (*function)(struct alarm *, ktime_t)){	timerqueue_init(&alarm->node);	alarm->function = function;	alarm->type = type;	alarm->state = ALARMTIMER_STATE_INACTIVE;} /** * alarm_start - Sets an alarm to fire * @alarm: ptr to alarm to set * @start: time to run the alarm */void alarm_start(struct alarm *alarm, ktime_t start){	struct alarm_base *base = &alarm_bases[alarm->type];	unsigned long flags; 	spin_lock_irqsave(&base->lock, flags);	if (alarmtimer_active(alarm))		alarmtimer_remove(base, alarm);	alarm->node.expires = start;	alarmtimer_enqueue(base, alarm);	spin_unlock_irqrestore(&base->lock, flags);} /** * alarm_try_to_cancel - Tries to cancel an alarm timer * @alarm: ptr to alarm to be canceled * * Returns 1 if the timer was canceled, 0 if it was not running, * and -1 if the callback was running */int alarm_try_to_cancel(struct alarm *alarm){	struct alarm_base *base = &alarm_bases[alarm->type];	unsigned long flags;	int ret = -1;	spin_lock_irqsave(&base->lock, flags); 	if (alarmtimer_callback_running(alarm))		goto out; 	if (alarmtimer_is_queued(alarm)) {		alarmtimer_remove(base, alarm);		ret = 1;	} else		ret = 0;out:	spin_unlock_irqrestore(&base->lock, flags);	return ret;}  /** * alarm_cancel - Spins trying to cancel an alarm timer until it is done * @alarm: ptr to alarm to be canceled * * Returns 1 if the timer was canceled, 0 if it was not active. */int alarm_cancel(struct alarm *alarm){	for (;;) {		int ret = alarm_try_to_cancel(alarm);		if (ret >= 0)			return ret;		cpu_relax();	}}  u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval){	u64 overrun = 1;	ktime_t delta; 	delta = ktime_sub(now, alarm->node.expires); 	if (delta.tv64 < 0)		return 0; 	if (unlikely(delta.tv64 >= interval.tv64)) {		s64 incr = ktime_to_ns(interval); 		overrun = ktime_divns(delta, incr); 		alarm->node.expires = ktime_add_ns(alarm->node.expires,							incr*overrun); 		if (alarm->node.expires.tv64 > now.tv64)			return overrun;		/*		 * This (and the ktime_add() below) is the		 * correction for exact:		 */		overrun++;	} 	alarm->node.expires = ktime_add(alarm->node.expires, interval);	return overrun;}    /** * clock2alarm - helper that converts from clockid to alarmtypes * @clockid: clockid. */static enum alarmtimer_type clock2alarm(clockid_t clockid){	if (clockid == CLOCK_REALTIME_ALARM)		return ALARM_REALTIME;	if (clockid == CLOCK_BOOTTIME_ALARM)		return ALARM_BOOTTIME;	return -1;} /** * alarm_handle_timer - Callback for posix timers * @alarm: alarm that fired * * Posix timer callback for expired alarm timers. */static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,							ktime_t now){	struct k_itimer *ptr = container_of(alarm, struct k_itimer,						it.alarm.alarmtimer);	if (posix_timer_event(ptr, 0) != 0)		ptr->it_overrun++; 	/* Re-add periodic timers */	if (ptr->it.alarm.interval.tv64) {		ptr->it_overrun += alarm_forward(alarm, now,						ptr->it.alarm.interval);		return ALARMTIMER_RESTART;	}	return ALARMTIMER_NORESTART;} /** * alarm_clock_getres - posix getres interface * @which_clock: clockid * @tp: timespec to fill * * Returns the granularity of underlying alarm base clock */static int alarm_clock_getres(const clockid_t which_clock, struct timespec *tp){	clockid_t baseid = alarm_bases[clock2alarm(which_clock)].base_clockid; 	if (!alarmtimer_get_rtcdev())		return -ENOTSUPP; 	return hrtimer_get_res(baseid, tp);} /** * alarm_clock_get - posix clock_get interface * @which_clock: clockid * @tp: timespec to fill. * * Provides the underlying alarm base time. */static int alarm_clock_get(clockid_t which_clock, struct timespec *tp){	struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)]; 	if (!alarmtimer_get_rtcdev())		return -ENOTSUPP; 	*tp = ktime_to_timespec(base->gettime());	return 0;} /**

Lines 1–500 of 832. Load more