Date:   Fri, 10 Dec 2021 11:52:39 +0100
From:   Vincent Guittot <vincent.guittot@...aro.org>
To:     Cristian Marussi <cristian.marussi@....com>
Cc:     linux-kernel@...r.kernel.org, linux-arm-kernel@...ts.infradead.org,
        sudeep.holla@....com, james.quinlan@...adcom.com,
        jonathan.cameron@...wei.com, f.fainelli@...il.com,
        etienne.carriere@...aro.org, Souvik.Chakravarty@....com,
        Michael Turquette <mturquette@...libre.com>,
        Stephen Boyd <sboyd@...nel.org>, linux-clk@...r.kernel.org
Subject: Re: [PATCH v7 16/16] clk: scmi: Support atomic clock enable/disable API

Hi Cristian,

On Mon, 29 Nov 2021 at 20:13, Cristian Marussi <cristian.marussi@....com> wrote:
>
> Support also atomic enable/disable clk_ops beside the bare non-atomic one
> (prepare/unprepare) when the underlying SCMI transport is configured to
> support atomic transactions for synchronous commands.
>
> Cc: Michael Turquette <mturquette@...libre.com>
> Cc: Stephen Boyd <sboyd@...nel.org>
> Cc: linux-clk@...r.kernel.org
> Signed-off-by: Cristian Marussi <cristian.marussi@....com>
> ---
> V5 --> V6
> - add concurrent availability of atomic and non atomic reqs
> ---
>  drivers/clk/clk-scmi.c | 56 +++++++++++++++++++++++++++++++++++-------
>  1 file changed, 47 insertions(+), 9 deletions(-)
>
> diff --git a/drivers/clk/clk-scmi.c b/drivers/clk/clk-scmi.c
> index 1e357d364ca2..50033d873dde 100644
> --- a/drivers/clk/clk-scmi.c
> +++ b/drivers/clk/clk-scmi.c
> @@ -88,21 +88,53 @@ static void scmi_clk_disable(struct clk_hw *hw)
>         scmi_proto_clk_ops->disable(clk->ph, clk->id);
>  }
>
> +static int scmi_clk_atomic_enable(struct clk_hw *hw)
> +{
> +       struct scmi_clk *clk = to_scmi_clk(hw);
> +
> +       return scmi_proto_clk_ops->enable_atomic(clk->ph, clk->id);
> +}
> +
> +static void scmi_clk_atomic_disable(struct clk_hw *hw)
> +{
> +       struct scmi_clk *clk = to_scmi_clk(hw);
> +
> +       scmi_proto_clk_ops->disable_atomic(clk->ph, clk->id);
> +}
> +
> +/*
> + * We can provide enable/disable atomic callbacks only if the underlying SCMI
> + * transport for an SCMI instance is configured to handle SCMI commands in an
> + * atomic manner.
> + *
> + * When no SCMI atomic transport support is available we instead provide only
> + * the prepare/unprepare API, as allowed by the clock framework when atomic
> + * calls are not available.
> + *
> + * Two distinct sets of clk_ops are provided since we could have multiple SCMI
> + * instances with different underlying transport quality, so they cannot be
> + * shared.
> + */
>  static const struct clk_ops scmi_clk_ops = {
>         .recalc_rate = scmi_clk_recalc_rate,
>         .round_rate = scmi_clk_round_rate,
>         .set_rate = scmi_clk_set_rate,
> -       /*
> -        * We can't provide enable/disable callback as we can't perform the same
> -        * in atomic context. Since the clock framework provides standard API
> -        * clk_prepare_enable that helps cases using clk_enable in non-atomic
> -        * context, it should be fine providing prepare/unprepare.
> -        */
>         .prepare = scmi_clk_enable,
>         .unprepare = scmi_clk_disable,
>  };
>
> -static int scmi_clk_ops_init(struct device *dev, struct scmi_clk *sclk)
> +static const struct clk_ops scmi_atomic_clk_ops = {
> +       .recalc_rate = scmi_clk_recalc_rate,
> +       .round_rate = scmi_clk_round_rate,
> +       .set_rate = scmi_clk_set_rate,
> +       .prepare = scmi_clk_enable,
> +       .unprepare = scmi_clk_disable,
> +       .enable = scmi_clk_atomic_enable,

For  each clock, we have to start with  clk_prepare and then clk_enable
this means that for scmi clk we will do
scmi_clk_enable
then
scmi_clk_atomic_enable

scmi_clk_enable and scmi_clk_atomic_enable ends up doing the same
thing: scmi_clock_config_set but the atomic version doesn't sleep

So you will set enable twice the clock.

This is confirmed when testing your series with virtio scmi backend as
I can see to consecutive scmi clk set enable request for the same
clock

In case of atomic mode, the clk_prepare should  be a nop

> +       .disable = scmi_clk_atomic_disable,
> +};
> +
> +static int scmi_clk_ops_init(struct device *dev, struct scmi_clk *sclk,
> +                            const struct clk_ops *scmi_ops)
>  {
>         int ret;
>         unsigned long min_rate, max_rate;
> @@ -110,7 +142,7 @@ static int scmi_clk_ops_init(struct device *dev, struct scmi_clk *sclk)
>         struct clk_init_data init = {
>                 .flags = CLK_GET_RATE_NOCACHE,
>                 .num_parents = 0,
> -               .ops = &scmi_clk_ops,
> +               .ops = scmi_ops,
>                 .name = sclk->info->name,
>         };
>
> @@ -145,6 +177,7 @@ static int scmi_clocks_probe(struct scmi_device *sdev)
>         struct device_node *np = dev->of_node;
>         const struct scmi_handle *handle = sdev->handle;
>         struct scmi_protocol_handle *ph;
> +       const struct clk_ops *scmi_ops;
>
>         if (!handle)
>                 return -ENODEV;
> @@ -168,6 +201,11 @@ static int scmi_clocks_probe(struct scmi_device *sdev)
>         clk_data->num = count;
>         hws = clk_data->hws;
>
> +       if (handle->is_transport_atomic(handle))
> +               scmi_ops = &scmi_atomic_clk_ops;
> +       else
> +               scmi_ops = &scmi_clk_ops;
> +
>         for (idx = 0; idx < count; idx++) {
>                 struct scmi_clk *sclk;
>
> @@ -184,7 +222,7 @@ static int scmi_clocks_probe(struct scmi_device *sdev)
>                 sclk->id = idx;
>                 sclk->ph = ph;
>
> -               err = scmi_clk_ops_init(dev, sclk);
> +               err = scmi_clk_ops_init(dev, sclk, scmi_ops);
>                 if (err) {
>                         dev_err(dev, "failed to register clock %d\n", idx);
>                         devm_kfree(dev, sclk);
> --
> 2.17.1
>

Powered by blists - more mailing lists