346 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * linux/drivers/pinctrl/pinctrl-lantiq.c4 * based on linux/drivers/pinctrl/pinctrl-pxa3xx.c5 *6 * Copyright (C) 2012 John Crispin <john@phrozen.org>7 */8 9#include <linux/device.h>10#include <linux/io.h>11#include <linux/module.h>12#include <linux/of.h>13#include <linux/platform_device.h>14#include <linux/seq_file.h>15#include <linux/slab.h>16 17#include "pinctrl-lantiq.h"18 19static int ltq_get_group_count(struct pinctrl_dev *pctrldev)20{21 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);22 return info->num_grps;23}24 25static const char *ltq_get_group_name(struct pinctrl_dev *pctrldev,26 unsigned selector)27{28 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);29 if (selector >= info->num_grps)30 return NULL;31 return info->grps[selector].name;32}33 34static int ltq_get_group_pins(struct pinctrl_dev *pctrldev,35 unsigned selector,36 const unsigned **pins,37 unsigned *num_pins)38{39 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);40 if (selector >= info->num_grps)41 return -EINVAL;42 *pins = info->grps[selector].pins;43 *num_pins = info->grps[selector].npins;44 return 0;45}46 47static void ltq_pinctrl_dt_free_map(struct pinctrl_dev *pctldev,48 struct pinctrl_map *map, unsigned num_maps)49{50 int i;51 52 for (i = 0; i < num_maps; i++)53 if (map[i].type == PIN_MAP_TYPE_CONFIGS_PIN ||54 map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP)55 kfree(map[i].data.configs.configs);56 kfree(map);57}58 59static void ltq_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,60 struct seq_file *s,61 unsigned offset)62{63 seq_printf(s, " %s", dev_name(pctldev->dev));64}65 66static void ltq_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,67 struct device_node *np,68 struct pinctrl_map **map)69{70 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctldev);71 struct property *pins = of_find_property(np, "lantiq,pins", NULL);72 struct property *groups = of_find_property(np, "lantiq,groups", NULL);73 unsigned long configs[3];74 unsigned num_configs = 0;75 struct property *prop;76 const char *group, *pin;77 const char *function;78 int ret, i;79 80 if (!pins && !groups) {81 dev_err(pctldev->dev, "%pOFn defines neither pins nor groups\n",82 np);83 return;84 }85 86 if (pins && groups) {87 dev_err(pctldev->dev, "%pOFn defines both pins and groups\n",88 np);89 return;90 }91 92 ret = of_property_read_string(np, "lantiq,function", &function);93 if (groups && !ret) {94 of_property_for_each_string(np, "lantiq,groups", prop, group) {95 (*map)->type = PIN_MAP_TYPE_MUX_GROUP;96 (*map)->name = function;97 (*map)->data.mux.group = group;98 (*map)->data.mux.function = function;99 (*map)++;100 }101 }102 103 for (i = 0; i < info->num_params; i++) {104 u32 val;105 int ret = of_property_read_u32(np,106 info->params[i].property, &val);107 if (!ret)108 configs[num_configs++] =109 LTQ_PINCONF_PACK(info->params[i].param,110 val);111 }112 113 if (!num_configs)114 return;115 116 of_property_for_each_string(np, "lantiq,pins", prop, pin) {117 (*map)->data.configs.configs = kmemdup(configs,118 num_configs * sizeof(unsigned long),119 GFP_KERNEL);120 (*map)->type = PIN_MAP_TYPE_CONFIGS_PIN;121 (*map)->name = pin;122 (*map)->data.configs.group_or_pin = pin;123 (*map)->data.configs.num_configs = num_configs;124 (*map)++;125 }126 of_property_for_each_string(np, "lantiq,groups", prop, group) {127 (*map)->data.configs.configs = kmemdup(configs,128 num_configs * sizeof(unsigned long),129 GFP_KERNEL);130 (*map)->type = PIN_MAP_TYPE_CONFIGS_GROUP;131 (*map)->name = group;132 (*map)->data.configs.group_or_pin = group;133 (*map)->data.configs.num_configs = num_configs;134 (*map)++;135 }136}137 138static int ltq_pinctrl_dt_subnode_size(struct device_node *np)139{140 int ret;141 142 ret = of_property_count_strings(np, "lantiq,groups");143 if (ret < 0)144 ret = of_property_count_strings(np, "lantiq,pins");145 return ret;146}147 148static int ltq_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,149 struct device_node *np_config,150 struct pinctrl_map **map,151 unsigned *num_maps)152{153 struct pinctrl_map *tmp;154 struct device_node *np;155 int max_maps = 0;156 157 for_each_child_of_node(np_config, np)158 max_maps += ltq_pinctrl_dt_subnode_size(np);159 *map = kzalloc(array3_size(max_maps, sizeof(struct pinctrl_map), 2),160 GFP_KERNEL);161 if (!*map)162 return -ENOMEM;163 tmp = *map;164 165 for_each_child_of_node(np_config, np)166 ltq_pinctrl_dt_subnode_to_map(pctldev, np, &tmp);167 *num_maps = ((int)(tmp - *map));168 169 return 0;170}171 172static const struct pinctrl_ops ltq_pctrl_ops = {173 .get_groups_count = ltq_get_group_count,174 .get_group_name = ltq_get_group_name,175 .get_group_pins = ltq_get_group_pins,176 .pin_dbg_show = ltq_pinctrl_pin_dbg_show,177 .dt_node_to_map = ltq_pinctrl_dt_node_to_map,178 .dt_free_map = ltq_pinctrl_dt_free_map,179};180 181static int ltq_pmx_func_count(struct pinctrl_dev *pctrldev)182{183 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);184 185 return info->num_funcs;186}187 188static const char *ltq_pmx_func_name(struct pinctrl_dev *pctrldev,189 unsigned selector)190{191 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);192 193 if (selector >= info->num_funcs)194 return NULL;195 196 return info->funcs[selector].name;197}198 199static int ltq_pmx_get_groups(struct pinctrl_dev *pctrldev,200 unsigned func,201 const char * const **groups,202 unsigned * const num_groups)203{204 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);205 206 *groups = info->funcs[func].groups;207 *num_groups = info->funcs[func].num_groups;208 209 return 0;210}211 212/* Return function number. If failure, return negative value. */213static int match_mux(const struct ltq_mfp_pin *mfp, unsigned mux)214{215 int i;216 for (i = 0; i < LTQ_MAX_MUX; i++) {217 if (mfp->func[i] == mux)218 break;219 }220 if (i >= LTQ_MAX_MUX)221 return -EINVAL;222 return i;223}224 225/* don't assume .mfp is linearly mapped. find the mfp with the correct .pin */226static int match_mfp(const struct ltq_pinmux_info *info, int pin)227{228 int i;229 for (i = 0; i < info->num_mfp; i++) {230 if (info->mfp[i].pin == pin)231 return i;232 }233 return -1;234}235 236/* check whether current pin configuration is valid. Negative for failure */237static int match_group_mux(const struct ltq_pin_group *grp,238 const struct ltq_pinmux_info *info,239 unsigned mux)240{241 int i, pin, ret = 0;242 for (i = 0; i < grp->npins; i++) {243 pin = match_mfp(info, grp->pins[i]);244 if (pin < 0) {245 dev_err(info->dev, "could not find mfp for pin %d\n",246 grp->pins[i]);247 return -EINVAL;248 }249 ret = match_mux(&info->mfp[pin], mux);250 if (ret < 0) {251 dev_err(info->dev, "Can't find mux %d on pin%d\n",252 mux, pin);253 break;254 }255 }256 return ret;257}258 259static int ltq_pmx_set(struct pinctrl_dev *pctrldev,260 unsigned func,261 unsigned group)262{263 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);264 const struct ltq_pin_group *pin_grp = &info->grps[group];265 int i, pin, pin_func, ret;266 267 if (!pin_grp->npins ||268 (match_group_mux(pin_grp, info, pin_grp->mux) < 0)) {269 dev_err(info->dev, "Failed to set the pin group: %s\n",270 info->grps[group].name);271 return -EINVAL;272 }273 for (i = 0; i < pin_grp->npins; i++) {274 pin = match_mfp(info, pin_grp->pins[i]);275 if (pin < 0) {276 dev_err(info->dev, "could not find mfp for pin %d\n",277 pin_grp->pins[i]);278 return -EINVAL;279 }280 pin_func = match_mux(&info->mfp[pin], pin_grp->mux);281 ret = info->apply_mux(pctrldev, pin, pin_func);282 if (ret) {283 dev_err(info->dev,284 "failed to apply mux %d for pin %d\n",285 pin_func, pin);286 return ret;287 }288 }289 return 0;290}291 292static int ltq_pmx_gpio_request_enable(struct pinctrl_dev *pctrldev,293 struct pinctrl_gpio_range *range,294 unsigned pin)295{296 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);297 int mfp = match_mfp(info, pin);298 int pin_func;299 300 if (mfp < 0) {301 dev_err(info->dev, "could not find mfp for pin %d\n", pin);302 return -EINVAL;303 }304 305 pin_func = match_mux(&info->mfp[mfp], 0);306 if (pin_func < 0) {307 dev_err(info->dev, "No GPIO function on pin%d\n", mfp);308 return -EINVAL;309 }310 311 return info->apply_mux(pctrldev, mfp, pin_func);312}313 314static const struct pinmux_ops ltq_pmx_ops = {315 .get_functions_count = ltq_pmx_func_count,316 .get_function_name = ltq_pmx_func_name,317 .get_function_groups = ltq_pmx_get_groups,318 .set_mux = ltq_pmx_set,319 .gpio_request_enable = ltq_pmx_gpio_request_enable,320};321 322/*323 * allow different socs to register with the generic part of the lanti324 * pinctrl code325 */326int ltq_pinctrl_register(struct platform_device *pdev,327 struct ltq_pinmux_info *info)328{329 struct pinctrl_desc *desc;330 331 if (!info)332 return -EINVAL;333 desc = info->desc;334 desc->pctlops = <q_pctrl_ops;335 desc->pmxops = <q_pmx_ops;336 info->dev = &pdev->dev;337 338 info->pctrl = devm_pinctrl_register(&pdev->dev, desc, info);339 if (IS_ERR(info->pctrl)) {340 dev_err(&pdev->dev, "failed to register LTQ pinmux driver\n");341 return PTR_ERR(info->pctrl);342 }343 platform_set_drvdata(pdev, info);344 return 0;345}346