Received-SPF: pass (google.com: domain of linux-kernel+bounces-141995-linux.lists.archive=gmail.com@vger.kernel.org designates 2604:1380:45d1:ec00::1 as permitted sender) client-ip=2604:1380:45d1:ec00::1;
Message-ID: <f97cb190debc849b598e6675f8780470.sboyd@kernel.org>
Content-Type: text/plain; charset="utf-8"
Precedence: bulk
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
In-Reply-To: <D0H8EDEDKGV9.2FT5JGT59AU8A@bootlin.com>
References: <20240410-mbly-olb-v1-0-335e496d7be3@bootlin.com> <20240410-mbly-olb-v1-5-335e496d7be3@bootlin.com> <daa732cb31d947c308513b535930c729.sboyd@kernel.org> <D0H8EDEDKGV9.2FT5JGT59AU8A@bootlin.com>
Subject: Re: [PATCH 05/11] clk: eyeq: add driver
From: Stephen Boyd <sboyd@kernel.org>
Cc: linux-mips@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org, linux-gpio@vger.kernel.org, Vladimir Kondratiev <vladimir.kondratiev@mobileye.com>, Gregory CLEMENT <gregory.clement@bootlin.com>, Thomas Petazzoni <thomas.petazzoni@bootlin.com>, Tawfik Bayouk <tawfik.bayouk@mobileye.com>
To: Conor Dooley <conor+dt@kernel.org>, Krzysztof Kozlowski <krzysztof.kozlowski+dt@linaro.org>, Linus Walleij <linus.walleij@linaro.org>, Michael Turquette <mturquette@baylibre.com>, Philipp Zabel <p.zabel@pengutronix.de>, Rob Herring <robh@kernel.org>, =?utf-8?q?Th=C3=A9o?= Lebrun <theo.lebrun@bootlin.com>
Date: Thu, 11 Apr 2024 22:46:38 -0700
User-Agent: alot/0.10

