// 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_obj(*ocs);
        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");