/*
 * Copyright (C) 2015  Masahiro Yamada <yamada.masahiro@socionext.com>
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <linux/compat.h>
#include <dm/device.h>
#include <dm/pinctrl.h>

DECLARE_GLOBAL_DATA_PTR;

/**
 * pinctrl_pin_name_to_selector() - return the pin selector for a pin
 *
 * @dev: pin controller device
 * @pin: the pin name to look up
 * @return: pin selector, or negative error code on failure
 */
static int pinctrl_pin_name_to_selector(struct udevice *dev, const char *pin)
{
        const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
        unsigned npins, selector;

        if (!ops->get_pins_count || !ops->get_pin_name) {
                dev_dbg(dev, "get_pins_count or get_pin_name missing\n");
                return -ENOSYS;
        }

        npins = ops->get_pins_count(dev);

        /* See if this pctldev has this pin */
        for (selector = 0; selector < npins; selector++) {
                const char *pname = ops->get_pin_name(dev, selector);

                if (!strcmp(pin, pname))
                        return selector;
        }

        return -ENOSYS;
}

/**
 * pinctrl_group_name_to_selector() - return the group selector for a group
 *
 * @dev: pin controller device
 * @group: the pin group name to look up
 * @return: pin group selector, or negative error code on failure
 */
static int pinctrl_group_name_to_selector(struct udevice *dev,
                                          const char *group)
{
        const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
        unsigned ngroups, selector;

        if (!ops->get_groups_count || !ops->get_group_name) {
                dev_dbg(dev, "get_groups_count or get_group_name missing\n");
                return -ENOSYS;
        }

        ngroups = ops->get_groups_count(dev);

        /* See if this pctldev has this group */
        for (selector = 0; selector < ngroups; selector++) {
                const char *gname = ops->get_group_name(dev, selector);

                if (!strcmp(group, gname))
                        return selector;
        }

        return -ENOSYS;
}

#if CONFIG_IS_ENABLED(PINMUX)
/**
 * pinmux_func_name_to_selector() - return the function selector for a function
 *
 * @dev: pin controller device
 * @function: the function name to look up
 * @return: function selector, or negative error code on failure
 */
static int pinmux_func_name_to_selector(struct udevice *dev,
                                        const char *function)
{
        const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
        unsigned nfuncs, selector = 0;

        if (!ops->get_functions_count || !ops->get_function_name) {
                dev_dbg(dev,
                        "get_functions_count or get_function_name missing\n");
                return -ENOSYS;
        }

        nfuncs = ops->get_functions_count(dev);

        /* See if this pctldev has this function */
        for (selector = 0; selector < nfuncs; selector++) {
                const char *fname = ops->get_function_name(dev, selector);

                if (!strcmp(function, fname))
                        return selector;
        }

        return -ENOSYS;
}

/**
 * pinmux_enable_setting() - enable pin-mux setting for a certain pin/group
 *
 * @dev: pin controller device
 * @is_group: target of operation (true: pin group, false: pin)
 * @selector: pin selector or group selector, depending on @is_group
 * @func_selector: function selector
 * @return: 0 on success, or negative error code on failure
 */
static int pinmux_enable_setting(struct udevice *dev, bool is_group,
                                 unsigned selector, unsigned func_selector)
{
        const struct pinctrl_ops *ops = pinctrl_get_ops(dev);

        if (is_group) {
                if (!ops->pinmux_group_set) {
                        dev_dbg(dev, "pinmux_group_set op missing\n");
                        return -ENOSYS;
                }

                return ops->pinmux_group_set(dev, selector, func_selector);
        } else {
                if (!ops->pinmux_set) {
                        dev_dbg(dev, "pinmux_set op missing\n");
                        return -ENOSYS;
                }
                return ops->pinmux_set(dev, selector, func_selector);
        }
}
#else
static int pinmux_func_name_to_selector(struct udevice *dev,
                                        const char *function)
{
        return 0;
}

static int pinmux_enable_setting(struct udevice *dev, bool is_group,
                                 unsigned selector, unsigned func_selector)
{
        return 0;
}
#endif

#if CONFIG_IS_ENABLED(PINCONF)
/**
 * pinconf_prop_name_to_param() - return parameter ID for a property name
 *
 * @dev: pin controller device
 * @property: property name in DTS, such as "bias-pull-up", "slew-rate", etc.
 * @default_value: return default value in case no value is specified in DTS
 * @return: return pamater ID, or negative error code on failure
 */
static int pinconf_prop_name_to_param(struct udevice *dev,
                                      const char *property, u32 *default_value)
{
        const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
        const struct pinconf_param *p, *end;

        if (!ops->pinconf_num_params || !ops->pinconf_params) {
                dev_dbg(dev, "pinconf_num_params or pinconf_params missing\n");
                return -ENOSYS;
        }

        p = ops->pinconf_params;
        end = p + ops->pinconf_num_params;

        /* See if this pctldev supports this parameter */
        for (; p < end; p++) {
                if (!strcmp(property, p->property)) {
                        *default_value = p->default_value;
                        return p->param;
                }
        }

        return -ENOSYS;
}

