| Message ID | 20240904090016.2841572-1-wenst@chromium.org |
|---|---|
| Headers | show |
| Series | platform/chrome: Introduce DT hardware prober | expand |
On Fri, Sep 6, 2024 at 2:15 AM Doug Anderson <dianders@chromium.org> wrote: > > Hi, > > On Thu, Sep 5, 2024 at 8:10 AM Chen-Yu Tsai <wenst@chromium.org> wrote: > > > > On Thu, Sep 5, 2024 at 6:57 AM Doug Anderson <dianders@chromium.org> wrote: > > > > > > Hi, > > > > > > On Wed, Sep 4, 2024 at 2:01 AM Chen-Yu Tsai <wenst@chromium.org> wrote: > > > > > > > > This adds regulator management to the I2C OF component prober. > > > > Components that the prober intends to probe likely require their > > > > regulator supplies be enabled, and GPIOs be toggled to enable them or > > > > bring them out of reset before they will respond to probe attempts. > > > > GPIOs will be handled in the next patch. > > > > > > > > Without specific knowledge of each component's resource names or > > > > power sequencing requirements, the prober can only enable the > > > > regulator supplies all at once, and toggle the GPIOs all at once. > > > > Luckily, reset pins tend to be active low, while enable pins tend to > > > > be active high, so setting the raw status of all GPIO pins to high > > > > should work. The wait time before and after resources are enabled > > > > are collected from existing drivers and device trees. > > > > > > > > The prober collects resources from all possible components and enables > > > > them together, instead of enabling resources and probing each component > > > > one by one. The latter approach does not provide any boot time benefits > > > > over simply enabling each component and letting each driver probe > > > > sequentially. > > > > > > > > The prober will also deduplicate the resources, since on a component > > > > swap out or co-layout design, the resources are always the same. > > > > While duplicate regulator supplies won't cause much issue, shared > > > > GPIOs don't work reliably, especially with other drivers. For the > > > > same reason, the prober will release the GPIOs before the successfully > > > > probed component is actually enabled. > > > > > > > > Signed-off-by: Chen-Yu Tsai <wenst@chromium.org> > > > > --- > > > > Changes since v5: > > > > - Split of_regulator_bulk_get_all() return value check and explain > > > > "ret == 0" case > > > > - Switched to of_get_next_child_with_prefix_scoped() where applicable > > > > - Used krealloc_array() instead of directly calculating size > > > > - copy whole regulator array in one memcpy() call > > > > - Drop "0" from struct zeroing initializer > > > > - Split out regulator helper from i2c_of_probe_enable_res() to keep > > > > code cleaner when combined with the next patch > > > > - Added options for customizing power sequencing delay > > > > - Rename i2c_of_probe_get_regulator() to i2c_of_probe_get_regulators() > > > > - Add i2c_of_probe_free_regulator() helper > > > > > > > > Changes since v4: > > > > - Split out GPIO handling to separate patch > > > > - Rewrote using of_regulator_bulk_get_all() > > > > - Replaced "regulators" with "regulator supplies" in debug messages > > > > > > > > Changes since v3: > > > > - New patch > > > > > > > > This change is kept as a separate patch for now since the changes are > > > > quite numerous. > > > > --- > > > > drivers/i2c/i2c-core-of-prober.c | 154 +++++++++++++++++++++++++++++-- > > > > include/linux/i2c.h | 10 +- > > > > 2 files changed, 155 insertions(+), 9 deletions(-) > > > > > > I never jumped back into looking at this since you started sending new > > > versions last month (sorry), but I finally did... > > > > > > At a high level, I have to say I'm not really a fan of the "reach into > > > all of the devices, jam their regulators on, force their GPIOs high, > > > and hope for the best" approach. It just feels like it's going to > > > break at the first bit of slightly different hardware and cause power > > > sequence violations left and right. If nothing else, regulators often > > > need delays between when one regulator is enabled and the next. There > > > may also be complex relationships between regulators and GPIOs, GPIOs, > > > GPIOs that need to be low, or even GPIO "toggle sequences" (power on > > > rail 1, wait 1 ms, assert reset, wait 10 ms, deassert reset, power on > > > rail 2). > > > > > > IMO the only way to make this reliable is to have this stuff be much > > > less automatic and much more driven by the board. > > > > > > I think that, in general, before the board prober checks i2c address > > > then the prober should be in charge of setting up pinctrl and turning > > > on regulators / GPIOs. Given that the same regulator(s) and GPIO(s) > > > may be specified by different children, the prober will just have to > > > pick one child to find those resources. It should have enough > > > board-specific knowledge to make this choice. Then the prober should > > > turn them on via a board-specific power-on sequence that's known to > > > work for all the children. Then it should start probing. > > > > > > I think there can still be plenty of common helper functions that the > > > board-specific prober can leverage, but overall I'd expect the actual > > > power-on and power-off code to be board-specific. > > > > > > If many boards have in common that we need to turn on exactly one > > > regulator + one GPIO, or just one regulator, or whatever then having a > > > helper function that handles these cases is fine. ...but it should be > > > one of many choices that a board proper could use and not the only > > > one. > > > > IIUC we could have the "options" data structure have much more board > > specific information: > > > > - name of node to fetch resources (regulator supplies and GPIOs) from > > - names of the resources for the node given from the previous item > > - delay time after each resource is toggled > > - polarity in the case of GPIOs > > - prober callback to do power sequencing > > > > The "resource collection" step would use the first two items to retrieve > > the regulator supplies and GPIOS instead of the bulk APIs used right now. > > > > The power sequencing callback would use the resources combined with the > > given delays to enable the supplies and toggle the GPIOs. > > > > For now I would probably only implement a generic one regulator supply > > plus one GPIO helper. That is the common case for touchscreens and > > trackpads connected over a ribbon cable. > > > > Does that sound like what you have in mind? > > I guess I'd have to see how the code looks to know for sure, but if I > understand it sounds a little awkward. Specifically, the "options" > sound like they might become complicated enough that you're inventing > your own little programming language (with delays, abilities to drive > pins low and high, abilities to turn on/off clocks, and abilities to > turn off/on regulators) and then probers need to code up their > programs in this language. You also need to handle undoing things > properly if there is a failure in the middle. Like your "program" > would look like this (obviously you'd have to play with enums more, > but you get the idea): > > { > { OPCODE_TURN_REGULATOR_ON, "vdd" }, > { OPCODE_DELAY, 10 }, > { OPCODE_GPIO_ASSERT, "reset" }, > { OPCODE_DELAY, 5 }, > { OPCODE_GPIO_DEASSERT "reset" }, > { OPCODE_DELAY, 100 }, > { OPCODE_TURN_REGULATOR_ON, "vddIO" }, > } > > Why not just expect the board probers to write C code to turn things > on before looking for i2c devices, then provide helpers to the C code? > > So there wouldn't be some generic "resource collection" API, but you'd > provide a helper to make it easy to grab regulators from one of the > nodes by name. If you think bulk enabling regulators is common then > you could make a helper that grabs all of the regulators from a node > in a way that is consistent with the bulk APIs, but I wouldn't expect > every driver to use that since devices I've seen expect regulators to > be enabled in a very specific order even if they don't need a delay > between them. > > I wouldn't expect a "collect all GPIOs" API because it seems really > weird to me that we'd ever want to jam multiple GPIOs in a state > without knowing exactly which GPIO was what and asserting them in the > right sequence. So I'm slightly confused, as it sounds like at this point the i2c prober would be litter more than just a framework, and the heavy lifting is to be all done by callbacks provided by the board-specific driver? So the framework becomes something like: 1. find i2c bus node 2. call provided callback with i2c bus node to gather resources; let callback handle specifics 3. call provided callback to enable resources 4. for each i2c component, call provided callback to probe If the probe succeeded: 5. call provided callback for early release of resources (GPIOs) 6. set "status" to "okay" 7. call provided callback for late release of resources (regulators) Otherwise at the end of the loop 8. release resources The current code can be reworked into helpers for steps 2, 3, 5, 7 for the single regulator single GPIO case. > > This next item would be a later enhancement (which isn't implemented in > > this series anyway): > > > > - optional prober callback that does actual probing > > > > In our case it would only be used for cases where an HID-over-I2C > > component shares the same address as a non-HID one, and some extra > > work is needed to determine which type it is. I still need to think > > about the structure of this. > > IMO _that_ would be a great option to the i2c prober. It feels like > you could have an optional register read that needs to match to have > the i2c prober succeed. Most people would leave it blank (just the i2c > device existing is enough) but probably a single register read would > be enough to confirm you got the right device. Most i2c devices have > some sort of "version" / "vendor" / "id" type register somewhere. At least for the stuff that we have (touchscreens and trackpads) such registers typically don't exist, unless it's an HID-over-I2C device, in which case there's the standard HID descriptor at some address. But, yeah, reading the HID descriptor was the use case I had in mind. At least for one Chromebooks it's a bit more tricky because that one HID-over-I2C component shares the same address as a non-HID one. We currently have different SKU IDs and thus different device trees for them, but we could make the prober work with this. It just has be able to tell if the component it's currently probing needs the special prober and is it responding correctly. This bit I need to think about. ChenYu
On Wed, Sep 11, 2024 at 8:30 AM Doug Anderson <dianders@chromium.org> wrote: > > Hi, > > On Thu, Sep 5, 2024 at 8:45 PM Chen-Yu Tsai <wenst@chromium.org> wrote: > > > > > > IIUC we could have the "options" data structure have much more board > > > > specific information: > > > > > > > > - name of node to fetch resources (regulator supplies and GPIOs) from > > > > - names of the resources for the node given from the previous item > > > > - delay time after each resource is toggled > > > > - polarity in the case of GPIOs > > > > - prober callback to do power sequencing > > > > > > > > The "resource collection" step would use the first two items to retrieve > > > > the regulator supplies and GPIOS instead of the bulk APIs used right now. > > > > > > > > The power sequencing callback would use the resources combined with the > > > > given delays to enable the supplies and toggle the GPIOs. > > > > > > > > For now I would probably only implement a generic one regulator supply > > > > plus one GPIO helper. That is the common case for touchscreens and > > > > trackpads connected over a ribbon cable. > > > > > > > > Does that sound like what you have in mind? > > > > > > I guess I'd have to see how the code looks to know for sure, but if I > > > understand it sounds a little awkward. Specifically, the "options" > > > sound like they might become complicated enough that you're inventing > > > your own little programming language (with delays, abilities to drive > > > pins low and high, abilities to turn on/off clocks, and abilities to > > > turn off/on regulators) and then probers need to code up their > > > programs in this language. You also need to handle undoing things > > > properly if there is a failure in the middle. Like your "program" > > > would look like this (obviously you'd have to play with enums more, > > > but you get the idea): > > > > > > { > > > { OPCODE_TURN_REGULATOR_ON, "vdd" }, > > > { OPCODE_DELAY, 10 }, > > > { OPCODE_GPIO_ASSERT, "reset" }, > > > { OPCODE_DELAY, 5 }, > > > { OPCODE_GPIO_DEASSERT "reset" }, > > > { OPCODE_DELAY, 100 }, > > > { OPCODE_TURN_REGULATOR_ON, "vddIO" }, > > > } > > > > > > Why not just expect the board probers to write C code to turn things > > > on before looking for i2c devices, then provide helpers to the C code? > > > > > > So there wouldn't be some generic "resource collection" API, but you'd > > > provide a helper to make it easy to grab regulators from one of the > > > nodes by name. If you think bulk enabling regulators is common then > > > you could make a helper that grabs all of the regulators from a node > > > in a way that is consistent with the bulk APIs, but I wouldn't expect > > > every driver to use that since devices I've seen expect regulators to > > > be enabled in a very specific order even if they don't need a delay > > > between them. > > > > > > I wouldn't expect a "collect all GPIOs" API because it seems really > > > weird to me that we'd ever want to jam multiple GPIOs in a state > > > without knowing exactly which GPIO was what and asserting them in the > > > right sequence. > > > > So I'm slightly confused, as it sounds like at this point the i2c prober > > would be litter more than just a framework, and the heavy lifting is to > > be all done by callbacks provided by the board-specific driver? > > > > So the framework becomes something like: > > > > 1. find i2c bus node > > 2. call provided callback with i2c bus node to gather resources; > > let callback handle specifics > > 3. call provided callback to enable resources > > 4. for each i2c component, call provided callback to probe > > I don't think I'd do it as callbacks but just have the HW prober call > the functions directly. AKA, instead of doing: > > i2c_of_probe_component(dev, "touchscreen", ts_opts, ts_callbacks); > > Do: > > grab_touchscreen_resources(...); > power_on_touchscreens(...); > i2c_of_probe_component(...); > power_off_touchscreen(...); > release_touchscreen_resources(...); > > Obviously I'm spitballing here, though. Without writing the code it's > hard for me to know that my proposal would be better, but my gut tells > me that trying to write something overly generic with lots of options > / callbacks would be more confusing. The helpers would be exported along with the framework, so there's nothing preventing others from using the helpers directly. The framework provides boilerplate so that scenarios fitting it won't have to duplicate the code. Obviously I'm basing it on my scenario here, but I think it works out for the simpler cases. I'll send out what I have reworked, and we can continue the discussion either on the mailing list or in person at ELCE and Plumbers. > > If the probe succeeded: > > > > 5. call provided callback for early release of resources (GPIOs) > > 6. set "status" to "okay" > > 7. call provided callback for late release of resources (regulators) > > > > Otherwise at the end of the loop > > > > 8. release resources > > > > The current code can be reworked into helpers for steps 2, 3, 5, 7 for > > the single regulator single GPIO case. > > > > > > This next item would be a later enhancement (which isn't implemented in > > > > this series anyway): > > > > > > > > - optional prober callback that does actual probing > > > > > > > > In our case it would only be used for cases where an HID-over-I2C > > > > component shares the same address as a non-HID one, and some extra > > > > work is needed to determine which type it is. I still need to think > > > > about the structure of this. > > > > > > IMO _that_ would be a great option to the i2c prober. It feels like > > > you could have an optional register read that needs to match to have > > > the i2c prober succeed. Most people would leave it blank (just the i2c > > > device existing is enough) but probably a single register read would > > > be enough to confirm you got the right device. Most i2c devices have > > > some sort of "version" / "vendor" / "id" type register somewhere. > > > > At least for the stuff that we have (touchscreens and trackpads) such > > registers typically don't exist, unless it's an HID-over-I2C device, > > in which case there's the standard HID descriptor at some address. > > But, yeah, reading the HID descriptor was the use case I had in mind. > > > > At least for one Chromebooks it's a bit more tricky because that one > > HID-over-I2C component shares the same address as a non-HID one. We > > currently have different SKU IDs and thus different device trees for > > them, but we could make the prober work with this. It just has be able > > to tell if the component it's currently probing needs the special > > prober and is it responding correctly. This bit I need to think about. > > I guess Mark Brown also thought that there wouldn't be some magic > register, but my gut still tells me that most i2c devices have some > way to confirm that they are what you expect even if it's not an > official "vendor" or "version" register. Some type of predictable > register at a predictable location that you could use, at least if you > knew all of the options that someone might stuff. > > For instance, in elan trackpads you can see elan_i2c_get_product_id(). > That just reads a location (ETP_I2C_UNIQUEID_CMD = 0x0101) that could > theoretically be used to figure out (maybe in conjunction with other > registers) that it's an elan trackpad instead of an i2c-hid one. You'd > have to (of course) confirm that an i2c-hid device wouldn't somehow > return back data from this read that made it look like an elan > trackpad, but it feels like there ought to be some way to figure it > out with a few i2c register reads. > > ...that being said, I guess my original assertion that you might be > able to figure out with a simple register read was naive and you'd > actually need a function (maybe as a callback) to figure this out. Yeah, that's my plan for a follow-up series, likely after the SKU ID based prober work is done. The actual probe function would likely only target the known cases of I2C address conflicts we have on ChromeOS devices.
On Tue, Sep 10, 2024 at 05:30:07PM -0700, Doug Anderson wrote: > On Thu, Sep 5, 2024 at 8:45 PM Chen-Yu Tsai <wenst@chromium.org> wrote: ... > > At least for the stuff that we have (touchscreens and trackpads) such > > registers typically don't exist, unless it's an HID-over-I2C device, > > in which case there's the standard HID descriptor at some address. > > But, yeah, reading the HID descriptor was the use case I had in mind. > > > > At least for one Chromebooks it's a bit more tricky because that one > > HID-over-I2C component shares the same address as a non-HID one. We > > currently have different SKU IDs and thus different device trees for > > them, but we could make the prober work with this. It just has be able > > to tell if the component it's currently probing needs the special > > prober and is it responding correctly. This bit I need to think about. > > I guess Mark Brown also thought that there wouldn't be some magic > register, but my gut still tells me that most i2c devices have some > way to confirm that they are what you expect even if it's not an > official "vendor" or "version" register. Some type of predictable > register at a predictable location that you could use, at least if you > knew all of the options that someone might stuff. "most" is way too optimistic to say, I believe that not even close to majority of I²C target devices they are not reliably discoverable. That's the downside of non-discoverable busses like I²C. Maybe I³C has a mechanism for that, but I am not an expert, just wondering. > For instance, in elan trackpads you can see elan_i2c_get_product_id(). > That just reads a location (ETP_I2C_UNIQUEID_CMD = 0x0101) that could > theoretically be used to figure out (maybe in conjunction with other > registers) that it's an elan trackpad instead of an i2c-hid one. You'd > have to (of course) confirm that an i2c-hid device wouldn't somehow > return back data from this read that made it look like an elan > trackpad, but it feels like there ought to be some way to figure it > out with a few i2c register reads. > > ...that being said, I guess my original assertion that you might be > able to figure out with a simple register read was naive and you'd > actually need a function (maybe as a callback) to figure this out.
Hi everyone, This is v6 of my "of: Introduce hardware prober driver" [1] series. v6 mainly addresses comments from Andy. v2 continued Doug's "of: device: Support 2nd sources of probeable but undiscoverable devices" [2] series, but follows the scheme suggested by Rob, marking all second source component device nodes as "fail-needs-probe", and having a hardware prober driver enable the one of them. Changes since v5: - Link to v5: https://lore.kernel.org/all/20240822092006.3134096-1-wenst@chromium.org/ - Patch 1 "of: dynamic: Add of_changeset_update_prop_string" - Collected Rob's reviewed-by - Patch 2 "of: base: Add for_each_child_of_node_with_prefix_scoped()" - New patch - Patch 3 "regulator: Move OF-specific regulator lookup code to of_regulator.c" - Fix kerneldoc format of of_regulator_dev_lookup() - Fix stub compile error for !CONFIG_OF in drivers/regulator/internal.h - Patch 4 "regulator: Split up _regulator_get()" - Fixed kerneldoc "Return" section format for _regulator_get_common() - Slightly reworded return value description - Patch 5 "regulator: Do pure DT regulator lookup in of_regulator_bulk_get_all()" - Used "dev_of_node(dev)" instead of "dev->of_node" - Replaced "dev_printk" with "dev_printk()" in kerneldoc mentions - Fixed kerneldoc "Return" section format for of_regulator_get_optional() - Fix @np parameter name in of_regulator_dev_lookup() kerneldoc - Patch 6 "gpiolib: Add gpio_property_name_length()" - Changed function name to "gpio_get_property_name_length()" - Changed argument name to "propname" - Clarified return value for "*-<GPIO suffix>" case - Reworked according to Andy's suggestion - Added stub function - Patch 7 "i2c: core: Remove extra space in Makefile" - New patch - Patch 8 "i2c: Introduce OF component probe function" - Fixed indent in Makefile - Split regulator and GPIO TODO items - Reversed final conditional in i2c_of_probe_enable_node() - Patch 9 "i2c: of-prober: Add regulator support" - Split of_regulator_bulk_get_all() return value check and explain "ret == 0" case - Switched to of_get_next_child_with_prefix_scoped() where applicable - Used krealloc_array() instead of directly calculating size - copy whole regulator array in one memcpy() call - Drop "0" from struct zeroing initializer - Split out regulator helper from i2c_of_probe_enable_res() to keep code cleaner when combined with the next patch - Added options for customizing power sequencing delay - Rename i2c_of_probe_get_regulator() to i2c_of_probe_get_regulators() - Add i2c_of_probe_free_regulator() helper - Patch 10 "i2c: of-prober: Add GPIO support" - Renamed "con" to "propname" in i2c_of_probe_get_gpiod() - Copy string first and check return value of strscpy() for overflow in i2c_of_probe_get_gpiod() - Add parenthesis around "enable" and "reset" GPIO names in comments - Split resource count debug message into two separate lines - Split out GPIO helper from i2c_of_probe_enable_res() to keep code cleaner following the previous patch - Adopted options for customizing power sequencing delay following previous patch - Patch 11 "platform/chrome: Introduce device tree hardware prober" - Adapt to new i2c_of_probe_component() parameters - Patch 12 "arm64: dts: mediatek: mt8173-elm-hana: Mark touchscreens and trackpads as fail" - None See v5 cover letter for previous change logs. 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 a ribbon cable and always have the same resources. The prober will also grab these resources and enable them. The other case, selecting a display panel to use based on the SKU ID from the firmware, hit a bit of an issue with fixing the OF graph. It has been left out since v3. Patch 1 adds of_changeset_update_prop_string(), as requested by Rob. Patch 2 adds for_each_child_of_node_with_prefix_scoped(), as suggested by Andy. Patches 3 through 5 reorganize the OF-specific regulator core code and reworks the existing of_regulator_bulk_get_all() function to look up regulator supplies solely using device tree nodes. Patch 6 adds a function to the GPIO library that checks whether a given string (property name) matches the GPIO property pattern, and if it does, returns the length of the GPIO name. Patch 7 cleans up some extra spaces in the i2c core Makefile Patch 8 implements probing the I2C bus for presence of components as a helper function in the I2C core. Patch 9 implements regulator supply support for the I2C component prober. Patch 10 implements GPIO support for the I2C component prober. Patch 11 adds a ChromeOS specific DT hardware prober. This initial version targets the Hana Chromebooks, probing its I2C trackpads and touchscreens. Patch 12 modifies the Hana device tree and marks the touchscreens and trackpads as "fail-needs-probe", ready for the driver to probe. The patch and build time dependencies for this series is now quite complicated: of_regulator.c cleanups [1] -> regulator patches here ---- | v gpio patch in -next [2] -> gpiolib patch here -----> i2c of-prober -- | platform/chrome device tree hardware prober <----- The regulator patches in this series depend on other cleanup patches [1] I sent earlier. The gpiolib patch depends on a commit in -next [2] changing the GPIO suffixes array. Patches 7 through 10 introducting i2c of-prober depend on the first 5 patches. Patch 11, The chrome prober, depends on patches 7 through 10. I think it might be easier if the respective maintainers take the first six patches for -rc1. Patches 7 through 11 can go through either the i2c or chrome trees either very late in the merge window or right after it. Patch 12 can go in only after everything else is in. This should be better than having an immutable branch on top of some commit in -next for three other trees to consume. Wolfram, would you be able to handle the late PR? Assuming you get a chance to look at the patches that is. Thanks ChenYu [1] https://lore.kernel.org/all/20240822072047.3097740-1-wenst@chromium.org/ [2] commit 4b91188dced8 ("gpiolib: Replace gpio_suffix_count with NULL-terminated array") Chen-Yu Tsai (12): of: dynamic: Add of_changeset_update_prop_string of: base: Add for_each_child_of_node_with_prefix_scoped() regulator: Move OF-specific regulator lookup code to of_regulator.c regulator: Split up _regulator_get() regulator: Do pure DT regulator lookup in of_regulator_bulk_get_all() gpiolib: Add gpio_get_property_name_length() i2c: core: Remove extra space in Makefile i2c: Introduce OF component probe function i2c: of-prober: Add regulator support i2c: of-prober: Add GPIO support platform/chrome: Introduce device tree hardware prober arm64: dts: mediatek: mt8173-elm-hana: Mark touchscreens and trackpads as fail .../boot/dts/mediatek/mt8173-elm-hana.dtsi | 13 + arch/arm64/boot/dts/mediatek/mt8173-elm.dtsi | 4 +- drivers/gpio/gpiolib.c | 25 + drivers/i2c/Makefile | 7 +- drivers/i2c/i2c-core-of-prober.c | 437 ++++++++++++++++++ drivers/of/base.c | 35 ++ drivers/of/dynamic.c | 44 ++ drivers/platform/chrome/Kconfig | 11 + drivers/platform/chrome/Makefile | 1 + .../platform/chrome/chromeos_of_hw_prober.c | 104 +++++ drivers/regulator/core.c | 143 ++---- drivers/regulator/internal.h | 15 +- drivers/regulator/of_regulator.c | 150 +++++- include/linux/gpio/consumer.h | 7 + include/linux/i2c.h | 14 + include/linux/of.h | 13 + 16 files changed, 918 insertions(+), 105 deletions(-) create mode 100644 drivers/i2c/i2c-core-of-prober.c create mode 100644 drivers/platform/chrome/chromeos_of_hw_prober.c