Merge tag 'rtc-4.19' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux

Pull RTC updates from Alexandre Belloni:
 "It is now possible to add custom sysfs attributes while avoiding a
  possible race condition. Unused code has been removed resulting in a
  nice reduction of the code base. And more drivers have been switched
  to SPDX by their maintainers.

 Summary:

  Subsystem:
   - new helpers to add custom sysfs attributes
   - struct rtc_task removal along with rtc_irq_[un]register()
   - rtc_irq_set_state and rtc_irq_set_freq are not exported anymore

  Drivers:
   - armada38x: reset after rtc power loss
   - ds1307: now supports m41t11
   - isl1208: now supports isl1219 and tamper detection
   - pcf2127: internal SRAM support"

* tag 'rtc-4.19' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux: (34 commits)
  rtc: ds1307: simplify hwmon config
  rtc: s5m: Add SPDX license identifier
  rtc: maxim: Add SPDX license identifiers
  rtc: isl1219: add device tree documentation
  rtc: isl1208: set ev-evienb bit from device tree
  rtc: isl1208: Add "evdet" interrupt source for isl1219
  rtc: isl1208: add support for isl1219 with tamper detection
  rtc: sysfs: facilitate attribute add to rtc device
  rtc: remove struct rtc_task
  char: rtc: remove task handling
  rtc: pcf85063: preserve control register value between stop and start
  rtc: sh: remove unused variable rtc_dev
  rtc: unexport rtc_irq_set_*
  rtc: simplify rtc_irq_set_state/rtc_irq_set_freq
  rtc: remove irq_task and irq_task_lock
  rtc: remove rtc_irq_register/rtc_irq_unregister
  rtc: sh: remove dead code
  rtc: sa1100: don't set PIE frequency
  rtc: ds1307: support m41t11 variant
  rtc: ds1307: fix data pointer to m41t0
  ...

1 files changed, 16 insertions, 81 deletions

diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index bac1eeb3d312..3d577e259e91 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -607,12 +607,6 @@ void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
         rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode);
         spin_unlock_irqrestore(&rtc->irq_lock, flags);
 
-        /* call the task func */
-        spin_lock_irqsave(&rtc->irq_task_lock, flags);
-        if (rtc->irq_task)
-                rtc->irq_task->func(rtc->irq_task->private_data);
-        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
-
         wake_up_interruptible(&rtc->irq_queue);
         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
 }
@@ -721,39 +715,6 @@ void rtc_class_close(struct rtc_device *rtc)
 }
 EXPORT_SYMBOL_GPL(rtc_class_close);
 
-int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
-{
-        int retval = -EBUSY;
-
-        if (task == NULL || task->func == NULL)
-                return -EINVAL;
-
-        /* Cannot register while the char dev is in use */
-        if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
-                return -EBUSY;
-
-        spin_lock_irq(&rtc->irq_task_lock);
-        if (rtc->irq_task == NULL) {
-                rtc->irq_task = task;
-                retval = 0;
-        }
-        spin_unlock_irq(&rtc->irq_task_lock);
-
-        clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
-
-        return retval;
-}
-EXPORT_SYMBOL_GPL(rtc_irq_register);
-
-void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
-{
-        spin_lock_irq(&rtc->irq_task_lock);
-        if (rtc->irq_task == task)
-                rtc->irq_task = NULL;
-        spin_unlock_irq(&rtc->irq_task_lock);
-}
-EXPORT_SYMBOL_GPL(rtc_irq_unregister);
-
 static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
 {
         /*
@@ -785,71 +746,45 @@ static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
  * Context: any
  *
  * Note that rtc_irq_set_freq() should previously have been used to
- * specify the desired frequency of periodic IRQ task->func() callbacks.
+ * specify the desired frequency of periodic IRQ.
  */
-int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
+int rtc_irq_set_state(struct rtc_device *rtc, int enabled)
 {
         int err = 0;
-        unsigned long flags;
 
-retry:
-        spin_lock_irqsave(&rtc->irq_task_lock, flags);
-        if (rtc->irq_task != NULL && task == NULL)
-                err = -EBUSY;
-        else if (rtc->irq_task != task)
-                err = -EACCES;
-        else {
-                if (rtc_update_hrtimer(rtc, enabled) < 0) {
-                        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
-                        cpu_relax();
-                        goto retry;
-                }
-                rtc->pie_enabled = enabled;
-        }
-        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
+        while (rtc_update_hrtimer(rtc, enabled) < 0)
+                cpu_relax();
+
+        rtc->pie_enabled = enabled;
 
         trace_rtc_irq_set_state(enabled, err);
         return err;
 }
-EXPORT_SYMBOL_GPL(rtc_irq_set_state);
 
 /**
  * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
  * @rtc: the rtc device
  * @task: currently registered with rtc_irq_register()
- * @freq: positive frequency with which task->func() will be called
+ * @freq: positive frequency
  * Context: any
  *
  * Note that rtc_irq_set_state() is used to enable or disable the
  * periodic IRQs.
  */
-int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
+int rtc_irq_set_freq(struct rtc_device *rtc, int freq)
 {
         int err = 0;
-        unsigned long flags;
 
         if (freq <= 0 || freq > RTC_MAX_FREQ)
                 return -EINVAL;
-retry:
-        spin_lock_irqsave(&rtc->irq_task_lock, flags);
-        if (rtc->irq_task != NULL && task == NULL)
-                err = -EBUSY;
-        else if (rtc->irq_task != task)
-                err = -EACCES;
-        else {
-                rtc->irq_freq = freq;
-                if (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) {
-                        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
-                        cpu_relax();
-                        goto retry;
-                }
-        }
-        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
+
+        rtc->irq_freq = freq;
+        while (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0)
+                cpu_relax();
 
         trace_rtc_irq_set_freq(freq, err);
         return err;
 }
-EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
 
 /**
  * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
@@ -979,8 +914,8 @@ again:
                 timerqueue_del(&rtc->timerqueue, &timer->node);
                 trace_rtc_timer_dequeue(timer);
                 timer->enabled = 0;
-                if (timer->task.func)
-                        timer->task.func(timer->task.private_data);
+                if (timer->func)
+                        timer->func(timer->private_data);
 
                 trace_rtc_timer_fired(timer);
                 /* Re-add/fwd periodic timers */
@@ -1035,8 +970,8 @@ void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data)
 {
         timerqueue_init(&timer->node);
         timer->enabled = 0;
-        timer->task.func = f;
-        timer->task.private_data = data;
+        timer->func = f;
+        timer->private_data = data;
 }
 
 /* rtc_timer_start - Sets an rtc_timer to fire in the future