/**
 * pinconf_enable_setting() - apply pin configuration for a certain pin/group
 *
 * @dev: pin controller device
 * @is_group: target of operation (true: pin group, false: pin)
 * @selector: pin selector or group selector, depending on @is_group
 * @param: configuration paramter
 * @argument: argument taken by some configuration parameters
 * @return: 0 on success, or negative error code on failure
 */
static int pinconf_enable_setting(struct udevice *dev, bool is_group,
                                  unsigned selector, unsigned param,
                                  u32 argument)
{
        const struct pinctrl_ops *ops = pinctrl_get_ops(dev);

        if (is_group) {
                if (!ops->pinconf_group_set) {
                        dev_dbg(dev, "pinconf_group_set op missing\n");
                        return -ENOSYS;
                }

                return ops->pinconf_group_set(dev, selector, param,
                                              argument);
        } else {
                if (!ops->pinconf_set) {
                        dev_dbg(dev, "pinconf_set op missing\n");
                        return -ENOSYS;
                }
                return ops->pinconf_set(dev, selector, param, argument);
        }
}
#else
static int pinconf_prop_name_to_param(struct udevice *dev,
                                      const char *property, u32 *default_value)
{
        return -ENOSYS;
}

static int pinconf_enable_setting(struct udevice *dev, bool is_group,
                                  unsigned selector, unsigned param,
                                  u32 argument)
{
        return 0;
}
#endif

/**
 * pinctrl_generic_set_state_one() - set state for a certain pin/group
 * Apply all pin multiplexing and pin configurations specified by @config
 * for a given pin or pin group.
 *
 * @dev: pin controller device
 * @config: pseudo device pointing to config node
 * @is_group: target of operation (true: pin group, false: pin)
 * @selector: pin selector or group selector, depending on @is_group
 * @return: 0 on success, or negative error code on failure
 */
static int pinctrl_generic_set_state_one(struct udevice *dev,
                                         struct udevice *config,
                                         bool is_group, unsigned selector)
{
        const void *fdt = gd->fdt_blob;
        int node_offset = config->of_offset;
        const char *propname;
        const void *value;
        int prop_offset, len, func_selector, param, ret;
        u32 arg, default_val;

        for (prop_offset = fdt_first_property_offset(fdt, node_offset);
             prop_offset > 0;
             prop_offset = fdt_next_property_offset(fdt, prop_offset)) {
                value = fdt_getprop_by_offset(fdt, prop_offset,
                                              &propname, &len);
                if (!value)
                        return -EINVAL;

                if (!strcmp(propname, "function")) {
                        func_selector = pinmux_func_name_to_selector(dev,
                                                                     value);
                        if (func_selector < 0)
                                return func_selector;
                        ret = pinmux_enable_setting(dev, is_group,
                                                    selector,
                                                    func_selector);
                } else {
                        param = pinconf_prop_name_to_param(dev, propname,
                                                           &default_val);
                        if (param < 0)
                                continue; /* just skip unknown properties */

                        if (len >= sizeof(fdt32_t))
                                arg = fdt32_to_cpu(*(fdt32_t *)value);
                        else
                                arg = default_val;

                        ret = pinconf_enable_setting(dev, is_group,
                                                     selector, param, arg);
                }

                if (ret)
                        return ret;
        }

        return 0;
}

/**
 * pinctrl_generic_set_state_subnode() - apply all settings in config node
 *
 * @dev: pin controller device
 * @config: pseudo device pointing to config node
 * @return: 0 on success, or negative error code on failure
 */
static int pinctrl_generic_set_state_subnode(struct udevice *dev,
                                             struct udevice *config)
{
        const void *fdt = gd->fdt_blob;
        int node = config->of_offset;
        const char *subnode_target_type = "pins";
        bool is_group = false;
        const char *name;
        int strings_count, selector, i, ret;

        strings_count = fdt_count_strings(fdt, node, subnode_target_type);
        if (strings_count < 0) {
                subnode_target_type = "groups";
                is_group = true;
                strings_count = fdt_count_strings(fdt, node,
                                                  subnode_target_type);
                if (strings_count < 0) {
                        /* skip this node; may contain config child nodes */
                        return 0;
                }
        }

        for (i = 0; i < strings_count; i++) {
                ret = fdt_get_string_index(fdt, node, subnode_target_type,
                                           i, &name);
                if (ret < 0)
                        return -EINVAL;

                if (is_group)
                        selector = pinctrl_group_name_to_selector(dev, name);
                else
                        selector = pinctrl_pin_name_to_selector(dev, name);
                if (selector < 0)
                        return selector;

                ret = pinctrl_generic_set_state_one(dev, config,
                                                    is_group, selector);
                if (ret)
                        return ret;
        }

        return 0;
}

int pinctrl_generic_set_state(struct udevice *dev, struct udevice *config)
{
        struct udevice *child;
        int ret;

        ret = pinctrl_generic_set_state_subnode(dev, config);
        if (ret)
                return ret;

        for (device_find_first_child(config, &child);
             child;
             device_find_next_child(&child)) {
                ret = pinctrl_generic_set_state_subnode(dev, child);
                if (ret)
                        return ret;
        }

        return 0;
}