Loading...
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
18static 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
24static 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
33static 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
46static 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
58static 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
65static 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
137static 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
147static 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
171static 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
180static 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
187static 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
198static 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. */
212static 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 */
225static 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 */
236static 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
258static 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
291static 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
313static 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 */
325int 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}
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/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 lanti
324 * pinctrl code
325 */
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}