| Message ID | 20231109100606.1245545-1-wenst@chromium.org |
|---|---|
| Headers | show |
| Series | of: Introduce hardware prober driver | expand |
Il 09/11/23 11:05, Chen-Yu Tsai ha scritto: > Hi everyone, > > This v2 series continues Doug's "of: device: Support 2nd sources of > probeable but undiscoverable devices" [1] series, but follows the scheme > suggested by Rob, marking all second source component device nodes > as "fail-needs-probe-XXX", and having a hardware prober driver enable > the one of them. I tried to include everyone from the original Cc: list. > Please let me know if you would like to be dropped from future > submissions. > > > For the I2C component (touchscreens and trackpads) case from the > original series, the hardware prober driver finds the particular > class of device in the device tree, gets its parent I2C adapter, > and tries to initiate a simple I2C read for each device under that > I2C bus. When it finds one that responds, it considers that one > present, marks it as "okay", and returns, letting the driver core > actually probe the device. > > This works fine in most cases since these components are connected > via ribbon cable and always have the same resources. The driver as > implemented currently doesn't deal with regulators or GPIO pins, > since in the existing device trees they are either always on for > regulators, or have GPIO hogs or pinmux and pinconfig directly > tied to the pin controller. > > > Another case this driver could handle is selecting components based > on some identifier passed in by the firmware. On Chromebooks we have > a SKU ID which is inserted by the bootloader at > /firmware/coreboot/sku-id. When a new combination of components is > introduced, a new SKU ID is allocated to it. To have SKU ID based > device trees, we would need to have one per SKU ID. This ends up > increasing the number of device trees we have a lot. The recent > MT8186 devices already have 10+10 SKUs [2], with possibly more to come. > > Instead, we could have just one device tree for each device, with > component options listed and marked as "fail-needs-probe-XXX", and > let the hardware prober enable one of them based on the given SKU ID. > The driver will also fix up OF graph remote endpoints to point to the > enabled component. > > The MT8186 Corsola series [2] can also benefit from this, though I > haven't implemented anything yet. > > > Patch 1 adds of_device_is_fail() for the new driver to use. > > Patch 2 implements the first case, probing the I2C bus for presence > of components. This initial version targets the Hana Chromebooks. > > Patch 3 modifies the Hana device tree and marks the touchscreens > and trackpads as "fail-needs-probe-XXX", ready for the driver to > probe. > > Patch 4 adds a missing touchscreen variant to Hana. > > Patch 5 implements the second case, selectively enabling components > based on the SKU ID. This initial version targets the Krane ChromeOS > tablet, which has two possible MIPI DSI display panel options. > > Patch 6 drops Krane's SKU-specific compatible strings from the bindings. > > Patch 7 merges Krane's SKU-specific device trees into one, with the > device tree now containing two possible panels. This unfortunately > introduces a dtc warning: > > arch/arm64/boot/dts/mediatek/mt8183-kukui-krane.dts:81.13-83.6: > Warning (graph_endpoint): /soc/dsi@14014000/panel2@0/port/endpoint: > graph connection to node '/soc/dsi@14014000/ports/port/endpoint' > is not bidirectional > > > Please take a look. > > Johan, I'm not sure if this works as is for the Lenovo Thinkpad 13S > case, since it looks like the trackpad shares the I2C bus with the > keyboard. > > > Thanks > ChenYu > > > Background as given in Doug's cover letter: > > Support for multiple "equivalent" sources for components (also known > as second sourcing components) is a standard practice that helps keep > cost down and also makes sure that if one component is unavailable due > to a shortage that we don't need to stop production for the whole > product. > > Some components are very easy to second source. eMMC, for instance, is > fully discoverable and probable so you can stuff a wide variety of > similar eMMC chips on your board and things will work without a hitch. > > Some components are more difficult to second source, specifically > because it's difficult for software to probe what component is present > on any given board. In cases like this software is provided > supplementary information to help it, like a GPIO strap or a SKU ID > programmed into an EEPROM. This helpful information can allow the > bootloader to select a different device tree. The various different > "SKUs" of different Chromebooks are examples of this. > > Some components are somewhere in between. These in-between components > are the subject of this patch. Specifically, these components are > easily "probeable" but not easily "discoverable". > > A good example of a probeable but undiscoverable device is an > i2c-connected touchscreen or trackpad. Two separate components may be > electrically compatible with each other and may have compatible power > sequencing requirements but may require different software. If > software is told about the different possible components (because it > can't discover them), it can safely probe them to figure out which > ones are present. > > On systems using device tree, if we want to tell the OS about all of > the different components we need to list them all in the device > tree. This leads to a problem. The multiple sources for components > likely use the same resources (GPIOs, interrupts, regulators). If the > OS tries to probe all of these components at the same time then it > will detect a resource conflict and that's a fatal error. > > The fact that Linux can't handle these probeable but undiscoverable > devices well has had a few consequences: > 1. In some cases, we've abandoned the idea of second sourcing > components for a given board, which increases cost / generates > manufacturing headaches. > 2. In some cases, we've been forced to add some sort of strapping / > EEPROM to indicate which component is present. This adds difficulty > to manufacturing / refurb processes. > 3. In some cases, we've managed to make things work by the skin of our > teeth through slightly hacky solutions. Specifically, if we remove > the "pinctrl" entry from the various options then it won't > conflict. Regulators inherently can have more than one consumer, so > as long as there are no GPIOs involved in power sequencing and > probing devices then things can work. This is how > "sc8280xp-lenovo-thinkpad-x13s" works and also how > "mt8173-elm-hana" works. > > End of background from Doug's cover letter. I think that using "status" is not a good idea, I find that confusing. Perhaps we could have a node like something { device-class-one = <&device1>, <&device2>, <&device3>; device-class-two = <&device4>, <&device5>, <&device6>; } so that'd be more or less hw-prober { trackpads = <&tp1>, <&tp2>; keyboards = <&kb1>, <&kb2>; touchscreens = <&ts1>, <&ts2>; } Besides, something else I can suggest here is to make this more generic: actually, this issue is spread across way more devices than you maybe think... for example, I know of some smartphones that may have the same situation with DSI displays and they're sometimes distinguished by an ADC value, sometimes by reading back the manufacturer ID (or panel id) through DSI. Also, if Chromebooks really need something "special", such as that coreboot sku-id parameter, I think that this should be registered externally into the hw prober and not embedded inside of the *generic* hw prober driver. We can even reuse of_device_id instead of inventing a new hw_prober_entry struct... Idea: drivers/platform/chrome/cros_of_hw_prober.c static int cros_sku_hw_prober(struct platform_device *pdev, const void *data) { ...this is your cros_sku_component_selector() function, anyway... } static const struct of_device_id cros_hw_prober_ids[] = { { .compatible = "google,hana", .data = something }, { /* sentinel */ } }; static int some_kind_of_early_init_function(something) { int a,b,c,ret,something; .. some logic if necessary .. return of_hw_prober_register(cros_sku_hw_prober, cros_hw_prober_ids); } Btw, thanks for starting that. If this will be done the right way, it's going to be useful to many, many people. Regards, Angelo > > [1] https://lore.kernel.org/all/20230921102420.RFC.1.I9dddd99ccdca175e3ceb1b9fa1827df0928c5101@changeid/ > [2] https://lore.kernel.org/linux-mediatek/20231012230237.2676469-1-wenst@chromium.org/ > > Chen-Yu Tsai (7): > of: base: Add of_device_is_fail > of: Introduce hardware prober driver > arm64: dts: mediatek: mt8173-elm-hana: Mark touchscreens and trackpads > as fail > arm64: dts: mediatek: mt8173-elm-hana: Add G2touch G7500 touchscreen > of: hw_prober: Support Chromebook SKU ID based component selection > dt-bindings: arm: mediatek: Remove SKU specific compatibles for Google > Krane > arm64: dts: mediatek: mt8183-kukui: Merge Krane device trees > > .../devicetree/bindings/arm/mediatek.yaml | 3 - > arch/arm64/boot/dts/mediatek/Makefile | 3 +- > .../boot/dts/mediatek/mt8173-elm-hana.dtsi | 20 ++ > .../dts/mediatek/mt8183-kukui-krane-sku0.dts | 24 -- > .../mediatek/mt8183-kukui-krane-sku176.dts | 24 -- > ...ukui-krane.dtsi => mt8183-kukui-krane.dts} | 47 ++- > drivers/of/Kconfig | 13 + > drivers/of/Makefile | 1 + > drivers/of/base.c | 20 ++ > drivers/of/hw_prober.c | 314 ++++++++++++++++++ > include/linux/of.h | 6 + > 11 files changed, 418 insertions(+), 57 deletions(-) > delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku0.dts > delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku176.dts > rename arch/arm64/boot/dts/mediatek/{mt8183-kukui-krane.dtsi => mt8183-kukui-krane.dts} (86%) > create mode 100644 drivers/of/hw_prober.c >
On Thu, Nov 9, 2023 at 4:54 AM AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com> wrote: > > Il 09/11/23 11:05, Chen-Yu Tsai ha scritto: > > Hi everyone, > > > > This v2 series continues Doug's "of: device: Support 2nd sources of > > probeable but undiscoverable devices" [1] series, but follows the scheme > > suggested by Rob, marking all second source component device nodes > > as "fail-needs-probe-XXX", and having a hardware prober driver enable > > the one of them. I tried to include everyone from the original Cc: list. > > Please let me know if you would like to be dropped from future > > submissions. > > > > > > For the I2C component (touchscreens and trackpads) case from the > > original series, the hardware prober driver finds the particular > > class of device in the device tree, gets its parent I2C adapter, > > and tries to initiate a simple I2C read for each device under that > > I2C bus. When it finds one that responds, it considers that one > > present, marks it as "okay", and returns, letting the driver core > > actually probe the device. > > > > This works fine in most cases since these components are connected > > via ribbon cable and always have the same resources. The driver as > > implemented currently doesn't deal with regulators or GPIO pins, > > since in the existing device trees they are either always on for > > regulators, or have GPIO hogs or pinmux and pinconfig directly > > tied to the pin controller. > > > > > > Another case this driver could handle is selecting components based > > on some identifier passed in by the firmware. On Chromebooks we have > > a SKU ID which is inserted by the bootloader at > > /firmware/coreboot/sku-id. When a new combination of components is > > introduced, a new SKU ID is allocated to it. To have SKU ID based > > device trees, we would need to have one per SKU ID. This ends up > > increasing the number of device trees we have a lot. The recent > > MT8186 devices already have 10+10 SKUs [2], with possibly more to come. > > > > Instead, we could have just one device tree for each device, with > > component options listed and marked as "fail-needs-probe-XXX", and > > let the hardware prober enable one of them based on the given SKU ID. > > The driver will also fix up OF graph remote endpoints to point to the > > enabled component. > > > > The MT8186 Corsola series [2] can also benefit from this, though I > > haven't implemented anything yet. > > > > > > Patch 1 adds of_device_is_fail() for the new driver to use. > > > > Patch 2 implements the first case, probing the I2C bus for presence > > of components. This initial version targets the Hana Chromebooks. > > > > Patch 3 modifies the Hana device tree and marks the touchscreens > > and trackpads as "fail-needs-probe-XXX", ready for the driver to > > probe. > > > > Patch 4 adds a missing touchscreen variant to Hana. > > > > Patch 5 implements the second case, selectively enabling components > > based on the SKU ID. This initial version targets the Krane ChromeOS > > tablet, which has two possible MIPI DSI display panel options. > > > > Patch 6 drops Krane's SKU-specific compatible strings from the bindings. > > > > Patch 7 merges Krane's SKU-specific device trees into one, with the > > device tree now containing two possible panels. This unfortunately > > introduces a dtc warning: > > > > arch/arm64/boot/dts/mediatek/mt8183-kukui-krane.dts:81.13-83.6: > > Warning (graph_endpoint): /soc/dsi@14014000/panel2@0/port/endpoint: > > graph connection to node '/soc/dsi@14014000/ports/port/endpoint' > > is not bidirectional > > > > > > Please take a look. > > > > Johan, I'm not sure if this works as is for the Lenovo Thinkpad 13S > > case, since it looks like the trackpad shares the I2C bus with the > > keyboard. > > > > > > Thanks > > ChenYu > > > > > > Background as given in Doug's cover letter: > > > > Support for multiple "equivalent" sources for components (also known > > as second sourcing components) is a standard practice that helps keep > > cost down and also makes sure that if one component is unavailable due > > to a shortage that we don't need to stop production for the whole > > product. > > > > Some components are very easy to second source. eMMC, for instance, is > > fully discoverable and probable so you can stuff a wide variety of > > similar eMMC chips on your board and things will work without a hitch. > > > > Some components are more difficult to second source, specifically > > because it's difficult for software to probe what component is present > > on any given board. In cases like this software is provided > > supplementary information to help it, like a GPIO strap or a SKU ID > > programmed into an EEPROM. This helpful information can allow the > > bootloader to select a different device tree. The various different > > "SKUs" of different Chromebooks are examples of this. > > > > Some components are somewhere in between. These in-between components > > are the subject of this patch. Specifically, these components are > > easily "probeable" but not easily "discoverable". > > > > A good example of a probeable but undiscoverable device is an > > i2c-connected touchscreen or trackpad. Two separate components may be > > electrically compatible with each other and may have compatible power > > sequencing requirements but may require different software. If > > software is told about the different possible components (because it > > can't discover them), it can safely probe them to figure out which > > ones are present. > > > > On systems using device tree, if we want to tell the OS about all of > > the different components we need to list them all in the device > > tree. This leads to a problem. The multiple sources for components > > likely use the same resources (GPIOs, interrupts, regulators). If the > > OS tries to probe all of these components at the same time then it > > will detect a resource conflict and that's a fatal error. > > > > The fact that Linux can't handle these probeable but undiscoverable > > devices well has had a few consequences: > > 1. In some cases, we've abandoned the idea of second sourcing > > components for a given board, which increases cost / generates > > manufacturing headaches. > > 2. In some cases, we've been forced to add some sort of strapping / > > EEPROM to indicate which component is present. This adds difficulty > > to manufacturing / refurb processes. > > 3. In some cases, we've managed to make things work by the skin of our > > teeth through slightly hacky solutions. Specifically, if we remove > > the "pinctrl" entry from the various options then it won't > > conflict. Regulators inherently can have more than one consumer, so > > as long as there are no GPIOs involved in power sequencing and > > probing devices then things can work. This is how > > "sc8280xp-lenovo-thinkpad-x13s" works and also how > > "mt8173-elm-hana" works. > > > > End of background from Doug's cover letter. > > I think that using "status" is not a good idea, I find that confusing. "status" is what defines a device's state in terms of enabled, present, available. That's exactly what we're expressing here. Now, I do not think we should be mixing the device class (e.g. touchscreen) into status. I said this on v1, but apparently that was not listened to. > > Perhaps we could have a node like > > something { > device-class-one = <&device1>, <&device2>, <&device3>; > device-class-two = <&device4>, <&device5>, <&device6>; > } > > so that'd be more or less > > hw-prober { > trackpads = <&tp1>, <&tp2>; > keyboards = <&kb1>, <&kb2>; > touchscreens = <&ts1>, <&ts2>; > } No. That's more or less what v1 had. Rob
On Thu, Nov 09, 2023 at 06:06:02PM +0800, Chen-Yu Tsai wrote: > In cases where the same Chromebook model is manufactured with different > components (MIPI DSI panels, MIPI CSI camera sensors, or trackpad / > touchscreens with conflicting addresses), a different SKU ID is > allocated to each specific combination. This SKU ID is exported by the > bootloader into the device tree, and can be used to "discover" which > combination is present on the current machine. > > This change adds a hardware prober that will match the SKU ID against > a provided table, and enable the component for the matched entry based > on the given compatible string. In the MIPI DSI panel and MIPI CSI > camera sensor cases which have OF graphs, it will also update the > remote endpoint to point to the enabled component. This assumes a single > endpoint only. > > This will provide a path to reducing the number of Chromebook device > trees. > > Signed-off-by: Chen-Yu Tsai <wenst@chromium.org> > --- > drivers/of/hw_prober.c | 160 +++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 160 insertions(+) This certainly does not belong in drivers/of/. > diff --git a/drivers/of/hw_prober.c b/drivers/of/hw_prober.c > index 442da6eff896..4345e5aed6d8 100644 > --- a/drivers/of/hw_prober.c > +++ b/drivers/of/hw_prober.c > @@ -8,6 +8,7 @@ > #include <linux/array_size.h> > #include <linux/i2c.h> > #include <linux/of.h> > +#include <linux/of_graph.h> > #include <linux/platform_device.h> > > #define DRV_NAME "hw_prober" > @@ -108,9 +109,168 @@ static int i2c_component_prober(struct platform_device *pdev, const void *data) > return ret; > } > > +static int cros_get_coreboot_sku_id(struct device *dev, u32 *sku_id) > +{ > + struct device_node *node = NULL; > + int ret; > + > + node = of_find_node_by_path("/firmware/coreboot"); > + if (!node) > + return dev_err_probe(dev, -EINVAL, "Cannot find coreboot firmware node\n"); > + > + ret = of_property_read_u32(node, "sku-id", sku_id); Not documented. Rob
Hi, On Thu, Nov 9, 2023 at 5:52 AM Rob Herring <robh+dt@kernel.org> wrote: > > > > End of background from Doug's cover letter. > > > > I think that using "status" is not a good idea, I find that confusing. > > "status" is what defines a device's state in terms of enabled, > present, available. That's exactly what we're expressing here. > > Now, I do not think we should be mixing the device class (e.g. > touchscreen) into status. I said this on v1, but apparently that was > not listened to. Interesting. I must have missed the "don't mix device class into status" part. Do you have a link to your post about that? Maybe there's other stuff I missed... Having the device class stuck at the end there was at least part of my last post [1] which gathered no response. I think one of the reasons that I felt we needed to mux the device class into status was that it was going to make the code a lot less fragile. Everything I've seen indicates that you don't want us to create a "HW prober" node that could be used to provide relevant phandles for different classes of devices, so the "HW prober" code needs to either search through the whole device tree for a status of "failed-needs-probe" or needs to contain per-board, hardcoded, fully-qualified paths. I don't think we want to include hardcoded, fully-qualified paths in the code. That would mean that if someone changed a node name somewhere in the path to one of the devices that we're dealing with then it would break. So if we're searching the whole device tree for "failed-needs-probe" then we need to figure out which devices are related to each other. If a given board has second sources for MIPI panels, touchscreens, and trackpads then we need to know which of the "failed-needs-probe" devices are trackpads, which are touchscreens, and which are MIPI panels. Do you have any suggestions for how we should do that? Maybe it was in some other thread that I missed? I guess we could have a board-specific table mapping (compatible + node name + reg) to a class, but that feels awkward. [1] https://lore.kernel.org/r/CAD=FV=UjVAgT-febtj4=UZ2GQp01D-ern2Ff9+ODcHeQBOsdTQ@mail.gmail.com
Hi, On Thu, Nov 9, 2023 at 2:06 AM Chen-Yu Tsai <wenst@chromium.org> wrote: > > The driver as > implemented currently doesn't deal with regulators or GPIO pins, > since in the existing device trees they are either always on for > regulators, or have GPIO hogs or pinmux and pinconfig directly > tied to the pin controller. I guess I won't object too much about this limitation for v1, but IMO it would be good to get this sorted out since I think part of the power of having the HW Prober is specifically that it can handle this type of use case. You have a little bit of board-specific code that knows how to turn on the regulators / GPIOs and can then probe the devices. Note: even if this is "board specific", it doesn't mean you couldn't share code between boards. For instance, you could have a helper function that would turn on regulators/GPIOs based on some type of table and that helper function could be used across a whole pile of Chromebooks. If a Chromebook is sufficiently different that it couldn't use the helper function then it could call its own function, but presumably it wouldn't be hard to support a bunch of boards without much code. As part of this, I think that your main "HW Prober" for Chromebooks should be in "drivers/platform/chrome/". I think that the only things that should be in the "drivers/of" directory should be helper functions used by the Chromebook HW Probers. -Doug
On Thu, Nov 9, 2023 at 9:52 PM Rob Herring <robh+dt@kernel.org> wrote: > > On Thu, Nov 9, 2023 at 4:54 AM AngeloGioacchino Del Regno > <angelogioacchino.delregno@collabora.com> wrote: > > > > Il 09/11/23 11:05, Chen-Yu Tsai ha scritto: > > > Hi everyone, > > > > > > This v2 series continues Doug's "of: device: Support 2nd sources of > > > probeable but undiscoverable devices" [1] series, but follows the scheme > > > suggested by Rob, marking all second source component device nodes > > > as "fail-needs-probe-XXX", and having a hardware prober driver enable > > > the one of them. I tried to include everyone from the original Cc: list. > > > Please let me know if you would like to be dropped from future > > > submissions. > > > > > > > > > For the I2C component (touchscreens and trackpads) case from the > > > original series, the hardware prober driver finds the particular > > > class of device in the device tree, gets its parent I2C adapter, > > > and tries to initiate a simple I2C read for each device under that > > > I2C bus. When it finds one that responds, it considers that one > > > present, marks it as "okay", and returns, letting the driver core > > > actually probe the device. > > > > > > This works fine in most cases since these components are connected > > > via ribbon cable and always have the same resources. The driver as > > > implemented currently doesn't deal with regulators or GPIO pins, > > > since in the existing device trees they are either always on for > > > regulators, or have GPIO hogs or pinmux and pinconfig directly > > > tied to the pin controller. > > > > > > > > > Another case this driver could handle is selecting components based > > > on some identifier passed in by the firmware. On Chromebooks we have > > > a SKU ID which is inserted by the bootloader at > > > /firmware/coreboot/sku-id. When a new combination of components is > > > introduced, a new SKU ID is allocated to it. To have SKU ID based > > > device trees, we would need to have one per SKU ID. This ends up > > > increasing the number of device trees we have a lot. The recent > > > MT8186 devices already have 10+10 SKUs [2], with possibly more to come. > > > > > > Instead, we could have just one device tree for each device, with > > > component options listed and marked as "fail-needs-probe-XXX", and > > > let the hardware prober enable one of them based on the given SKU ID. > > > The driver will also fix up OF graph remote endpoints to point to the > > > enabled component. > > > > > > The MT8186 Corsola series [2] can also benefit from this, though I > > > haven't implemented anything yet. > > > > > > > > > Patch 1 adds of_device_is_fail() for the new driver to use. > > > > > > Patch 2 implements the first case, probing the I2C bus for presence > > > of components. This initial version targets the Hana Chromebooks. > > > > > > Patch 3 modifies the Hana device tree and marks the touchscreens > > > and trackpads as "fail-needs-probe-XXX", ready for the driver to > > > probe. > > > > > > Patch 4 adds a missing touchscreen variant to Hana. > > > > > > Patch 5 implements the second case, selectively enabling components > > > based on the SKU ID. This initial version targets the Krane ChromeOS > > > tablet, which has two possible MIPI DSI display panel options. > > > > > > Patch 6 drops Krane's SKU-specific compatible strings from the bindings. > > > > > > Patch 7 merges Krane's SKU-specific device trees into one, with the > > > device tree now containing two possible panels. This unfortunately > > > introduces a dtc warning: > > > > > > arch/arm64/boot/dts/mediatek/mt8183-kukui-krane.dts:81.13-83.6: > > > Warning (graph_endpoint): /soc/dsi@14014000/panel2@0/port/endpoint: > > > graph connection to node '/soc/dsi@14014000/ports/port/endpoint' > > > is not bidirectional > > > > > > > > > Please take a look. > > > > > > Johan, I'm not sure if this works as is for the Lenovo Thinkpad 13S > > > case, since it looks like the trackpad shares the I2C bus with the > > > keyboard. > > > > > > > > > Thanks > > > ChenYu > > > > > > > > > Background as given in Doug's cover letter: > > > > > > Support for multiple "equivalent" sources for components (also known > > > as second sourcing components) is a standard practice that helps keep > > > cost down and also makes sure that if one component is unavailable due > > > to a shortage that we don't need to stop production for the whole > > > product. > > > > > > Some components are very easy to second source. eMMC, for instance, is > > > fully discoverable and probable so you can stuff a wide variety of > > > similar eMMC chips on your board and things will work without a hitch. > > > > > > Some components are more difficult to second source, specifically > > > because it's difficult for software to probe what component is present > > > on any given board. In cases like this software is provided > > > supplementary information to help it, like a GPIO strap or a SKU ID > > > programmed into an EEPROM. This helpful information can allow the > > > bootloader to select a different device tree. The various different > > > "SKUs" of different Chromebooks are examples of this. > > > > > > Some components are somewhere in between. These in-between components > > > are the subject of this patch. Specifically, these components are > > > easily "probeable" but not easily "discoverable". > > > > > > A good example of a probeable but undiscoverable device is an > > > i2c-connected touchscreen or trackpad. Two separate components may be > > > electrically compatible with each other and may have compatible power > > > sequencing requirements but may require different software. If > > > software is told about the different possible components (because it > > > can't discover them), it can safely probe them to figure out which > > > ones are present. > > > > > > On systems using device tree, if we want to tell the OS about all of > > > the different components we need to list them all in the device > > > tree. This leads to a problem. The multiple sources for components > > > likely use the same resources (GPIOs, interrupts, regulators). If the > > > OS tries to probe all of these components at the same time then it > > > will detect a resource conflict and that's a fatal error. > > > > > > The fact that Linux can't handle these probeable but undiscoverable > > > devices well has had a few consequences: > > > 1. In some cases, we've abandoned the idea of second sourcing > > > components for a given board, which increases cost / generates > > > manufacturing headaches. > > > 2. In some cases, we've been forced to add some sort of strapping / > > > EEPROM to indicate which component is present. This adds difficulty > > > to manufacturing / refurb processes. > > > 3. In some cases, we've managed to make things work by the skin of our > > > teeth through slightly hacky solutions. Specifically, if we remove > > > the "pinctrl" entry from the various options then it won't > > > conflict. Regulators inherently can have more than one consumer, so > > > as long as there are no GPIOs involved in power sequencing and > > > probing devices then things can work. This is how > > > "sc8280xp-lenovo-thinkpad-x13s" works and also how > > > "mt8173-elm-hana" works. > > > > > > End of background from Doug's cover letter. > > > > I think that using "status" is not a good idea, I find that confusing. > > "status" is what defines a device's state in terms of enabled, > present, available. That's exactly what we're expressing here. > > Now, I do not think we should be mixing the device class (e.g. > touchscreen) into status. I said this on v1, but apparently that was > not listened to. I must have missed it and only took in Doug's final response. My code doesn't actually use the class in the status property though. I will remove it and just keep "fail-needs-probe". ChenYu > > > > Perhaps we could have a node like > > > > something { > > device-class-one = <&device1>, <&device2>, <&device3>; > > device-class-two = <&device4>, <&device5>, <&device6>; > > } > > > > so that'd be more or less > > > > hw-prober { > > trackpads = <&tp1>, <&tp2>; > > keyboards = <&kb1>, <&kb2>; > > touchscreens = <&ts1>, <&ts2>; > > } > > No. That's more or less what v1 had. > > Rob
On Sat, Nov 11, 2023 at 8:22 AM Doug Anderson <dianders@chromium.org> wrote: > > Hi, > > On Thu, Nov 9, 2023 at 2:06 AM Chen-Yu Tsai <wenst@chromium.org> wrote: > > > > The driver as > > implemented currently doesn't deal with regulators or GPIO pins, > > since in the existing device trees they are either always on for > > regulators, or have GPIO hogs or pinmux and pinconfig directly > > tied to the pin controller. > > I guess I won't object too much about this limitation for v1, but IMO > it would be good to get this sorted out since I think part of the > power of having the HW Prober is specifically that it can handle this > type of use case. You have a little bit of board-specific code that > knows how to turn on the regulators / GPIOs and can then probe the > devices. > > Note: even if this is "board specific", it doesn't mean you couldn't > share code between boards. For instance, you could have a helper > function that would turn on regulators/GPIOs based on some type of > table and that helper function could be used across a whole pile of > Chromebooks. If a Chromebook is sufficiently different that it > couldn't use the helper function then it could call its own function, > but presumably it wouldn't be hard to support a bunch of boards > without much code. I agree this part is fairly generic and should be implemented. We probably don't even need such a table. If these components share a common connection to the mainboard, they certainly will have the same GPIO lines and regulator supplies. The prober could just scan the nodes looking for -gpio and -supply properties, de-duplicate them, and turn them on. The reason this isn't implemented in this version is because the devices I'm currently using do not have these resources togglable. The supply is always on, and the GPIO line is disconnected from the SoC. So I have no way of testing it yet. > As part of this, I think that your main "HW Prober" for Chromebooks > should be in "drivers/platform/chrome/". I think that the only things > that should be in the "drivers/of" directory should be helper > functions used by the Chromebook HW Probers. Sound like what Rob wants. ChenYu
On Thu, Nov 9, 2023 at 6:54 PM AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com> wrote: > > Il 09/11/23 11:05, Chen-Yu Tsai ha scritto: > > Hi everyone, > > > > This v2 series continues Doug's "of: device: Support 2nd sources of > > probeable but undiscoverable devices" [1] series, but follows the scheme > > suggested by Rob, marking all second source component device nodes > > as "fail-needs-probe-XXX", and having a hardware prober driver enable > > the one of them. I tried to include everyone from the original Cc: list. > > Please let me know if you would like to be dropped from future > > submissions. > > > > > > For the I2C component (touchscreens and trackpads) case from the > > original series, the hardware prober driver finds the particular > > class of device in the device tree, gets its parent I2C adapter, > > and tries to initiate a simple I2C read for each device under that > > I2C bus. When it finds one that responds, it considers that one > > present, marks it as "okay", and returns, letting the driver core > > actually probe the device. > > > > This works fine in most cases since these components are connected > > via ribbon cable and always have the same resources. The driver as > > implemented currently doesn't deal with regulators or GPIO pins, > > since in the existing device trees they are either always on for > > regulators, or have GPIO hogs or pinmux and pinconfig directly > > tied to the pin controller. > > > > > > Another case this driver could handle is selecting components based > > on some identifier passed in by the firmware. On Chromebooks we have > > a SKU ID which is inserted by the bootloader at > > /firmware/coreboot/sku-id. When a new combination of components is > > introduced, a new SKU ID is allocated to it. To have SKU ID based > > device trees, we would need to have one per SKU ID. This ends up > > increasing the number of device trees we have a lot. The recent > > MT8186 devices already have 10+10 SKUs [2], with possibly more to come. > > > > Instead, we could have just one device tree for each device, with > > component options listed and marked as "fail-needs-probe-XXX", and > > let the hardware prober enable one of them based on the given SKU ID. > > The driver will also fix up OF graph remote endpoints to point to the > > enabled component. > > > > The MT8186 Corsola series [2] can also benefit from this, though I > > haven't implemented anything yet. > > > > > > Patch 1 adds of_device_is_fail() for the new driver to use. > > > > Patch 2 implements the first case, probing the I2C bus for presence > > of components. This initial version targets the Hana Chromebooks. > > > > Patch 3 modifies the Hana device tree and marks the touchscreens > > and trackpads as "fail-needs-probe-XXX", ready for the driver to > > probe. > > > > Patch 4 adds a missing touchscreen variant to Hana. > > > > Patch 5 implements the second case, selectively enabling components > > based on the SKU ID. This initial version targets the Krane ChromeOS > > tablet, which has two possible MIPI DSI display panel options. > > > > Patch 6 drops Krane's SKU-specific compatible strings from the bindings. > > > > Patch 7 merges Krane's SKU-specific device trees into one, with the > > device tree now containing two possible panels. This unfortunately > > introduces a dtc warning: > > > > arch/arm64/boot/dts/mediatek/mt8183-kukui-krane.dts:81.13-83.6: > > Warning (graph_endpoint): /soc/dsi@14014000/panel2@0/port/endpoint: > > graph connection to node '/soc/dsi@14014000/ports/port/endpoint' > > is not bidirectional > > > > > > Please take a look. > > > > Johan, I'm not sure if this works as is for the Lenovo Thinkpad 13S > > case, since it looks like the trackpad shares the I2C bus with the > > keyboard. > > > > > > Thanks > > ChenYu > > > > > > Background as given in Doug's cover letter: > > > > Support for multiple "equivalent" sources for components (also known > > as second sourcing components) is a standard practice that helps keep > > cost down and also makes sure that if one component is unavailable due > > to a shortage that we don't need to stop production for the whole > > product. > > > > Some components are very easy to second source. eMMC, for instance, is > > fully discoverable and probable so you can stuff a wide variety of > > similar eMMC chips on your board and things will work without a hitch. > > > > Some components are more difficult to second source, specifically > > because it's difficult for software to probe what component is present > > on any given board. In cases like this software is provided > > supplementary information to help it, like a GPIO strap or a SKU ID > > programmed into an EEPROM. This helpful information can allow the > > bootloader to select a different device tree. The various different > > "SKUs" of different Chromebooks are examples of this. > > > > Some components are somewhere in between. These in-between components > > are the subject of this patch. Specifically, these components are > > easily "probeable" but not easily "discoverable". > > > > A good example of a probeable but undiscoverable device is an > > i2c-connected touchscreen or trackpad. Two separate components may be > > electrically compatible with each other and may have compatible power > > sequencing requirements but may require different software. If > > software is told about the different possible components (because it > > can't discover them), it can safely probe them to figure out which > > ones are present. > > > > On systems using device tree, if we want to tell the OS about all of > > the different components we need to list them all in the device > > tree. This leads to a problem. The multiple sources for components > > likely use the same resources (GPIOs, interrupts, regulators). If the > > OS tries to probe all of these components at the same time then it > > will detect a resource conflict and that's a fatal error. > > > > The fact that Linux can't handle these probeable but undiscoverable > > devices well has had a few consequences: > > 1. In some cases, we've abandoned the idea of second sourcing > > components for a given board, which increases cost / generates > > manufacturing headaches. > > 2. In some cases, we've been forced to add some sort of strapping / > > EEPROM to indicate which component is present. This adds difficulty > > to manufacturing / refurb processes. > > 3. In some cases, we've managed to make things work by the skin of our > > teeth through slightly hacky solutions. Specifically, if we remove > > the "pinctrl" entry from the various options then it won't > > conflict. Regulators inherently can have more than one consumer, so > > as long as there are no GPIOs involved in power sequencing and > > probing devices then things can work. This is how > > "sc8280xp-lenovo-thinkpad-x13s" works and also how > > "mt8173-elm-hana" works. > > > > End of background from Doug's cover letter. > > I think that using "status" is not a good idea, I find that confusing. It isn't a hard requirement. The current I2C prober actually just looks at the node name, which already should be a generic class type. It then assumes that all the components of the same class that it is supposed to probe for are on the same bus. I think this is a fair assumption for replaceable parts connected via ribbon cable or co-layout parts? > Perhaps we could have a node like > > something { > device-class-one = <&device1>, <&device2>, <&device3>; > device-class-two = <&device4>, <&device5>, <&device6>; > } > > so that'd be more or less > > hw-prober { > trackpads = <&tp1>, <&tp2>; > keyboards = <&kb1>, <&kb2>; > touchscreens = <&ts1>, <&ts2>; > } This was already nacked by Rob. > Besides, something else I can suggest here is to make this more generic: actually, > this issue is spread across way more devices than you maybe think... for example, > I know of some smartphones that may have the same situation with DSI displays and > they're sometimes distinguished by an ADC value, sometimes by reading back the > manufacturer ID (or panel id) through DSI. ADC strapping is common. Though we might need some kind of binding about how to describe the ADC strapping scheme, as this is bound to be different across boards. Reading back from DSI feels problematic to implement. But I don't know much about DSI ATM. Doug implied in our offline discussion that DSI panels might have power sequencing requirements that are all over the place. > Also, if Chromebooks really need something "special", such as that coreboot sku-id > parameter, I think that this should be registered externally into the hw prober > and not embedded inside of the *generic* hw prober driver. > > We can even reuse of_device_id instead of inventing a new hw_prober_entry struct... > > Idea: > > drivers/platform/chrome/cros_of_hw_prober.c > > static int cros_sku_hw_prober(struct platform_device *pdev, const void *data) > { > ...this is your cros_sku_component_selector() function, anyway... > } > > static const struct of_device_id cros_hw_prober_ids[] = { > { .compatible = "google,hana", .data = something }, > { /* sentinel */ } > }; > > static int some_kind_of_early_init_function(something) > { > int a,b,c,ret,something; > > .. some logic if necessary .. > > return of_hw_prober_register(cros_sku_hw_prober, cros_hw_prober_ids); > } This feels a bit too layered, and requires all the board specific code to have an early init function. I think exposing common helper functions for boards to implement prober drivers would be better. Then the prober could also be a module if that made sense. Given that SoC vendors are making clock controller drivers modules, this doesn't seem very far fetched. > Btw, thanks for starting that. If this will be done the right way, it's going to > be useful to many, many people. Right. I only have a limited view of applications, so input is always welcome. Thanks ChenYu > Regards, > Angelo > > > > > [1] https://lore.kernel.org/all/20230921102420.RFC.1.I9dddd99ccdca175e3ceb1b9fa1827df0928c5101@changeid/ > > [2] https://lore.kernel.org/linux-mediatek/20231012230237.2676469-1-wenst@chromium.org/ > > > > Chen-Yu Tsai (7): > > of: base: Add of_device_is_fail > > of: Introduce hardware prober driver > > arm64: dts: mediatek: mt8173-elm-hana: Mark touchscreens and trackpads > > as fail > > arm64: dts: mediatek: mt8173-elm-hana: Add G2touch G7500 touchscreen > > of: hw_prober: Support Chromebook SKU ID based component selection > > dt-bindings: arm: mediatek: Remove SKU specific compatibles for Google > > Krane > > arm64: dts: mediatek: mt8183-kukui: Merge Krane device trees > > > > .../devicetree/bindings/arm/mediatek.yaml | 3 - > > arch/arm64/boot/dts/mediatek/Makefile | 3 +- > > .../boot/dts/mediatek/mt8173-elm-hana.dtsi | 20 ++ > > .../dts/mediatek/mt8183-kukui-krane-sku0.dts | 24 -- > > .../mediatek/mt8183-kukui-krane-sku176.dts | 24 -- > > ...ukui-krane.dtsi => mt8183-kukui-krane.dts} | 47 ++- > > drivers/of/Kconfig | 13 + > > drivers/of/Makefile | 1 + > > drivers/of/base.c | 20 ++ > > drivers/of/hw_prober.c | 314 ++++++++++++++++++ > > include/linux/of.h | 6 + > > 11 files changed, 418 insertions(+), 57 deletions(-) > > delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku0.dts > > delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku176.dts > > rename arch/arm64/boot/dts/mediatek/{mt8183-kukui-krane.dtsi => mt8183-kukui-krane.dts} (86%) > > create mode 100644 drivers/of/hw_prober.c > > >
Il 14/11/23 09:57, Chen-Yu Tsai ha scritto: > On Thu, Nov 9, 2023 at 6:54 PM AngeloGioacchino Del Regno > <angelogioacchino.delregno@collabora.com> wrote: >> >> Il 09/11/23 11:05, Chen-Yu Tsai ha scritto: >>> Hi everyone, >>> >>> This v2 series continues Doug's "of: device: Support 2nd sources of >>> probeable but undiscoverable devices" [1] series, but follows the scheme >>> suggested by Rob, marking all second source component device nodes >>> as "fail-needs-probe-XXX", and having a hardware prober driver enable >>> the one of them. I tried to include everyone from the original Cc: list. >>> Please let me know if you would like to be dropped from future >>> submissions. >>> >>> >>> For the I2C component (touchscreens and trackpads) case from the >>> original series, the hardware prober driver finds the particular >>> class of device in the device tree, gets its parent I2C adapter, >>> and tries to initiate a simple I2C read for each device under that >>> I2C bus. When it finds one that responds, it considers that one >>> present, marks it as "okay", and returns, letting the driver core >>> actually probe the device. >>> >>> This works fine in most cases since these components are connected >>> via ribbon cable and always have the same resources. The driver as >>> implemented currently doesn't deal with regulators or GPIO pins, >>> since in the existing device trees they are either always on for >>> regulators, or have GPIO hogs or pinmux and pinconfig directly >>> tied to the pin controller. >>> >>> >>> Another case this driver could handle is selecting components based >>> on some identifier passed in by the firmware. On Chromebooks we have >>> a SKU ID which is inserted by the bootloader at >>> /firmware/coreboot/sku-id. When a new combination of components is >>> introduced, a new SKU ID is allocated to it. To have SKU ID based >>> device trees, we would need to have one per SKU ID. This ends up >>> increasing the number of device trees we have a lot. The recent >>> MT8186 devices already have 10+10 SKUs [2], with possibly more to come. >>> >>> Instead, we could have just one device tree for each device, with >>> component options listed and marked as "fail-needs-probe-XXX", and >>> let the hardware prober enable one of them based on the given SKU ID. >>> The driver will also fix up OF graph remote endpoints to point to the >>> enabled component. >>> >>> The MT8186 Corsola series [2] can also benefit from this, though I >>> haven't implemented anything yet. >>> >>> >>> Patch 1 adds of_device_is_fail() for the new driver to use. >>> >>> Patch 2 implements the first case, probing the I2C bus for presence >>> of components. This initial version targets the Hana Chromebooks. >>> >>> Patch 3 modifies the Hana device tree and marks the touchscreens >>> and trackpads as "fail-needs-probe-XXX", ready for the driver to >>> probe. >>> >>> Patch 4 adds a missing touchscreen variant to Hana. >>> >>> Patch 5 implements the second case, selectively enabling components >>> based on the SKU ID. This initial version targets the Krane ChromeOS >>> tablet, which has two possible MIPI DSI display panel options. >>> >>> Patch 6 drops Krane's SKU-specific compatible strings from the bindings. >>> >>> Patch 7 merges Krane's SKU-specific device trees into one, with the >>> device tree now containing two possible panels. This unfortunately >>> introduces a dtc warning: >>> >>> arch/arm64/boot/dts/mediatek/mt8183-kukui-krane.dts:81.13-83.6: >>> Warning (graph_endpoint): /soc/dsi@14014000/panel2@0/port/endpoint: >>> graph connection to node '/soc/dsi@14014000/ports/port/endpoint' >>> is not bidirectional >>> >>> >>> Please take a look. >>> >>> Johan, I'm not sure if this works as is for the Lenovo Thinkpad 13S >>> case, since it looks like the trackpad shares the I2C bus with the >>> keyboard. >>> >>> >>> Thanks >>> ChenYu >>> >>> >>> Background as given in Doug's cover letter: >>> >>> Support for multiple "equivalent" sources for components (also known >>> as second sourcing components) is a standard practice that helps keep >>> cost down and also makes sure that if one component is unavailable due >>> to a shortage that we don't need to stop production for the whole >>> product. >>> >>> Some components are very easy to second source. eMMC, for instance, is >>> fully discoverable and probable so you can stuff a wide variety of >>> similar eMMC chips on your board and things will work without a hitch. >>> >>> Some components are more difficult to second source, specifically >>> because it's difficult for software to probe what component is present >>> on any given board. In cases like this software is provided >>> supplementary information to help it, like a GPIO strap or a SKU ID >>> programmed into an EEPROM. This helpful information can allow the >>> bootloader to select a different device tree. The various different >>> "SKUs" of different Chromebooks are examples of this. >>> >>> Some components are somewhere in between. These in-between components >>> are the subject of this patch. Specifically, these components are >>> easily "probeable" but not easily "discoverable". >>> >>> A good example of a probeable but undiscoverable device is an >>> i2c-connected touchscreen or trackpad. Two separate components may be >>> electrically compatible with each other and may have compatible power >>> sequencing requirements but may require different software. If >>> software is told about the different possible components (because it >>> can't discover them), it can safely probe them to figure out which >>> ones are present. >>> >>> On systems using device tree, if we want to tell the OS about all of >>> the different components we need to list them all in the device >>> tree. This leads to a problem. The multiple sources for components >>> likely use the same resources (GPIOs, interrupts, regulators). If the >>> OS tries to probe all of these components at the same time then it >>> will detect a resource conflict and that's a fatal error. >>> >>> The fact that Linux can't handle these probeable but undiscoverable >>> devices well has had a few consequences: >>> 1. In some cases, we've abandoned the idea of second sourcing >>> components for a given board, which increases cost / generates >>> manufacturing headaches. >>> 2. In some cases, we've been forced to add some sort of strapping / >>> EEPROM to indicate which component is present. This adds difficulty >>> to manufacturing / refurb processes. >>> 3. In some cases, we've managed to make things work by the skin of our >>> teeth through slightly hacky solutions. Specifically, if we remove >>> the "pinctrl" entry from the various options then it won't >>> conflict. Regulators inherently can have more than one consumer, so >>> as long as there are no GPIOs involved in power sequencing and >>> probing devices then things can work. This is how >>> "sc8280xp-lenovo-thinkpad-x13s" works and also how >>> "mt8173-elm-hana" works. >>> >>> End of background from Doug's cover letter. >> >> I think that using "status" is not a good idea, I find that confusing. > > It isn't a hard requirement. The current I2C prober actually just looks > at the node name, which already should be a generic class type. It then > assumes that all the components of the same class that it is supposed > to probe for are on the same bus. I think this is a fair assumption for > replaceable parts connected via ribbon cable or co-layout parts? > Assuming that the parts are on the exact same bus is ok, there has to be a flexibility limit, or this framework will definitely get abused in the wrong ways. >> Perhaps we could have a node like >> >> something { >> device-class-one = <&device1>, <&device2>, <&device3>; >> device-class-two = <&device4>, <&device5>, <&device6>; >> } >> >> so that'd be more or less >> >> hw-prober { >> trackpads = <&tp1>, <&tp2>; >> keyboards = <&kb1>, <&kb2>; >> touchscreens = <&ts1>, <&ts2>; >> } > > This was already nacked by Rob. Oh. Oops. :-) > >> Besides, something else I can suggest here is to make this more generic: actually, >> this issue is spread across way more devices than you maybe think... for example, >> I know of some smartphones that may have the same situation with DSI displays and >> they're sometimes distinguished by an ADC value, sometimes by reading back the >> manufacturer ID (or panel id) through DSI. > > ADC strapping is common. Though we might need some kind of binding about how > to describe the ADC strapping scheme, as this is bound to be different across > boards. > > Reading back from DSI feels problematic to implement. But I don't know much > about DSI ATM. Doug implied in our offline discussion that DSI panels might > have power sequencing requirements that are all over the place. > This is exactly why I think that this should allow a certain kind of "modularity", meaning that subsystems should be able to register their own hook into this: in both cases of ADC and/or DSI readback we're getting into some fairly (less, or more) complicated territory - and it's something that people around each subsystem knows best - and they must have that kind of flexibility and freedom to change the hooked implementation in their own subsystem instead of somewhere else. There would be much more to say about this, but I'm avoiding to write a wall of text because I'm sure that you can read through the lines and can get my point anyway. >> Also, if Chromebooks really need something "special", such as that coreboot sku-id >> parameter, I think that this should be registered externally into the hw prober >> and not embedded inside of the *generic* hw prober driver. >> >> We can even reuse of_device_id instead of inventing a new hw_prober_entry struct... >> >> Idea: >> >> drivers/platform/chrome/cros_of_hw_prober.c >> >> static int cros_sku_hw_prober(struct platform_device *pdev, const void *data) >> { >> ...this is your cros_sku_component_selector() function, anyway... >> } >> >> static const struct of_device_id cros_hw_prober_ids[] = { >> { .compatible = "google,hana", .data = something }, >> { /* sentinel */ } >> }; >> >> static int some_kind_of_early_init_function(something) >> { >> int a,b,c,ret,something; >> >> .. some logic if necessary .. >> >> return of_hw_prober_register(cros_sku_hw_prober, cros_hw_prober_ids); >> } > > This feels a bit too layered, and requires all the board specific code to > have an early init function. I think exposing common helper functions for > boards to implement prober drivers would be better. Then the prober could > also be a module if that made sense. Given that SoC vendors are making > clock controller drivers modules, this doesn't seem very far fetched. > That would as well work - and would be way better than early init. Reading it back now, putting that in a early init function would be counter-productive in general. >> Btw, thanks for starting that. If this will be done the right way, it's going to >> be useful to many, many people. > > Right. I only have a limited view of applications, so input is always welcome. > > Thanks > ChenYu > >> Regards, >> Angelo >> >>> >>> [1] https://lore.kernel.org/all/20230921102420.RFC.1.I9dddd99ccdca175e3ceb1b9fa1827df0928c5101@changeid/ >>> [2] https://lore.kernel.org/linux-mediatek/20231012230237.2676469-1-wenst@chromium.org/ >>> >>> Chen-Yu Tsai (7): >>> of: base: Add of_device_is_fail >>> of: Introduce hardware prober driver >>> arm64: dts: mediatek: mt8173-elm-hana: Mark touchscreens and trackpads >>> as fail >>> arm64: dts: mediatek: mt8173-elm-hana: Add G2touch G7500 touchscreen >>> of: hw_prober: Support Chromebook SKU ID based component selection >>> dt-bindings: arm: mediatek: Remove SKU specific compatibles for Google >>> Krane >>> arm64: dts: mediatek: mt8183-kukui: Merge Krane device trees >>> >>> .../devicetree/bindings/arm/mediatek.yaml | 3 - >>> arch/arm64/boot/dts/mediatek/Makefile | 3 +- >>> .../boot/dts/mediatek/mt8173-elm-hana.dtsi | 20 ++ >>> .../dts/mediatek/mt8183-kukui-krane-sku0.dts | 24 -- >>> .../mediatek/mt8183-kukui-krane-sku176.dts | 24 -- >>> ...ukui-krane.dtsi => mt8183-kukui-krane.dts} | 47 ++- >>> drivers/of/Kconfig | 13 + >>> drivers/of/Makefile | 1 + >>> drivers/of/base.c | 20 ++ >>> drivers/of/hw_prober.c | 314 ++++++++++++++++++ >>> include/linux/of.h | 6 + >>> 11 files changed, 418 insertions(+), 57 deletions(-) >>> delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku0.dts >>> delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku176.dts >>> rename arch/arm64/boot/dts/mediatek/{mt8183-kukui-krane.dtsi => mt8183-kukui-krane.dts} (86%) >>> create mode 100644 drivers/of/hw_prober.c >>> >>
On Fri, Nov 10, 2023 at 6:12 PM Doug Anderson <dianders@chromium.org> wrote: > > Hi, > > On Thu, Nov 9, 2023 at 5:52 AM Rob Herring <robh+dt@kernel.org> wrote: > > > > > > End of background from Doug's cover letter. > > > > > > I think that using "status" is not a good idea, I find that confusing. > > > > "status" is what defines a device's state in terms of enabled, > > present, available. That's exactly what we're expressing here. > > > > Now, I do not think we should be mixing the device class (e.g. > > touchscreen) into status. I said this on v1, but apparently that was > > not listened to. > > Interesting. I must have missed the "don't mix device class into > status" part. Do you have a link to your post about that? Maybe > there's other stuff I missed... Having the device class stuck at the > end there was at least part of my last post [1] which gathered no > response. https://lore.kernel.org/all/CAL_JsqKK0tjeXNv=a8L3k0AjhCa15XOq1tPWqVod9mycsKXJHg@mail.gmail.com/ "I would not combine the 2 things. Knowing the class/type of the device may be useful independent of your problem." > I think one of the reasons that I felt we needed to mux the device > class into status was that it was going to make the code a lot less > fragile. Everything I've seen indicates that you don't want us to > create a "HW prober" node that could be used to provide relevant > phandles for different classes of devices, so the "HW prober" code > needs to either search through the whole device tree for a status of > "failed-needs-probe" or needs to contain per-board, hardcoded, > fully-qualified paths. > > I don't think we want to include hardcoded, fully-qualified paths in > the code. That would mean that if someone changed a node name > somewhere in the path to one of the devices that we're dealing with > then it would break. Right, nothing should depend on the full path. That's not an ABI just like the device path in sysfs is not (despite what Android HALs do). > So if we're searching the whole device tree for "failed-needs-probe" > then we need to figure out which devices are related to each other. If > a given board has second sources for MIPI panels, touchscreens, and > trackpads then we need to know which of the "failed-needs-probe" > devices are trackpads, which are touchscreens, and which are MIPI > panels. Do you have any suggestions for how we should do that? Maybe > it was in some other thread that I missed? I guess we could have a > board-specific table mapping (compatible + node name + reg) to a > class, but that feels awkward. Node name is supposed to correspond to device class, so why not use that (no path or unit-address.) and nothing else (well, besides "status")? Rob
Hi, On Wed, Nov 15, 2023 at 2:28 PM Rob Herring <robh+dt@kernel.org> wrote: > > > So if we're searching the whole device tree for "failed-needs-probe" > > then we need to figure out which devices are related to each other. If > > a given board has second sources for MIPI panels, touchscreens, and > > trackpads then we need to know which of the "failed-needs-probe" > > devices are trackpads, which are touchscreens, and which are MIPI > > panels. Do you have any suggestions for how we should do that? Maybe > > it was in some other thread that I missed? I guess we could have a > > board-specific table mapping (compatible + node name + reg) to a > > class, but that feels awkward. > > Node name is supposed to correspond to device class, so why not use > that (no path or unit-address.) and nothing else (well, besides > "status")? One problem is that I could imagine having two second source trackpads that both have the same i2c address. That would give them the same name, right? I guess you could maybe come up with some sort of suffix rule? Like trackpad-1@10 { compatible = "elan,blah"; ret = <0x10>; status = "failed-needs-probe"; ... } trackpad-2@10 { compatible = "goodix,gt7375p"; ret = <0x10>; status = "failed-needs-probe"; ... } Then I guess the class would be "trackpad"? -Doug
On Wed, Nov 15, 2023 at 2:45 PM Doug Anderson <dianders@chromium.org> wrote: > > Hi, > > On Wed, Nov 15, 2023 at 2:28 PM Rob Herring <robh+dt@kernel.org> wrote: > > > > > So if we're searching the whole device tree for "failed-needs-probe" > > > then we need to figure out which devices are related to each other. If > > > a given board has second sources for MIPI panels, touchscreens, and > > > trackpads then we need to know which of the "failed-needs-probe" > > > devices are trackpads, which are touchscreens, and which are MIPI > > > panels. Do you have any suggestions for how we should do that? Maybe > > > it was in some other thread that I missed? I guess we could have a > > > board-specific table mapping (compatible + node name + reg) to a > > > class, but that feels awkward. > > > > Node name is supposed to correspond to device class, so why not use > > that (no path or unit-address.) and nothing else (well, besides > > "status")? > > One problem is that I could imagine having two second source trackpads > that both have the same i2c address. That would give them the same > name, right? I guess you could maybe come up with some sort of suffix > rule? Like > > trackpad-1@10 { > compatible = "elan,blah"; > ret = <0x10>; > status = "failed-needs-probe"; > ... > } > trackpad-2@10 { > compatible = "goodix,gt7375p"; > ret = <0x10>; > status = "failed-needs-probe"; > ... > } > > Then I guess the class would be "trackpad"? That issue is somewhat orthogonal because it is not following the spec. I'm not sure mixing the 2 styles of node names is a good idea. While not used too much, matching by node name does ignore the unit-address, but I'm not sure we could ignore a '-N'. I think our options are either add something to the unit-address or use i2c-mux binding. Adding to the unit-address is not unprecedented. I did that for some of the register bit level bindings where you have a node for different bits at the same address. The downside is unit-address is bus specific, so we'd have to add that for multiple buses. For the i2c-mux, it's perhaps a bit complex and I'm not sure what if anything you'd have to do to manage the mux that's not really there. Rob
Hi, On Wed, Nov 15, 2023 at 4:35 PM Rob Herring <robh+dt@kernel.org> wrote: > > On Wed, Nov 15, 2023 at 2:45 PM Doug Anderson <dianders@chromium.org> wrote: > > > > Hi, > > > > On Wed, Nov 15, 2023 at 2:28 PM Rob Herring <robh+dt@kernel.org> wrote: > > > > > > > So if we're searching the whole device tree for "failed-needs-probe" > > > > then we need to figure out which devices are related to each other. If > > > > a given board has second sources for MIPI panels, touchscreens, and > > > > trackpads then we need to know which of the "failed-needs-probe" > > > > devices are trackpads, which are touchscreens, and which are MIPI > > > > panels. Do you have any suggestions for how we should do that? Maybe > > > > it was in some other thread that I missed? I guess we could have a > > > > board-specific table mapping (compatible + node name + reg) to a > > > > class, but that feels awkward. > > > > > > Node name is supposed to correspond to device class, so why not use > > > that (no path or unit-address.) and nothing else (well, besides > > > "status")? > > > > One problem is that I could imagine having two second source trackpads > > that both have the same i2c address. That would give them the same > > name, right? I guess you could maybe come up with some sort of suffix > > rule? Like > > > > trackpad-1@10 { > > compatible = "elan,blah"; > > ret = <0x10>; > > status = "failed-needs-probe"; > > ... > > } > > trackpad-2@10 { > > compatible = "goodix,gt7375p"; > > ret = <0x10>; > > status = "failed-needs-probe"; > > ... > > } > > > > Then I guess the class would be "trackpad"? > > That issue is somewhat orthogonal because it is not following the spec. I'm not sure why you say it's orthogonal. The whole reason why we get into the situation above is that we could have two devices, only one of which is present (hence the status of "failed-needs-probe"), that are the same type and have the same "reg" address. Essentially the whole "failed-needs-probe" is extending the spec, right? While extending the spec, we also need to talk about what to do if some of the devices that we need to probe have the same class and the same "reg". > I'm not sure mixing the 2 styles of node names is a good idea. While > not used too much, matching by node name does ignore the unit-address, > but I'm not sure we could ignore a '-N'. > > I think our options are either add something to the unit-address or > use i2c-mux binding. Adding to the unit-address is not unprecedented. > I did that for some of the register bit level bindings where you have > a node for different bits at the same address. The downside is > unit-address is bus specific, so we'd have to add that for multiple > buses. For the i2c-mux, it's perhaps a bit complex and I'm not sure > what if anything you'd have to do to manage the mux that's not really > there. Somehow it feels weird to use an i2c-mux because there's no real mux present, right? ...so this would be a virtual (bogus) device that doesn't really exist in hardware. ...though I guess if the "mux" type binding is OK then maybe we just use that as the HW prober, at least for i2c devices... -Doug
On Thu, Nov 16, 2023 at 5:35 AM Rob Herring <robh+dt@kernel.org> wrote: > > On Wed, Nov 15, 2023 at 2:45 PM Doug Anderson <dianders@chromium.org> wrote: > > > > Hi, > > > > On Wed, Nov 15, 2023 at 2:28 PM Rob Herring <robh+dt@kernel.org> wrote: > > > > > > > So if we're searching the whole device tree for "failed-needs-probe" > > > > then we need to figure out which devices are related to each other. If > > > > a given board has second sources for MIPI panels, touchscreens, and > > > > trackpads then we need to know which of the "failed-needs-probe" > > > > devices are trackpads, which are touchscreens, and which are MIPI > > > > panels. Do you have any suggestions for how we should do that? Maybe > > > > it was in some other thread that I missed? I guess we could have a > > > > board-specific table mapping (compatible + node name + reg) to a > > > > class, but that feels awkward. > > > > > > Node name is supposed to correspond to device class, so why not use > > > that (no path or unit-address.) and nothing else (well, besides > > > "status")? > > > > One problem is that I could imagine having two second source trackpads > > that both have the same i2c address. That would give them the same > > name, right? I guess you could maybe come up with some sort of suffix > > rule? Like > > > > trackpad-1@10 { > > compatible = "elan,blah"; > > ret = <0x10>; > > status = "failed-needs-probe"; > > ... > > } > > trackpad-2@10 { > > compatible = "goodix,gt7375p"; > > ret = <0x10>; > > status = "failed-needs-probe"; > > ... > > } > > > > Then I guess the class would be "trackpad"? > > That issue is somewhat orthogonal because it is not following the spec. > > I'm not sure mixing the 2 styles of node names is a good idea. While > not used too much, matching by node name does ignore the unit-address, > but I'm not sure we could ignore a '-N'. of_node_name_prefix() solves that. I assume that's the intended use case? > I think our options are either add something to the unit-address or > use i2c-mux binding. Adding to the unit-address is not unprecedented. > I did that for some of the register bit level bindings where you have > a node for different bits at the same address. The downside is > unit-address is bus specific, so we'd have to add that for multiple > buses. For the i2c-mux, it's perhaps a bit complex and I'm not sure > what if anything you'd have to do to manage the mux that's not really > there. > > Rob
On Thu, Nov 16, 2023 at 6:14 AM Doug Anderson <dianders@chromium.org> wrote: > > Hi, > > On Wed, Nov 15, 2023 at 4:35 PM Rob Herring <robh+dt@kernel.org> wrote: > > > > On Wed, Nov 15, 2023 at 2:45 PM Doug Anderson <dianders@chromium.org> wrote: > > > > > > Hi, > > > > > > On Wed, Nov 15, 2023 at 2:28 PM Rob Herring <robh+dt@kernel.org> wrote: > > > > > > > > > So if we're searching the whole device tree for "failed-needs-probe" > > > > > then we need to figure out which devices are related to each other. If > > > > > a given board has second sources for MIPI panels, touchscreens, and > > > > > trackpads then we need to know which of the "failed-needs-probe" > > > > > devices are trackpads, which are touchscreens, and which are MIPI > > > > > panels. Do you have any suggestions for how we should do that? Maybe > > > > > it was in some other thread that I missed? I guess we could have a > > > > > board-specific table mapping (compatible + node name + reg) to a > > > > > class, but that feels awkward. > > > > > > > > Node name is supposed to correspond to device class, so why not use > > > > that (no path or unit-address.) and nothing else (well, besides > > > > "status")? > > > > > > One problem is that I could imagine having two second source trackpads > > > that both have the same i2c address. That would give them the same > > > name, right? I guess you could maybe come up with some sort of suffix > > > rule? Like > > > > > > trackpad-1@10 { > > > compatible = "elan,blah"; > > > ret = <0x10>; > > > status = "failed-needs-probe"; > > > ... > > > } > > > trackpad-2@10 { > > > compatible = "goodix,gt7375p"; > > > ret = <0x10>; > > > status = "failed-needs-probe"; > > > ... > > > } > > > > > > Then I guess the class would be "trackpad"? > > > > That issue is somewhat orthogonal because it is not following the spec. > > I'm not sure why you say it's orthogonal. The whole reason why we get > into the situation above is that we could have two devices, only one > of which is present (hence the status of "failed-needs-probe"), that > are the same type and have the same "reg" address. > > Essentially the whole "failed-needs-probe" is extending the spec, > right? While extending the spec, we also need to talk about what to do > if some of the devices that we need to probe have the same class and > the same "reg". If it's at the same address, then you would need some device specific probing code, like reading a register back and checking if matches some known value. This could be done by passing in some kind of table, but it is by no means as generic as checking if an address responds. This is what we have on MT8186 Tentacruel. We do have the ability to differentiate using the SKU ID for the same address case, but I'm happy to try other methods if it helps everyone else. ChenYu > > I'm not sure mixing the 2 styles of node names is a good idea. While > > not used too much, matching by node name does ignore the unit-address, > > but I'm not sure we could ignore a '-N'. > > > > I think our options are either add something to the unit-address or > > use i2c-mux binding. Adding to the unit-address is not unprecedented. > > I did that for some of the register bit level bindings where you have > > a node for different bits at the same address. The downside is > > unit-address is bus specific, so we'd have to add that for multiple > > buses. For the i2c-mux, it's perhaps a bit complex and I'm not sure > > what if anything you'd have to do to manage the mux that's not really > > there. > > Somehow it feels weird to use an i2c-mux because there's no real mux > present, right? ...so this would be a virtual (bogus) device that > doesn't really exist in hardware. > > ...though I guess if the "mux" type binding is OK then maybe we just > use that as the HW prober, at least for i2c devices... > > -Doug
Hi everyone, This v2 series continues Doug's "of: device: Support 2nd sources of probeable but undiscoverable devices" [1] series, but follows the scheme suggested by Rob, marking all second source component device nodes as "fail-needs-probe-XXX", and having a hardware prober driver enable the one of them. I tried to include everyone from the original Cc: list. Please let me know if you would like to be dropped from future submissions. For the I2C component (touchscreens and trackpads) case from the original series, the hardware prober driver finds the particular class of device in the device tree, gets its parent I2C adapter, and tries to initiate a simple I2C read for each device under that I2C bus. When it finds one that responds, it considers that one present, marks it as "okay", and returns, letting the driver core actually probe the device. This works fine in most cases since these components are connected via ribbon cable and always have the same resources. The driver as implemented currently doesn't deal with regulators or GPIO pins, since in the existing device trees they are either always on for regulators, or have GPIO hogs or pinmux and pinconfig directly tied to the pin controller. Another case this driver could handle is selecting components based on some identifier passed in by the firmware. On Chromebooks we have a SKU ID which is inserted by the bootloader at /firmware/coreboot/sku-id. When a new combination of components is introduced, a new SKU ID is allocated to it. To have SKU ID based device trees, we would need to have one per SKU ID. This ends up increasing the number of device trees we have a lot. The recent MT8186 devices already have 10+10 SKUs [2], with possibly more to come. Instead, we could have just one device tree for each device, with component options listed and marked as "fail-needs-probe-XXX", and let the hardware prober enable one of them based on the given SKU ID. The driver will also fix up OF graph remote endpoints to point to the enabled component. The MT8186 Corsola series [2] can also benefit from this, though I haven't implemented anything yet. Patch 1 adds of_device_is_fail() for the new driver to use. Patch 2 implements the first case, probing the I2C bus for presence of components. This initial version targets the Hana Chromebooks. Patch 3 modifies the Hana device tree and marks the touchscreens and trackpads as "fail-needs-probe-XXX", ready for the driver to probe. Patch 4 adds a missing touchscreen variant to Hana. Patch 5 implements the second case, selectively enabling components based on the SKU ID. This initial version targets the Krane ChromeOS tablet, which has two possible MIPI DSI display panel options. Patch 6 drops Krane's SKU-specific compatible strings from the bindings. Patch 7 merges Krane's SKU-specific device trees into one, with the device tree now containing two possible panels. This unfortunately introduces a dtc warning: arch/arm64/boot/dts/mediatek/mt8183-kukui-krane.dts:81.13-83.6: Warning (graph_endpoint): /soc/dsi@14014000/panel2@0/port/endpoint: graph connection to node '/soc/dsi@14014000/ports/port/endpoint' is not bidirectional Please take a look. Johan, I'm not sure if this works as is for the Lenovo Thinkpad 13S case, since it looks like the trackpad shares the I2C bus with the keyboard. Thanks ChenYu Background as given in Doug's cover letter: Support for multiple "equivalent" sources for components (also known as second sourcing components) is a standard practice that helps keep cost down and also makes sure that if one component is unavailable due to a shortage that we don't need to stop production for the whole product. Some components are very easy to second source. eMMC, for instance, is fully discoverable and probable so you can stuff a wide variety of similar eMMC chips on your board and things will work without a hitch. Some components are more difficult to second source, specifically because it's difficult for software to probe what component is present on any given board. In cases like this software is provided supplementary information to help it, like a GPIO strap or a SKU ID programmed into an EEPROM. This helpful information can allow the bootloader to select a different device tree. The various different "SKUs" of different Chromebooks are examples of this. Some components are somewhere in between. These in-between components are the subject of this patch. Specifically, these components are easily "probeable" but not easily "discoverable". A good example of a probeable but undiscoverable device is an i2c-connected touchscreen or trackpad. Two separate components may be electrically compatible with each other and may have compatible power sequencing requirements but may require different software. If software is told about the different possible components (because it can't discover them), it can safely probe them to figure out which ones are present. On systems using device tree, if we want to tell the OS about all of the different components we need to list them all in the device tree. This leads to a problem. The multiple sources for components likely use the same resources (GPIOs, interrupts, regulators). If the OS tries to probe all of these components at the same time then it will detect a resource conflict and that's a fatal error. The fact that Linux can't handle these probeable but undiscoverable devices well has had a few consequences: 1. In some cases, we've abandoned the idea of second sourcing components for a given board, which increases cost / generates manufacturing headaches. 2. In some cases, we've been forced to add some sort of strapping / EEPROM to indicate which component is present. This adds difficulty to manufacturing / refurb processes. 3. In some cases, we've managed to make things work by the skin of our teeth through slightly hacky solutions. Specifically, if we remove the "pinctrl" entry from the various options then it won't conflict. Regulators inherently can have more than one consumer, so as long as there are no GPIOs involved in power sequencing and probing devices then things can work. This is how "sc8280xp-lenovo-thinkpad-x13s" works and also how "mt8173-elm-hana" works. End of background from Doug's cover letter. [1] https://lore.kernel.org/all/20230921102420.RFC.1.I9dddd99ccdca175e3ceb1b9fa1827df0928c5101@changeid/ [2] https://lore.kernel.org/linux-mediatek/20231012230237.2676469-1-wenst@chromium.org/ Chen-Yu Tsai (7): of: base: Add of_device_is_fail of: Introduce hardware prober driver arm64: dts: mediatek: mt8173-elm-hana: Mark touchscreens and trackpads as fail arm64: dts: mediatek: mt8173-elm-hana: Add G2touch G7500 touchscreen of: hw_prober: Support Chromebook SKU ID based component selection dt-bindings: arm: mediatek: Remove SKU specific compatibles for Google Krane arm64: dts: mediatek: mt8183-kukui: Merge Krane device trees .../devicetree/bindings/arm/mediatek.yaml | 3 - arch/arm64/boot/dts/mediatek/Makefile | 3 +- .../boot/dts/mediatek/mt8173-elm-hana.dtsi | 20 ++ .../dts/mediatek/mt8183-kukui-krane-sku0.dts | 24 -- .../mediatek/mt8183-kukui-krane-sku176.dts | 24 -- ...ukui-krane.dtsi => mt8183-kukui-krane.dts} | 47 ++- drivers/of/Kconfig | 13 + drivers/of/Makefile | 1 + drivers/of/base.c | 20 ++ drivers/of/hw_prober.c | 314 ++++++++++++++++++ include/linux/of.h | 6 + 11 files changed, 418 insertions(+), 57 deletions(-) delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku0.dts delete mode 100644 arch/arm64/boot/dts/mediatek/mt8183-kukui-krane-sku176.dts rename arch/arm64/boot/dts/mediatek/{mt8183-kukui-krane.dtsi => mt8183-kukui-krane.dts} (86%) create mode 100644 drivers/of/hw_prober.c