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