Re: [PATCH v7 16/16] clk: scmi: Support atomic clock enable/disable API

Vincent Guittot
2021-12-10T10:52:54Z

Hi Cristian,

On Mon, 29 Nov 2021 at 20:13, Cristian Marussi <cristian.marussi@arm.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@baylibre.com>
> Cc: Stephen Boyd <sboyd@kernel.org>
> Cc: linux-clk@vger.kernel.org
> Signed-off-by: Cristian Marussi <cristian.marussi@arm.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
>