clocksource/drivers/sh_cmt: Split start/stop of clock source and events

The CMT do a housekeeping such as dealing with runtime PM and
enable/disable clocks when either a clock source is enabled, or when a
new clock event is registered.

Doing this type of housekeeping for when a clock event is registered is
not always possible as it can happen in contexts where holding spinlocks
is not possible. However doing it when registering a clock source is
possible.

As a first step to address this design break apart the CMT start and
stop functions. The path for clock sources need not change, while the
one for clock events need to be reworked in future work.

There is no indented functional change, just breaking the two use-cases
controlled by a flag into two distinct functions.

Signed-off-by: Niklas Söderlund <niklas.soderlund+renesas@ragnatech.se>
Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Tested-by: Geert Uytterhoeven <geert+renesas@glider.be>
Link: https://lore.kernel.org/r/20250910142657.1148696-2-niklas.soderlund+renesas@ragnatech.se

diff --git a/drivers/clocksource/sh_cmt.c b/drivers/clocksource/sh_cmt.c
index b72b36e0abed860202a2aba001d6d8f002f50983..385eb94bbe7ce544a4e77cc472f22d5a9604c341 100644 (file)
--- a/drivers/clocksource/sh_cmt.c
+++ b/drivers/clocksource/sh_cmt.c
@@ -578,37 +578,74 @@ static irqreturn_t sh_cmt_interrupt(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
 
-static int sh_cmt_start(struct sh_cmt_channel *ch, unsigned long flag)
+static int sh_cmt_start_clocksource(struct sh_cmt_channel *ch)
 {
        int ret = 0;
        unsigned long flags;
 
-       if (flag & FLAG_CLOCKSOURCE)
-               pm_runtime_get_sync(&ch->cmt->pdev->dev);
+       pm_runtime_get_sync(&ch->cmt->pdev->dev);
 
        raw_spin_lock_irqsave(&ch->lock, flags);
 
-       if (!(ch->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE))) {
-               if (flag & FLAG_CLOCKEVENT)
-                       pm_runtime_get_sync(&ch->cmt->pdev->dev);
+       if (!(ch->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE)))
                ret = sh_cmt_enable(ch);
-       }
 
        if (ret)
                goto out;
-       ch->flags |= flag;
+
+       ch->flags |= FLAG_CLOCKSOURCE;
 
        /* setup timeout if no clockevent */
-       if (ch->cmt->num_channels == 1 &&
-           flag == FLAG_CLOCKSOURCE && (!(ch->flags & FLAG_CLOCKEVENT)))
+       if (ch->cmt->num_channels == 1 && !(ch->flags & FLAG_CLOCKEVENT))
                __sh_cmt_set_next(ch, ch->max_match_value);
+out:
+       raw_spin_unlock_irqrestore(&ch->lock, flags);
+
+       return ret;
+}
+
+static void sh_cmt_stop_clocksource(struct sh_cmt_channel *ch)
+{
+       unsigned long flags;
+       unsigned long f;
+
+       raw_spin_lock_irqsave(&ch->lock, flags);
+
+       f = ch->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE);
+
+       ch->flags &= ~FLAG_CLOCKSOURCE;
+
+       if (f && !(ch->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE)))
+               sh_cmt_disable(ch);
+
+       raw_spin_unlock_irqrestore(&ch->lock, flags);
+
+       pm_runtime_put(&ch->cmt->pdev->dev);
+}
+
+static int sh_cmt_start_clockevent(struct sh_cmt_channel *ch)
+{
+       int ret = 0;
+       unsigned long flags;
+
+       raw_spin_lock_irqsave(&ch->lock, flags);
+
+       if (!(ch->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE))) {
+               pm_runtime_get_sync(&ch->cmt->pdev->dev);
+               ret = sh_cmt_enable(ch);
+       }
+
+       if (ret)
+               goto out;
+
+       ch->flags |= FLAG_CLOCKEVENT;
  out:
        raw_spin_unlock_irqrestore(&ch->lock, flags);
 
        return ret;
 }
 
