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