@@ -6,6 +6,7 @@
*/
#include <linux/cleanup.h>
+#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dev_printk.h>
#include <linux/err.h>
@@ -13,6 +14,7 @@
#include <linux/i2c-of-prober.h>
#include <linux/module.h>
#include <linux/of.h>
+#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/stddef.h>
@@ -29,7 +31,6 @@
* address responds.
*
* TODO:
- * - Support handling common regulators.
* - Support handling common GPIOs.
* - Support I2C muxes
*/
@@ -181,3 +182,138 @@ int i2c_of_probe_component(struct device *dev, const struct i2c_of_probe_cfg *cf
return ret;
}
EXPORT_SYMBOL_NS_GPL(i2c_of_probe_component, I2C_OF_PROBER);
+
+static int i2c_of_probe_simple_get_supply(struct device *dev, struct device_node *node,
+ struct i2c_of_probe_simple_ctx *ctx)
+{
+ const char *supply_name;
+ struct regulator *supply;
+
+ /*
+ * It's entirely possible for the component's device node to not have the
+ * regulator supplies. While it does not make sense from a hardware perspective,
+ * the supplies could be always on or otherwise not modeled in the device tree,
+ * but the device would still work.
+ */
+ supply_name = ctx->opts->supply_name;
+ if (!supply_name)
+ return 0;
+
+ supply = of_regulator_get_optional(dev, node, supply_name);
+ if (IS_ERR(supply)) {
+ return dev_err_probe(dev, PTR_ERR(supply),
+ "Failed to get regulator supply \"%s\" from %pOF\n",
+ supply_name, node);
+ }
+
+ ctx->supply = supply;
+
+ return 0;
+}
+
+static void i2c_of_probe_simple_put_supply(struct i2c_of_probe_simple_ctx *ctx)
+{
+ regulator_put(ctx->supply);
+ ctx->supply = NULL;
+}
+
+static int i2c_of_probe_simple_enable_regulator(struct device *dev, struct i2c_of_probe_simple_ctx *ctx)
+{
+ int ret;
+
+ if (!ctx->supply)
+ return 0;
+
+ dev_dbg(dev, "Enabling regulator supply \"%s\"\n", ctx->opts->supply_name);
+
+ ret = regulator_enable(ctx->supply);
+ if (ret)
+ return ret;
+
+ if (ctx->opts->post_power_on_delay_ms)
+ msleep(ctx->opts->post_power_on_delay_ms);
+
+ return 0;
+}
+
+static void i2c_of_probe_simple_disable_regulator(struct device *dev, struct i2c_of_probe_simple_ctx *ctx)
+{
+ if (!ctx->supply)
+ return;
+
+ dev_dbg(dev, "Disabling regulator supply \"%s\"\n", ctx->opts->supply_name);
+
+ regulator_disable(ctx->supply);
+}
+
+/**
+ * i2c_of_probe_simple_enable - Simple helper for I2C OF prober to get and enable resources
+ * @dev: Pointer to the &struct device of the caller, only used for dev_printk() messages
+ * @bus_node: Pointer to the &struct device_node of the I2C adapter.
+ * @data: Pointer to &struct i2c_of_probe_simple_ctx helper context.
+ *
+ * If &i2c_of_probe_simple_opts->supply_name is given, request the named regulator supply.
+ * If a regulator supply was found, enable that regulator.
+ *
+ * Return: %0 on success or no-op, or a negative error number on failure.
+ */
+int i2c_of_probe_simple_enable(struct device *dev, struct device_node *bus_node, void *data)
+{
+ struct i2c_of_probe_simple_ctx *ctx = data;
+ struct device_node *node;
+ const char *compat;
+ int ret;
+
+ dev_dbg(dev, "Requesting resources for components under I2C bus %pOF\n", bus_node);
+
+ if (!ctx || !ctx->opts)
+ return -EINVAL;
+
+ compat = ctx->opts->res_node_compatible;
+ if (!compat)
+ return -EINVAL;
+
+ node = of_get_compatible_child(bus_node, compat);
+ if (!node)
+ return dev_err_probe(dev, -ENODEV, "No device compatible with \"%s\" found\n",
+ compat);
+
+ ret = i2c_of_probe_simple_get_supply(dev, node, ctx);
+ if (ret)
+ goto out_put_node;
+
+ ret = i2c_of_probe_simple_enable_regulator(dev, ctx);
+ if (ret)
+ goto out_put_supply;
+
+ return 0;
+
+out_put_supply:
+ i2c_of_probe_simple_put_supply(ctx);
+out_put_node:
+ of_node_put(node);
+ return ret;
+}
+EXPORT_SYMBOL_NS_GPL(i2c_of_probe_simple_enable, I2C_OF_PROBER);
+
+/**
+ * i2c_of_probe_simple_cleanup - Clean up and release resources for I2C OF prober simple helpers
+ * @dev: Pointer to the &struct device of the caller, only used for dev_printk() messages
+ * @data: Pointer to &struct i2c_of_probe_simple_ctx helper context.
+ *
+ * * If a regulator supply was found, disable that regulator and release it.
+ */
+void i2c_of_probe_simple_cleanup(struct device *dev, void *data)
+{
+ struct i2c_of_probe_simple_ctx *ctx = data;
+
+ i2c_of_probe_simple_disable_regulator(dev, ctx);
+ i2c_of_probe_simple_put_supply(ctx);
+}
+EXPORT_SYMBOL_NS_GPL(i2c_of_probe_simple_cleanup, I2C_OF_PROBER);
+
+struct i2c_of_probe_ops i2c_of_probe_simple_ops = {
+ .enable = i2c_of_probe_simple_enable,
+ .cleanup = i2c_of_probe_simple_cleanup,
+};
+EXPORT_SYMBOL_NS_GPL(i2c_of_probe_simple_ops, I2C_OF_PROBER);
@@ -70,6 +70,50 @@ struct i2c_of_probe_cfg {
int i2c_of_probe_component(struct device *dev, const struct i2c_of_probe_cfg *cfg, void *ctx);
+/**
+ * DOC: I2C OF component prober simple helpers
+ *
+ * Components such as trackpads are commonly connected to a devices baseboard
+ * with a 6-pin ribbon cable. That gives at most one voltage supply and one
+ * GPIO (commonly a "enable" or "reset" line) besides the I2C bus, interrupt
+ * pin, and common ground. Touchscreens, while integrated into the display
+ * panel's connection, typically have the same set of connections.
+ *
+ * A simple set of helpers are provided here for use with the I2C OF component
+ * prober. This implementation targets such components, allowing for at most
+ * one regulator supply.
+ *
+ * The following helpers are provided:
+ * * i2c_of_probe_simple_enable()
+ * * i2c_of_probe_simple_cleanup()
+ */
+
+/**
+ * struct i2c_of_probe_simple_opts - Options for simple I2C component prober callbacks
+ * @res_node_compatible: Compatible string of device node to retrieve resources from.
+ * @supply_name: Name of regulator supply.
+ * @post_power_on_delay_ms: Delay after regulators are powered on. Passed to msleep().
+ */
+struct i2c_of_probe_simple_opts {
+ const char *res_node_compatible;
+ const char *supply_name;
+ unsigned int post_power_on_delay_ms;
+};
+
+struct regulator;
+
+struct i2c_of_probe_simple_ctx {
+ /* public: provided by user before helpers are used. */
+ const struct i2c_of_probe_simple_opts *opts;
+ /* private: internal fields for helpers. */
+ struct regulator *supply;
+};
+
+int i2c_of_probe_simple_enable(struct device *dev, struct device_node *bus_node, void *data);
+void i2c_of_probe_simple_cleanup(struct device *dev, void *data);
+
+extern struct i2c_of_probe_ops i2c_of_probe_simple_ops;
+
#endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
#endif /* _LINUX_I2C_OF_PROBER_H */