-static void sh_cmt_stop(struct sh_cmt_channel *ch, unsigned long flag)
+static void sh_cmt_stop_clockevent(struct sh_cmt_channel *ch)
 {
        unsigned long flags;
        unsigned long f;
@@ -616,22 +653,19 @@ static void sh_cmt_stop(struct sh_cmt_channel *ch, unsigned long flag)
        raw_spin_lock_irqsave(&ch->lock, flags);
 
        f = ch->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE);
-       ch->flags &= ~flag;
+
+       ch->flags &= ~FLAG_CLOCKEVENT;
 
        if (f && !(ch->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE))) {
                sh_cmt_disable(ch);
-               if (flag & FLAG_CLOCKEVENT)
-                       pm_runtime_put(&ch->cmt->pdev->dev);
+               pm_runtime_put(&ch->cmt->pdev->dev);
        }
 
        /* adjust the timeout to maximum if only clocksource left */
-       if ((flag == FLAG_CLOCKEVENT) && (ch->flags & FLAG_CLOCKSOURCE))
+       if (ch->flags & FLAG_CLOCKSOURCE)
                __sh_cmt_set_next(ch, ch->max_match_value);
 
        raw_spin_unlock_irqrestore(&ch->lock, flags);
-
-       if (flag & FLAG_CLOCKSOURCE)
-               pm_runtime_put(&ch->cmt->pdev->dev);
 }
 
 static struct sh_cmt_channel *cs_to_sh_cmt(struct clocksource *cs)
@@ -672,7 +706,7 @@ static int sh_cmt_clocksource_enable(struct clocksource *cs)
 
        ch->total_cycles = 0;
 
-       ret = sh_cmt_start(ch, FLAG_CLOCKSOURCE);
+       ret = sh_cmt_start_clocksource(ch);
        if (!ret)
                ch->cs_enabled = true;
 
@@ -685,7 +719,7 @@ static void sh_cmt_clocksource_disable(struct clocksource *cs)
 
        WARN_ON(!ch->cs_enabled);
 
-       sh_cmt_stop(ch, FLAG_CLOCKSOURCE);
+       sh_cmt_stop_clocksource(ch);
        ch->cs_enabled = false;
 }
 
@@ -696,7 +730,7 @@ static void sh_cmt_clocksource_suspend(struct clocksource *cs)
        if (!ch->cs_enabled)
                return;
 
-       sh_cmt_stop(ch, FLAG_CLOCKSOURCE);
+       sh_cmt_stop_clocksource(ch);
        dev_pm_genpd_suspend(&ch->cmt->pdev->dev);
 }
 
@@ -708,7 +742,7 @@ static void sh_cmt_clocksource_resume(struct clocksource *cs)
                return;
 
        dev_pm_genpd_resume(&ch->cmt->pdev->dev);
-       sh_cmt_start(ch, FLAG_CLOCKSOURCE);
+       sh_cmt_start_clocksource(ch);
 }
 
 static int sh_cmt_register_clocksource(struct sh_cmt_channel *ch,
@@ -740,7 +774,7 @@ static struct sh_cmt_channel *ced_to_sh_cmt(struct clock_event_device *ced)
 
 static void sh_cmt_clock_event_start(struct sh_cmt_channel *ch, int periodic)
 {
-       sh_cmt_start(ch, FLAG_CLOCKEVENT);
+       sh_cmt_start_clockevent(ch);
 
        if (periodic)
                sh_cmt_set_next(ch, ((ch->cmt->rate + HZ/2) / HZ) - 1);
@@ -752,7 +786,7 @@ static int sh_cmt_clock_event_shutdown(struct clock_event_device *ced)
 {
        struct sh_cmt_channel *ch = ced_to_sh_cmt(ced);
 
-       sh_cmt_stop(ch, FLAG_CLOCKEVENT);
+       sh_cmt_stop_clockevent(ch);
        return 0;
 }
 
@@ -763,7 +797,7 @@ static int sh_cmt_clock_event_set_state(struct clock_event_device *ced,
 
        /* deal with old setting first */
        if (clockevent_state_oneshot(ced) || clockevent_state_periodic(ced))
-               sh_cmt_stop(ch, FLAG_CLOCKEVENT);
+               sh_cmt_stop_clockevent(ch);
 
        dev_info(&ch->cmt->pdev->dev, "ch%u: used for %s clock events\n",
                 ch->index, periodic ? "periodic" : "oneshot");