1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/debugfs.h>
16#include <linux/err.h>
17#include <linux/init.h>
18#include <linux/io.h>
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/of.h>
22#include <linux/of_device.h>
23#include <linux/platform_device.h>
24#include <linux/pinctrl/machine.h>
25#include <linux/pinctrl/pinconf.h>
26#include <linux/pinctrl/pinconf-generic.h>
27#include <linux/pinctrl/pinctrl.h>
28#include <linux/pinctrl/pinmux.h>
29#include <linux/slab.h>
30
31#include "../core.h"
32#include "../pinmux.h"
33#include "../pinconf.h"
34#include "../pinctrl-utils.h"
35#include "pinctrl-sprd.h"
36
37#define PINCTRL_BIT_MASK(width) (~(~0UL << (width)))
38#define PINCTRL_REG_OFFSET 0x20
39#define PINCTRL_REG_MISC_OFFSET 0x4020
40#define PINCTRL_REG_LEN 0x4
41
42#define PIN_FUNC_MASK (BIT(4) | BIT(5))
43#define PIN_FUNC_SEL_1 ~PIN_FUNC_MASK
44#define PIN_FUNC_SEL_2 BIT(4)
45#define PIN_FUNC_SEL_3 BIT(5)
46#define PIN_FUNC_SEL_4 PIN_FUNC_MASK
47
48#define AP_SLEEP_MODE BIT(13)
49#define PUBCP_SLEEP_MODE BIT(14)
50#define TGLDSP_SLEEP_MODE BIT(15)
51#define AGDSP_SLEEP_MODE BIT(16)
52#define SLEEP_MODE_MASK GENMASK(3, 0)
53#define SLEEP_MODE_SHIFT 13
54
55#define SLEEP_INPUT BIT(1)
56#define SLEEP_INPUT_MASK 0x1
57#define SLEEP_INPUT_SHIFT 1
58
59#define SLEEP_OUTPUT BIT(0)
60#define SLEEP_OUTPUT_MASK 0x1
61#define SLEEP_OUTPUT_SHIFT 0
62
63#define DRIVE_STRENGTH_MASK GENMASK(3, 0)
64#define DRIVE_STRENGTH_SHIFT 19
65
66#define SLEEP_PULL_DOWN BIT(2)
67#define SLEEP_PULL_DOWN_MASK 0x1
68#define SLEEP_PULL_DOWN_SHIFT 2
69
70#define PULL_DOWN BIT(6)
71#define PULL_DOWN_MASK 0x1
72#define PULL_DOWN_SHIFT 6
73
74#define SLEEP_PULL_UP BIT(3)
75#define SLEEP_PULL_UP_MASK 0x1
76#define SLEEP_PULL_UP_SHIFT 3
77
78#define PULL_UP_20K (BIT(12) | BIT(7))
79#define PULL_UP_4_7K BIT(12)
80#define PULL_UP_MASK 0x21
81#define PULL_UP_SHIFT 7
82
83#define INPUT_SCHMITT BIT(11)
84#define INPUT_SCHMITT_MASK 0x1
85#define INPUT_SCHMITT_SHIFT 11
86
87enum pin_sleep_mode {
88 AP_SLEEP = BIT(0),
89 PUBCP_SLEEP = BIT(1),
90 TGLDSP_SLEEP = BIT(2),
91 AGDSP_SLEEP = BIT(3),
92};
93
94enum pin_func_sel {
95 PIN_FUNC_1,
96 PIN_FUNC_2,
97 PIN_FUNC_3,
98 PIN_FUNC_4,
99 PIN_FUNC_MAX,
100};
101
102
103
104
105
106
107
108
109
110
111struct sprd_pin {
112 const char *name;
113 unsigned int number;
114 enum pin_type type;
115 unsigned long reg;
116 unsigned long bit_offset;
117 unsigned long bit_width;
118};
119
120
121
122
123
124
125
126struct sprd_pin_group {
127 const char *name;
128 unsigned int npins;
129 unsigned int *pins;
130};
131
132
133
134
135
136
137
138
139
140struct sprd_pinctrl_soc_info {
141 struct sprd_pin_group *groups;
142 unsigned int ngroups;
143 struct sprd_pin *pins;
144 unsigned int npins;
145 const char **grp_names;
146};
147
148
149
150
151
152
153
154
155struct sprd_pinctrl {
156 struct device *dev;
157 struct pinctrl_dev *pctl;
158 void __iomem *base;
159 struct sprd_pinctrl_soc_info *info;
160};
161
162enum sprd_pinconf_params {
163 SPRD_PIN_CONFIG_CONTROL = PIN_CONFIG_END + 1,
164 SPRD_PIN_CONFIG_SLEEP_MODE = PIN_CONFIG_END + 2,
165};
166
167static int sprd_pinctrl_get_id_by_name(struct sprd_pinctrl *sprd_pctl,
168 const char *name)
169{
170 struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
171 int i;
172
173 for (i = 0; i < info->npins; i++) {
174 if (!strcmp(info->pins[i].name, name))
175 return info->pins[i].number;
176 }
177
178 return -ENODEV;
179}
180
181static struct sprd_pin *
182sprd_pinctrl_get_pin_by_id(struct sprd_pinctrl *sprd_pctl, unsigned int id)
183{
184 struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
185 struct sprd_pin *pin = NULL;
186 int i;
187
188 for (i = 0; i < info->npins; i++) {
189 if (info->pins[i].number == id) {
190 pin = &info->pins[i];
191 break;
192 }
193 }
194
195 return pin;
196}
197
198static const struct sprd_pin_group *
199sprd_pinctrl_find_group_by_name(struct sprd_pinctrl *sprd_pctl,
200 const char *name)
201{
202 struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
203 const struct sprd_pin_group *grp = NULL;
204 int i;
205
206 for (i = 0; i < info->ngroups; i++) {
207 if (!strcmp(info->groups[i].name, name)) {
208 grp = &info->groups[i];
209 break;
210 }
211 }
212
213 return grp;
214}
215
216static int sprd_pctrl_group_count(struct pinctrl_dev *pctldev)
217{
218 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
219 struct sprd_pinctrl_soc_info *info = pctl->info;
220
221 return info->ngroups;
222}
223
224static const char *sprd_pctrl_group_name(struct pinctrl_dev *pctldev,
225 unsigned int selector)
226{
227 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
228 struct sprd_pinctrl_soc_info *info = pctl->info;
229
230 return info->groups[selector].name;
231}
232
233static int sprd_pctrl_group_pins(struct pinctrl_dev *pctldev,
234 unsigned int selector,
235 const unsigned int **pins,
236 unsigned int *npins)
237{
238 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
239 struct sprd_pinctrl_soc_info *info = pctl->info;
240
241 if (selector >= info->ngroups)
242 return -EINVAL;
243
244 *pins = info->groups[selector].pins;
245 *npins = info->groups[selector].npins;
246
247 return 0;
248}
249
250static int sprd_dt_node_to_map(struct pinctrl_dev *pctldev,
251 struct device_node *np,
252 struct pinctrl_map **map,
253 unsigned int *num_maps)
254{
255 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
256 const struct sprd_pin_group *grp;
257 unsigned long *configs = NULL;
258 unsigned int num_configs = 0;
259 unsigned int reserved_maps = 0;
260 unsigned int reserve = 0;
261 const char *function;
262 enum pinctrl_map_type type;
263 int ret;
264
265 grp = sprd_pinctrl_find_group_by_name(pctl, np->name);
266 if (!grp) {
267 dev_err(pctl->dev, "unable to find group for node %s\n",
268 of_node_full_name(np));
269 return -EINVAL;
270 }
271
272 ret = of_property_count_strings(np, "pins");
273 if (ret < 0)
274 return ret;
275
276 if (ret == 1)
277 type = PIN_MAP_TYPE_CONFIGS_PIN;
278 else
279 type = PIN_MAP_TYPE_CONFIGS_GROUP;
280
281 ret = of_property_read_string(np, "function", &function);
282 if (ret < 0) {
283 if (ret != -EINVAL)
284 dev_err(pctl->dev,
285 "%s: could not parse property function\n",
286 of_node_full_name(np));
287 function = NULL;
288 }
289
290 ret = pinconf_generic_parse_dt_config(np, pctldev, &configs,
291 &num_configs);
292 if (ret < 0) {
293 dev_err(pctl->dev, "%s: could not parse node property\n",
294 of_node_full_name(np));
295 return ret;
296 }
297
298 *map = NULL;
299 *num_maps = 0;
300
301 if (function != NULL)
302 reserve++;
303 if (num_configs)
304 reserve++;
305
306 ret = pinctrl_utils_reserve_map(pctldev, map, &reserved_maps,
307 num_maps, reserve);
308 if (ret < 0)
309 goto out;
310
311 if (function) {
312 ret = pinctrl_utils_add_map_mux(pctldev, map,
313 &reserved_maps, num_maps,
314 grp->name, function);
315 if (ret < 0)
316 goto out;
317 }
318
319 if (num_configs) {
320 const char *group_or_pin;
321 unsigned int pin_id;
322
323 if (type == PIN_MAP_TYPE_CONFIGS_PIN) {
324 pin_id = grp->pins[0];
325 group_or_pin = pin_get_name(pctldev, pin_id);
326 } else {
327 group_or_pin = grp->name;
328 }
329
330 ret = pinctrl_utils_add_map_configs(pctldev, map,
331 &reserved_maps, num_maps,
332 group_or_pin, configs,
333 num_configs, type);
334 }
335
336out:
337 kfree(configs);
338 return ret;
339}
340
341static void sprd_pctrl_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
342 unsigned int offset)
343{
344 seq_printf(s, "%s", dev_name(pctldev->dev));
345}
346
347static const struct pinctrl_ops sprd_pctrl_ops = {
348 .get_groups_count = sprd_pctrl_group_count,
349 .get_group_name = sprd_pctrl_group_name,
350 .get_group_pins = sprd_pctrl_group_pins,
351 .pin_dbg_show = sprd_pctrl_dbg_show,
352 .dt_node_to_map = sprd_dt_node_to_map,
353 .dt_free_map = pinctrl_utils_free_map,
354};
355
356static int sprd_pmx_get_function_count(struct pinctrl_dev *pctldev)
357{
358 return PIN_FUNC_MAX;
359}
360
361static const char *sprd_pmx_get_function_name(struct pinctrl_dev *pctldev,
362 unsigned int selector)
363{
364 switch (selector) {
365 case PIN_FUNC_1:
366 return "func1";
367 case PIN_FUNC_2:
368 return "func2";
369 case PIN_FUNC_3:
370 return "func3";
371 case PIN_FUNC_4:
372 return "func4";
373 default:
374 return "null";
375 }
376}
377
378static int sprd_pmx_get_function_groups(struct pinctrl_dev *pctldev,
379 unsigned int selector,
380 const char * const **groups,
381 unsigned int * const num_groups)
382{
383 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
384 struct sprd_pinctrl_soc_info *info = pctl->info;
385
386 *groups = info->grp_names;
387 *num_groups = info->ngroups;
388
389 return 0;
390}
391
392static int sprd_pmx_set_mux(struct pinctrl_dev *pctldev,
393 unsigned int func_selector,
394 unsigned int group_selector)
395{
396 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
397 struct sprd_pinctrl_soc_info *info = pctl->info;
398 struct sprd_pin_group *grp = &info->groups[group_selector];
399 unsigned int i, grp_pins = grp->npins;
400 unsigned long reg;
401 unsigned int val = 0;
402
403 if (group_selector >= info->ngroups)
404 return -EINVAL;
405
406 switch (func_selector) {
407 case PIN_FUNC_1:
408 val &= PIN_FUNC_SEL_1;
409 break;
410 case PIN_FUNC_2:
411 val |= PIN_FUNC_SEL_2;
412 break;
413 case PIN_FUNC_3:
414 val |= PIN_FUNC_SEL_3;
415 break;
416 case PIN_FUNC_4:
417 val |= PIN_FUNC_SEL_4;
418 break;
419 default:
420 break;
421 }
422
423 for (i = 0; i < grp_pins; i++) {
424 unsigned int pin_id = grp->pins[i];
425 struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
426
427 if (!pin || pin->type != COMMON_PIN)
428 continue;
429
430 reg = readl((void __iomem *)pin->reg);
431 reg &= ~PIN_FUNC_MASK;
432 reg |= val;
433 writel(reg, (void __iomem *)pin->reg);
434 }
435
436 return 0;
437}
438
439static const struct pinmux_ops sprd_pmx_ops = {
440 .get_functions_count = sprd_pmx_get_function_count,
441 .get_function_name = sprd_pmx_get_function_name,
442 .get_function_groups = sprd_pmx_get_function_groups,
443 .set_mux = sprd_pmx_set_mux,
444};
445
446static int sprd_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin_id,
447 unsigned long *config)
448{
449 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
450 struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
451 unsigned int param = pinconf_to_config_param(*config);
452 unsigned int reg, arg;
453
454 if (!pin)
455 return -EINVAL;
456
457 if (pin->type == GLOBAL_CTRL_PIN) {
458 reg = (readl((void __iomem *)pin->reg) >>
459 pin->bit_offset) & PINCTRL_BIT_MASK(pin->bit_width);
460 } else {
461 reg = readl((void __iomem *)pin->reg);
462 }
463
464 if (pin->type == GLOBAL_CTRL_PIN &&
465 param == SPRD_PIN_CONFIG_CONTROL) {
466 arg = reg;
467 } else if (pin->type == COMMON_PIN) {
468 switch (param) {
469 case SPRD_PIN_CONFIG_SLEEP_MODE:
470 arg = (reg >> SLEEP_MODE_SHIFT) & SLEEP_MODE_MASK;
471 break;
472 case PIN_CONFIG_INPUT_ENABLE:
473 arg = (reg >> SLEEP_INPUT_SHIFT) & SLEEP_INPUT_MASK;
474 break;
475 case PIN_CONFIG_OUTPUT:
476 arg = reg & SLEEP_OUTPUT_MASK;
477 break;
478 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
479 arg = 0;
480 break;
481 default:
482 return -ENOTSUPP;
483 }
484 } else if (pin->type == MISC_PIN) {
485 switch (param) {
486 case PIN_CONFIG_DRIVE_STRENGTH:
487 arg = (reg >> DRIVE_STRENGTH_SHIFT) &
488 DRIVE_STRENGTH_MASK;
489 break;
490 case PIN_CONFIG_BIAS_PULL_DOWN:
491
492 arg = ((reg >> SLEEP_PULL_DOWN_SHIFT) &
493 SLEEP_PULL_DOWN_MASK) << 16;
494 arg |= (reg >> PULL_DOWN_SHIFT) & PULL_DOWN_MASK;
495 break;
496 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
497 arg = (reg >> INPUT_SCHMITT_SHIFT) & INPUT_SCHMITT_MASK;
498 break;
499 case PIN_CONFIG_BIAS_PULL_UP:
500
501 arg = ((reg >> SLEEP_PULL_UP_SHIFT) &
502 SLEEP_PULL_UP_MASK) << 16;
503 arg |= (reg >> PULL_UP_SHIFT) & PULL_UP_MASK;
504 break;
505 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
506 arg = 0;
507 break;
508 default:
509 return -ENOTSUPP;
510 }
511 } else {
512 return -ENOTSUPP;
513 }
514
515 *config = pinconf_to_config_packed(param, arg);
516 return 0;
517}
518
519static unsigned int sprd_pinconf_drive(unsigned int mA)
520{
521 unsigned int val = 0;
522
523 switch (mA) {
524 case 2:
525 break;
526 case 4:
527 val |= BIT(19);
528 break;
529 case 6:
530 val |= BIT(20);
531 break;
532 case 8:
533 val |= BIT(19) | BIT(20);
534 break;
535 case 10:
536 val |= BIT(21);
537 break;
538 case 12:
539 val |= BIT(21) | BIT(19);
540 break;
541 case 14:
542 val |= BIT(21) | BIT(20);
543 break;
544 case 16:
545 val |= BIT(19) | BIT(20) | BIT(21);
546 break;
547 case 20:
548 val |= BIT(22);
549 break;
550 case 21:
551 val |= BIT(22) | BIT(19);
552 break;
553 case 24:
554 val |= BIT(22) | BIT(20);
555 break;
556 case 25:
557 val |= BIT(22) | BIT(20) | BIT(19);
558 break;
559 case 27:
560 val |= BIT(22) | BIT(21);
561 break;
562 case 29:
563 val |= BIT(22) | BIT(21) | BIT(19);
564 break;
565 case 31:
566 val |= BIT(22) | BIT(21) | BIT(20);
567 break;
568 case 33:
569 val |= BIT(22) | BIT(21) | BIT(20) | BIT(19);
570 break;
571 default:
572 break;
573 }
574
575 return val;
576}
577
578static bool sprd_pinctrl_check_sleep_config(unsigned long *configs,
579 unsigned int num_configs)
580{
581 unsigned int param;
582 int i;
583
584 for (i = 0; i < num_configs; i++) {
585 param = pinconf_to_config_param(configs[i]);
586 if (param == PIN_CONFIG_SLEEP_HARDWARE_STATE)
587 return true;
588 }
589
590 return false;
591}
592
593static int sprd_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin_id,
594 unsigned long *configs, unsigned int num_configs)
595{
596 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
597 struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
598 bool is_sleep_config;
599 unsigned long reg;
600 int i;
601
602 if (!pin)
603 return -EINVAL;
604
605 is_sleep_config = sprd_pinctrl_check_sleep_config(configs, num_configs);
606
607 for (i = 0; i < num_configs; i++) {
608 unsigned int param, arg, shift, mask, val;
609
610 param = pinconf_to_config_param(configs[i]);
611 arg = pinconf_to_config_argument(configs[i]);
612
613 val = 0;
614 shift = 0;
615 mask = 0;
616 if (pin->type == GLOBAL_CTRL_PIN &&
617 param == SPRD_PIN_CONFIG_CONTROL) {
618 val = arg;
619 } else if (pin->type == COMMON_PIN) {
620 switch (param) {
621 case SPRD_PIN_CONFIG_SLEEP_MODE:
622 if (arg & AP_SLEEP)
623 val |= AP_SLEEP_MODE;
624 if (arg & PUBCP_SLEEP)
625 val |= PUBCP_SLEEP_MODE;
626 if (arg & TGLDSP_SLEEP)
627 val |= TGLDSP_SLEEP_MODE;
628 if (arg & AGDSP_SLEEP)
629 val |= AGDSP_SLEEP_MODE;
630
631 mask = SLEEP_MODE_MASK;
632 shift = SLEEP_MODE_SHIFT;
633 break;
634 case PIN_CONFIG_INPUT_ENABLE:
635 if (is_sleep_config == true) {
636 if (arg > 0)
637 val |= SLEEP_INPUT;
638 else
639 val &= ~SLEEP_INPUT;
640
641 mask = SLEEP_INPUT_MASK;
642 shift = SLEEP_INPUT_SHIFT;
643 }
644 break;
645 case PIN_CONFIG_OUTPUT:
646 if (is_sleep_config == true) {
647 val |= SLEEP_OUTPUT;
648 mask = SLEEP_OUTPUT_MASK;
649 shift = SLEEP_OUTPUT_SHIFT;
650 }
651 break;
652 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
653 continue;
654 default:
655 return -ENOTSUPP;
656 }
657 } else if (pin->type == MISC_PIN) {
658 switch (param) {
659 case PIN_CONFIG_DRIVE_STRENGTH:
660 if (arg < 2 || arg > 60)
661 return -EINVAL;
662
663 val = sprd_pinconf_drive(arg);
664 mask = DRIVE_STRENGTH_MASK;
665 shift = DRIVE_STRENGTH_SHIFT;
666 break;
667 case PIN_CONFIG_BIAS_PULL_DOWN:
668 if (is_sleep_config == true) {
669 val |= SLEEP_PULL_DOWN;
670 mask = SLEEP_PULL_DOWN_MASK;
671 shift = SLEEP_PULL_DOWN_SHIFT;
672 } else {
673 val |= PULL_DOWN;
674 mask = PULL_DOWN_MASK;
675 shift = PULL_DOWN_SHIFT;
676 }
677 break;
678 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
679 if (arg > 0)
680 val |= INPUT_SCHMITT;
681 else
682 val &= ~INPUT_SCHMITT;
683
684 mask = INPUT_SCHMITT_MASK;
685 shift = INPUT_SCHMITT_SHIFT;
686 break;
687 case PIN_CONFIG_BIAS_PULL_UP:
688 if (is_sleep_config == true) {
689 val |= SLEEP_PULL_UP;
690 mask = SLEEP_PULL_UP_MASK;
691 shift = SLEEP_PULL_UP_SHIFT;
692 } else {
693 if (arg == 20000)
694 val |= PULL_UP_20K;
695 else if (arg == 4700)
696 val |= PULL_UP_4_7K;
697
698 mask = PULL_UP_MASK;
699 shift = PULL_UP_SHIFT;
700 }
701 break;
702 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
703 continue;
704 default:
705 return -ENOTSUPP;
706 }
707 } else {
708 return -ENOTSUPP;
709 }
710
711 if (pin->type == GLOBAL_CTRL_PIN) {
712 reg = readl((void __iomem *)pin->reg);
713 reg &= ~(PINCTRL_BIT_MASK(pin->bit_width)
714 << pin->bit_offset);
715 reg |= (val & PINCTRL_BIT_MASK(pin->bit_width))
716 << pin->bit_offset;
717 writel(reg, (void __iomem *)pin->reg);
718 } else {
719 reg = readl((void __iomem *)pin->reg);
720 reg &= ~(mask << shift);
721 reg |= val;
722 writel(reg, (void __iomem *)pin->reg);
723 }
724 }
725
726 return 0;
727}
728
729static int sprd_pinconf_group_get(struct pinctrl_dev *pctldev,
730 unsigned int selector, unsigned long *config)
731{
732 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
733 struct sprd_pinctrl_soc_info *info = pctl->info;
734 struct sprd_pin_group *grp;
735 unsigned int pin_id;
736
737 if (selector >= info->ngroups)
738 return -EINVAL;
739
740 grp = &info->groups[selector];
741 pin_id = grp->pins[0];
742
743 return sprd_pinconf_get(pctldev, pin_id, config);
744}
745
746static int sprd_pinconf_group_set(struct pinctrl_dev *pctldev,
747 unsigned int selector,
748 unsigned long *configs,
749 unsigned int num_configs)
750{
751 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
752 struct sprd_pinctrl_soc_info *info = pctl->info;
753 struct sprd_pin_group *grp;
754 int ret, i;
755
756 if (selector >= info->ngroups)
757 return -EINVAL;
758
759 grp = &info->groups[selector];
760
761 for (i = 0; i < grp->npins; i++) {
762 unsigned int pin_id = grp->pins[i];
763
764 ret = sprd_pinconf_set(pctldev, pin_id, configs, num_configs);
765 if (ret)
766 return ret;
767 }
768
769 return 0;
770}
771
772static int sprd_pinconf_get_config(struct pinctrl_dev *pctldev,
773 unsigned int pin_id,
774 unsigned long *config)
775{
776 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
777 struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
778
779 if (!pin)
780 return -EINVAL;
781
782 if (pin->type == GLOBAL_CTRL_PIN) {
783 *config = (readl((void __iomem *)pin->reg) >>
784 pin->bit_offset) & PINCTRL_BIT_MASK(pin->bit_width);
785 } else {
786 *config = readl((void __iomem *)pin->reg);
787 }
788
789 return 0;
790}
791
792static void sprd_pinconf_dbg_show(struct pinctrl_dev *pctldev,
793 struct seq_file *s, unsigned int pin_id)
794{
795 unsigned long config;
796 int ret;
797
798 ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
799 if (ret)
800 return;
801
802 seq_printf(s, "0x%lx", config);
803}
804
805static void sprd_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
806 struct seq_file *s,
807 unsigned int selector)
808{
809 struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
810 struct sprd_pinctrl_soc_info *info = pctl->info;
811 struct sprd_pin_group *grp;
812 unsigned long config;
813 const char *name;
814 int i, ret;
815
816 if (selector >= info->ngroups)
817 return;
818
819 grp = &info->groups[selector];
820
821 seq_putc(s, '\n');
822 for (i = 0; i < grp->npins; i++, config++) {
823 unsigned int pin_id = grp->pins[i];
824
825 name = pin_get_name(pctldev, pin_id);
826 ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
827 if (ret)
828 return;
829
830 seq_printf(s, "%s: 0x%lx ", name, config);
831 }
832}
833
834static const struct pinconf_ops sprd_pinconf_ops = {
835 .is_generic = true,
836 .pin_config_get = sprd_pinconf_get,
837 .pin_config_set = sprd_pinconf_set,
838 .pin_config_group_get = sprd_pinconf_group_get,
839 .pin_config_group_set = sprd_pinconf_group_set,
840 .pin_config_dbg_show = sprd_pinconf_dbg_show,
841 .pin_config_group_dbg_show = sprd_pinconf_group_dbg_show,
842};
843
844static const struct pinconf_generic_params sprd_dt_params[] = {
845 {"sprd,control", SPRD_PIN_CONFIG_CONTROL, 0},
846 {"sprd,sleep-mode", SPRD_PIN_CONFIG_SLEEP_MODE, 0},
847};
848
849#ifdef CONFIG_DEBUG_FS
850static const struct pin_config_item sprd_conf_items[] = {
851 PCONFDUMP(SPRD_PIN_CONFIG_CONTROL, "global control", NULL, true),
852 PCONFDUMP(SPRD_PIN_CONFIG_SLEEP_MODE, "sleep mode", NULL, true),
853};
854#endif
855
856static struct pinctrl_desc sprd_pinctrl_desc = {
857 .pctlops = &sprd_pctrl_ops,
858 .pmxops = &sprd_pmx_ops,
859 .confops = &sprd_pinconf_ops,
860 .num_custom_params = ARRAY_SIZE(sprd_dt_params),
861 .custom_params = sprd_dt_params,
862#ifdef CONFIG_DEBUG_FS
863 .custom_conf_items = sprd_conf_items,
864#endif
865 .owner = THIS_MODULE,
866};
867
868static int sprd_pinctrl_parse_groups(struct device_node *np,
869 struct sprd_pinctrl *sprd_pctl,
870 struct sprd_pin_group *grp)
871{
872 struct property *prop;
873 const char *pin_name;
874 int ret, i = 0;
875
876 ret = of_property_count_strings(np, "pins");
877 if (ret < 0)
878 return ret;
879
880 grp->name = np->name;
881 grp->npins = ret;
882 grp->pins = devm_kzalloc(sprd_pctl->dev, grp->npins *
883 sizeof(unsigned int), GFP_KERNEL);
884 if (!grp->pins)
885 return -ENOMEM;
886
887 of_property_for_each_string(np, "pins", prop, pin_name) {
888 ret = sprd_pinctrl_get_id_by_name(sprd_pctl, pin_name);
889 if (ret >= 0)
890 grp->pins[i++] = ret;
891 }
892
893 for (i = 0; i < grp->npins; i++) {
894 dev_dbg(sprd_pctl->dev,
895 "Group[%s] contains [%d] pins: id = %d\n",
896 grp->name, grp->npins, grp->pins[i]);
897 }
898
899 return 0;
900}
901
902static unsigned int sprd_pinctrl_get_groups(struct device_node *np)
903{
904 struct device_node *child;
905 unsigned int group_cnt, cnt;
906
907 group_cnt = of_get_child_count(np);
908
909 for_each_child_of_node(np, child) {
910 cnt = of_get_child_count(child);
911 if (cnt > 0)
912 group_cnt += cnt;
913 }
914
915 return group_cnt;
916}
917
918static int sprd_pinctrl_parse_dt(struct sprd_pinctrl *sprd_pctl)
919{
920 struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
921 struct device_node *np = sprd_pctl->dev->of_node;
922 struct device_node *child, *sub_child;
923 struct sprd_pin_group *grp;
924 const char **temp;
925 int ret;
926
927 if (!np)
928 return -ENODEV;
929
930 info->ngroups = sprd_pinctrl_get_groups(np);
931 if (!info->ngroups)
932 return 0;
933
934 info->groups = devm_kzalloc(sprd_pctl->dev, info->ngroups *
935 sizeof(struct sprd_pin_group),
936 GFP_KERNEL);
937 if (!info->groups)
938 return -ENOMEM;
939
940 info->grp_names = devm_kzalloc(sprd_pctl->dev,
941 info->ngroups * sizeof(char *),
942 GFP_KERNEL);
943 if (!info->grp_names)
944 return -ENOMEM;
945
946 temp = info->grp_names;
947 grp = info->groups;
948
949 for_each_child_of_node(np, child) {
950 ret = sprd_pinctrl_parse_groups(child, sprd_pctl, grp);
951 if (ret)
952 return ret;
953
954 *temp++ = grp->name;
955 grp++;
956
957 if (of_get_child_count(child) > 0) {
958 for_each_child_of_node(child, sub_child) {
959 ret = sprd_pinctrl_parse_groups(sub_child,
960 sprd_pctl, grp);
961 if (ret)
962 return ret;
963
964 *temp++ = grp->name;
965 grp++;
966 }
967 }
968 }
969
970 return 0;
971}
972
973static int sprd_pinctrl_add_pins(struct sprd_pinctrl *sprd_pctl,
974 struct sprd_pins_info *sprd_soc_pin_info,
975 int pins_cnt)
976{
977 struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
978 unsigned int ctrl_pin = 0, com_pin = 0;
979 struct sprd_pin *pin;
980 int i;
981
982 info->npins = pins_cnt;
983 info->pins = devm_kzalloc(sprd_pctl->dev,
984 info->npins * sizeof(struct sprd_pin),
985 GFP_KERNEL);
986 if (!info->pins)
987 return -ENOMEM;
988
989 for (i = 0, pin = info->pins; i < info->npins; i++, pin++) {
990 unsigned int reg;
991
992 pin->name = sprd_soc_pin_info[i].name;
993 pin->type = sprd_soc_pin_info[i].type;
994 pin->number = sprd_soc_pin_info[i].num;
995 reg = sprd_soc_pin_info[i].reg;
996 if (pin->type == GLOBAL_CTRL_PIN) {
997 pin->reg = (unsigned long)sprd_pctl->base +
998 PINCTRL_REG_LEN * reg;
999 pin->bit_offset = sprd_soc_pin_info[i].bit_offset;
1000 pin->bit_width = sprd_soc_pin_info[i].bit_width;
1001 ctrl_pin++;
1002 } else if (pin->type == COMMON_PIN) {
1003 pin->reg = (unsigned long)sprd_pctl->base +
1004 PINCTRL_REG_OFFSET + PINCTRL_REG_LEN *
1005 (i - ctrl_pin);
1006 com_pin++;
1007 } else if (pin->type == MISC_PIN) {
1008 pin->reg = (unsigned long)sprd_pctl->base +
1009 PINCTRL_REG_MISC_OFFSET + PINCTRL_REG_LEN *
1010 (i - ctrl_pin - com_pin);
1011 }
1012 }
1013
1014 for (i = 0, pin = info->pins; i < info->npins; pin++, i++) {
1015 dev_dbg(sprd_pctl->dev, "pin name[%s-%d], type = %d, "
1016 "bit offset = %ld, bit width = %ld, reg = 0x%lx\n",
1017 pin->name, pin->number, pin->type,
1018 pin->bit_offset, pin->bit_width, pin->reg);
1019 }
1020
1021 return 0;
1022}
1023
1024int sprd_pinctrl_core_probe(struct platform_device *pdev,
1025 struct sprd_pins_info *sprd_soc_pin_info,
1026 int pins_cnt)
1027{
1028 struct sprd_pinctrl *sprd_pctl;
1029 struct sprd_pinctrl_soc_info *pinctrl_info;
1030 struct pinctrl_pin_desc *pin_desc;
1031 struct resource *res;
1032 int ret, i;
1033
1034 sprd_pctl = devm_kzalloc(&pdev->dev, sizeof(struct sprd_pinctrl),
1035 GFP_KERNEL);
1036 if (!sprd_pctl)
1037 return -ENOMEM;
1038
1039 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1040 sprd_pctl->base = devm_ioremap_resource(&pdev->dev, res);
1041 if (IS_ERR(sprd_pctl->base))
1042 return PTR_ERR(sprd_pctl->base);
1043
1044 pinctrl_info = devm_kzalloc(&pdev->dev,
1045 sizeof(struct sprd_pinctrl_soc_info),
1046 GFP_KERNEL);
1047 if (!pinctrl_info)
1048 return -ENOMEM;
1049
1050 sprd_pctl->info = pinctrl_info;
1051 sprd_pctl->dev = &pdev->dev;
1052 platform_set_drvdata(pdev, sprd_pctl);
1053
1054 ret = sprd_pinctrl_add_pins(sprd_pctl, sprd_soc_pin_info, pins_cnt);
1055 if (ret) {
1056 dev_err(&pdev->dev, "fail to add pins information\n");
1057 return ret;
1058 }
1059
1060 pin_desc = devm_kzalloc(&pdev->dev, pinctrl_info->npins *
1061 sizeof(struct pinctrl_pin_desc),
1062 GFP_KERNEL);
1063 if (!pin_desc)
1064 return -ENOMEM;
1065
1066 for (i = 0; i < pinctrl_info->npins; i++) {
1067 pin_desc[i].number = pinctrl_info->pins[i].number;
1068 pin_desc[i].name = pinctrl_info->pins[i].name;
1069 pin_desc[i].drv_data = pinctrl_info;
1070 }
1071
1072 sprd_pinctrl_desc.pins = pin_desc;
1073 sprd_pinctrl_desc.name = dev_name(&pdev->dev);
1074 sprd_pinctrl_desc.npins = pinctrl_info->npins;
1075
1076 sprd_pctl->pctl = pinctrl_register(&sprd_pinctrl_desc,
1077 &pdev->dev, (void *)sprd_pctl);
1078 if (IS_ERR(sprd_pctl->pctl)) {
1079 dev_err(&pdev->dev, "could not register pinctrl driver\n");
1080 return PTR_ERR(sprd_pctl->pctl);
1081 }
1082
1083 ret = sprd_pinctrl_parse_dt(sprd_pctl);
1084 if (ret) {
1085 dev_err(&pdev->dev, "fail to parse dt properties\n");
1086 pinctrl_unregister(sprd_pctl->pctl);
1087 return ret;
1088 }
1089
1090 return 0;
1091}
1092
1093int sprd_pinctrl_remove(struct platform_device *pdev)
1094{
1095 struct sprd_pinctrl *sprd_pctl = platform_get_drvdata(pdev);
1096
1097 pinctrl_unregister(sprd_pctl->pctl);
1098 return 0;
1099}
1100
1101void sprd_pinctrl_shutdown(struct platform_device *pdev)
1102{
1103 struct pinctrl *pinctl;
1104 struct pinctrl_state *state;
1105
1106 pinctl = devm_pinctrl_get(&pdev->dev);
1107 if (IS_ERR(pinctl))
1108 return;
1109 state = pinctrl_lookup_state(pinctl, "shutdown");
1110 if (IS_ERR(state))
1111 return;
1112 pinctrl_select_state(pinctl, state);
1113}
1114
1115MODULE_DESCRIPTION("SPREADTRUM Pin Controller Driver");
1116MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");
1117MODULE_LICENSE("GPL v2");
1118
