1 files changed, 51 insertions, 56 deletions

diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 98d9c87b0d1b..4124f4dd376b 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * RTC subsystem, interface functions
  *
@@ -5,11 +6,7 @@
  * Author: Alessandro Zummo <a.zummo@towertech.it>
  *
  * based on arch/arm/common/rtctime.c
- *
- * 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/rtc.h>
 #include <linux/sched.h>
@@ -87,11 +84,12 @@ static int rtc_valid_range(struct rtc_device *rtc, struct rtc_time *tm)
 static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
 {
         int err;
-        if (!rtc->ops)
+
+        if (!rtc->ops) {
                 err = -ENODEV;
-        else if (!rtc->ops->read_time)
+        } else if (!rtc->ops->read_time) {
                 err = -EINVAL;
-        else {
+        } else {
                 memset(tm, 0, sizeof(struct rtc_time));
                 err = rtc->ops->read_time(rtc->dev.parent, tm);
                 if (err < 0) {
@@ -147,14 +145,7 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
                 err = -ENODEV;
         else if (rtc->ops->set_time)
                 err = rtc->ops->set_time(rtc->dev.parent, tm);
-        else if (rtc->ops->set_mmss64) {
-                time64_t secs64 = rtc_tm_to_time64(tm);
-
-                err = rtc->ops->set_mmss64(rtc->dev.parent, secs64);
-        } else if (rtc->ops->set_mmss) {
-                time64_t secs64 = rtc_tm_to_time64(tm);
-                err = rtc->ops->set_mmss(rtc->dev.parent, secs64);
-        } else
+        else
                 err = -EINVAL;
 
         pm_stay_awake(rtc->dev.parent);
@@ -167,7 +158,8 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
 }
 EXPORT_SYMBOL_GPL(rtc_set_time);
 
-static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
+static int rtc_read_alarm_internal(struct rtc_device *rtc,
+                                   struct rtc_wkalrm *alarm)
 {
         int err;
 
@@ -175,11 +167,11 @@ static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *al
         if (err)
                 return err;
 
-        if (rtc->ops == NULL)
+        if (!rtc->ops) {
                 err = -ENODEV;
-        else if (!rtc->ops->read_alarm)
+        } else if (!rtc->ops->read_alarm) {
                 err = -EINVAL;
-        else {
+        } else {
                 alarm->enabled = 0;
                 alarm->pending = 0;
                 alarm->time.tm_sec = -1;
@@ -207,7 +199,7 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         int first_time = 1;
         time64_t t_now, t_alm;
         enum { none, day, month, year } missing = none;
-        unsigned days;
+        unsigned int days;
 
         /* The lower level RTC driver may return -1 in some fields,
          * creating invalid alarm->time values, for reasons like:
@@ -276,10 +268,10 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
                         return err;
 
                 /* note that tm_sec is a "don't care" value here: */
-        } while (   before.tm_min   != now.tm_min
-                 || before.tm_hour  != now.tm_hour
-                 || before.tm_mon   != now.tm_mon
-                 || before.tm_year  != now.tm_year);
+        } while (before.tm_min  != now.tm_min ||
+                 before.tm_hour != now.tm_hour ||
+                 before.tm_mon  != now.tm_mon ||
+                 before.tm_year != now.tm_year);
 
         /* Fill in the missing alarm fields using the timestamp; we
          * know there's at least one since alarm->time is invalid.
@@ -296,7 +288,7 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
                 alarm->time.tm_mday = now.tm_mday;
                 missing = day;
         }
-        if ((unsigned)alarm->time.tm_mon >= 12) {
+        if ((unsigned int)alarm->time.tm_mon >= 12) {
                 alarm->time.tm_mon = now.tm_mon;
                 if (missing == none)
                         missing = month;
@@ -321,7 +313,6 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
                 goto done;
 
         switch (missing) {
-
         /* 24 hour rollover ... if it's now 10am Monday, an alarm that
          * that will trigger at 5am will do so at 5am Tuesday, which
          * could also be in the next month or year.  This is a common
@@ -341,14 +332,14 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         case month:
                 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
                 do {
-                        if (alarm->time.tm_mon < 11)
+                        if (alarm->time.tm_mon < 11) {
                                 alarm->time.tm_mon++;
-                        else {
+                        } else {
                                 alarm->time.tm_mon = 0;
                                 alarm->time.tm_year++;
                         }
                         days = rtc_month_days(alarm->time.tm_mon,
-                                        alarm->time.tm_year);
+                                              alarm->time.tm_year);
                 } while (days < alarm->time.tm_mday);
                 break;
 
@@ -357,8 +348,8 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
                 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
                 do {
                         alarm->time.tm_year++;
-                } while (!is_leap_year(alarm->time.tm_year + 1900)
-                        && rtc_valid_tm(&alarm->time) != 0);
+                } while (!is_leap_year(alarm->time.tm_year + 1900) &&
+                         rtc_valid_tm(&alarm->time) != 0);
                 break;
 
         default:
@@ -369,7 +360,8 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 
 done:
         if (err)
-                dev_warn(&rtc->dev, "invalid alarm value: %ptR\n", &alarm->time);
+                dev_warn(&rtc->dev, "invalid alarm value: %ptR\n",
+                         &alarm->time);
 
         return err;
 }
@@ -381,11 +373,11 @@ int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
                 return err;
-        if (rtc->ops == NULL)
+        if (!rtc->ops) {
                 err = -ENODEV;
-        else if (!rtc->ops->read_alarm)
+        } else if (!rtc->ops->read_alarm) {
                 err = -EINVAL;
-        else {
+        } 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);
@@ -494,7 +486,6 @@ int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         /* Alarm has to be enabled & in the future for us to enqueue it */
         if (alarm->enabled && (rtc_tm_to_ktime(now) <
                          rtc->aie_timer.node.expires)) {
-
                 rtc->aie_timer.enabled = 1;
                 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
                 trace_rtc_timer_enqueue(&rtc->aie_timer);
@@ -506,7 +497,9 @@ EXPORT_SYMBOL_GPL(rtc_initialize_alarm);
 
 int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
 {
-        int err = mutex_lock_interruptible(&rtc->ops_lock);
+        int err;
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
                 return err;
 
@@ -535,7 +528,9 @@ EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
 
 int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
 {
-        int err = mutex_lock_interruptible(&rtc->ops_lock);
+        int err;
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
                 return err;
 
@@ -564,27 +559,25 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
                 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
                 rtc->uie_rtctimer.period = ktime_set(1, 0);
                 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
-        } else
+        } else {
                 rtc_timer_remove(rtc, &rtc->uie_rtctimer);
+        }
 
 out:
         mutex_unlock(&rtc->ops_lock);
 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
         /*
-         * Enable emulation if the driver did not provide
-         * the update_irq_enable function pointer or if returned
-         * -EINVAL to signal that it has been configured without
-         * interrupts or that are not available at the moment.
+         * Enable emulation if the driver returned -EINVAL to signal that it has
+         * been configured without interrupts or they are not available at the
+         * moment.
          */
         if (err == -EINVAL)
                 err = rtc_dev_update_irq_enable_emul(rtc, enabled);
 #endif
         return err;
-
 }
 EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
 
-
 /**
  * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
  * @rtc: pointer to the rtc device
@@ -599,14 +592,13 @@ void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
 
         /* mark one irq of the appropriate mode */
         spin_lock_irqsave(&rtc->irq_lock, flags);
-        rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode);
+        rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF | mode);
         spin_unlock_irqrestore(&rtc->irq_lock, flags);
 
         wake_up_interruptible(&rtc->irq_queue);
         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
 }
 
-
 /**
  * rtc_aie_update_irq - AIE mode rtctimer hook
  * @rtc: pointer to the rtc_device
@@ -618,7 +610,6 @@ void rtc_aie_update_irq(struct rtc_device *rtc)
         rtc_handle_legacy_irq(rtc, 1, RTC_AF);
 }
 
-
 /**
  * rtc_uie_update_irq - UIE mode rtctimer hook
  * @rtc: pointer to the rtc_device
@@ -630,7 +621,6 @@ void rtc_uie_update_irq(struct rtc_device *rtc)
         rtc_handle_legacy_irq(rtc, 1,  RTC_UF);
 }
 
-
 /**
  * rtc_pie_update_irq - PIE mode hrtimer hook
  * @timer: pointer to the pie mode hrtimer
@@ -644,6 +634,7 @@ enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
         struct rtc_device *rtc;
         ktime_t period;
         int count;
+
         rtc = container_of(timer, struct rtc_device, pie_timer);
 
         period = NSEC_PER_SEC / rtc->irq_freq;
@@ -662,7 +653,7 @@ enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
  * Context: any
  */
 void rtc_update_irq(struct rtc_device *rtc,
-                unsigned long num, unsigned long events)
+                    unsigned long num, unsigned long events)
 {
         if (IS_ERR_OR_NULL(rtc))
                 return;
@@ -811,6 +802,7 @@ static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
         if (!next || ktime_before(timer->node.expires, next->expires)) {
                 struct rtc_wkalrm alarm;
                 int err;
+
                 alarm.time = rtc_ktime_to_tm(timer->node.expires);
                 alarm.enabled = 1;
                 err = __rtc_set_alarm(rtc, &alarm);
@@ -851,12 +843,14 @@ static void rtc_alarm_disable(struct rtc_device *rtc)
 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);
         trace_rtc_timer_dequeue(timer);
         timer->enabled = 0;
         if (next == &timer->node) {
                 struct rtc_wkalrm alarm;
                 int err;
+
                 next = timerqueue_getnext(&rtc->timerqueue);
                 if (!next) {
                         rtc_alarm_disable(rtc);
@@ -929,9 +923,9 @@ again:
                 alarm.enabled = 1;
 reprogram:
                 err = __rtc_set_alarm(rtc, &alarm);
-                if (err == -ETIME)
+                if (err == -ETIME) {
                         goto again;
-                else if (err) {
+                } else if (err) {
                         if (retry-- > 0)
                                 goto reprogram;
 
@@ -942,14 +936,14 @@ reprogram:
                         dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
                         goto again;
                 }
-        } else
+        } else {
                 rtc_alarm_disable(rtc);
+        }
 
         pm_relax(rtc->dev.parent);
         mutex_unlock(&rtc->ops_lock);
 }
 
-
 /* rtc_timer_init - Initializes an rtc_timer
  * @timer: timer to be intiialized
  * @f: function pointer to be called when timer fires
@@ -975,9 +969,10 @@ void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r),
  * Kernel interface to set an rtc_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)
 {
         int ret = 0;
+
         mutex_lock(&rtc->ops_lock);
         if (timer->enabled)
                 rtc_timer_remove(rtc, timer);