// SPDX-License-Identifier: GPL-2.0
/*
 * System Control and Power Interface (SCMI) Protocol based i.MX pinctrl driver
 *
 * Copyright 2024 NXP
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/of.h>
#include <linux/scmi_protocol.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/types.h>

#include <linux/pinctrl/machine.h>
#include <linux/pinctrl/pinconf.h>
#include <linux/pinctrl/pinconf-generic.h>
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinmux.h>

#include "../pinctrl-utils.h"
#include "../core.h"
#include "../pinconf.h"
#include "../pinmux.h"

#define DRV_NAME "scmi-pinctrl-imx"

struct scmi_pinctrl_imx {
        struct device *dev;
        struct scmi_protocol_handle *ph;
        struct pinctrl_dev *pctldev;
        struct pinctrl_desc pctl_desc;
        const struct scmi_pinctrl_proto_ops *ops;
};

/* SCMI pin control types, aligned with SCMI firmware */
#define IMX_SCMI_NUM_CFG        5
#define IMX_SCMI_PIN_MUX        192
#define IMX_SCMI_PIN_CONFIG     193
#define IMX_SCMI_PIN_DAISY_ID   194
#define IMX_SCMI_PIN_DAISY_CFG  195
#define IMX_SCMI_PIN_EXT        196

#define IMX_SCMI_NO_PAD_CTL             BIT(31)
#define IMX_SCMI_PAD_SION               BIT(30)
#define IMX_SCMI_IOMUXC_CONFIG_SION     BIT(4)

#define IMX_SCMI_PIN_SIZE       24

#define IMX94_DAISY_OFF         0x608
#define IMX95_DAISY_OFF         0x408
#define IMX952_DAISY_OFF        0x460

static int pinctrl_scmi_imx_dt_node_to_map(struct pinctrl_dev *pctldev,
                                           struct device_node *np,
                                           struct pinctrl_map **map,
                                           unsigned int *num_maps)
{
        struct pinctrl_map *new_map;
        const __be32 *list;
        unsigned long *configs = NULL;
        unsigned long cfg[IMX_SCMI_NUM_CFG];
        int map_num, size, pin_size, pin_id, num_pins;
        int mux_reg, conf_reg, input_reg, mux_val, conf_val, input_val;
        int i, j;
        uint32_t ncfg;
        static uint32_t daisy_off;

        if (!daisy_off) {
                if (of_machine_is_compatible("fsl,imx95")) {
                        daisy_off = IMX95_DAISY_OFF;
                } else if (of_machine_is_compatible("fsl,imx94")) {
                        daisy_off = IMX94_DAISY_OFF;
                } else if (of_machine_is_compatible("fsl,imx952")) {
                        daisy_off = IMX952_DAISY_OFF;
                } else {
                        dev_err(pctldev->dev, "platform not support scmi pinctrl\n");
                        return -EINVAL;
                }
        }

        list = of_get_property(np, "fsl,pins", &size);
        if (!list) {
                dev_err(pctldev->dev, "no fsl,pins property in node %pOF\n", np);
                return -EINVAL;
        }

        pin_size = IMX_SCMI_PIN_SIZE;

        if (!size || size % pin_size) {
                dev_err(pctldev->dev, "Invalid fsl,pins or pins property in node %pOF\n", np);
                return -EINVAL;
        }

        num_pins = size / pin_size;
        map_num = num_pins;

        new_map = kmalloc_objs(struct pinctrl_map, map_num);
        if (!new_map)
                return -ENOMEM;

        *map = new_map;
        *num_maps = map_num;

        /* create config map */
        for (i = 0; i < num_pins; i++) {
                j = 0;
                ncfg = IMX_SCMI_NUM_CFG;
                mux_reg = be32_to_cpu(*list++);
                conf_reg = be32_to_cpu(*list++);
                input_reg = be32_to_cpu(*list++);
                mux_val = be32_to_cpu(*list++);
                input_val = be32_to_cpu(*list++);
                conf_val = be32_to_cpu(*list++);
                if (conf_val & IMX_SCMI_PAD_SION)
                        mux_val |= IMX_SCMI_IOMUXC_CONFIG_SION;

                pin_id = mux_reg / 4;

                cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_MUX, (mux_val & 0xFF));

                if (mux_val & 0xFF00) {
                        int ext_val = (mux_val & 0xFF00) >> 8;

                        cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_EXT, ext_val);
                } else
                        ncfg--;

                if (!conf_reg || (conf_val & IMX_SCMI_NO_PAD_CTL))
                        ncfg--;
                else
                        cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_CONFIG, conf_val);

                if (!input_reg) {
                        ncfg -= 2;
                } else {
                        cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_DAISY_ID,
                                                            (input_reg - daisy_off) / 4);
                        cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_DAISY_CFG, input_val);
                }

                configs = kmemdup_array(cfg, ncfg, sizeof(unsigned long), GFP_KERNEL);

                new_map[i].type = PIN_MAP_TYPE_CONFIGS_PIN;
                new_map[i].data.configs.group_or_pin = pin_get_name(pctldev, pin_id);
                new_map[i].data.configs.configs = configs;
                new_map[i].data.configs.num_configs = ncfg;
        }

        return 0;
}

