pinctrl-lantiq.c 8.6 KB

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