1
2
3
4
5
6
7
8
9
10
11#include <linux/module.h>
12#include <linux/device.h>
13#include <linux/io.h>
14#include <linux/platform_device.h>
15#include <linux/slab.h>
16#include <linux/of.h>
17#include <linux/pinctrl/pinctrl.h>
18#include <linux/pinctrl/pinconf.h>
19#include <linux/pinctrl/pinmux.h>
20#include <linux/pinctrl/consumer.h>
21#include <linux/pinctrl/machine.h>
22
23#include <asm/mach-ralink/ralink_regs.h>
24#include <asm/mach-ralink/pinmux.h>
25#include <asm/mach-ralink/mt7620.h>
26
27#include "core.h"
28
29#define SYSC_REG_GPIO_MODE 0x60
30#define SYSC_REG_GPIO_MODE2 0x64
31
32struct rt2880_priv {
33 struct device *dev;
34
35 struct pinctrl_pin_desc *pads;
36 struct pinctrl_desc *desc;
37
38 struct rt2880_pmx_func **func;
39 int func_count;
40
41 struct rt2880_pmx_group *groups;
42 const char **group_names;
43 int group_count;
44
45 uint8_t *gpio;
46 int max_pins;
47};
48
49static int rt2880_get_group_count(struct pinctrl_dev *pctrldev)
50{
51 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
52
53 return p->group_count;
54}
55
56static const char *rt2880_get_group_name(struct pinctrl_dev *pctrldev,
57 unsigned group)
58{
59 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
60
61 if (group >= p->group_count)
62 return NULL;
63
64 return p->group_names[group];
65}
66
67static int rt2880_get_group_pins(struct pinctrl_dev *pctrldev,
68 unsigned group,
69 const unsigned **pins,
70 unsigned *num_pins)
71{
72 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
73
74 if (group >= p->group_count)
75 return -EINVAL;
76
77 *pins = p->groups[group].func[0].pins;
78 *num_pins = p->groups[group].func[0].pin_count;
79
80 return 0;
81}
82
83static void rt2880_pinctrl_dt_free_map(struct pinctrl_dev *pctrldev,
84 struct pinctrl_map *map, unsigned num_maps)
85{
86 int i;
87
88 for (i = 0; i < num_maps; i++)
89 if (map[i].type == PIN_MAP_TYPE_CONFIGS_PIN ||
90 map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP)
91 kfree(map[i].data.configs.configs);
92 kfree(map);
93}
94
95static void rt2880_pinctrl_pin_dbg_show(struct pinctrl_dev *pctrldev,
96 struct seq_file *s,
97 unsigned offset)
98{
99 seq_printf(s, "ralink pio");
100}
101
102static void rt2880_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctrldev,
103 struct device_node *np,
104 struct pinctrl_map **map)
105{
106 const char *function;
107 int func = of_property_read_string(np, "ralink,function", &function);
108 int grps = of_property_count_strings(np, "ralink,group");
109 int i;
110
111 if (func || !grps)
112 return;
113
114 for (i = 0; i < grps; i++) {
115 const char *group;
116
117 of_property_read_string_index(np, "ralink,group", i, &group);
118
119 (*map)->type = PIN_MAP_TYPE_MUX_GROUP;
120 (*map)->name = function;
121 (*map)->data.mux.group = group;
122 (*map)->data.mux.function = function;
123 (*map)++;
124 }
125}
126
127static int rt2880_pinctrl_dt_node_to_map(struct pinctrl_dev *pctrldev,
128 struct device_node *np_config,
129 struct pinctrl_map **map,
130 unsigned *num_maps)
131{
132 int max_maps = 0;
133 struct pinctrl_map *tmp;
134 struct device_node *np;
135
136 for_each_child_of_node(np_config, np) {
137 int ret = of_property_count_strings(np, "ralink,group");
138
139 if (ret >= 0)
140 max_maps += ret;
141 }
142
143 if (!max_maps)
144 return max_maps;
145
146 *map = kzalloc(max_maps * sizeof(struct pinctrl_map), GFP_KERNEL);
147 if (!*map)
148 return -ENOMEM;
149
150 tmp = *map;
151
152 for_each_child_of_node(np_config, np)
153 rt2880_pinctrl_dt_subnode_to_map(pctrldev, np, &tmp);
154 *num_maps = max_maps;
155
156 return 0;
157}
158
159static const struct pinctrl_ops rt2880_pctrl_ops = {
160 .get_groups_count = rt2880_get_group_count,
161 .get_group_name = rt2880_get_group_name,
162 .get_group_pins = rt2880_get_group_pins,
163 .pin_dbg_show = rt2880_pinctrl_pin_dbg_show,
164 .dt_node_to_map = rt2880_pinctrl_dt_node_to_map,
165 .dt_free_map = rt2880_pinctrl_dt_free_map,
166};
167
168static int rt2880_pmx_func_count(struct pinctrl_dev *pctrldev)
169{
170 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
171
172 return p->func_count;
173}
174
175static const char *rt2880_pmx_func_name(struct pinctrl_dev *pctrldev,
176 unsigned func)
177{
178 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
179
180 return p->func[func]->name;
181}
182
183static int rt2880_pmx_group_get_groups(struct pinctrl_dev *pctrldev,
184 unsigned func,
185 const char * const **groups,
186 unsigned * const num_groups)
187{
188 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
189
190 if (p->func[func]->group_count == 1)
191 *groups = &p->group_names[p->func[func]->groups[0]];
192 else
193 *groups = p->group_names;
194
195 *num_groups = p->func[func]->group_count;
196
197 return 0;
198}
199
200static int rt2880_pmx_group_enable(struct pinctrl_dev *pctrldev,
201 unsigned func,
202 unsigned group)
203{
204 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
205 u32 mode = 0;
206 u32 reg = SYSC_REG_GPIO_MODE;
207 int i;
208 int shift;
209
210
211 if (p->groups[group].enabled) {
212 dev_err(p->dev, "%s is already enabled\n", p->groups[group].name);
213 return -EBUSY;
214 }
215
216 p->groups[group].enabled = 1;
217 p->func[func]->enabled = 1;
218
219 shift = p->groups[group].shift;
220 if (shift >= 32) {
221 shift -= 32;
222 reg = SYSC_REG_GPIO_MODE2;
223 }
224 mode = rt_sysc_r32(reg);
225 mode &= ~(p->groups[group].mask << shift);
226
227
228 for (i = 0; i < p->groups[group].func[0].pin_count; i++)
229 p->gpio[p->groups[group].func[0].pins[i]] = 1;
230
231
232 if (func == 0) {
233 mode |= p->groups[group].gpio << shift;
234 } else {
235 for (i = 0; i < p->func[func]->pin_count; i++)
236 p->gpio[p->func[func]->pins[i]] = 0;
237 mode |= p->func[func]->value << shift;
238 }
239 rt_sysc_w32(mode, reg);
240
241 return 0;
242}
243
244static int rt2880_pmx_group_gpio_request_enable(struct pinctrl_dev *pctrldev,
245 struct pinctrl_gpio_range *range,
246 unsigned pin)
247{
248 struct rt2880_priv *p = pinctrl_dev_get_drvdata(pctrldev);
249
250 if (!p->gpio[pin]) {
251 dev_err(p->dev, "pin %d is not set to gpio mux\n", pin);
252 return -EINVAL;
253 }
254
255 return 0;
256}
257
258static const struct pinmux_ops rt2880_pmx_group_ops = {
259 .get_functions_count = rt2880_pmx_func_count,
260 .get_function_name = rt2880_pmx_func_name,
261 .get_function_groups = rt2880_pmx_group_get_groups,
262 .set_mux = rt2880_pmx_group_enable,
263 .gpio_request_enable = rt2880_pmx_group_gpio_request_enable,
264};
265
266static struct pinctrl_desc rt2880_pctrl_desc = {
267 .owner = THIS_MODULE,
268 .name = "rt2880-pinmux",
269 .pctlops = &rt2880_pctrl_ops,
270 .pmxops = &rt2880_pmx_group_ops,
271};
272
273static struct rt2880_pmx_func gpio_func = {
274 .name = "gpio",
275};
276
277static int rt2880_pinmux_index(struct rt2880_priv *p)
278{
279 struct rt2880_pmx_func **f;
280 struct rt2880_pmx_group *mux = p->groups;
281 int i, j, c = 0;
282
283
284 while (mux->name) {
285 p->group_count++;
286 mux++;
287 }
288
289
290 p->group_names = devm_kzalloc(p->dev, sizeof(char *) * p->group_count, GFP_KERNEL);
291 if (!p->group_names)
292 return -1;
293
294 for (i = 0; i < p->group_count; i++) {
295 p->group_names[i] = p->groups[i].name;
296 p->func_count += p->groups[i].func_count;
297 }
298
299
300 p->func_count++;
301
302
303 f = p->func = devm_kzalloc(p->dev, sizeof(struct rt2880_pmx_func) * p->func_count, GFP_KERNEL);
304 gpio_func.groups = devm_kzalloc(p->dev, sizeof(int) * p->group_count, GFP_KERNEL);
305 if (!f || !gpio_func.groups)
306 return -1;
307
308
309 gpio_func.group_count = p->group_count;
310 for (i = 0; i < gpio_func.group_count; i++)
311 gpio_func.groups[i] = i;
312
313 f[c] = &gpio_func;
314 c++;
315
316
317 for (i = 0; i < p->group_count; i++) {
318 for (j = 0; j < p->groups[i].func_count; j++) {
319 f[c] = &p->groups[i].func[j];
320 f[c]->groups = devm_kzalloc(p->dev, sizeof(int), GFP_KERNEL);
321 f[c]->groups[0] = i;
322 f[c]->group_count = 1;
323 c++;
324 }
325 }
326 return 0;
327}
328
329static int rt2880_pinmux_pins(struct rt2880_priv *p)
330{
331 int i, j;
332
333
334 for (i = 0; i < p->func_count; i++) {
335 int pin;
336
337 if (!p->func[i]->pin_count)
338 continue;
339
340 p->func[i]->pins = devm_kzalloc(p->dev, sizeof(int) * p->func[i]->pin_count, GFP_KERNEL);
341 for (j = 0; j < p->func[i]->pin_count; j++)
342 p->func[i]->pins[j] = p->func[i]->pin_first + j;
343
344 pin = p->func[i]->pin_first + p->func[i]->pin_count;
345 if (pin > p->max_pins)
346 p->max_pins = pin;
347 }
348
349
350 p->gpio = devm_kzalloc(p->dev,sizeof(uint8_t) * p->max_pins,
351 GFP_KERNEL);
352
353 p->pads = devm_kzalloc(p->dev,
354 sizeof(struct pinctrl_pin_desc) * p->max_pins,
355 GFP_KERNEL);
356 if (!p->pads || !p->gpio ) {
357 dev_err(p->dev, "Failed to allocate gpio data\n");
358 return -ENOMEM;
359 }
360
361 memset(p->gpio, 1, sizeof(uint8_t) * p->max_pins);
362 for (i = 0; i < p->func_count; i++) {
363 if (!p->func[i]->pin_count)
364 continue;
365
366 for (j = 0; j < p->func[i]->pin_count; j++)
367 p->gpio[p->func[i]->pins[j]] = 0;
368 }
369
370
371 p->gpio[0] = 1;
372
373
374 for (i = 0; i < p->max_pins; i++) {
375
376 char *name = devm_kzalloc(p->dev, 5, GFP_KERNEL);
377
378 if (!name) {
379 dev_err(p->dev, "Failed to allocate pad name\n");
380 return -ENOMEM;
381 }
382 snprintf(name, 5, "io%d", i);
383 p->pads[i].number = i;
384 p->pads[i].name = name;
385 }
386 p->desc->pins = p->pads;
387 p->desc->npins = p->max_pins;
388
389 return 0;
390}
391
392static int rt2880_pinmux_probe(struct platform_device *pdev)
393{
394 struct rt2880_priv *p;
395 struct pinctrl_dev *dev;
396 struct device_node *np;
397
398 if (!rt2880_pinmux_data)
399 return -ENOSYS;
400
401
402 p = devm_kzalloc(&pdev->dev, sizeof(struct rt2880_priv), GFP_KERNEL);
403 if (!p)
404 return -ENOMEM;
405
406 p->dev = &pdev->dev;
407 p->desc = &rt2880_pctrl_desc;
408 p->groups = rt2880_pinmux_data;
409 platform_set_drvdata(pdev, p);
410
411
412 if (rt2880_pinmux_index(p)) {
413 dev_err(&pdev->dev, "failed to load index\n");
414 return -EINVAL;
415 }
416 if (rt2880_pinmux_pins(p)) {
417 dev_err(&pdev->dev, "failed to load pins\n");
418 return -EINVAL;
419 }
420 dev = pinctrl_register(p->desc, &pdev->dev, p);
421 if (IS_ERR(dev))
422 return PTR_ERR(dev);
423
424
425 for_each_compatible_node(np, NULL, "ralink,rt2880-gpio") {
426 const __be32 *ngpio, *gpiobase;
427 struct pinctrl_gpio_range *range;
428 char *name;
429
430 if (!of_device_is_available(np))
431 continue;
432
433 ngpio = of_get_property(np, "ralink,num-gpios", NULL);
434 gpiobase = of_get_property(np, "ralink,gpio-base", NULL);
435 if (!ngpio || !gpiobase) {
436 dev_err(&pdev->dev, "failed to load chip info\n");
437 return -EINVAL;
438 }
439
440 range = devm_kzalloc(p->dev, sizeof(struct pinctrl_gpio_range) + 4, GFP_KERNEL);
441 range->name = name = (char *) &range[1];
442 sprintf(name, "pio");
443 range->npins = __be32_to_cpu(*ngpio);
444 range->base = __be32_to_cpu(*gpiobase);
445 range->pin_base = range->base;
446 pinctrl_add_gpio_range(dev, range);
447 }
448
449 return 0;
450}
451
452static const struct of_device_id rt2880_pinmux_match[] = {
453 { .compatible = "ralink,rt2880-pinmux" },
454 {},
455};
456MODULE_DEVICE_TABLE(of, rt2880_pinmux_match);
457
458static struct platform_driver rt2880_pinmux_driver = {
459 .probe = rt2880_pinmux_probe,
460 .driver = {
461 .name = "rt2880-pinmux",
462 .owner = THIS_MODULE,
463 .of_match_table = rt2880_pinmux_match,
464 },
465};
466
467int __init rt2880_pinmux_init(void)
468{
469 return platform_driver_register(&rt2880_pinmux_driver);
470}
471
472core_initcall_sync(rt2880_pinmux_init);
473