// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Linux I2C core OF component prober code
 *
 * Copyright (C) 2024 Google LLC
 */

#include <linux/cleanup.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dev_printk.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#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>

/*
 * Some devices, such as Google Hana Chromebooks, are produced by multiple
 * vendors each using their preferred components. Such components are all
 * in the device tree. Instead of having all of them enabled and having each
 * driver separately try and probe its device while fighting over shared
 * resources, they can be marked as "fail-needs-probe" and have a prober
 * figure out which one is actually used beforehand.
 *
 * This prober assumes such drop-in parts are on the same I2C bus, have
 * non-conflicting addresses, and can be directly probed by seeing which
 * address responds.
 *
 * TODO:
 * - Support I2C muxes
 */

static struct device_node *i2c_of_probe_get_i2c_node(struct device *dev, const char *type)
{
 struct device_node *node __free(device_node) = of_find_node_by_name(NULL, type);
 if (!node) {
  dev_err(dev, "Could not find %s device node\n", type);
  return NULL;
 }

 struct device_node *i2c_node __free(device_node) = of_get_parent(node);
 if (!of_node_name_eq(i2c_node, "i2c")) {
  dev_err(dev, "%s device isn't on I2C bus\n", type);
  return NULL;
 }

 if (!of_device_is_available(i2c_node)) {
  dev_err(dev, "I2C controller not available\n");
  return NULL;
 }

 return no_free_ptr(i2c_node);
}

static int i2c_of_probe_enable_node(struct device *dev, struct device_node *node)
{
 int ret;

 dev_dbg(dev, "Enabling %pOF\n", node);

 struct of_changeset *ocs __free(kfree) = kzalloc(sizeof(*ocs), GFP_KERNEL);
 if (!ocs)
  return -ENOMEM;

 of_changeset_init(ocs);
 ret = of_changeset_update_prop_string(ocs, node, "status", "okay");
 if (ret)
  return ret;

 ret = of_changeset_apply(ocs);
 if (ret) {
  /* ocs needs to be explicitly cleaned up before being freed. */
  of_changeset_destroy(ocs);
 } else {
  /*
   * ocs is intentionally kept around as it needs to
   * exist as long as the change is applied.
 */
  void *ptr __always_unused = no_free_ptr(ocs);
 }

 return ret;
}

static const struct i2c_of_probe_ops i2c_of_probe_dummy_ops;

/**
 * i2c_of_probe_component() - probe for devices of "type" on the same i2c bus
 * @dev: Pointer to the &struct device of the caller, only used for dev_printk() messages.
 * @cfg: Pointer to the &struct i2c_of_probe_cfg containing callbacks and other options
 *       for the prober.
 * @ctx: Context data for callbacks.
 *
 * Probe for possible I2C components of the same "type" (&i2c_of_probe_cfg->type)
 * on the same I2C bus that have their status marked as "fail-needs-probe".
 *
 * Assumes that across the entire device tree the only instances of nodes
 * with "type" prefixed node names (not including the address portion) are
 * the ones that need handling for second source components. In other words,
 * if "type" is "touchscreen", then all device nodes named "touchscreen*"
 * are the ones that need probing. There cannot be another "touchscreen*"
 * node that is already enabled.
 *
 * Assumes that for each "type" of component, only one actually exists. In
 * other words, only one matching and existing device will be enabled.
 *
 * Context: Process context only. Does non-atomic I2C transfers.
 *          Should only be used from a driver probe function, as the function
 *          can return -EPROBE_DEFER if the I2C adapter or other resources
 *          are unavailable.
 * Return: 0 on success or no-op, error code otherwise.
 *         A no-op can happen when it seems like the device tree already
 *         has components of the type to be probed already enabled. This
 *         can happen when the device tree had not been updated to mark
 *         the status of the to-be-probed components as "fail-needs-probe".
 *         Or this function was already run with the same parameters and
 *         succeeded in enabling a component. The latter could happen if
 *         the user had multiple types of components to probe, and one of
 *         them down the list caused a deferred probe. This is expected
 *         behavior.
 */
