nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

RTC: Propagate error handling via rtc_timer_enqueue properly

Browse source 
In cases where RTC hardware does not support alarms, the virtualized
RTC interfaces did not have a way to propagate the error up to userland.

This patch extends rtc_timer_enqueue so it catches errors from the hardware
and returns them upwards to the virtualized interfaces. To simplify error
handling, it also internalizes the management of the timer->enabled bit
into rtc_timer_enqueue and rtc_timer_remove.

Also makes rtc_timer_enqueue and rtc_timer_remove static.

Reported-by: David Daney <ddaney@caviumnetworks.com>
Reported-by: Andreas Schwab <schwab@linux-m68k.org>
Reported-by: Geert Uytterhoeven <geert@linux-m68k.org>
Diagnosed-by: David Daney <ddaney@caviumnetworks.com>
Tested-by: David Daney <ddaney@caviumnetworks.com>
Signed-off-by: John Stultz <john.stultz@linaro.org>
LKML-Reference: <1295565973-14358-1-git-send-email-john.stultz@linaro.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
This commit is contained in:
John Stultz 2011-01-20 15:26:12 -08:00 committed by Thomas Gleixner
parent db6b175fa6
commit aa0be0f465
2 changed files with 28 additions and 23 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

49
drivers/rtc/interface.c
View file

@ -16,6 +16,9 @@
#include <linux/log2.h> #include <linux/log2.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);
static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer);
static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
{ {
int err; int err;
@ -175,16 +178,14 @@ int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
return err; return err;
if (rtc->aie_timer.enabled) { if (rtc->aie_timer.enabled) {
rtc_timer_remove(rtc, &rtc->aie_timer); rtc_timer_remove(rtc, &rtc->aie_timer);
rtc->aie_timer.enabled = 0;
} }
rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
rtc->aie_timer.period = ktime_set(0, 0); rtc->aie_timer.period = ktime_set(0, 0);
if (alarm->enabled) { if (alarm->enabled) {
rtc->aie_timer.enabled = 1; err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
rtc_timer_enqueue(rtc, &rtc->aie_timer);
} }
mutex_unlock(&rtc->ops_lock); mutex_unlock(&rtc->ops_lock);
return 0; return err;
} }
EXPORT_SYMBOL_GPL(rtc_set_alarm); EXPORT_SYMBOL_GPL(rtc_set_alarm);
@ -195,15 +196,15 @@ int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
return err; return err;
if (rtc->aie_timer.enabled != enabled) { if (rtc->aie_timer.enabled != enabled) {
if (enabled) { if (enabled)
rtc->aie_timer.enabled = 1; err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
rtc_timer_enqueue(rtc, &rtc->aie_timer); else
} else {
rtc_timer_remove(rtc, &rtc->aie_timer); rtc_timer_remove(rtc, &rtc->aie_timer);
rtc->aie_timer.enabled = 0;
}
} }
if (err)
return err;
if (!rtc->ops) if (!rtc->ops)
err = -ENODEV; err = -ENODEV;
else if (!rtc->ops->alarm_irq_enable) else if (!rtc->ops->alarm_irq_enable)
@ -235,12 +236,9 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
now = rtc_tm_to_ktime(tm); now = rtc_tm_to_ktime(tm);
rtc->uie_rtctimer.node.expires = ktime_add(now, onesec); rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
rtc->uie_rtctimer.period = ktime_set(1, 0); rtc->uie_rtctimer.period = ktime_set(1, 0);
rtc->uie_rtctimer.enabled = 1; err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
rtc_timer_enqueue(rtc, &rtc->uie_rtctimer); } else
} else {
rtc_timer_remove(rtc, &rtc->uie_rtctimer); rtc_timer_remove(rtc, &rtc->uie_rtctimer);
rtc->uie_rtctimer.enabled = 0;
}
out: out:
mutex_unlock(&rtc->ops_lock); mutex_unlock(&rtc->ops_lock);
@ -488,10 +486,13 @@ EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
* Enqueues a timer onto the rtc devices timerqueue and sets * Enqueues a timer onto the rtc devices timerqueue and sets
* the next alarm event appropriately. * the next alarm event appropriately.
* *
* Sets the enabled bit on the added timer.
*
* Must hold ops_lock for proper serialization of timerqueue * Must hold ops_lock for proper serialization of timerqueue
*/ */
void rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer) static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
{ {
timer->enabled = 1;
timerqueue_add(&rtc->timerqueue, &timer->node); timerqueue_add(&rtc->timerqueue, &timer->node);
if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) { if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) {
struct rtc_wkalrm alarm; struct rtc_wkalrm alarm;
@ -501,7 +502,13 @@ void rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
err = __rtc_set_alarm(rtc, &alarm); err = __rtc_set_alarm(rtc, &alarm);
if (err == -ETIME) if (err == -ETIME)
schedule_work(&rtc->irqwork); schedule_work(&rtc->irqwork);
else if (err) {
timerqueue_del(&rtc->timerqueue, &timer->node);
timer->enabled = 0;
return err;
} }
}
return 0;
} }
/** /**
@ -512,13 +519,15 @@ void rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
* Removes a timer onto the rtc devices timerqueue and sets * Removes a timer onto the rtc devices timerqueue and sets
* the next alarm event appropriately. * the next alarm event appropriately.
* *
* Clears the enabled bit on the removed timer.
*
* Must hold ops_lock for proper serialization of timerqueue * Must hold ops_lock for proper serialization of timerqueue
*/ */
void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer) static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
{ {
struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
timerqueue_del(&rtc->timerqueue, &timer->node); timerqueue_del(&rtc->timerqueue, &timer->node);
timer->enabled = 0;
if (next == &timer->node) { if (next == &timer->node) {
struct rtc_wkalrm alarm; struct rtc_wkalrm alarm;
int err; int err;
@ -626,8 +635,7 @@ int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
timer->node.expires = expires; timer->node.expires = expires;
timer->period = period; timer->period = period;
timer->enabled = 1; ret = rtc_timer_enqueue(rtc, timer);
rtc_timer_enqueue(rtc, timer);
mutex_unlock(&rtc->ops_lock); mutex_unlock(&rtc->ops_lock);
return ret; return ret;
@ -645,7 +653,6 @@ int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer)
mutex_lock(&rtc->ops_lock); mutex_lock(&rtc->ops_lock);
if (timer->enabled) if (timer->enabled)
rtc_timer_remove(rtc, timer); rtc_timer_remove(rtc, timer);
timer->enabled = 0;
mutex_unlock(&rtc->ops_lock); mutex_unlock(&rtc->ops_lock);
return ret; return ret;
} }

2
include/linux/rtc.h
View file

@ -244,8 +244,6 @@ int rtc_register(rtc_task_t *task);
int rtc_unregister(rtc_task_t *task); int rtc_unregister(rtc_task_t *task);
int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg); int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
void rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);
void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer);
void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data); void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data);
int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer, int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
ktime_t expires, ktime_t period); ktime_t expires, ktime_t period);