?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[cris-mirror.git] / drivers / pinctrl / stm32 / pinctrl-stm32.c
blob4ae596bf19b5b594a0f8fd1807a8d7d8599b5679
1 /*
2 * Copyright (C) Maxime Coquelin 2015
3 * Author: Maxime Coquelin <mcoquelin.stm32@gmail.com>
4 * License terms: GNU General Public License (GPL), version 2
5 *
6 * Heavily based on Mediatek's pinctrl driver
7 */
8 #include <linux/clk.h>
9 #include <linux/gpio/driver.h>
10 #include <linux/io.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/of_address.h>
14 #include <linux/of_device.h>
15 #include <linux/of_irq.h>
16 #include <linux/pinctrl/consumer.h>
17 #include <linux/pinctrl/machine.h>
18 #include <linux/pinctrl/pinconf.h>
19 #include <linux/pinctrl/pinconf-generic.h>
20 #include <linux/pinctrl/pinctrl.h>
21 #include <linux/pinctrl/pinmux.h>
22 #include <linux/platform_device.h>
23 #include <linux/reset.h>
24 #include <linux/slab.h>
25
26 #include "../core.h"
27 #include "../pinconf.h"
28 #include "../pinctrl-utils.h"
29 #include "pinctrl-stm32.h"
30
31 #define STM32_GPIO_MODER 0x00
32 #define STM32_GPIO_TYPER 0x04
33 #define STM32_GPIO_SPEEDR 0x08
34 #define STM32_GPIO_PUPDR 0x0c
35 #define STM32_GPIO_IDR 0x10
36 #define STM32_GPIO_ODR 0x14
37 #define STM32_GPIO_BSRR 0x18
38 #define STM32_GPIO_LCKR 0x1c
39 #define STM32_GPIO_AFRL 0x20
40 #define STM32_GPIO_AFRH 0x24
41
42 #define STM32_GPIO_PINS_PER_BANK 16
43
44 #define gpio_range_to_bank(chip) \
45 container_of(chip, struct stm32_gpio_bank, range)
46
47 static const char * const stm32_gpio_functions[] = {
48 "gpio", "af0", "af1",
49 "af2", "af3", "af4",
50 "af5", "af6", "af7",
51 "af8", "af9", "af10",
52 "af11", "af12", "af13",
53 "af14", "af15", "analog",
54 };
55
56 struct stm32_pinctrl_group {
57 const char *name;
58 unsigned long config;
59 unsigned pin;
60 };
61
62 struct stm32_gpio_bank {
63 void __iomem *base;
64 struct clk *clk;
65 spinlock_t lock;
66 struct gpio_chip gpio_chip;
67 struct pinctrl_gpio_range range;
68 };
69
70 struct stm32_pinctrl {
71 struct device *dev;
72 struct pinctrl_dev *pctl_dev;
73 struct pinctrl_desc pctl_desc;
74 struct stm32_pinctrl_group *groups;
75 unsigned ngroups;
76 const char **grp_names;
77 struct stm32_gpio_bank *banks;
78 unsigned nbanks;
79 const struct stm32_pinctrl_match_data *match_data;
80 };
81
82 static inline int stm32_gpio_pin(int gpio)
83 {
84 return gpio % STM32_GPIO_PINS_PER_BANK;
85 }
86
87 static inline u32 stm32_gpio_get_mode(u32 function)
88 {
89 switch (function) {
90 case STM32_PIN_GPIO:
91 return 0;
92 case STM32_PIN_AF(0) ... STM32_PIN_AF(15):
93 return 2;
94 case STM32_PIN_ANALOG:
95 return 3;
96 }
97
98 return 0;
99 }
100
101 static inline u32 stm32_gpio_get_alt(u32 function)
102 {
103 switch (function) {
104 case STM32_PIN_GPIO:
105 return 0;
106 case STM32_PIN_AF(0) ... STM32_PIN_AF(15):
107 return function - 1;
108 case STM32_PIN_ANALOG:
109 return 0;
110 }
111
112 return 0;
113 }
114
115 /* GPIO functions */
116
117 static inline void __stm32_gpio_set(struct stm32_gpio_bank *bank,
118 unsigned offset, int value)
119 {
120 if (!value)
121 offset += STM32_GPIO_PINS_PER_BANK;
122
123 clk_enable(bank->clk);
124
125 writel_relaxed(BIT(offset), bank->base + STM32_GPIO_BSRR);
126
127 clk_disable(bank->clk);
128 }
129
130 static int stm32_gpio_request(struct gpio_chip *chip, unsigned offset)
131 {
132 return pinctrl_request_gpio(chip->base + offset);
133 }
134
135 static void stm32_gpio_free(struct gpio_chip *chip, unsigned offset)
136 {
137 pinctrl_free_gpio(chip->base + offset);
138 }
139
140 static int stm32_gpio_get(struct gpio_chip *chip, unsigned offset)
141 {
142 struct stm32_gpio_bank *bank = gpiochip_get_data(chip);
143 int ret;
144
145 clk_enable(bank->clk);
146
147 ret = !!(readl_relaxed(bank->base + STM32_GPIO_IDR) & BIT(offset));
148
149 clk_disable(bank->clk);
150
151 return ret;
152 }
153
154 static void stm32_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
155 {
156 struct stm32_gpio_bank *bank = gpiochip_get_data(chip);
157
158 __stm32_gpio_set(bank, offset, value);
159 }
160
161 static int stm32_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
162 {
163 return pinctrl_gpio_direction_input(chip->base + offset);
164 }
165
166 static int stm32_gpio_direction_output(struct gpio_chip *chip,
167 unsigned offset, int value)
168 {
169 struct stm32_gpio_bank *bank = gpiochip_get_data(chip);
170
171 __stm32_gpio_set(bank, offset, value);
172 pinctrl_gpio_direction_output(chip->base + offset);
173
174 return 0;
175 }
176
177 static struct gpio_chip stm32_gpio_template = {
178 .request = stm32_gpio_request,
179 .free = stm32_gpio_free,
180 .get = stm32_gpio_get,
181 .set = stm32_gpio_set,
182 .direction_input = stm32_gpio_direction_input,
183 .direction_output = stm32_gpio_direction_output,
184 };
185
186 /* Pinctrl functions */
187
188 static struct stm32_pinctrl_group *
189 stm32_pctrl_find_group_by_pin(struct stm32_pinctrl *pctl, u32 pin)
190 {
191 int i;
192
193 for (i = 0; i < pctl->ngroups; i++) {
194 struct stm32_pinctrl_group *grp = pctl->groups + i;
195
196 if (grp->pin == pin)
197 return grp;
198 }
199
200 return NULL;
201 }
202
203 static bool stm32_pctrl_is_function_valid(struct stm32_pinctrl *pctl,
204 u32 pin_num, u32 fnum)
205 {
206 int i;
207
208 for (i = 0; i < pctl->match_data->npins; i++) {
209 const struct stm32_desc_pin *pin = pctl->match_data->pins + i;
210 const struct stm32_desc_function *func = pin->functions;
211
212 if (pin->pin.number != pin_num)
213 continue;
214
215 while (func && func->name) {
216 if (func->num == fnum)
217 return true;
218 func++;
219 }
220
221 break;
222 }
223
224 return false;
225 }
226
227 static int stm32_pctrl_dt_node_to_map_func(struct stm32_pinctrl *pctl,
228 u32 pin, u32 fnum, struct stm32_pinctrl_group *grp,
229 struct pinctrl_map **map, unsigned *reserved_maps,
230 unsigned *num_maps)
231 {
232 if (*num_maps == *reserved_maps)
233 return -ENOSPC;
234
235 (*map)[*num_maps].type = PIN_MAP_TYPE_MUX_GROUP;
236 (*map)[*num_maps].data.mux.group = grp->name;
237
238 if (!stm32_pctrl_is_function_valid(pctl, pin, fnum)) {
239 dev_err(pctl->dev, "invalid function %d on pin %d .\n",
240 fnum, pin);
241 return -EINVAL;
242 }
243
244 (*map)[*num_maps].data.mux.function = stm32_gpio_functions[fnum];
245 (*num_maps)++;
246
247 return 0;
248 }
249
250 static int stm32_pctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
251 struct device_node *node,
252 struct pinctrl_map **map,
253 unsigned *reserved_maps,
254 unsigned *num_maps)
255 {
256 struct stm32_pinctrl *pctl;
257 struct stm32_pinctrl_group *grp;
258 struct property *pins;
259 u32 pinfunc, pin, func;
260 unsigned long *configs;
261 unsigned int num_configs;
262 bool has_config = 0;
263 unsigned reserve = 0;
264 int num_pins, num_funcs, maps_per_pin, i, err;
265
266 pctl = pinctrl_dev_get_drvdata(pctldev);
267
268 pins = of_find_property(node, "pinmux", NULL);
269 if (!pins) {
270 dev_err(pctl->dev, "missing pins property in node %s .\n",
271 node->name);
272 return -EINVAL;
273 }
274
275 err = pinconf_generic_parse_dt_config(node, pctldev, &configs,
276 &num_configs);
277 if (err)
278 return err;
279
280 if (num_configs)
281 has_config = 1;
282
283 num_pins = pins->length / sizeof(u32);
284 num_funcs = num_pins;
285 maps_per_pin = 0;
286 if (num_funcs)
287 maps_per_pin++;
288 if (has_config && num_pins >= 1)
289 maps_per_pin++;
290
291 if (!num_pins || !maps_per_pin)
292 return -EINVAL;
293
294 reserve = num_pins * maps_per_pin;
295
296 err = pinctrl_utils_reserve_map(pctldev, map,
297 reserved_maps, num_maps, reserve);
298 if (err)
299 return err;
300
301 for (i = 0; i < num_pins; i++) {
302 err = of_property_read_u32_index(node, "pinmux",
303 i, &pinfunc);
304 if (err)
305 return err;
306
307 pin = STM32_GET_PIN_NO(pinfunc);
308 func = STM32_GET_PIN_FUNC(pinfunc);
309
310 if (pin >= pctl->match_data->npins) {
311 dev_err(pctl->dev, "invalid pin number.\n");
312 return -EINVAL;
313 }
314
315 if (!stm32_pctrl_is_function_valid(pctl, pin, func)) {
316 dev_err(pctl->dev, "invalid function.\n");
317 return -EINVAL;
318 }
319
320 grp = stm32_pctrl_find_group_by_pin(pctl, pin);
321 if (!grp) {
322 dev_err(pctl->dev, "unable to match pin %d to group\n",
323 pin);
324 return -EINVAL;
325 }
326
327 err = stm32_pctrl_dt_node_to_map_func(pctl, pin, func, grp, map,
328 reserved_maps, num_maps);
329 if (err)
330 return err;
331
332 if (has_config) {
333 err = pinctrl_utils_add_map_configs(pctldev, map,
334 reserved_maps, num_maps, grp->name,
335 configs, num_configs,
336 PIN_MAP_TYPE_CONFIGS_GROUP);
337 if (err)
338 return err;
339 }
340 }
341
342 return 0;
343 }
344
345 static int stm32_pctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
346 struct device_node *np_config,
347 struct pinctrl_map **map, unsigned *num_maps)
348 {
349 struct device_node *np;
350 unsigned reserved_maps;
351 int ret;
352
353 *map = NULL;
354 *num_maps = 0;
355 reserved_maps = 0;
356
357 for_each_child_of_node(np_config, np) {
358 ret = stm32_pctrl_dt_subnode_to_map(pctldev, np, map,
359 &reserved_maps, num_maps);
360 if (ret < 0) {
361 pinctrl_utils_free_map(pctldev, *map, *num_maps);
362 return ret;
363 }
364 }
365
366 return 0;
367 }
368
369 static int stm32_pctrl_get_groups_count(struct pinctrl_dev *pctldev)
370 {
371 struct stm32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
372
373 return pctl->ngroups;
374 }
375
376 static const char *stm32_pctrl_get_group_name(struct pinctrl_dev *pctldev,
377 unsigned group)
378 {
379 struct stm32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
380
381 return pctl->groups[group].name;
382 }
383
384 static int stm32_pctrl_get_group_pins(struct pinctrl_dev *pctldev,
385 unsigned group,
386 const unsigned **pins,
387 unsigned *num_pins)
388 {
389 struct stm32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
390
391 *pins = (unsigned *)&pctl->groups[group].pin;
392 *num_pins = 1;
393
394 return 0;
395 }
396
397 static const struct pinctrl_ops stm32_pctrl_ops = {
398 .dt_node_to_map = stm32_pctrl_dt_node_to_map,
399 .dt_free_map = pinctrl_utils_free_map,
400 .get_groups_count = stm32_pctrl_get_groups_count,
401 .get_group_name = stm32_pctrl_get_group_name,
402 .get_group_pins = stm32_pctrl_get_group_pins,
403 };
404
405
406 /* Pinmux functions */
407
408 static int stm32_pmx_get_funcs_cnt(struct pinctrl_dev *pctldev)
409 {
410 return ARRAY_SIZE(stm32_gpio_functions);
411 }
412
413 static const char *stm32_pmx_get_func_name(struct pinctrl_dev *pctldev,
414 unsigned selector)
415 {
416 return stm32_gpio_functions[selector];
417 }
418
419 static int stm32_pmx_get_func_groups(struct pinctrl_dev *pctldev,
420 unsigned function,
421 const char * const **groups,
422 unsigned * const num_groups)
423 {
424 struct stm32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
425
426 *groups = pctl->grp_names;
427 *num_groups = pctl->ngroups;
428
429 return 0;
430 }
431
432 static void stm32_pmx_set_mode(struct stm32_gpio_bank *bank,
433 int pin, u32 mode, u32 alt)
434 {
435 u32 val;
436 int alt_shift = (pin % 8) * 4;
437 int alt_offset = STM32_GPIO_AFRL + (pin / 8) * 4;
438 unsigned long flags;
439
440 clk_enable(bank->clk);
441 spin_lock_irqsave(&bank->lock, flags);
442
443 val = readl_relaxed(bank->base + alt_offset);
444 val &= ~GENMASK(alt_shift + 3, alt_shift);
445 val |= (alt << alt_shift);
446 writel_relaxed(val, bank->base + alt_offset);
447
448 val = readl_relaxed(bank->base + STM32_GPIO_MODER);
449 val &= ~GENMASK(pin * 2 + 1, pin * 2);
450 val |= mode << (pin * 2);
451 writel_relaxed(val, bank->base + STM32_GPIO_MODER);
452
453 spin_unlock_irqrestore(&bank->lock, flags);
454 clk_disable(bank->clk);
455 }
456
457 static void stm32_pmx_get_mode(struct stm32_gpio_bank *bank,
458 int pin, u32 *mode, u32 *alt)
459 {
460 u32 val;
461 int alt_shift = (pin % 8) * 4;
462 int alt_offset = STM32_GPIO_AFRL + (pin / 8) * 4;
463 unsigned long flags;
464
465 clk_enable(bank->clk);
466 spin_lock_irqsave(&bank->lock, flags);
467
468 val = readl_relaxed(bank->base + alt_offset);
469 val &= GENMASK(alt_shift + 3, alt_shift);
470 *alt = val >> alt_shift;
471
472 val = readl_relaxed(bank->base + STM32_GPIO_MODER);
473 val &= GENMASK(pin * 2 + 1, pin * 2);
474 *mode = val >> (pin * 2);
475
476 spin_unlock_irqrestore(&bank->lock, flags);
477 clk_disable(bank->clk);
478 }
479
480 static int stm32_pmx_set_mux(struct pinctrl_dev *pctldev,
481 unsigned function,
482 unsigned group)
483 {
484 bool ret;
485 struct stm32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
486 struct stm32_pinctrl_group *g = pctl->groups + group;
487 struct pinctrl_gpio_range *range;
488 struct stm32_gpio_bank *bank;
489 u32 mode, alt;
490 int pin;
491
492 ret = stm32_pctrl_is_function_valid(pctl, g->pin, function);
493 if (!ret) {
494 dev_err(pctl->dev, "invalid function %d on group %d .\n",
495 function, group);
496 return -EINVAL;
497 }
498
499 range = pinctrl_find_gpio_range_from_pin(pctldev, g->pin);
500 bank = gpio_range_to_bank(range);
501 pin = stm32_gpio_pin(g->pin);
502
503 mode = stm32_gpio_get_mode(function);
504 alt = stm32_gpio_get_alt(function);
505
506 stm32_pmx_set_mode(bank, pin, mode, alt);
507
508 return 0;
509 }
510
511 static int stm32_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
512 struct pinctrl_gpio_range *range, unsigned gpio,
513 bool input)
514 {
515 struct stm32_gpio_bank *bank = gpio_range_to_bank(range);
516 int pin = stm32_gpio_pin(gpio);
517
518 stm32_pmx_set_mode(bank, pin, !input, 0);
519
520 return 0;
521 }
522
523 static const struct pinmux_ops stm32_pmx_ops = {
524 .get_functions_count = stm32_pmx_get_funcs_cnt,
525 .get_function_name = stm32_pmx_get_func_name,
526 .get_function_groups = stm32_pmx_get_func_groups,
527 .set_mux = stm32_pmx_set_mux,
528 .gpio_set_direction = stm32_pmx_gpio_set_direction,
529 };
530
531 /* Pinconf functions */
532
533 static void stm32_pconf_set_driving(struct stm32_gpio_bank *bank,
534 unsigned offset, u32 drive)
535 {
536 unsigned long flags;
537 u32 val;
538
539 clk_enable(bank->clk);
540 spin_lock_irqsave(&bank->lock, flags);
541
542 val = readl_relaxed(bank->base + STM32_GPIO_TYPER);
543 val &= ~BIT(offset);
544 val |= drive << offset;
545 writel_relaxed(val, bank->base + STM32_GPIO_TYPER);
546
547 spin_unlock_irqrestore(&bank->lock, flags);
548 clk_disable(bank->clk);
549 }
550
551 static u32 stm32_pconf_get_driving(struct stm32_gpio_bank *bank,
552 unsigned int offset)
553 {
554 unsigned long flags;
555 u32 val;
556
557 clk_enable(bank->clk);
558 spin_lock_irqsave(&bank->lock, flags);
559
560 val = readl_relaxed(bank->base + STM32_GPIO_TYPER);
561 val &= BIT(offset);
562
563 spin_unlock_irqrestore(&bank->lock, flags);
564 clk_disable(bank->clk);
565
566 return (val >> offset);
567 }
568
569 static void stm32_pconf_set_speed(struct stm32_gpio_bank *bank,
570 unsigned offset, u32 speed)
571 {
572 unsigned long flags;
573 u32 val;
574
575 clk_enable(bank->clk);
576 spin_lock_irqsave(&bank->lock, flags);
577
578 val = readl_relaxed(bank->base + STM32_GPIO_SPEEDR);
579 val &= ~GENMASK(offset * 2 + 1, offset * 2);
580 val |= speed << (offset * 2);
581 writel_relaxed(val, bank->base + STM32_GPIO_SPEEDR);
582
583 spin_unlock_irqrestore(&bank->lock, flags);
584 clk_disable(bank->clk);
585 }
586
587 static u32 stm32_pconf_get_speed(struct stm32_gpio_bank *bank,
588 unsigned int offset)
589 {
590 unsigned long flags;
591 u32 val;
592
593 clk_enable(bank->clk);
594 spin_lock_irqsave(&bank->lock, flags);
595
596 val = readl_relaxed(bank->base + STM32_GPIO_SPEEDR);
597 val &= GENMASK(offset * 2 + 1, offset * 2);
598
599 spin_unlock_irqrestore(&bank->lock, flags);
600 clk_disable(bank->clk);
601
602 return (val >> (offset * 2));
603 }
604
605 static void stm32_pconf_set_bias(struct stm32_gpio_bank *bank,
606 unsigned offset, u32 bias)
607 {
608 unsigned long flags;
609 u32 val;
610
611 clk_enable(bank->clk);
612 spin_lock_irqsave(&bank->lock, flags);
613
614 val = readl_relaxed(bank->base + STM32_GPIO_PUPDR);
615 val &= ~GENMASK(offset * 2 + 1, offset * 2);
616 val |= bias << (offset * 2);
617 writel_relaxed(val, bank->base + STM32_GPIO_PUPDR);
618
619 spin_unlock_irqrestore(&bank->lock, flags);
620 clk_disable(bank->clk);
621 }
622
623 static u32 stm32_pconf_get_bias(struct stm32_gpio_bank *bank,
624 unsigned int offset)
625 {
626 unsigned long flags;
627 u32 val;
628
629 clk_enable(bank->clk);
630 spin_lock_irqsave(&bank->lock, flags);
631
632 val = readl_relaxed(bank->base + STM32_GPIO_PUPDR);
633 val &= GENMASK(offset * 2 + 1, offset * 2);
634
635 spin_unlock_irqrestore(&bank->lock, flags);
636 clk_disable(bank->clk);
637
638 return (val >> (offset * 2));
639 }
640
641 static bool stm32_pconf_get(struct stm32_gpio_bank *bank,
642 unsigned int offset, bool dir)
643 {
644 unsigned long flags;
645 u32 val;
646
647 clk_enable(bank->clk);
648 spin_lock_irqsave(&bank->lock, flags);
649
650 if (dir)
651 val = !!(readl_relaxed(bank->base + STM32_GPIO_IDR) &
652 BIT(offset));
653 else
654 val = !!(readl_relaxed(bank->base + STM32_GPIO_ODR) &
655 BIT(offset));
656
657 spin_unlock_irqrestore(&bank->lock, flags);
658 clk_disable(bank->clk);
659
660 return val;
661 }
662
663 static int stm32_pconf_parse_conf(struct pinctrl_dev *pctldev,
664 unsigned int pin, enum pin_config_param param,
665 enum pin_config_param arg)
666 {
667 struct pinctrl_gpio_range *range;
668 struct stm32_gpio_bank *bank;
669 int offset, ret = 0;
670
671 range = pinctrl_find_gpio_range_from_pin(pctldev, pin);
672 bank = gpio_range_to_bank(range);
673 offset = stm32_gpio_pin(pin);
674
675 switch (param) {
676 case PIN_CONFIG_DRIVE_PUSH_PULL:
677 stm32_pconf_set_driving(bank, offset, 0);
678 break;
679 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
680 stm32_pconf_set_driving(bank, offset, 1);
681 break;
682 case PIN_CONFIG_SLEW_RATE:
683 stm32_pconf_set_speed(bank, offset, arg);
684 break;
685 case PIN_CONFIG_BIAS_DISABLE:
686 stm32_pconf_set_bias(bank, offset, 0);
687 break;
688 case PIN_CONFIG_BIAS_PULL_UP:
689 stm32_pconf_set_bias(bank, offset, 1);
690 break;
691 case PIN_CONFIG_BIAS_PULL_DOWN:
692 stm32_pconf_set_bias(bank, offset, 2);
693 break;
694 case PIN_CONFIG_OUTPUT:
695 __stm32_gpio_set(bank, offset, arg);
696 ret = stm32_pmx_gpio_set_direction(pctldev, NULL, pin, false);
697 break;
698 default:
699 ret = -EINVAL;
700 }
701
702 return ret;
703 }
704
705 static int stm32_pconf_group_get(struct pinctrl_dev *pctldev,
706 unsigned group,
707 unsigned long *config)
708 {
709 struct stm32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
710
711 *config = pctl->groups[group].config;
712
713 return 0;
714 }
715
716 static int stm32_pconf_group_set(struct pinctrl_dev *pctldev, unsigned group,
717 unsigned long *configs, unsigned num_configs)
718 {
719 struct stm32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
720 struct stm32_pinctrl_group *g = &pctl->groups[group];
721 int i, ret;
722
723 for (i = 0; i < num_configs; i++) {
724 ret = stm32_pconf_parse_conf(pctldev, g->pin,
725 pinconf_to_config_param(configs[i]),
726 pinconf_to_config_argument(configs[i]));
727 if (ret < 0)
728 return ret;
729
730 g->config = configs[i];
731 }
732
733 return 0;
734 }
735
736 static void stm32_pconf_dbg_show(struct pinctrl_dev *pctldev,
737 struct seq_file *s,
738 unsigned int pin)
739 {
740 struct pinctrl_gpio_range *range;
741 struct stm32_gpio_bank *bank;
742 int offset;
743 u32 mode, alt, drive, speed, bias;
744 static const char * const modes[] = {
745 "input", "output", "alternate", "analog" };
746 static const char * const speeds[] = {
747 "low", "medium", "high", "very high" };
748 static const char * const biasing[] = {
749 "floating", "pull up", "pull down", "" };
750 bool val;
751
752 range = pinctrl_find_gpio_range_from_pin_nolock(pctldev, pin);
753 bank = gpio_range_to_bank(range);
754 offset = stm32_gpio_pin(pin);
755
756 stm32_pmx_get_mode(bank, offset, &mode, &alt);
757 bias = stm32_pconf_get_bias(bank, offset);
758
759 seq_printf(s, "%s ", modes[mode]);
760
761 switch (mode) {
762 /* input */
763 case 0:
764 val = stm32_pconf_get(bank, offset, true);
765 seq_printf(s, "- %s - %s",
766 val ? "high" : "low",
767 biasing[bias]);
768 break;
769
770 /* output */
771 case 1:
772 drive = stm32_pconf_get_driving(bank, offset);
773 speed = stm32_pconf_get_speed(bank, offset);
774 val = stm32_pconf_get(bank, offset, false);
775 seq_printf(s, "- %s - %s - %s - %s %s",
776 val ? "high" : "low",
777 drive ? "open drain" : "push pull",
778 biasing[bias],
779 speeds[speed], "speed");
780 break;
781
782 /* alternate */
783 case 2:
784 drive = stm32_pconf_get_driving(bank, offset);
785 speed = stm32_pconf_get_speed(bank, offset);
786 seq_printf(s, "%d - %s - %s - %s %s", alt,
787 drive ? "open drain" : "push pull",
788 biasing[bias],
789 speeds[speed], "speed");
790 break;
791
792 /* analog */
793 case 3:
794 break;
795 }
796 }
797
798
799 static const struct pinconf_ops stm32_pconf_ops = {
800 .pin_config_group_get = stm32_pconf_group_get,
801 .pin_config_group_set = stm32_pconf_group_set,
802 .pin_config_dbg_show = stm32_pconf_dbg_show,
803 };
804
805 static int stm32_gpiolib_register_bank(struct stm32_pinctrl *pctl,
806 struct device_node *np)
807 {
808 int bank_nr = pctl->nbanks;
809 struct stm32_gpio_bank *bank = &pctl->banks[bank_nr];
810 struct pinctrl_gpio_range *range = &bank->range;
811 struct device *dev = pctl->dev;
812 struct resource res;
813 struct reset_control *rstc;
814 int err, npins;
815
816 rstc = of_reset_control_get(np, NULL);
817 if (!IS_ERR(rstc))
818 reset_control_deassert(rstc);
819
820 if (of_address_to_resource(np, 0, &res))
821 return -ENODEV;
822
823 bank->base = devm_ioremap_resource(dev, &res);
824 if (IS_ERR(bank->base))
825 return PTR_ERR(bank->base);
826
827 bank->clk = of_clk_get_by_name(np, NULL);
828 if (IS_ERR(bank->clk)) {
829 dev_err(dev, "failed to get clk (%ld)\n", PTR_ERR(bank->clk));
830 return PTR_ERR(bank->clk);
831 }
832
833 err = clk_prepare(bank->clk);
834 if (err) {
835 dev_err(dev, "failed to prepare clk (%d)\n", err);
836 return err;
837 }
838
839 npins = pctl->match_data->npins;
840 npins -= bank_nr * STM32_GPIO_PINS_PER_BANK;
841 if (npins < 0)
842 return -EINVAL;
843 else if (npins > STM32_GPIO_PINS_PER_BANK)
844 npins = STM32_GPIO_PINS_PER_BANK;
845
846 bank->gpio_chip = stm32_gpio_template;
847 bank->gpio_chip.base = bank_nr * STM32_GPIO_PINS_PER_BANK;
848 bank->gpio_chip.ngpio = npins;
849 bank->gpio_chip.of_node = np;
850 bank->gpio_chip.parent = dev;
851 spin_lock_init(&bank->lock);
852
853 of_property_read_string(np, "st,bank-name", &range->name);
854 bank->gpio_chip.label = range->name;
855
856 range->id = bank_nr;
857 range->pin_base = range->base = range->id * STM32_GPIO_PINS_PER_BANK;
858 range->npins = bank->gpio_chip.ngpio;
859 range->gc = &bank->gpio_chip;
860 err = gpiochip_add_data(&bank->gpio_chip, bank);
861 if (err) {
862 dev_err(dev, "Failed to add gpiochip(%d)!\n", bank_nr);
863 return err;
864 }
865
866 dev_info(dev, "%s bank added\n", range->name);
867 return 0;
868 }
869
870 static int stm32_pctrl_build_state(struct platform_device *pdev)
871 {
872 struct stm32_pinctrl *pctl = platform_get_drvdata(pdev);
873 int i;
874
875 pctl->ngroups = pctl->match_data->npins;
876
877 /* Allocate groups */
878 pctl->groups = devm_kcalloc(&pdev->dev, pctl->ngroups,
879 sizeof(*pctl->groups), GFP_KERNEL);
880 if (!pctl->groups)
881 return -ENOMEM;
882
883 /* We assume that one pin is one group, use pin name as group name. */
884 pctl->grp_names = devm_kcalloc(&pdev->dev, pctl->ngroups,
885 sizeof(*pctl->grp_names), GFP_KERNEL);
886 if (!pctl->grp_names)
887 return -ENOMEM;
888
889 for (i = 0; i < pctl->match_data->npins; i++) {
890 const struct stm32_desc_pin *pin = pctl->match_data->pins + i;
891 struct stm32_pinctrl_group *group = pctl->groups + i;
892
893 group->name = pin->pin.name;
894 group->pin = pin->pin.number;
895
896 pctl->grp_names[i] = pin->pin.name;
897 }
898
899 return 0;
900 }
901
902 int stm32_pctl_probe(struct platform_device *pdev)
903 {
904 struct device_node *np = pdev->dev.of_node;
905 struct device_node *child;
906 const struct of_device_id *match;
907 struct device *dev = &pdev->dev;
908 struct stm32_pinctrl *pctl;
909 struct pinctrl_pin_desc *pins;
910 int i, ret, banks = 0;
911
912 if (!np)
913 return -EINVAL;
914
915 match = of_match_device(dev->driver->of_match_table, dev);
916 if (!match || !match->data)
917 return -EINVAL;
918
919 if (!of_find_property(np, "pins-are-numbered", NULL)) {
920 dev_err(dev, "only support pins-are-numbered format\n");
921 return -EINVAL;
922 }
923
924 pctl = devm_kzalloc(dev, sizeof(*pctl), GFP_KERNEL);
925 if (!pctl)
926 return -ENOMEM;
927
928 platform_set_drvdata(pdev, pctl);
929
930 pctl->dev = dev;
931 pctl->match_data = match->data;
932 ret = stm32_pctrl_build_state(pdev);
933 if (ret) {
934 dev_err(dev, "build state failed: %d\n", ret);
935 return -EINVAL;
936 }
937
938 for_each_child_of_node(np, child)
939 if (of_property_read_bool(child, "gpio-controller"))
940 banks++;
941
942 if (!banks) {
943 dev_err(dev, "at least one GPIO bank is required\n");
944 return -EINVAL;
945 }
946
947 pctl->banks = devm_kcalloc(dev, banks, sizeof(*pctl->banks),
948 GFP_KERNEL);
949 if (!pctl->banks)
950 return -ENOMEM;
951
952 for_each_child_of_node(np, child) {
953 if (of_property_read_bool(child, "gpio-controller")) {
954 ret = stm32_gpiolib_register_bank(pctl, child);
955 if (ret)
956 return ret;
957
958 pctl->nbanks++;
959 }
960 }
961
962 pins = devm_kcalloc(&pdev->dev, pctl->match_data->npins, sizeof(*pins),
963 GFP_KERNEL);
964 if (!pins)
965 return -ENOMEM;
966
967 for (i = 0; i < pctl->match_data->npins; i++)
968 pins[i] = pctl->match_data->pins[i].pin;
969
970 pctl->pctl_desc.name = dev_name(&pdev->dev);
971 pctl->pctl_desc.owner = THIS_MODULE;
972 pctl->pctl_desc.pins = pins;
973 pctl->pctl_desc.npins = pctl->match_data->npins;
974 pctl->pctl_desc.confops = &stm32_pconf_ops;
975 pctl->pctl_desc.pctlops = &stm32_pctrl_ops;
976 pctl->pctl_desc.pmxops = &stm32_pmx_ops;
977 pctl->dev = &pdev->dev;
978
979 pctl->pctl_dev = devm_pinctrl_register(&pdev->dev, &pctl->pctl_desc,
980 pctl);
981 if (IS_ERR(pctl->pctl_dev)) {
982 dev_err(&pdev->dev, "Failed pinctrl registration\n");
983 return PTR_ERR(pctl->pctl_dev);
984 }
985
986 for (i = 0; i < pctl->nbanks; i++)
987 pinctrl_add_gpio_range(pctl->pctl_dev, &pctl->banks[i].range);
988
989 dev_info(dev, "Pinctrl STM32 initialized\n");
990
991 return 0;
992 }
993
CRIS linux kernel tree