int i2c_of_probe_component(struct device *dev, const struct i2c_of_probe_cfg *cfg, void *ctx)
{
 const struct i2c_of_probe_ops *ops;
 const char *type;
 struct i2c_adapter *i2c;
 int ret;

 ops = cfg->ops ?: &i2c_of_probe_dummy_ops;
 type = cfg->type;

 struct device_node *i2c_node __free(device_node) = i2c_of_probe_get_i2c_node(dev, type);
 if (!i2c_node)
  return -ENODEV;

 /*
  * If any devices of the given "type" are already enabled then this function is a no-op.
  * Either the device tree hasn't been modified to work with this probe function, or the
  * function had already run before and enabled some component.
 */
 for_each_child_of_node_with_prefix(i2c_node, node, type)
  if (of_device_is_available(node))
   return 0;

 i2c = of_get_i2c_adapter_by_node(i2c_node);
 if (!i2c)
  return dev_err_probe(dev, -EPROBE_DEFER, "Couldn't get I2C adapter\n");

 /* Grab and enable resources */
 ret = 0;
 if (ops->enable)
  ret = ops->enable(dev, i2c_node, ctx);
 if (ret)
  goto out_put_i2c_adapter;

 for_each_child_of_node_with_prefix(i2c_node, node, type) {
  union i2c_smbus_data data;
  u32 addr;

  if (of_property_read_u32(node, "reg", &addr))
   continue;
  if (i2c_smbus_xfer(i2c, addr, 0, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data) < 0)
   continue;

  /* Found a device that is responding */
  if (ops->cleanup_early)
   ops->cleanup_early(dev, ctx);
  ret = i2c_of_probe_enable_node(dev, node);
  break;
 }

 if (ops->cleanup)
  ops->cleanup(dev, ctx);
out_put_i2c_adapter:
 i2c_put_adapter(i2c);

 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);
}

static int i2c_of_probe_simple_get_gpiod(struct device *dev, struct device_node *node,
      struct i2c_of_probe_simple_ctx *ctx)
{
 struct fwnode_handle *fwnode = of_fwnode_handle(node);
 struct gpio_desc *gpiod;
 const char *con_id;

 /* NULL signals no GPIO needed */
 if (!ctx->opts->gpio_name)
  return 0;

 /* An empty string signals an unnamed GPIO */
 if (!ctx->opts->gpio_name[0])
  con_id = NULL;
 else
  con_id = ctx->opts->gpio_name;

 gpiod = fwnode_gpiod_get_index(fwnode, con_id, 0, GPIOD_ASIS, "i2c-of-prober");
 if (IS_ERR(gpiod))
  return PTR_ERR(gpiod);

 ctx->gpiod = gpiod;

 return 0;
}

static void i2c_of_probe_simple_put_gpiod(struct i2c_of_probe_simple_ctx *ctx)
{
 gpiod_put(ctx->gpiod);
 ctx->gpiod = NULL;
}

static int i2c_of_probe_simple_set_gpio(struct device *dev, struct i2c_of_probe_simple_ctx *ctx)
{
 int ret;

 if (!ctx->gpiod)
  return 0;

 dev_dbg(dev, "Configuring GPIO\n");

 ret = gpiod_direction_output(ctx->gpiod, ctx->opts->gpio_assert_to_enable);
 if (ret)
  return ret;

 if (ctx->opts->post_gpio_config_delay_ms)
  msleep(ctx->opts->post_gpio_config_delay_ms);

 return 0;
}

static void i2c_of_probe_simple_disable_gpio(struct device *dev, struct i2c_of_probe_simple_ctx *ctx)
{
 gpiod_set_value(ctx->gpiod, !ctx->opts->gpio_assert_to_enable);
}

/**
 * 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 &i2c_of_probe_simple_opts->gpio_name is given, request the named GPIO. Or if it is
 * the empty string, request the unnamed GPIO.
 * If a regulator supply was found, enable that regulator.
 * If a GPIO line was found, configure the GPIO line to output and set value
 * according to given options.
 *
 * 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_get_gpiod(dev, node, ctx);
 if (ret)
  goto out_put_supply;

 ret = i2c_of_probe_simple_enable_regulator(dev, ctx);
 if (ret)
  goto out_put_gpiod;

 ret = i2c_of_probe_simple_set_gpio(dev, ctx);
 if (ret)
  goto out_disable_regulator;

 return 0;

out_disable_regulator:
 i2c_of_probe_simple_disable_regulator(dev, ctx);
out_put_gpiod:
 i2c_of_probe_simple_put_gpiod(ctx);
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_early - \
 * Simple helper for I2C OF prober to release GPIOs before component is enabled
 * @dev: Pointer to the &struct device of the caller; unused.
 * @data: Pointer to &struct i2c_of_probe_simple_ctx helper context.
 *
 * GPIO descriptors are exclusive and have to be released before the
 * actual driver probes so that the latter can acquire them.
 */
void i2c_of_probe_simple_cleanup_early(struct device *dev, void *data)
{
 struct i2c_of_probe_simple_ctx *ctx = data;

 i2c_of_probe_simple_put_gpiod(ctx);
}
EXPORT_SYMBOL_NS_GPL(i2c_of_probe_simple_cleanup_early, "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 GPIO line was found and not yet released, set its value to the opposite of that
 *   set in i2c_of_probe_simple_enable() and release it.
 * * 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;

 /* GPIO operations here are no-ops if i2c_of_probe_simple_cleanup_early was called. */
 i2c_of_probe_simple_disable_gpio(dev, ctx);
 i2c_of_probe_simple_put_gpiod(ctx);

 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_early = i2c_of_probe_simple_cleanup_early,
 .cleanup = i2c_of_probe_simple_cleanup,
};
EXPORT_SYMBOL_NS_GPL(i2c_of_probe_simple_ops, "I2C_OF_PROBER");