Quoting Th=C3=A9o Lebrun (2024-04-11 03:46:04)
> Hello,
>=20
> On Thu Apr 11, 2024 at 5:22 AM CEST, Stephen Boyd wrote:
> > Quoting Th=C3=A9o Lebrun (2024-04-10 10:12:34)
> > > diff --git a/drivers/clk/clk-eyeq.c b/drivers/clk/clk-eyeq.c
> > > new file mode 100644
> > > index 000000000000..bb2535010ae6
> > > --- /dev/null
> > > +++ b/drivers/clk/clk-eyeq.c
> > > @@ -0,0 +1,644 @@
> > > +// SPDX-License-Identifier: GPL-2.0-only
> > > +/*
> > > + * PLL clock driver for the Mobileye EyeQ5, EyeQ6L and EyeQ6H platfo=
rms.
> > > + *
> > > + * This controller handles read-only PLLs, all derived from the same=
 main
> > > + * crystal clock. It also exposes divider clocks, those are children=
 to PLLs.
> > > + * Parent clock is expected to be constant. This driver's registers =
live in
> > > + * a shared region called OLB. Some PLLs are initialised early by of=
_clk_init().
> >
> > Is OLB a different DT node? It sounds like maybe this is trying to jam a
> > driver into DT when the OLB node should be a #clock-cells node.
>=20
> Yes OLB is a different DT node. It looks like on EyeQ5:
>=20
>         olb: system-controller@e00000 {
>                 compatible =3D "mobileye,eyeq5-olb", "syscon", "simple-mf=
d";
>                 reg =3D <0 0xe00000 0x0 0x400>;
>                 ranges =3D <0x0 0x0 0xe00000 0x400>;
>                 #address-cells =3D <1>;
>                 #size-cells =3D <1>;
>=20
>                 reset: reset-controller@e00000 {
>                         compatible =3D "mobileye,eyeq5-reset";
>                         reg =3D <0x000 0x0c>, <0x200 0x34>, <0x120 0x04>;
>                         reg-names =3D "d0", "d1", "d2";
>                         #reset-cells =3D <2>;
>                 };
>=20
>                 clocks: clock-controller@e0002c {
>                         compatible =3D "mobileye,eyeq5-clk";
>                         reg =3D <0x02c 0x50>, <0x11c 0x04>;

Is this reg property always the same value '0x2c'?

>                         reg-names =3D "plls", "ospi";
>                         #clock-cells =3D <1>;
>                         clocks =3D <&xtal>;
>                         clock-names =3D "ref";
>                 };
>=20
>                 pinctrl: pinctrl@e000b0 {
>                         compatible =3D "mobileye,eyeq5-pinctrl";
>                         reg =3D <0x0b0 0x30>;
>                 };
>         };


>=20
> Keep in mind OLB is a complex beast. On EyeQ5, it hosts something like
> 150 registers, describing 20ish various hardware features. We have to
> expose registers to drivers for one-off reads/writes. One example found
> upstream: I2C speed mode register. Others will be Ethernet, eMMC DMA
> config, etc. A syscon makes sense.

Syscons are a slippery slope. It makes it easy to give up abstracting
the 20ish hardware features and makes the resulting drivers which use
the syscon highly platform specific.

Regardless of having a syscon or not, the binding should collapse the
sub-nodes into the olb node. If that requires making a different
compatible for different olb nodes, then that's actually better because
there may be some quirk for one of the olbs and not the other and we
won't be able to fix that without a compatible string update. It would
also make the reg-names property go away, because the sub-functionality
drivers would have the register offsets hard-coded as some offset from
the base of olb, instead of encoding that in DT.

>=20
> I2C looks like like this for example, look at mobileye,olb.
>=20
>         i2c@300000 {
>                 compatible =3D "mobileye,eyeq5-i2c", "arm,primecell";
>                 reg =3D <0x300000 0x1000>;
>                 interrupt-parent =3D <&gic>;
>                 interrupts =3D <GIC_SHARED 1 IRQ_TYPE_LEVEL_HIGH>;
>                 clock-frequency =3D <400000>;
>                 #address-cells =3D <1>;
>                 #size-cells =3D <0>;
>                 clocks =3D <&i2c_ser_clk>, <&i2c_clk>;
>                 clock-names =3D "i2cclk", "apb_pclk";
>                 mobileye,olb =3D <&olb 0>;
>         };
>=20
> See commits 7d4c57abb928 and 1b9a8e8af0d9:
>   i2c: nomadik: support Mobileye EyeQ5 I2C controller
>   dt-bindings: i2c: nomadik: add mobileye,eyeq5-i2c bindings and example

Why isn't i2c speed mode another clk exposed by OLB that rounds to the
different rates?

>=20
> > > +
> > > +       for (i =3D 0; i < data->div_count; i++) {
> > > +               const struct eqc_div *div =3D &data->divs[i];
> > > +               void __iomem *base =3D NULL;
> > > +               struct clk_hw *parent;
> > > +               unsigned int j;
> > > +
> > > +               /*
> > > +                * Multiple divider clocks can request the same resou=
rce. Store
> > > +                * resource pointers during probe(). For each divider=
 clock,
> > > +                * check if previous clocks referenced the same resou=
rce name.
> > > +                *
> > > +                * See EQ6HC_SOUTH_DIV_OSPI_REF and EQ6HC_SOUTH_DIV_O=
SPI_SYS.
> > > +                */
> > > +               for (j =3D 0; j < i; j++) {
> > > +                       if (strcmp(data->divs[j].resource_name, div->=
resource_name) =3D=3D 0) {
> > > +                               base =3D div_resources[j];
> > > +                               break;
> > > +                       }
> > > +               }
> > > +
> > > +               /* Resource is first encountered. */
> > > +               if (!base) {
> > > +                       base =3D devm_platform_ioremap_resource_bynam=
e(pdev, div->resource_name);
> > > +                       if (IS_ERR(base)) {
> > > +                               dev_warn(dev, "failed to iomap resour=
ce for %s\n", div->name);
> > > +                               priv->cells->hws[div->index] =3D base;
> > > +                               continue;
> > > +                       }
> > > +               }
> >
> > I don't get this code at all. The driver should simply map the
> > resources because it knows that there's an io resource. I'll look at the
> > binding which is probably wrong and causing the driver to be written
> > this way.
>=20
> This is here for a single reason: EyeQ6H south OLB has two clocks that
> live in the same register:
>=20
>  - div-ospi-ref, reg offset 0x90, mask GENMASK(9,  8) =3D=3D 0x300.
>  - div-ospi-sys, reg offset 0x90, mask GENMASK(12, 4) =3D=3D 0x1FF0.
>=20
> Calling twice devm_platform_ioremap_resource_byname() with the same
> resource name gives an error. So we need to buffer resources already
> requested.
>=20
> If there is a simpler & better solution I'd be happy to take it.

Sure, don't call platform_ioremap_resource() and friends more than once
per index. But why is the code written in a way that that is happening?
Maybe the driver can ioremap resources, and then register clks for those
resources. I suspect the only way of getting here is that the driver is
focused on registering clks, and ioremapping resources while registering
clks. Don't do that, because then you have to write code to track
resources.

>=20
>=20
> [...]
>=20
> > > +       /*
> > > +        * We expect named resources if divider clocks are present.
> > > +        * Else, we only expect one resource.
> > > +        */
> >
> > Please avoid named resources. They give the false sense of hope that the
> > binding can re-order the reg property when that can't be done. Instead,
> > just index and know which index to use in the driver.
>=20
> It is unclear what you mean by not being able to re-order reg property?
> Are you talking about reg-names being most often defined as items const
> list and therefore cannot be reordered? Here binding declare things
> using minItems/maxItems/enum so it can be reordered, looking like:

Yes, that's wrong.

>=20
>   properties:
>     reg:
>       minItems: 2
>       maxItems: 2
>     reg-names:
>       minItems: 2
>       maxItems: 2
>       items:
>         enum: [ plls, ospi ]
>=20
> If this is not what you are talking about then I rambled about garbage
> and I'll use indexed resources.
>=20

You cannot reorder strings in a DT binding property after the fact.
While the code will keep working if the reg-names elements are
re-ordered, the binding will be backwards incompatible, because the
reg-names property must have the same order. It can be convenient to use
reg-names if you have a long list of reg properties to map, but having
two or one elements isn't a very strong argument.