| Message ID | 20240405-pinctrl-scmi-v8-4-5fc8e33871bf@nxp.com |
|---|---|
| State | Superseded |
| Headers | show |
| Series | firmware: arm_scmi: Add SCMI v3.2 pincontrol protocol basic support | expand |
On Apr 05, 2024 at 09:59:35 +0800, Peng Fan (OSS) wrote: > From: Peng Fan <peng.fan@nxp.com> > > scmi-pinctrl driver implements pinctrl driver interface and using > SCMI protocol to redirect messages from pinctrl subsystem SDK to > SCMI platform firmware, which does the changes in HW. > > Co-developed-by: Oleksii Moisieiev <oleksii_moisieiev@epam.com> > Signed-off-by: Oleksii Moisieiev <oleksii_moisieiev@epam.com> > Signed-off-by: Peng Fan <peng.fan@nxp.com> > --- > MAINTAINERS | 1 + > drivers/pinctrl/Kconfig | 11 + > drivers/pinctrl/Makefile | 1 + > drivers/pinctrl/pinctrl-scmi.c | 564 +++++++++++++++++++++++++++++++++++++++++ > 4 files changed, 577 insertions(+) > > diff --git a/MAINTAINERS b/MAINTAINERS > index 4b511a55101c..d8270ac6651a 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -21457,6 +21457,7 @@ F: drivers/cpufreq/sc[mp]i-cpufreq.c > F: drivers/firmware/arm_scmi/ > F: drivers/firmware/arm_scpi.c > F: drivers/hwmon/scmi-hwmon.c > +F: drivers/pinctrl/pinctrl-scmi.c > F: drivers/pmdomain/arm/ > F: drivers/powercap/arm_scmi_powercap.c > F: drivers/regulator/scmi-regulator.c > diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig > index d45657aa986a..4e6f65cf0e76 100644 > --- a/drivers/pinctrl/Kconfig > +++ b/drivers/pinctrl/Kconfig > @@ -450,6 +450,17 @@ config PINCTRL_ROCKCHIP > help > This support pinctrl and GPIO driver for Rockchip SoCs. > > +config PINCTRL_SCMI > + tristate "Pinctrl driver using SCMI protocol interface" > + depends on ARM_SCMI_PROTOCOL || COMPILE_TEST > + select PINMUX > + select GENERIC_PINCONF > + help > + This driver provides support for pinctrl which is controlled > + by firmware that implements the SCMI interface. > + It uses SCMI Message Protocol to interact with the > + firmware providing all the pinctrl controls. > + > config PINCTRL_SINGLE > tristate "One-register-per-pin type device tree based pinctrl driver" > depends on OF > diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile > index 2152539b53d5..cc809669405a 100644 > --- a/drivers/pinctrl/Makefile > +++ b/drivers/pinctrl/Makefile > @@ -45,6 +45,7 @@ obj-$(CONFIG_PINCTRL_PIC32) += pinctrl-pic32.o > obj-$(CONFIG_PINCTRL_PISTACHIO) += pinctrl-pistachio.o > obj-$(CONFIG_PINCTRL_RK805) += pinctrl-rk805.o > obj-$(CONFIG_PINCTRL_ROCKCHIP) += pinctrl-rockchip.o > +obj-$(CONFIG_PINCTRL_SCMI) += pinctrl-scmi.o > obj-$(CONFIG_PINCTRL_SINGLE) += pinctrl-single.o > obj-$(CONFIG_PINCTRL_ST) += pinctrl-st.o > obj-$(CONFIG_PINCTRL_STMFX) += pinctrl-stmfx.o > diff --git a/drivers/pinctrl/pinctrl-scmi.c b/drivers/pinctrl/pinctrl-scmi.c > new file mode 100644 > index 000000000000..0f55f000a679 > --- /dev/null > +++ b/drivers/pinctrl/pinctrl-scmi.c > @@ -0,0 +1,564 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * System Control and Power Interface (SCMI) Protocol based pinctrl driver > + * > + * Copyright (C) 2024 EPAM > + * Copyright 2024 NXP > + */ > + > +#include <linux/device.h> > +#include <linux/dev_printk.h> > +#include <linux/err.h> > +#include <linux/module.h> > +#include <linux/scmi_protocol.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" > + > +#define DRV_NAME "scmi-pinctrl" > + > +/* Define num configs, if not large than 4 use stack, else use kcalloc */ > +#define SCMI_NUM_CONFIGS 4 > + > +static const struct scmi_pinctrl_proto_ops *pinctrl_ops; > + > +struct scmi_pinctrl { > + struct device *dev; > + struct scmi_protocol_handle *ph; > + struct pinctrl_dev *pctldev; > + struct pinctrl_desc pctl_desc; > + struct pinfunction *functions; > + unsigned int nr_functions; > + struct pinctrl_pin_desc *pins; > + unsigned int nr_pins; > +}; > + > +static int pinctrl_scmi_get_groups_count(struct pinctrl_dev *pctldev) > +{ > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > + > + return pinctrl_ops->count_get(pmx->ph, GROUP_TYPE); > +} > + > +static const char *pinctrl_scmi_get_group_name(struct pinctrl_dev *pctldev, > + unsigned int selector) > +{ > + int ret; > + const char *name; > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > + > + ret = pinctrl_ops->name_get(pmx->ph, selector, GROUP_TYPE, &name); > + if (ret) { > + dev_err(pmx->dev, "get name failed with err %d", ret); > + return NULL; > + } > + > + return name; > +} > + > +static int pinctrl_scmi_get_group_pins(struct pinctrl_dev *pctldev, > + unsigned int selector, > + const unsigned int **pins, > + unsigned int *num_pins) > +{ > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > + > + return pinctrl_ops->group_pins_get(pmx->ph, selector, pins, num_pins); > +} > + > +static const struct pinctrl_ops pinctrl_scmi_pinctrl_ops = { > + .get_groups_count = pinctrl_scmi_get_groups_count, > + .get_group_name = pinctrl_scmi_get_group_name, > + .get_group_pins = pinctrl_scmi_get_group_pins, > +#ifdef CONFIG_OF > + .dt_node_to_map = pinconf_generic_dt_node_to_map_all, > + .dt_free_map = pinconf_generic_dt_free_map, > +#endif > +}; > + > +static int pinctrl_scmi_get_functions_count(struct pinctrl_dev *pctldev) > +{ > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > + > + return pinctrl_ops->count_get(pmx->ph, FUNCTION_TYPE); > +} > + > +static const char *pinctrl_scmi_get_function_name(struct pinctrl_dev *pctldev, > + unsigned int selector) > +{ > + int ret; > + const char *name; > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > + > + ret = pinctrl_ops->name_get(pmx->ph, selector, FUNCTION_TYPE, &name); > + if (ret) { > + dev_err(pmx->dev, "get name failed with err %d", ret); > + return NULL; > + } > + > + return name; > +} > + > +static int pinctrl_scmi_get_function_groups(struct pinctrl_dev *pctldev, > + unsigned int selector, > + const char * const **p_groups, > + unsigned int * const p_num_groups) > +{ > + struct pinfunction *func; > + const unsigned int *group_ids; > + unsigned int num_groups; > + const char **groups; > + int ret, i; Just a nit maybe, but I would be more comfortable making i with num_groups as unsigned, because you're comparing them after all in the loop. Also, I don't see a reason for i to become negative in any case. > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > + > + if (!p_groups || !p_num_groups) > + return -EINVAL; > + > + if (selector >= pmx->nr_functions) > + return -EINVAL; > + > + func = &pmx->functions[selector]; > + if (func->ngroups) > + goto done; > + > + ret = pinctrl_ops->function_groups_get(pmx->ph, selector, &num_groups, > + &group_ids); > + if (ret) { > + dev_err(pmx->dev, "Unable to get function groups, err %d", ret); > + return ret; > + } > + if (!num_groups) > + return -EINVAL; > + > + groups = kcalloc(num_groups, sizeof(*groups), GFP_KERNEL); > + if (!groups) > + return -ENOMEM; > + > + for (i = 0; i < num_groups; i++) { > + groups[i] = pinctrl_scmi_get_group_name(pctldev, group_ids[i]); > + if (!groups[i]) { > + ret = -EINVAL; > + goto err_free; > + } > + } > + > + func->ngroups = num_groups; > + func->groups = groups; > +done: > + *p_groups = func->groups; > + *p_num_groups = func->ngroups; > + > + return 0; > + > +err_free: > + kfree(groups); > + > + return ret; > +} > + [...] > + > +static int pinctrl_scmi_get_pins(struct scmi_pinctrl *pmx, > + struct pinctrl_desc *desc) > +{ > + struct pinctrl_pin_desc *pins; > + unsigned int npins; > + int ret, i; better unsigned i? > + > + npins = pinctrl_ops->count_get(pmx->ph, PIN_TYPE); > + /* > + * npins will never be zero, the scmi pinctrl driver has bailed out > + * if npins is zero. > + */ > + 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; > + /* > + * The memory for name is handled by the scmi firmware driver, > + * no need free here > + */ > + ret = pinctrl_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; > +} > + [...] Unrelated and beyond scope of this patch series, but would've loved to see concept of wakeup enable and wakeup event bits inside the pinctrl SCMI spec like we have in pinctrl-single kernel driver. There are SOC's out there that support wakeup IRQ's from their padconfig controllers itself... But this is more of a feedback for the SCMI spec. Maybe a future revision can take care of this. The reason this needs to be standard and not something vendor specific is because the kernel does support a wake IRQ framework, and we will need to make this driver have wake IRQ support if a device that supports pinctrl wakeup need to use scmi to configure it. Look at Table 6-2045. Description Of The Pad Configuration Register Bit in [0] for further details for an example of a padconfig wakeup config specially bits 29,30. No major comments otherwise, Reviewed-by: Dhruva Gole <d-gole@ti.com> [0] https://www.ti.com/lit/pdf/SPRUIV7
Hi Linus, > Subject: RE: [PATCH v8 4/4] pinctrl: Implementation of the generic scmi- > pinctrl driver > > > Subject: [PATCH v8 4/4] pinctrl: Implementation of the generic > > scmi-pinctrl driver > > > > From: Peng Fan <peng.fan@nxp.com> > > > > scmi-pinctrl driver implements pinctrl driver interface and using SCMI > > protocol to redirect messages from pinctrl subsystem SDK to SCMI > > platform firmware, which does the changes in HW. > > Considering pinctrl expects ENOTSUPP, so I would add this in v9. > > diff --git a/drivers/pinctrl/pinctrl-scmi.c b/drivers/pinctrl/pinctrl-scmi.c index > 0f55f000a679..accebe3f0706 100644 > --- a/drivers/pinctrl/pinctrl-scmi.c > +++ b/drivers/pinctrl/pinctrl-scmi.c > @@ -296,8 +296,12 @@ static int pinctrl_scmi_pinconf_get(struct > pinctrl_dev *pctldev, > > ret = pinctrl_ops->settings_get_one(pmx->ph, pin, PIN_TYPE, type, > &config_value); > - if (ret) > + if (ret) { > + /* Convert SCMI error code to PINCTRL expected error code */ > + if (ret == -EOPNOTSUPP) > + ret = -ENOTSUPP; > return ret; > + } > > *config = pinconf_to_config_packed(config_type, config_value); > > @@ -445,8 +449,12 @@ static int pinctrl_scmi_pinconf_group_get(struct > pinctrl_dev *pctldev, > > ret = pinctrl_ops->settings_get_one(pmx->ph, group, GROUP_TYPE, type, > &config_value); > - if (ret) > + if (ret) { > + /* Convert SCMI error code to PINCTRL expected error code */ > + if (ret == -EOPNOTSUPP) > + ret = -ENOTSUPP; > return ret; > + } > > *config = pinconf_to_config_packed(config_type, config_value); I just rebased to linux-next and found the patch "pinctrl: pinconf-generic: check error value EOPNOTSUPP" is there, not removed. Do I still need to convert the error number from EOPNOTSUPP to ENOTSUPP in pinctrl-scmi.c? Thanks, Peng. > > I will collect more comments before post v9. Just post out upper diff to see > any disagreements. > > Thanks, > Peng. > > > > Co-developed-by: Oleksii Moisieiev <oleksii_moisieiev@epam.com> > > Signed-off-by: Oleksii Moisieiev <oleksii_moisieiev@epam.com> > > Signed-off-by: Peng Fan <peng.fan@nxp.com> > > --- > > MAINTAINERS | 1 + > > drivers/pinctrl/Kconfig | 11 + > > drivers/pinctrl/Makefile | 1 + > > drivers/pinctrl/pinctrl-scmi.c | 564 > > +++++++++++++++++++++++++++++++++++++++++ > > 4 files changed, 577 insertions(+) > > > > diff --git a/MAINTAINERS b/MAINTAINERS index > > 4b511a55101c..d8270ac6651a 100644 > > --- a/MAINTAINERS > > +++ b/MAINTAINERS > > @@ -21457,6 +21457,7 @@ F: drivers/cpufreq/sc[mp]i-cpufreq.c > > F: drivers/firmware/arm_scmi/ > > F: drivers/firmware/arm_scpi.c > > F: drivers/hwmon/scmi-hwmon.c > > +F: drivers/pinctrl/pinctrl-scmi.c > > F: drivers/pmdomain/arm/ > > F: drivers/powercap/arm_scmi_powercap.c > > F: drivers/regulator/scmi-regulator.c > > diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig index > > d45657aa986a..4e6f65cf0e76 100644 > > --- a/drivers/pinctrl/Kconfig > > +++ b/drivers/pinctrl/Kconfig > > @@ -450,6 +450,17 @@ config PINCTRL_ROCKCHIP > > help > > This support pinctrl and GPIO driver for Rockchip SoCs. > > > > +config PINCTRL_SCMI > > + tristate "Pinctrl driver using SCMI protocol interface" > > + depends on ARM_SCMI_PROTOCOL || COMPILE_TEST > > + select PINMUX > > + select GENERIC_PINCONF > > + help > > + This driver provides support for pinctrl which is controlled > > + by firmware that implements the SCMI interface. > > + It uses SCMI Message Protocol to interact with the > > + firmware providing all the pinctrl controls. > > + > > config PINCTRL_SINGLE > > tristate "One-register-per-pin type device tree based pinctrl driver" > > depends on OF > > diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile index > > 2152539b53d5..cc809669405a 100644 > > --- a/drivers/pinctrl/Makefile > > +++ b/drivers/pinctrl/Makefile > > @@ -45,6 +45,7 @@ obj-$(CONFIG_PINCTRL_PIC32) += pinctrl-pic32.o > > obj-$(CONFIG_PINCTRL_PISTACHIO) += pinctrl-pistachio.o > > obj-$(CONFIG_PINCTRL_RK805) += pinctrl-rk805.o > > obj-$(CONFIG_PINCTRL_ROCKCHIP) += pinctrl-rockchip.o > > +obj-$(CONFIG_PINCTRL_SCMI) += pinctrl-scmi.o > > obj-$(CONFIG_PINCTRL_SINGLE) += pinctrl-single.o > > obj-$(CONFIG_PINCTRL_ST) += pinctrl-st.o > > obj-$(CONFIG_PINCTRL_STMFX) += pinctrl-stmfx.o > > diff --git a/drivers/pinctrl/pinctrl-scmi.c > > b/drivers/pinctrl/pinctrl-scmi.c new file mode 100644 index > > 000000000000..0f55f000a679 > > --- /dev/null > > +++ b/drivers/pinctrl/pinctrl-scmi.c > > @@ -0,0 +1,564 @@ > > +// SPDX-License-Identifier: GPL-2.0 > > +/* > > + * System Control and Power Interface (SCMI) Protocol based pinctrl > > +driver > > + * > > + * Copyright (C) 2024 EPAM > > + * Copyright 2024 NXP > > + */ > > + > > +#include <linux/device.h> > > +#include <linux/dev_printk.h> > > +#include <linux/err.h> > > +#include <linux/module.h> > > +#include <linux/scmi_protocol.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" > > + > > +#define DRV_NAME "scmi-pinctrl" > > + > > +/* Define num configs, if not large than 4 use stack, else use kcalloc */ > > +#define SCMI_NUM_CONFIGS 4 > > + > > +static const struct scmi_pinctrl_proto_ops *pinctrl_ops; > > + > > +struct scmi_pinctrl { > > + struct device *dev; > > + struct scmi_protocol_handle *ph; > > + struct pinctrl_dev *pctldev; > > + struct pinctrl_desc pctl_desc; > > + struct pinfunction *functions; > > + unsigned int nr_functions; > > + struct pinctrl_pin_desc *pins; > > + unsigned int nr_pins; > > +}; > > + > > +static int pinctrl_scmi_get_groups_count(struct pinctrl_dev *pctldev) { > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + return pinctrl_ops->count_get(pmx->ph, GROUP_TYPE); } > > + > > +static const char *pinctrl_scmi_get_group_name(struct pinctrl_dev > *pctldev, > > + unsigned int selector) > > +{ > > + int ret; > > + const char *name; > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + ret = pinctrl_ops->name_get(pmx->ph, selector, GROUP_TYPE, > > &name); > > + if (ret) { > > + dev_err(pmx->dev, "get name failed with err %d", ret); > > + return NULL; > > + } > > + > > + return name; > > +} > > + > > +static int pinctrl_scmi_get_group_pins(struct pinctrl_dev *pctldev, > > + unsigned int selector, > > + const unsigned int **pins, > > + unsigned int *num_pins) > > +{ > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + return pinctrl_ops->group_pins_get(pmx->ph, selector, pins, > > num_pins); > > +} > > + > > +static const struct pinctrl_ops pinctrl_scmi_pinctrl_ops = { > > + .get_groups_count = pinctrl_scmi_get_groups_count, > > + .get_group_name = pinctrl_scmi_get_group_name, > > + .get_group_pins = pinctrl_scmi_get_group_pins, #ifdef CONFIG_OF > > + .dt_node_to_map = pinconf_generic_dt_node_to_map_all, > > + .dt_free_map = pinconf_generic_dt_free_map, #endif }; > > + > > +static int pinctrl_scmi_get_functions_count(struct pinctrl_dev > > +*pctldev) { > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + return pinctrl_ops->count_get(pmx->ph, FUNCTION_TYPE); } > > + > > +static const char *pinctrl_scmi_get_function_name(struct pinctrl_dev > > *pctldev, > > + unsigned int selector) > > +{ > > + int ret; > > + const char *name; > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + ret = pinctrl_ops->name_get(pmx->ph, selector, FUNCTION_TYPE, > > &name); > > + if (ret) { > > + dev_err(pmx->dev, "get name failed with err %d", ret); > > + return NULL; > > + } > > + > > + return name; > > +} > > + > > +static int pinctrl_scmi_get_function_groups(struct pinctrl_dev *pctldev, > > + unsigned int selector, > > + const char * const **p_groups, > > + unsigned int * const > > p_num_groups) { > > + struct pinfunction *func; > > + const unsigned int *group_ids; > > + unsigned int num_groups; > > + const char **groups; > > + int ret, i; > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + if (!p_groups || !p_num_groups) > > + return -EINVAL; > > + > > + if (selector >= pmx->nr_functions) > > + return -EINVAL; > > + > > + func = &pmx->functions[selector]; > > + if (func->ngroups) > > + goto done; > > + > > + ret = pinctrl_ops->function_groups_get(pmx->ph, selector, > > &num_groups, > > + &group_ids); > > + if (ret) { > > + dev_err(pmx->dev, "Unable to get function groups, err %d", > > ret); > > + return ret; > > + } > > + if (!num_groups) > > + return -EINVAL; > > + > > + groups = kcalloc(num_groups, sizeof(*groups), GFP_KERNEL); > > + if (!groups) > > + return -ENOMEM; > > + > > + for (i = 0; i < num_groups; i++) { > > + groups[i] = pinctrl_scmi_get_group_name(pctldev, > > group_ids[i]); > > + if (!groups[i]) { > > + ret = -EINVAL; > > + goto err_free; > > + } > > + } > > + > > + func->ngroups = num_groups; > > + func->groups = groups; > > +done: > > + *p_groups = func->groups; > > + *p_num_groups = func->ngroups; > > + > > + return 0; > > + > > +err_free: > > + kfree(groups); > > + > > + return ret; > > +} > > + > > +static int pinctrl_scmi_func_set_mux(struct pinctrl_dev *pctldev, > > + unsigned int selector, unsigned int group) > > { > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + return pinctrl_ops->mux_set(pmx->ph, selector, group); } > > + > > +static int pinctrl_scmi_request(struct pinctrl_dev *pctldev, > > + unsigned int offset) > > +{ > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + return pinctrl_ops->pin_request(pmx->ph, offset); } > > + > > +static int pinctrl_scmi_free(struct pinctrl_dev *pctldev, unsigned > > +int > > +offset) { > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + > > + return pinctrl_ops->pin_free(pmx->ph, offset); } > > + > > +static const struct pinmux_ops pinctrl_scmi_pinmux_ops = { > > + .request = pinctrl_scmi_request, > > + .free = pinctrl_scmi_free, > > + .get_functions_count = pinctrl_scmi_get_functions_count, > > + .get_function_name = pinctrl_scmi_get_function_name, > > + .get_function_groups = pinctrl_scmi_get_function_groups, > > + .set_mux = pinctrl_scmi_func_set_mux, }; > > + > > +static int pinctrl_scmi_map_pinconf_type(enum pin_config_param param, > > + enum scmi_pinctrl_conf_type > > *type) { > > + u32 arg = param; > > + > > + switch (arg) { > > + case PIN_CONFIG_BIAS_BUS_HOLD: > > + *type = SCMI_PIN_BIAS_BUS_HOLD; > > + break; > > + case PIN_CONFIG_BIAS_DISABLE: > > + *type = SCMI_PIN_BIAS_DISABLE; > > + break; > > + case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: > > + *type = SCMI_PIN_BIAS_HIGH_IMPEDANCE; > > + break; > > + case PIN_CONFIG_BIAS_PULL_DOWN: > > + *type = SCMI_PIN_BIAS_PULL_DOWN; > > + break; > > + case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT: > > + *type = SCMI_PIN_BIAS_PULL_DEFAULT; > > + break; > > + case PIN_CONFIG_BIAS_PULL_UP: > > + *type = SCMI_PIN_BIAS_PULL_UP; > > + break; > > + case PIN_CONFIG_DRIVE_OPEN_DRAIN: > > + *type = SCMI_PIN_DRIVE_OPEN_DRAIN; > > + break; > > + case PIN_CONFIG_DRIVE_OPEN_SOURCE: > > + *type = SCMI_PIN_DRIVE_OPEN_SOURCE; > > + break; > > + case PIN_CONFIG_DRIVE_PUSH_PULL: > > + *type = SCMI_PIN_DRIVE_PUSH_PULL; > > + break; > > + case PIN_CONFIG_DRIVE_STRENGTH: > > + *type = SCMI_PIN_DRIVE_STRENGTH; > > + break; > > + case PIN_CONFIG_DRIVE_STRENGTH_UA: > > + *type = SCMI_PIN_DRIVE_STRENGTH; > > + break; > > + case PIN_CONFIG_INPUT_DEBOUNCE: > > + *type = SCMI_PIN_INPUT_DEBOUNCE; > > + break; > > + case PIN_CONFIG_INPUT_ENABLE: > > + *type = SCMI_PIN_INPUT_MODE; > > + break; > > + case PIN_CONFIG_INPUT_SCHMITT: > > + *type = SCMI_PIN_INPUT_SCHMITT; > > + break; > > + case PIN_CONFIG_INPUT_SCHMITT_ENABLE: > > + *type = SCMI_PIN_INPUT_MODE; > > + break; > > + case PIN_CONFIG_MODE_LOW_POWER: > > + *type = SCMI_PIN_LOW_POWER_MODE; > > + break; > > + case PIN_CONFIG_OUTPUT: > > + *type = SCMI_PIN_OUTPUT_VALUE; > > + break; > > + case PIN_CONFIG_OUTPUT_ENABLE: > > + *type = SCMI_PIN_OUTPUT_MODE; > > + break; > > + case PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS: > > + *type = SCMI_PIN_OUTPUT_VALUE; > > + break; > > + case PIN_CONFIG_POWER_SOURCE: > > + *type = SCMI_PIN_POWER_SOURCE; > > + break; > > + case PIN_CONFIG_SLEW_RATE: > > + *type = SCMI_PIN_SLEW_RATE; > > + break; > > + case SCMI_PIN_OEM_START ... SCMI_PIN_OEM_END: > > + *type = arg; > > + break; > > + default: > > + return -EINVAL; > > + } > > + > > + return 0; > > +} > > + > > +static int pinctrl_scmi_pinconf_get(struct pinctrl_dev *pctldev, > > + unsigned int pin, unsigned long *config) { > > + int ret; > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + enum pin_config_param config_type; > > + enum scmi_pinctrl_conf_type type; > > + u32 config_value; > > + > > + if (!config) > > + return -EINVAL; > > + > > + config_type = pinconf_to_config_param(*config); > > + > > + ret = pinctrl_scmi_map_pinconf_type(config_type, &type); > > + if (ret) > > + return ret; > > + > > + ret = pinctrl_ops->settings_get_one(pmx->ph, pin, PIN_TYPE, type, > > + &config_value); > > + if (ret) > > + return ret; > > + > > + *config = pinconf_to_config_packed(config_type, config_value); > > + > > + return 0; > > +} > > + > > +static int > > +pinctrl_scmi_alloc_configs(struct pinctrl_dev *pctldev, u32 num_configs, > > + u32 **p_config_value, > > + enum scmi_pinctrl_conf_type **p_config_type) { > > + if (num_configs <= SCMI_NUM_CONFIGS) > > + return 0; > > + > > + *p_config_value = kcalloc(num_configs, sizeof(**p_config_value), > > GFP_KERNEL); > > + if (!*p_config_value) > > + return -ENOMEM; > > + > > + *p_config_type = kcalloc(num_configs, sizeof(**p_config_type), > > GFP_KERNEL); > > + if (!*p_config_type) { > > + kfree(*p_config_value); > > + return -ENOMEM; > > + } > > + > > + return 0; > > +} > > + > > +static void > > +pinctrl_scmi_free_configs(struct pinctrl_dev *pctldev, u32 num_configs, > > + u32 **p_config_value, > > + enum scmi_pinctrl_conf_type **p_config_type) { > > + if (num_configs <= SCMI_NUM_CONFIGS) > > + return; > > + > > + kfree(*p_config_value); > > + kfree(*p_config_type); > > +} > > + > > +static int pinctrl_scmi_pinconf_set(struct pinctrl_dev *pctldev, > > + unsigned int pin, > > + unsigned long *configs, > > + unsigned int num_configs) > > +{ > > + int i, ret; > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS]; > > + u32 config_value[SCMI_NUM_CONFIGS]; > > + enum scmi_pinctrl_conf_type *p_config_type = config_type; > > + u32 *p_config_value = config_value; > > + enum pin_config_param param; > > + > > + if (!configs || !num_configs) > > + return -EINVAL; > > + > > + ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, > > &p_config_type, > > + &p_config_value); > > + if (ret) > > + return ret; > > + > > + for (i = 0; i < num_configs; i++) { > > + param = pinconf_to_config_param(configs[i]); > > + ret = pinctrl_scmi_map_pinconf_type(param, > > &p_config_type[i]); > > + if (ret) { > > + dev_err(pmx->dev, "Error map pinconf_type %d\n", > > ret); > > + goto free_config; > > + } > > + p_config_value[i] = pinconf_to_config_argument(configs[i]); > > + } > > + > > + ret = pinctrl_ops->settings_conf(pmx->ph, pin, PIN_TYPE, > > num_configs, > > + p_config_type, p_config_value); > > + if (ret) > > + dev_err(pmx->dev, "Error parsing config %d\n", ret); > > + > > +free_config: > > + pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type, > > + &p_config_value); > > + return ret; > > +} > > + > > +static int pinctrl_scmi_pinconf_group_set(struct pinctrl_dev *pctldev, > > + unsigned int group, > > + unsigned long *configs, > > + unsigned int num_configs) > > +{ > > + int i, ret; > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS]; > > + u32 config_value[SCMI_NUM_CONFIGS]; > > + enum scmi_pinctrl_conf_type *p_config_type = config_type; > > + u32 *p_config_value = config_value; > > + enum pin_config_param param; > > + > > + if (!configs || !num_configs) > > + return -EINVAL; > > + > > + ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, > > &p_config_type, > > + &p_config_value); > > + if (ret) > > + return ret; > > + > > + for (i = 0; i < num_configs; i++) { > > + param = pinconf_to_config_param(configs[i]); > > + ret = pinctrl_scmi_map_pinconf_type(param, > > &p_config_type[i]); > > + if (ret) { > > + dev_err(pmx->dev, "Error map pinconf_type %d\n", > > ret); > > + goto free_config; > > + } > > + > > + p_config_value[i] = pinconf_to_config_argument(configs[i]); > > + } > > + > > + ret = pinctrl_ops->settings_conf(pmx->ph, group, GROUP_TYPE, > > + num_configs, p_config_type, > > + p_config_value); > > + if (ret) > > + dev_err(pmx->dev, "Error parsing config %d", ret); > > + > > +free_config: > > + pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type, > > + &p_config_value); > > + return ret; > > +}; > > + > > +static int pinctrl_scmi_pinconf_group_get(struct pinctrl_dev *pctldev, > > + unsigned int group, > > + unsigned long *config) > > +{ > > + int ret; > > + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); > > + enum pin_config_param config_type; > > + enum scmi_pinctrl_conf_type type; > > + u32 config_value; > > + > > + if (!config) > > + return -EINVAL; > > + > > + config_type = pinconf_to_config_param(*config); > > + ret = pinctrl_scmi_map_pinconf_type(config_type, &type); > > + if (ret) { > > + dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); > > + return ret; > > + } > > + > > + ret = pinctrl_ops->settings_get_one(pmx->ph, group, GROUP_TYPE, > > type, > > + &config_value); > > + if (ret) > > + return ret; > > + > > + *config = pinconf_to_config_packed(config_type, config_value); > > + > > + return 0; > > +} > > + > > +static const struct pinconf_ops pinctrl_scmi_pinconf_ops = { > > + .is_generic = true, > > + .pin_config_get = pinctrl_scmi_pinconf_get, > > + .pin_config_set = pinctrl_scmi_pinconf_set, > > + .pin_config_group_set = pinctrl_scmi_pinconf_group_set, > > + .pin_config_group_get = pinctrl_scmi_pinconf_group_get, > > + .pin_config_config_dbg_show = pinconf_generic_dump_config, }; > > + > > +static int pinctrl_scmi_get_pins(struct scmi_pinctrl *pmx, > > + struct pinctrl_desc *desc) > > +{ > > + struct pinctrl_pin_desc *pins; > > + unsigned int npins; > > + int ret, i; > > + > > + npins = pinctrl_ops->count_get(pmx->ph, PIN_TYPE); > > + /* > > + * npins will never be zero, the scmi pinctrl driver has bailed out > > + * if npins is zero. > > + */ > > + 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; > > + /* > > + * The memory for name is handled by the scmi firmware > > driver, > > + * no need free here > > + */ > > + ret = pinctrl_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 int scmi_pinctrl_probe(struct scmi_device *sdev) { > > + int ret; > > + struct device *dev = &sdev->dev; > > + struct scmi_pinctrl *pmx; > > + const struct scmi_handle *handle; > > + struct scmi_protocol_handle *ph; > > + > > + if (!sdev->handle) > > + return -EINVAL; > > + > > + handle = sdev->handle; > > + > > + 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->dev = dev; > > + pmx->pctl_desc.name = DRV_NAME; > > + pmx->pctl_desc.owner = THIS_MODULE; > > + pmx->pctl_desc.pctlops = &pinctrl_scmi_pinctrl_ops; > > + pmx->pctl_desc.pmxops = &pinctrl_scmi_pinmux_ops; > > + pmx->pctl_desc.confops = &pinctrl_scmi_pinconf_ops; > > + > > + ret = pinctrl_scmi_get_pins(pmx, &pmx->pctl_desc); > > + if (ret) > > + return ret; > > + > > + 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"); > > + > > + pmx->nr_functions = pinctrl_scmi_get_functions_count(pmx- > > >pctldev); > > + pmx->functions = devm_kcalloc(dev, pmx->nr_functions, > > + sizeof(*pmx->functions), GFP_KERNEL); > > + if (!pmx->functions) > > + return -ENOMEM; > > + > > + return pinctrl_enable(pmx->pctldev); } > > + > > +static const struct scmi_device_id scmi_id_table[] = { > > + { SCMI_PROTOCOL_PINCTRL, "pinctrl" }, > > + { } > > +}; > > +MODULE_DEVICE_TABLE(scmi, scmi_id_table); > > + > > +static struct scmi_driver scmi_pinctrl_driver = { > > + .name = DRV_NAME, > > + .probe = scmi_pinctrl_probe, > > + .id_table = scmi_id_table, > > +}; > > +module_scmi_driver(scmi_pinctrl_driver); > > + > > +MODULE_AUTHOR("Oleksii Moisieiev <oleksii_moisieiev@epam.com>"); > > +MODULE_AUTHOR("Peng Fan <peng.fan@nxp.com>"); > > MODULE_DESCRIPTION("ARM > > +SCMI pin controller driver"); MODULE_LICENSE("GPL"); > > > > -- > > 2.37.1
On Wed, Apr 10, 2024 at 9:06 AM Peng Fan <peng.fan@nxp.com> wrote: > I just rebased to linux-next and found the patch > "pinctrl: pinconf-generic: check error value EOPNOTSUPP" is there, not > removed. I just haven't had time to test and push out my tree, the patch is gone. Yours, Linus Walleij
diff --git a/MAINTAINERS b/MAINTAINERS index 4b511a55101c..d8270ac6651a 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21457,6 +21457,7 @@ F: drivers/cpufreq/sc[mp]i-cpufreq.c F: drivers/firmware/arm_scmi/ F: drivers/firmware/arm_scpi.c F: drivers/hwmon/scmi-hwmon.c +F: drivers/pinctrl/pinctrl-scmi.c F: drivers/pmdomain/arm/ F: drivers/powercap/arm_scmi_powercap.c F: drivers/regulator/scmi-regulator.c diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig index d45657aa986a..4e6f65cf0e76 100644 --- a/drivers/pinctrl/Kconfig +++ b/drivers/pinctrl/Kconfig @@ -450,6 +450,17 @@ config PINCTRL_ROCKCHIP help This support pinctrl and GPIO driver for Rockchip SoCs. +config PINCTRL_SCMI + tristate "Pinctrl driver using SCMI protocol interface" + depends on ARM_SCMI_PROTOCOL || COMPILE_TEST + select PINMUX + select GENERIC_PINCONF + help + This driver provides support for pinctrl which is controlled + by firmware that implements the SCMI interface. + It uses SCMI Message Protocol to interact with the + firmware providing all the pinctrl controls. + config PINCTRL_SINGLE tristate "One-register-per-pin type device tree based pinctrl driver" depends on OF diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile index 2152539b53d5..cc809669405a 100644 --- a/drivers/pinctrl/Makefile +++ b/drivers/pinctrl/Makefile @@ -45,6 +45,7 @@ obj-$(CONFIG_PINCTRL_PIC32) += pinctrl-pic32.o obj-$(CONFIG_PINCTRL_PISTACHIO) += pinctrl-pistachio.o obj-$(CONFIG_PINCTRL_RK805) += pinctrl-rk805.o obj-$(CONFIG_PINCTRL_ROCKCHIP) += pinctrl-rockchip.o +obj-$(CONFIG_PINCTRL_SCMI) += pinctrl-scmi.o obj-$(CONFIG_PINCTRL_SINGLE) += pinctrl-single.o obj-$(CONFIG_PINCTRL_ST) += pinctrl-st.o obj-$(CONFIG_PINCTRL_STMFX) += pinctrl-stmfx.o diff --git a/drivers/pinctrl/pinctrl-scmi.c b/drivers/pinctrl/pinctrl-scmi.c new file mode 100644 index 000000000000..0f55f000a679 --- /dev/null +++ b/drivers/pinctrl/pinctrl-scmi.c @@ -0,0 +1,564 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * System Control and Power Interface (SCMI) Protocol based pinctrl driver + * + * Copyright (C) 2024 EPAM + * Copyright 2024 NXP + */ + +#include <linux/device.h> +#include <linux/dev_printk.h> +#include <linux/err.h> +#include <linux/module.h> +#include <linux/scmi_protocol.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" + +#define DRV_NAME "scmi-pinctrl" + +/* Define num configs, if not large than 4 use stack, else use kcalloc */ +#define SCMI_NUM_CONFIGS 4 + +static const struct scmi_pinctrl_proto_ops *pinctrl_ops; + +struct scmi_pinctrl { + struct device *dev; + struct scmi_protocol_handle *ph; + struct pinctrl_dev *pctldev; + struct pinctrl_desc pctl_desc; + struct pinfunction *functions; + unsigned int nr_functions; + struct pinctrl_pin_desc *pins; + unsigned int nr_pins; +}; + +static int pinctrl_scmi_get_groups_count(struct pinctrl_dev *pctldev) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->count_get(pmx->ph, GROUP_TYPE); +} + +static const char *pinctrl_scmi_get_group_name(struct pinctrl_dev *pctldev, + unsigned int selector) +{ + int ret; + const char *name; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + ret = pinctrl_ops->name_get(pmx->ph, selector, GROUP_TYPE, &name); + if (ret) { + dev_err(pmx->dev, "get name failed with err %d", ret); + return NULL; + } + + return name; +} + +static int pinctrl_scmi_get_group_pins(struct pinctrl_dev *pctldev, + unsigned int selector, + const unsigned int **pins, + unsigned int *num_pins) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->group_pins_get(pmx->ph, selector, pins, num_pins); +} + +static const struct pinctrl_ops pinctrl_scmi_pinctrl_ops = { + .get_groups_count = pinctrl_scmi_get_groups_count, + .get_group_name = pinctrl_scmi_get_group_name, + .get_group_pins = pinctrl_scmi_get_group_pins, +#ifdef CONFIG_OF + .dt_node_to_map = pinconf_generic_dt_node_to_map_all, + .dt_free_map = pinconf_generic_dt_free_map, +#endif +}; + +static int pinctrl_scmi_get_functions_count(struct pinctrl_dev *pctldev) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->count_get(pmx->ph, FUNCTION_TYPE); +} + +static const char *pinctrl_scmi_get_function_name(struct pinctrl_dev *pctldev, + unsigned int selector) +{ + int ret; + const char *name; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + ret = pinctrl_ops->name_get(pmx->ph, selector, FUNCTION_TYPE, &name); + if (ret) { + dev_err(pmx->dev, "get name failed with err %d", ret); + return NULL; + } + + return name; +} + +static int pinctrl_scmi_get_function_groups(struct pinctrl_dev *pctldev, + unsigned int selector, + const char * const **p_groups, + unsigned int * const p_num_groups) +{ + struct pinfunction *func; + const unsigned int *group_ids; + unsigned int num_groups; + const char **groups; + int ret, i; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + if (!p_groups || !p_num_groups) + return -EINVAL; + + if (selector >= pmx->nr_functions) + return -EINVAL; + + func = &pmx->functions[selector]; + if (func->ngroups) + goto done; + + ret = pinctrl_ops->function_groups_get(pmx->ph, selector, &num_groups, + &group_ids); + if (ret) { + dev_err(pmx->dev, "Unable to get function groups, err %d", ret); + return ret; + } + if (!num_groups) + return -EINVAL; + + groups = kcalloc(num_groups, sizeof(*groups), GFP_KERNEL); + if (!groups) + return -ENOMEM; + + for (i = 0; i < num_groups; i++) { + groups[i] = pinctrl_scmi_get_group_name(pctldev, group_ids[i]); + if (!groups[i]) { + ret = -EINVAL; + goto err_free; + } + } + + func->ngroups = num_groups; + func->groups = groups; +done: + *p_groups = func->groups; + *p_num_groups = func->ngroups; + + return 0; + +err_free: + kfree(groups); + + return ret; +} + +static int pinctrl_scmi_func_set_mux(struct pinctrl_dev *pctldev, + unsigned int selector, unsigned int group) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->mux_set(pmx->ph, selector, group); +} + +static int pinctrl_scmi_request(struct pinctrl_dev *pctldev, + unsigned int offset) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->pin_request(pmx->ph, offset); +} + +static int pinctrl_scmi_free(struct pinctrl_dev *pctldev, unsigned int offset) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->pin_free(pmx->ph, offset); +} + +static const struct pinmux_ops pinctrl_scmi_pinmux_ops = { + .request = pinctrl_scmi_request, + .free = pinctrl_scmi_free, + .get_functions_count = pinctrl_scmi_get_functions_count, + .get_function_name = pinctrl_scmi_get_function_name, + .get_function_groups = pinctrl_scmi_get_function_groups, + .set_mux = pinctrl_scmi_func_set_mux, +}; + +static int pinctrl_scmi_map_pinconf_type(enum pin_config_param param, + enum scmi_pinctrl_conf_type *type) +{ + u32 arg = param; + + switch (arg) { + case PIN_CONFIG_BIAS_BUS_HOLD: + *type = SCMI_PIN_BIAS_BUS_HOLD; + break; + case PIN_CONFIG_BIAS_DISABLE: + *type = SCMI_PIN_BIAS_DISABLE; + break; + case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: + *type = SCMI_PIN_BIAS_HIGH_IMPEDANCE; + break; + case PIN_CONFIG_BIAS_PULL_DOWN: + *type = SCMI_PIN_BIAS_PULL_DOWN; + break; + case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT: + *type = SCMI_PIN_BIAS_PULL_DEFAULT; + break; + case PIN_CONFIG_BIAS_PULL_UP: + *type = SCMI_PIN_BIAS_PULL_UP; + break; + case PIN_CONFIG_DRIVE_OPEN_DRAIN: + *type = SCMI_PIN_DRIVE_OPEN_DRAIN; + break; + case PIN_CONFIG_DRIVE_OPEN_SOURCE: + *type = SCMI_PIN_DRIVE_OPEN_SOURCE; + break; + case PIN_CONFIG_DRIVE_PUSH_PULL: + *type = SCMI_PIN_DRIVE_PUSH_PULL; + break; + case PIN_CONFIG_DRIVE_STRENGTH: + *type = SCMI_PIN_DRIVE_STRENGTH; + break; + case PIN_CONFIG_DRIVE_STRENGTH_UA: + *type = SCMI_PIN_DRIVE_STRENGTH; + break; + case PIN_CONFIG_INPUT_DEBOUNCE: + *type = SCMI_PIN_INPUT_DEBOUNCE; + break; + case PIN_CONFIG_INPUT_ENABLE: + *type = SCMI_PIN_INPUT_MODE; + break; + case PIN_CONFIG_INPUT_SCHMITT: + *type = SCMI_PIN_INPUT_SCHMITT; + break; + case PIN_CONFIG_INPUT_SCHMITT_ENABLE: + *type = SCMI_PIN_INPUT_MODE; + break; + case PIN_CONFIG_MODE_LOW_POWER: + *type = SCMI_PIN_LOW_POWER_MODE; + break; + case PIN_CONFIG_OUTPUT: + *type = SCMI_PIN_OUTPUT_VALUE; + break; + case PIN_CONFIG_OUTPUT_ENABLE: + *type = SCMI_PIN_OUTPUT_MODE; + break; + case PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS: + *type = SCMI_PIN_OUTPUT_VALUE; + break; + case PIN_CONFIG_POWER_SOURCE: + *type = SCMI_PIN_POWER_SOURCE; + break; + case PIN_CONFIG_SLEW_RATE: + *type = SCMI_PIN_SLEW_RATE; + break; + case SCMI_PIN_OEM_START ... SCMI_PIN_OEM_END: + *type = arg; + break; + default: + return -EINVAL; + } + + return 0; +} + +static int pinctrl_scmi_pinconf_get(struct pinctrl_dev *pctldev, + unsigned int pin, unsigned long *config) +{ + int ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + enum pin_config_param config_type; + enum scmi_pinctrl_conf_type type; + u32 config_value; + + if (!config) + return -EINVAL; + + config_type = pinconf_to_config_param(*config); + + ret = pinctrl_scmi_map_pinconf_type(config_type, &type); + if (ret) + return ret; + + ret = pinctrl_ops->settings_get_one(pmx->ph, pin, PIN_TYPE, type, + &config_value); + if (ret) + return ret; + + *config = pinconf_to_config_packed(config_type, config_value); + + return 0; +} + +static int +pinctrl_scmi_alloc_configs(struct pinctrl_dev *pctldev, u32 num_configs, + u32 **p_config_value, + enum scmi_pinctrl_conf_type **p_config_type) +{ + if (num_configs <= SCMI_NUM_CONFIGS) + return 0; + + *p_config_value = kcalloc(num_configs, sizeof(**p_config_value), GFP_KERNEL); + if (!*p_config_value) + return -ENOMEM; + + *p_config_type = kcalloc(num_configs, sizeof(**p_config_type), GFP_KERNEL); + if (!*p_config_type) { + kfree(*p_config_value); + return -ENOMEM; + } + + return 0; +} + +static void +pinctrl_scmi_free_configs(struct pinctrl_dev *pctldev, u32 num_configs, + u32 **p_config_value, + enum scmi_pinctrl_conf_type **p_config_type) +{ + if (num_configs <= SCMI_NUM_CONFIGS) + return; + + kfree(*p_config_value); + kfree(*p_config_type); +} + +static int pinctrl_scmi_pinconf_set(struct pinctrl_dev *pctldev, + unsigned int pin, + unsigned long *configs, + unsigned int num_configs) +{ + int i, ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS]; + u32 config_value[SCMI_NUM_CONFIGS]; + enum scmi_pinctrl_conf_type *p_config_type = config_type; + u32 *p_config_value = config_value; + enum pin_config_param param; + + if (!configs || !num_configs) + return -EINVAL; + + ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, &p_config_type, + &p_config_value); + if (ret) + return ret; + + for (i = 0; i < num_configs; i++) { + param = pinconf_to_config_param(configs[i]); + ret = pinctrl_scmi_map_pinconf_type(param, &p_config_type[i]); + if (ret) { + dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); + goto free_config; + } + p_config_value[i] = pinconf_to_config_argument(configs[i]); + } + + ret = pinctrl_ops->settings_conf(pmx->ph, pin, PIN_TYPE, num_configs, + p_config_type, p_config_value); + if (ret) + dev_err(pmx->dev, "Error parsing config %d\n", ret); + +free_config: + pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type, + &p_config_value); + return ret; +} + +static int pinctrl_scmi_pinconf_group_set(struct pinctrl_dev *pctldev, + unsigned int group, + unsigned long *configs, + unsigned int num_configs) +{ + int i, ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS]; + u32 config_value[SCMI_NUM_CONFIGS]; + enum scmi_pinctrl_conf_type *p_config_type = config_type; + u32 *p_config_value = config_value; + enum pin_config_param param; + + if (!configs || !num_configs) + return -EINVAL; + + ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, &p_config_type, + &p_config_value); + if (ret) + return ret; + + for (i = 0; i < num_configs; i++) { + param = pinconf_to_config_param(configs[i]); + ret = pinctrl_scmi_map_pinconf_type(param, &p_config_type[i]); + if (ret) { + dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); + goto free_config; + } + + p_config_value[i] = pinconf_to_config_argument(configs[i]); + } + + ret = pinctrl_ops->settings_conf(pmx->ph, group, GROUP_TYPE, + num_configs, p_config_type, + p_config_value); + if (ret) + dev_err(pmx->dev, "Error parsing config %d", ret); + +free_config: + pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type, + &p_config_value); + return ret; +}; + +static int pinctrl_scmi_pinconf_group_get(struct pinctrl_dev *pctldev, + unsigned int group, + unsigned long *config) +{ + int ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + enum pin_config_param config_type; + enum scmi_pinctrl_conf_type type; + u32 config_value; + + if (!config) + return -EINVAL; + + config_type = pinconf_to_config_param(*config); + ret = pinctrl_scmi_map_pinconf_type(config_type, &type); + if (ret) { + dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); + return ret; + } + + ret = pinctrl_ops->settings_get_one(pmx->ph, group, GROUP_TYPE, type, + &config_value); + if (ret) + return ret; + + *config = pinconf_to_config_packed(config_type, config_value); + + return 0; +} + +static const struct pinconf_ops pinctrl_scmi_pinconf_ops = { + .is_generic = true, + .pin_config_get = pinctrl_scmi_pinconf_get, + .pin_config_set = pinctrl_scmi_pinconf_set, + .pin_config_group_set = pinctrl_scmi_pinconf_group_set, + .pin_config_group_get = pinctrl_scmi_pinconf_group_get, + .pin_config_config_dbg_show = pinconf_generic_dump_config, +}; + +static int pinctrl_scmi_get_pins(struct scmi_pinctrl *pmx, + struct pinctrl_desc *desc) +{ + struct pinctrl_pin_desc *pins; + unsigned int npins; + int ret, i; + + npins = pinctrl_ops->count_get(pmx->ph, PIN_TYPE); + /* + * npins will never be zero, the scmi pinctrl driver has bailed out + * if npins is zero. + */ + 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; + /* + * The memory for name is handled by the scmi firmware driver, + * no need free here + */ + ret = pinctrl_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 int scmi_pinctrl_probe(struct scmi_device *sdev) +{ + int ret; + struct device *dev = &sdev->dev; + struct scmi_pinctrl *pmx; + const struct scmi_handle *handle; + struct scmi_protocol_handle *ph; + + if (!sdev->handle) + return -EINVAL; + + handle = sdev->handle; + + 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->dev = dev; + pmx->pctl_desc.name = DRV_NAME; + pmx->pctl_desc.owner = THIS_MODULE; + pmx->pctl_desc.pctlops = &pinctrl_scmi_pinctrl_ops; + pmx->pctl_desc.pmxops = &pinctrl_scmi_pinmux_ops; + pmx->pctl_desc.confops = &pinctrl_scmi_pinconf_ops; + + ret = pinctrl_scmi_get_pins(pmx, &pmx->pctl_desc); + if (ret) + return ret; + + 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"); + + pmx->nr_functions = pinctrl_scmi_get_functions_count(pmx->pctldev); + pmx->functions = devm_kcalloc(dev, pmx->nr_functions, + sizeof(*pmx->functions), GFP_KERNEL); + if (!pmx->functions) + return -ENOMEM; + + return pinctrl_enable(pmx->pctldev); +} + +static const struct scmi_device_id scmi_id_table[] = { + { SCMI_PROTOCOL_PINCTRL, "pinctrl" }, + { } +}; +MODULE_DEVICE_TABLE(scmi, scmi_id_table); + +static struct scmi_driver scmi_pinctrl_driver = { + .name = DRV_NAME, + .probe = scmi_pinctrl_probe, + .id_table = scmi_id_table, +}; +module_scmi_driver(scmi_pinctrl_driver); + +MODULE_AUTHOR("Oleksii Moisieiev <oleksii_moisieiev@epam.com>"); +MODULE_AUTHOR("Peng Fan <peng.fan@nxp.com>"); +MODULE_DESCRIPTION("ARM SCMI pin controller driver"); +MODULE_LICENSE("GPL");