static void pinctrl_scmi_imx_dt_free_map(struct pinctrl_dev *pctldev,
                                         struct pinctrl_map *map, unsigned int num_maps)
{
        kfree(map);
}

static const struct pinctrl_ops pinctrl_scmi_imx_pinctrl_ops = {
        .get_groups_count = pinctrl_generic_get_group_count,
        .get_group_name = pinctrl_generic_get_group_name,
        .get_group_pins = pinctrl_generic_get_group_pins,
        .dt_node_to_map = pinctrl_scmi_imx_dt_node_to_map,
        .dt_free_map = pinctrl_scmi_imx_dt_free_map,
};

static int pinctrl_scmi_imx_func_set_mux(struct pinctrl_dev *pctldev,
                                         unsigned int selector, unsigned int group)
{
        /*
         * For i.MX SCMI PINCTRL , postpone the mux setting
         * until config is set as they can be set together
         * in one IPC call
         */
        return 0;
}

static const struct pinmux_ops pinctrl_scmi_imx_pinmux_ops = {
        .get_functions_count = pinmux_generic_get_function_count,
        .get_function_name = pinmux_generic_get_function_name,
        .get_function_groups = pinmux_generic_get_function_groups,
        .set_mux = pinctrl_scmi_imx_func_set_mux,
};

static int pinctrl_scmi_imx_pinconf_get(struct pinctrl_dev *pctldev,
                                        unsigned int pin, unsigned long *config)
{
        int ret;
        struct scmi_pinctrl_imx *pmx = pinctrl_dev_get_drvdata(pctldev);
        u32 config_type, val;

        if (!config)
                return -EINVAL;

        config_type = pinconf_to_config_param(*config);

        ret = pmx->ops->settings_get_one(pmx->ph, pin, PIN_TYPE, config_type, &val);
        /* Convert SCMI error code to PINCTRL expected error code */
        if (ret == -EOPNOTSUPP)
                return -ENOTSUPP;
        if (ret)
                return ret;

        *config = pinconf_to_config_packed(config_type, val);

        dev_dbg(pmx->dev, "pin:%s, conf:0x%x", pin_get_name(pctldev, pin), val);

        return 0;
}

static int pinctrl_scmi_imx_pinconf_set(struct pinctrl_dev *pctldev,
                                        unsigned int pin,
                                        unsigned long *configs,
                                        unsigned int num_configs)
{
        struct scmi_pinctrl_imx *pmx = pinctrl_dev_get_drvdata(pctldev);
        enum scmi_pinctrl_conf_type config_type[IMX_SCMI_NUM_CFG];
        u32 config_value[IMX_SCMI_NUM_CFG];
        enum scmi_pinctrl_conf_type *p_config_type = config_type;
        u32 *p_config_value = config_value;
        int ret;
        int i;

        if (!configs || !num_configs)
                return -EINVAL;

        if (num_configs > IMX_SCMI_NUM_CFG) {
                dev_err(pmx->dev, "num_configs(%d) too large\n", num_configs);
                return -EINVAL;
        }

        for (i = 0; i < num_configs; i++) {
                /* cast to avoid build warning */
                p_config_type[i] =
                        (enum scmi_pinctrl_conf_type)pinconf_to_config_param(configs[i]);
                p_config_value[i] = pinconf_to_config_argument(configs[i]);

                dev_dbg(pmx->dev, "pin: %u, type: %u, val: 0x%x\n",
                        pin, p_config_type[i], p_config_value[i]);
        }

        ret = pmx->ops->settings_conf(pmx->ph, pin, PIN_TYPE, num_configs,
                                      p_config_type,  p_config_value);
        if (ret)
                dev_err(pmx->dev, "Error set config %d\n", ret);

        return ret;
}

