1 files changed, 40 insertions, 24 deletions

diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 90384b9f6b2c..a0c01967244d 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -16,6 +16,9 @@
 #include <linux/log2.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)
 {
         int err;
@@ -120,12 +123,18 @@ int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
                 return err;
-        alarm->enabled = rtc->aie_timer.enabled;
-        if (alarm->enabled)
+        if (rtc->ops == NULL)
+                err = -ENODEV;
+        else if (!rtc->ops->read_alarm)
+                err = -EINVAL;
+        else {
+                memset(alarm, 0, sizeof(struct rtc_wkalrm));
+                alarm->enabled = rtc->aie_timer.enabled;
                 alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
+        }
         mutex_unlock(&rtc->ops_lock);
 
-        return 0;
+        return err;
 }
 EXPORT_SYMBOL_GPL(rtc_read_alarm);
 
@@ -175,16 +184,14 @@ int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
                 return err;
         if (rtc->aie_timer.enabled) {
                 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.period = ktime_set(0, 0);
         if (alarm->enabled) {
-                rtc->aie_timer.enabled = 1;
-                rtc_timer_enqueue(rtc, &rtc->aie_timer);
+                err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
         }
         mutex_unlock(&rtc->ops_lock);
-        return 0;
+        return err;
 }
 EXPORT_SYMBOL_GPL(rtc_set_alarm);
 
@@ -195,15 +202,15 @@ int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
                 return err;
 
         if (rtc->aie_timer.enabled != enabled) {
-                if (enabled) {
-                        rtc->aie_timer.enabled = 1;
-                        rtc_timer_enqueue(rtc, &rtc->aie_timer);
-                } else {
+                if (enabled)
+                        err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
+                else
                         rtc_timer_remove(rtc, &rtc->aie_timer);
-                        rtc->aie_timer.enabled = 0;
-                }
         }
 
+        if (err)
+                return err;
+
         if (!rtc->ops)
                 err = -ENODEV;
         else if (!rtc->ops->alarm_irq_enable)
@@ -235,12 +242,9 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
                 now = rtc_tm_to_ktime(tm);
                 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
                 rtc->uie_rtctimer.period = ktime_set(1, 0);
-                rtc->uie_rtctimer.enabled = 1;
-                rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
-        } else {
+                err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
+        } else
                 rtc_timer_remove(rtc, &rtc->uie_rtctimer);
-                rtc->uie_rtctimer.enabled = 0;
-        }
 
 out:
         mutex_unlock(&rtc->ops_lock);
@@ -460,6 +464,9 @@ int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
         int err = 0;
         unsigned long flags;
 
+        if (freq <= 0)
+                return -EINVAL;
+
         spin_lock_irqsave(&rtc->irq_task_lock, flags);
         if (rtc->irq_task != NULL && task == NULL)
                 err = -EBUSY;
@@ -488,10 +495,13 @@ EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
  * Enqueues a timer onto the rtc devices timerqueue and sets
  * the next alarm event appropriately.
  *
+ * Sets the enabled bit on the added timer.
+ *
  * 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);
         if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) {
                 struct rtc_wkalrm alarm;
@@ -501,7 +511,13 @@ void rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
                 err = __rtc_set_alarm(rtc, &alarm);
                 if (err == -ETIME)
                         schedule_work(&rtc->irqwork);
+                else if (err) {
+                        timerqueue_del(&rtc->timerqueue, &timer->node);
+                        timer->enabled = 0;
+                        return err;
+                }
         }
+        return 0;
 }
 
 /**
@@ -512,13 +528,15 @@ void rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
  * Removes a timer onto the rtc devices timerqueue and sets
  * the next alarm event appropriately.
  *
+ * Clears the enabled bit on the removed timer.
+ *
  * 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);
         timerqueue_del(&rtc->timerqueue, &timer->node);
-
+        timer->enabled = 0;
         if (next == &timer->node) {
                 struct rtc_wkalrm alarm;
                 int err;
@@ -626,8 +644,7 @@ int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
         timer->node.expires = expires;
         timer->period = period;
 
-        timer->enabled = 1;
-        rtc_timer_enqueue(rtc, timer);
+        ret = rtc_timer_enqueue(rtc, timer);
 
         mutex_unlock(&rtc->ops_lock);
         return ret;
@@ -645,7 +662,6 @@ int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer)
         mutex_lock(&rtc->ops_lock);
         if (timer->enabled)
                 rtc_timer_remove(rtc, timer);
-        timer->enabled = 0;
         mutex_unlock(&rtc->ops_lock);
         return ret;
 }