static void pinctrl_scmi_imx_pinconf_dbg_show(struct pinctrl_dev *pctldev,
                                              struct seq_file *s, unsigned int pin_id)
{
        unsigned long config = pinconf_to_config_packed(IMX_SCMI_PIN_CONFIG, 0);
        int ret;

        ret = pinctrl_scmi_imx_pinconf_get(pctldev, pin_id, &config);
        if (ret)
                config = 0;
        else
                config = pinconf_to_config_argument(config);

        seq_printf(s, "0x%lx", config);
}

static const struct pinconf_ops pinctrl_scmi_imx_pinconf_ops = {
        .pin_config_get = pinctrl_scmi_imx_pinconf_get,
        .pin_config_set = pinctrl_scmi_imx_pinconf_set,
        .pin_config_dbg_show = pinctrl_scmi_imx_pinconf_dbg_show,
};

static int
scmi_pinctrl_imx_get_pins(struct scmi_pinctrl_imx *pmx, struct pinctrl_desc *desc)
{
        struct pinctrl_pin_desc *pins;
        unsigned int npins;
        int ret, i;

        npins = pmx->ops->count_get(pmx->ph, PIN_TYPE);
        pins = devm_kmalloc_array(pmx->dev, npins, sizeof(*pins), GFP_KERNEL);
        if (!pins)
                return -ENOMEM;

        for (i = 0; i < npins; i++) {
                pins[i].number = i;
                /* no need free name, firmware driver handles it */
                ret = pmx->ops->name_get(pmx->ph, i, PIN_TYPE, &pins[i].name);
                if (ret)
                        return dev_err_probe(pmx->dev, ret,
                                             "Can't get name for pin %d", i);
        }

        desc->npins = npins;
        desc->pins = pins;
        dev_dbg(pmx->dev, "got pins %u", npins);

        return 0;
}

static const char * const scmi_pinctrl_imx_allowlist[] = {
        "fsl,imx94",
        "fsl,imx95",
        "fsl,imx952",
        NULL
};

static int scmi_pinctrl_imx_probe(struct scmi_device *sdev)
{
        struct device *dev = &sdev->dev;
        const struct scmi_handle *handle = sdev->handle;
        struct scmi_pinctrl_imx *pmx;
        struct scmi_protocol_handle *ph;
        const struct scmi_pinctrl_proto_ops *pinctrl_ops;
        int ret;

        if (!handle)
                return -EINVAL;

        if (!of_machine_compatible_match(scmi_pinctrl_imx_allowlist))
                return -ENODEV;

        pinctrl_ops = handle->devm_protocol_get(sdev, SCMI_PROTOCOL_PINCTRL, &ph);
        if (IS_ERR(pinctrl_ops))
                return PTR_ERR(pinctrl_ops);

        pmx = devm_kzalloc(dev, sizeof(*pmx), GFP_KERNEL);
        if (!pmx)
                return -ENOMEM;

        pmx->ph = ph;
        pmx->ops = pinctrl_ops;

        pmx->dev = dev;
        pmx->pctl_desc.name = DRV_NAME;
        pmx->pctl_desc.owner = THIS_MODULE;
        pmx->pctl_desc.pctlops = &pinctrl_scmi_imx_pinctrl_ops;
        pmx->pctl_desc.pmxops = &pinctrl_scmi_imx_pinmux_ops;
        pmx->pctl_desc.confops = &pinctrl_scmi_imx_pinconf_ops;

        ret = scmi_pinctrl_imx_get_pins(pmx, &pmx->pctl_desc);
        if (ret)
                return ret;

        pmx->dev = &sdev->dev;

        ret = devm_pinctrl_register_and_init(dev, &pmx->pctl_desc, pmx,
                                             &pmx->pctldev);
        if (ret)
                return dev_err_probe(dev, ret, "Failed to register pinctrl\n");

        return pinctrl_enable(pmx->pctldev);
}

static const struct scmi_device_id scmi_id_table[] = {
        { SCMI_PROTOCOL_PINCTRL, "pinctrl-imx" },
        { }
};
MODULE_DEVICE_TABLE(scmi, scmi_id_table);

static struct scmi_driver scmi_pinctrl_imx_driver = {
        .name = DRV_NAME,
        .probe = scmi_pinctrl_imx_probe,
        .id_table = scmi_id_table,
};
module_scmi_driver(scmi_pinctrl_imx_driver);

MODULE_AUTHOR("Peng Fan <peng.fan@nxp.com>");
MODULE_DESCRIPTION("i.MX SCMI pin controller driver");
MODULE_LICENSE("GPL");