GNU Linux-libre 4.19.314-gnu1
[releases.git] / drivers / pinctrl / sprd / pinctrl-sprd.c
1 /*
2  * Spreadtrum pin controller driver
3  * Copyright (C) 2017 Spreadtrum  - http://www.spreadtrum.com
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * version 2 as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
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
87 enum 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
94 enum 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  * struct sprd_pin: represent one pin's description
104  * @name: pin name
105  * @number: pin number
106  * @type: pin type, can be GLOBAL_CTRL_PIN/COMMON_PIN/MISC_PIN
107  * @reg: pin register address
108  * @bit_offset: bit offset in pin register
109  * @bit_width: bit width in pin register
110  */
111 struct 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  * struct sprd_pin_group: represent one group's description
122  * @name: group name
123  * @npins: pin numbers of this group
124  * @pins: pointer to pins array
125  */
126 struct sprd_pin_group {
127         const char *name;
128         unsigned int npins;
129         unsigned int *pins;
130 };
131
132 /**
133  * struct sprd_pinctrl_soc_info: represent the SoC's pins description
134  * @groups: pointer to groups of pins
135  * @ngroups: group numbers of the whole SoC
136  * @pins: pointer to pins description
137  * @npins: pin numbers of the whole SoC
138  * @grp_names: pointer to group names array
139  */
140 struct 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  * struct sprd_pinctrl: represent the pin controller device
150  * @dev: pointer to the device structure
151  * @pctl: pointer to the pinctrl handle
152  * @base: base address of the controller
153  * @info: pointer to SoC's pins description information
154  */
155 struct sprd_pinctrl {
156         struct device *dev;
157         struct pinctrl_dev *pctl;
158         void __iomem *base;
159         struct sprd_pinctrl_soc_info *info;
160 };
161
162 #define SPRD_PIN_CONFIG_CONTROL         (PIN_CONFIG_END + 1)
163 #define SPRD_PIN_CONFIG_SLEEP_MODE      (PIN_CONFIG_END + 2)
164
165 static int sprd_pinctrl_get_id_by_name(struct sprd_pinctrl *sprd_pctl,
166                                        const char *name)
167 {
168         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
169         int i;
170
171         for (i = 0; i < info->npins; i++) {
172                 if (!strcmp(info->pins[i].name, name))
173                         return info->pins[i].number;
174         }
175
176         return -ENODEV;
177 }
178
179 static struct sprd_pin *
180 sprd_pinctrl_get_pin_by_id(struct sprd_pinctrl *sprd_pctl, unsigned int id)
181 {
182         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
183         struct sprd_pin *pin = NULL;
184         int i;
185
186         for (i = 0; i < info->npins; i++) {
187                 if (info->pins[i].number == id) {
188                         pin = &info->pins[i];
189                         break;
190                 }
191         }
192
193         return pin;
194 }
195
196 static const struct sprd_pin_group *
197 sprd_pinctrl_find_group_by_name(struct sprd_pinctrl *sprd_pctl,
198                                 const char *name)
199 {
200         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
201         const struct sprd_pin_group *grp = NULL;
202         int i;
203
204         for (i = 0; i < info->ngroups; i++) {
205                 if (!strcmp(info->groups[i].name, name)) {
206                         grp = &info->groups[i];
207                         break;
208                 }
209         }
210
211         return grp;
212 }
213
214 static int sprd_pctrl_group_count(struct pinctrl_dev *pctldev)
215 {
216         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
217         struct sprd_pinctrl_soc_info *info = pctl->info;
218
219         return info->ngroups;
220 }
221
222 static const char *sprd_pctrl_group_name(struct pinctrl_dev *pctldev,
223                                          unsigned int selector)
224 {
225         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
226         struct sprd_pinctrl_soc_info *info = pctl->info;
227
228         return info->groups[selector].name;
229 }
230
231 static int sprd_pctrl_group_pins(struct pinctrl_dev *pctldev,
232                                  unsigned int selector,
233                                  const unsigned int **pins,
234                                  unsigned int *npins)
235 {
236         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
237         struct sprd_pinctrl_soc_info *info = pctl->info;
238
239         if (selector >= info->ngroups)
240                 return -EINVAL;
241
242         *pins = info->groups[selector].pins;
243         *npins = info->groups[selector].npins;
244
245         return 0;
246 }
247
248 static int sprd_dt_node_to_map(struct pinctrl_dev *pctldev,
249                                struct device_node *np,
250                                struct pinctrl_map **map,
251                                unsigned int *num_maps)
252 {
253         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
254         const struct sprd_pin_group *grp;
255         unsigned long *configs = NULL;
256         unsigned int num_configs = 0;
257         unsigned int reserved_maps = 0;
258         unsigned int reserve = 0;
259         const char *function;
260         enum pinctrl_map_type type;
261         int ret;
262
263         grp = sprd_pinctrl_find_group_by_name(pctl, np->name);
264         if (!grp) {
265                 dev_err(pctl->dev, "unable to find group for node %s\n",
266                         of_node_full_name(np));
267                 return -EINVAL;
268         }
269
270         ret = of_property_count_strings(np, "pins");
271         if (ret < 0)
272                 return ret;
273
274         if (ret == 1)
275                 type = PIN_MAP_TYPE_CONFIGS_PIN;
276         else
277                 type = PIN_MAP_TYPE_CONFIGS_GROUP;
278
279         ret = of_property_read_string(np, "function", &function);
280         if (ret < 0) {
281                 if (ret != -EINVAL)
282                         dev_err(pctl->dev,
283                                 "%s: could not parse property function\n",
284                                 of_node_full_name(np));
285                 function = NULL;
286         }
287
288         ret = pinconf_generic_parse_dt_config(np, pctldev, &configs,
289                                               &num_configs);
290         if (ret < 0) {
291                 dev_err(pctl->dev, "%s: could not parse node property\n",
292                         of_node_full_name(np));
293                 return ret;
294         }
295
296         *map = NULL;
297         *num_maps = 0;
298
299         if (function != NULL)
300                 reserve++;
301         if (num_configs)
302                 reserve++;
303
304         ret = pinctrl_utils_reserve_map(pctldev, map, &reserved_maps,
305                                         num_maps, reserve);
306         if (ret < 0)
307                 goto out;
308
309         if (function) {
310                 ret = pinctrl_utils_add_map_mux(pctldev, map,
311                                                 &reserved_maps, num_maps,
312                                                 grp->name, function);
313                 if (ret < 0)
314                         goto out;
315         }
316
317         if (num_configs) {
318                 const char *group_or_pin;
319                 unsigned int pin_id;
320
321                 if (type == PIN_MAP_TYPE_CONFIGS_PIN) {
322                         pin_id = grp->pins[0];
323                         group_or_pin = pin_get_name(pctldev, pin_id);
324                 } else {
325                         group_or_pin = grp->name;
326                 }
327
328                 ret = pinctrl_utils_add_map_configs(pctldev, map,
329                                                     &reserved_maps, num_maps,
330                                                     group_or_pin, configs,
331                                                     num_configs, type);
332         }
333
334 out:
335         kfree(configs);
336         return ret;
337 }
338
339 static void sprd_pctrl_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
340                                 unsigned int offset)
341 {
342         seq_printf(s, "%s", dev_name(pctldev->dev));
343 }
344
345 static const struct pinctrl_ops sprd_pctrl_ops = {
346         .get_groups_count = sprd_pctrl_group_count,
347         .get_group_name = sprd_pctrl_group_name,
348         .get_group_pins = sprd_pctrl_group_pins,
349         .pin_dbg_show = sprd_pctrl_dbg_show,
350         .dt_node_to_map = sprd_dt_node_to_map,
351         .dt_free_map = pinctrl_utils_free_map,
352 };
353
354 static int sprd_pmx_get_function_count(struct pinctrl_dev *pctldev)
355 {
356         return PIN_FUNC_MAX;
357 }
358
359 static const char *sprd_pmx_get_function_name(struct pinctrl_dev *pctldev,
360                                               unsigned int selector)
361 {
362         switch (selector) {
363         case PIN_FUNC_1:
364                 return "func1";
365         case PIN_FUNC_2:
366                 return "func2";
367         case PIN_FUNC_3:
368                 return "func3";
369         case PIN_FUNC_4:
370                 return "func4";
371         default:
372                 return "null";
373         }
374 }
375
376 static int sprd_pmx_get_function_groups(struct pinctrl_dev *pctldev,
377                                         unsigned int selector,
378                                         const char * const **groups,
379                                         unsigned int * const num_groups)
380 {
381         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
382         struct sprd_pinctrl_soc_info *info = pctl->info;
383
384         *groups = info->grp_names;
385         *num_groups = info->ngroups;
386
387         return 0;
388 }
389
390 static int sprd_pmx_set_mux(struct pinctrl_dev *pctldev,
391                             unsigned int func_selector,
392                             unsigned int group_selector)
393 {
394         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
395         struct sprd_pinctrl_soc_info *info = pctl->info;
396         struct sprd_pin_group *grp = &info->groups[group_selector];
397         unsigned int i, grp_pins = grp->npins;
398         unsigned long reg;
399         unsigned int val = 0;
400
401         if (group_selector >= info->ngroups)
402                 return -EINVAL;
403
404         switch (func_selector) {
405         case PIN_FUNC_1:
406                 val &= PIN_FUNC_SEL_1;
407                 break;
408         case PIN_FUNC_2:
409                 val |= PIN_FUNC_SEL_2;
410                 break;
411         case PIN_FUNC_3:
412                 val |= PIN_FUNC_SEL_3;
413                 break;
414         case PIN_FUNC_4:
415                 val |= PIN_FUNC_SEL_4;
416                 break;
417         default:
418                 break;
419         }
420
421         for (i = 0; i < grp_pins; i++) {
422                 unsigned int pin_id = grp->pins[i];
423                 struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
424
425                 if (!pin || pin->type != COMMON_PIN)
426                         continue;
427
428                 reg = readl((void __iomem *)pin->reg);
429                 reg &= ~PIN_FUNC_MASK;
430                 reg |= val;
431                 writel(reg, (void __iomem *)pin->reg);
432         }
433
434         return 0;
435 }
436
437 static const struct pinmux_ops sprd_pmx_ops = {
438         .get_functions_count = sprd_pmx_get_function_count,
439         .get_function_name = sprd_pmx_get_function_name,
440         .get_function_groups = sprd_pmx_get_function_groups,
441         .set_mux = sprd_pmx_set_mux,
442 };
443
444 static int sprd_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin_id,
445                             unsigned long *config)
446 {
447         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
448         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
449         unsigned int param = pinconf_to_config_param(*config);
450         unsigned int reg, arg;
451
452         if (!pin)
453                 return -EINVAL;
454
455         if (pin->type == GLOBAL_CTRL_PIN) {
456                 reg = (readl((void __iomem *)pin->reg) >>
457                            pin->bit_offset) & PINCTRL_BIT_MASK(pin->bit_width);
458         } else {
459                 reg = readl((void __iomem *)pin->reg);
460         }
461
462         if (pin->type == GLOBAL_CTRL_PIN &&
463             param == SPRD_PIN_CONFIG_CONTROL) {
464                 arg = reg;
465         } else if (pin->type == COMMON_PIN) {
466                 switch (param) {
467                 case SPRD_PIN_CONFIG_SLEEP_MODE:
468                         arg = (reg >> SLEEP_MODE_SHIFT) & SLEEP_MODE_MASK;
469                         break;
470                 case PIN_CONFIG_INPUT_ENABLE:
471                         arg = (reg >> SLEEP_INPUT_SHIFT) & SLEEP_INPUT_MASK;
472                         break;
473                 case PIN_CONFIG_OUTPUT:
474                         arg = reg & SLEEP_OUTPUT_MASK;
475                         break;
476                 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
477                         arg = 0;
478                         break;
479                 default:
480                         return -ENOTSUPP;
481                 }
482         } else if (pin->type == MISC_PIN) {
483                 switch (param) {
484                 case PIN_CONFIG_DRIVE_STRENGTH:
485                         arg = (reg >> DRIVE_STRENGTH_SHIFT) &
486                                 DRIVE_STRENGTH_MASK;
487                         break;
488                 case PIN_CONFIG_BIAS_PULL_DOWN:
489                         /* combine sleep pull down and pull down config */
490                         arg = ((reg >> SLEEP_PULL_DOWN_SHIFT) &
491                                SLEEP_PULL_DOWN_MASK) << 16;
492                         arg |= (reg >> PULL_DOWN_SHIFT) & PULL_DOWN_MASK;
493                         break;
494                 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
495                         arg = (reg >> INPUT_SCHMITT_SHIFT) & INPUT_SCHMITT_MASK;
496                         break;
497                 case PIN_CONFIG_BIAS_PULL_UP:
498                         /* combine sleep pull up and pull up config */
499                         arg = ((reg >> SLEEP_PULL_UP_SHIFT) &
500                                SLEEP_PULL_UP_MASK) << 16;
501                         arg |= (reg >> PULL_UP_SHIFT) & PULL_UP_MASK;
502                         break;
503                 case PIN_CONFIG_SLEEP_HARDWARE_STATE:
504                         arg = 0;
505                         break;
506                 default:
507                         return -ENOTSUPP;
508                 }
509         } else {
510                 return -ENOTSUPP;
511         }
512
513         *config = pinconf_to_config_packed(param, arg);
514         return 0;
515 }
516
517 static unsigned int sprd_pinconf_drive(unsigned int mA)
518 {
519         unsigned int val = 0;
520
521         switch (mA) {
522         case 2:
523                 break;
524         case 4:
525                 val |= BIT(19);
526                 break;
527         case 6:
528                 val |= BIT(20);
529                 break;
530         case 8:
531                 val |= BIT(19) | BIT(20);
532                 break;
533         case 10:
534                 val |= BIT(21);
535                 break;
536         case 12:
537                 val |= BIT(21) | BIT(19);
538                 break;
539         case 14:
540                 val |= BIT(21) | BIT(20);
541                 break;
542         case 16:
543                 val |= BIT(19) | BIT(20) | BIT(21);
544                 break;
545         case 20:
546                 val |= BIT(22);
547                 break;
548         case 21:
549                 val |= BIT(22) | BIT(19);
550                 break;
551         case 24:
552                 val |= BIT(22) | BIT(20);
553                 break;
554         case 25:
555                 val |= BIT(22) | BIT(20) | BIT(19);
556                 break;
557         case 27:
558                 val |= BIT(22) | BIT(21);
559                 break;
560         case 29:
561                 val |= BIT(22) | BIT(21) | BIT(19);
562                 break;
563         case 31:
564                 val |= BIT(22) | BIT(21) | BIT(20);
565                 break;
566         case 33:
567                 val |= BIT(22) | BIT(21) | BIT(20) | BIT(19);
568                 break;
569         default:
570                 break;
571         }
572
573         return val;
574 }
575
576 static bool sprd_pinctrl_check_sleep_config(unsigned long *configs,
577                                             unsigned int num_configs)
578 {
579         unsigned int param;
580         int i;
581
582         for (i = 0; i < num_configs; i++) {
583                 param = pinconf_to_config_param(configs[i]);
584                 if (param == PIN_CONFIG_SLEEP_HARDWARE_STATE)
585                         return true;
586         }
587
588         return false;
589 }
590
591 static int sprd_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin_id,
592                             unsigned long *configs, unsigned int num_configs)
593 {
594         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
595         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
596         bool is_sleep_config;
597         unsigned long reg;
598         int i;
599
600         if (!pin)
601                 return -EINVAL;
602
603         is_sleep_config = sprd_pinctrl_check_sleep_config(configs, num_configs);
604
605         for (i = 0; i < num_configs; i++) {
606                 unsigned int param, arg, shift, mask, val;
607
608                 param = pinconf_to_config_param(configs[i]);
609                 arg = pinconf_to_config_argument(configs[i]);
610
611                 val = 0;
612                 shift = 0;
613                 mask = 0;
614                 if (pin->type == GLOBAL_CTRL_PIN &&
615                     param == SPRD_PIN_CONFIG_CONTROL) {
616                         val = arg;
617                 } else if (pin->type == COMMON_PIN) {
618                         switch (param) {
619                         case SPRD_PIN_CONFIG_SLEEP_MODE:
620                                 if (arg & AP_SLEEP)
621                                         val |= AP_SLEEP_MODE;
622                                 if (arg & PUBCP_SLEEP)
623                                         val |= PUBCP_SLEEP_MODE;
624                                 if (arg & TGLDSP_SLEEP)
625                                         val |= TGLDSP_SLEEP_MODE;
626                                 if (arg & AGDSP_SLEEP)
627                                         val |= AGDSP_SLEEP_MODE;
628
629                                 mask = SLEEP_MODE_MASK;
630                                 shift = SLEEP_MODE_SHIFT;
631                                 break;
632                         case PIN_CONFIG_INPUT_ENABLE:
633                                 if (is_sleep_config == true) {
634                                         if (arg > 0)
635                                                 val |= SLEEP_INPUT;
636                                         else
637                                                 val &= ~SLEEP_INPUT;
638
639                                         mask = SLEEP_INPUT_MASK;
640                                         shift = SLEEP_INPUT_SHIFT;
641                                 }
642                                 break;
643                         case PIN_CONFIG_OUTPUT:
644                                 if (is_sleep_config == true) {
645                                         val |= SLEEP_OUTPUT;
646                                         mask = SLEEP_OUTPUT_MASK;
647                                         shift = SLEEP_OUTPUT_SHIFT;
648                                 }
649                                 break;
650                         case PIN_CONFIG_SLEEP_HARDWARE_STATE:
651                                 continue;
652                         default:
653                                 return -ENOTSUPP;
654                         }
655                 } else if (pin->type == MISC_PIN) {
656                         switch (param) {
657                         case PIN_CONFIG_DRIVE_STRENGTH:
658                                 if (arg < 2 || arg > 60)
659                                         return -EINVAL;
660
661                                 val = sprd_pinconf_drive(arg);
662                                 mask = DRIVE_STRENGTH_MASK;
663                                 shift = DRIVE_STRENGTH_SHIFT;
664                                 break;
665                         case PIN_CONFIG_BIAS_PULL_DOWN:
666                                 if (is_sleep_config == true) {
667                                         val |= SLEEP_PULL_DOWN;
668                                         mask = SLEEP_PULL_DOWN_MASK;
669                                         shift = SLEEP_PULL_DOWN_SHIFT;
670                                 } else {
671                                         val |= PULL_DOWN;
672                                         mask = PULL_DOWN_MASK;
673                                         shift = PULL_DOWN_SHIFT;
674                                 }
675                                 break;
676                         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
677                                 if (arg > 0)
678                                         val |= INPUT_SCHMITT;
679                                 else
680                                         val &= ~INPUT_SCHMITT;
681
682                                 mask = INPUT_SCHMITT_MASK;
683                                 shift = INPUT_SCHMITT_SHIFT;
684                                 break;
685                         case PIN_CONFIG_BIAS_PULL_UP:
686                                 if (is_sleep_config == true) {
687                                         val |= SLEEP_PULL_UP;
688                                         mask = SLEEP_PULL_UP_MASK;
689                                         shift = SLEEP_PULL_UP_SHIFT;
690                                 } else {
691                                         if (arg == 20000)
692                                                 val |= PULL_UP_20K;
693                                         else if (arg == 4700)
694                                                 val |= PULL_UP_4_7K;
695
696                                         mask = PULL_UP_MASK;
697                                         shift = PULL_UP_SHIFT;
698                                 }
699                                 break;
700                         case PIN_CONFIG_SLEEP_HARDWARE_STATE:
701                                 continue;
702                         default:
703                                 return -ENOTSUPP;
704                         }
705                 } else {
706                         return -ENOTSUPP;
707                 }
708
709                 if (pin->type == GLOBAL_CTRL_PIN) {
710                         reg = readl((void __iomem *)pin->reg);
711                         reg &= ~(PINCTRL_BIT_MASK(pin->bit_width)
712                                 << pin->bit_offset);
713                         reg |= (val & PINCTRL_BIT_MASK(pin->bit_width))
714                                 << pin->bit_offset;
715                         writel(reg, (void __iomem *)pin->reg);
716                 } else {
717                         reg = readl((void __iomem *)pin->reg);
718                         reg &= ~(mask << shift);
719                         reg |= val;
720                         writel(reg, (void __iomem *)pin->reg);
721                 }
722         }
723
724         return 0;
725 }
726
727 static int sprd_pinconf_group_get(struct pinctrl_dev *pctldev,
728                                   unsigned int selector, unsigned long *config)
729 {
730         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
731         struct sprd_pinctrl_soc_info *info = pctl->info;
732         struct sprd_pin_group *grp;
733         unsigned int pin_id;
734
735         if (selector >= info->ngroups)
736                 return -EINVAL;
737
738         grp = &info->groups[selector];
739         pin_id = grp->pins[0];
740
741         return sprd_pinconf_get(pctldev, pin_id, config);
742 }
743
744 static int sprd_pinconf_group_set(struct pinctrl_dev *pctldev,
745                                   unsigned int selector,
746                                   unsigned long *configs,
747                                   unsigned int num_configs)
748 {
749         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
750         struct sprd_pinctrl_soc_info *info = pctl->info;
751         struct sprd_pin_group *grp;
752         int ret, i;
753
754         if (selector >= info->ngroups)
755                 return -EINVAL;
756
757         grp = &info->groups[selector];
758
759         for (i = 0; i < grp->npins; i++) {
760                 unsigned int pin_id = grp->pins[i];
761
762                 ret = sprd_pinconf_set(pctldev, pin_id, configs, num_configs);
763                 if (ret)
764                         return ret;
765         }
766
767         return 0;
768 }
769
770 static int sprd_pinconf_get_config(struct pinctrl_dev *pctldev,
771                                    unsigned int pin_id,
772                                    unsigned long *config)
773 {
774         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
775         struct sprd_pin *pin = sprd_pinctrl_get_pin_by_id(pctl, pin_id);
776
777         if (!pin)
778                 return -EINVAL;
779
780         if (pin->type == GLOBAL_CTRL_PIN) {
781                 *config = (readl((void __iomem *)pin->reg) >>
782                            pin->bit_offset) & PINCTRL_BIT_MASK(pin->bit_width);
783         } else {
784                 *config = readl((void __iomem *)pin->reg);
785         }
786
787         return 0;
788 }
789
790 static void sprd_pinconf_dbg_show(struct pinctrl_dev *pctldev,
791                                   struct seq_file *s, unsigned int pin_id)
792 {
793         unsigned long config;
794         int ret;
795
796         ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
797         if (ret)
798                 return;
799
800         seq_printf(s, "0x%lx", config);
801 }
802
803 static void sprd_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
804                                         struct seq_file *s,
805                                         unsigned int selector)
806 {
807         struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
808         struct sprd_pinctrl_soc_info *info = pctl->info;
809         struct sprd_pin_group *grp;
810         unsigned long config;
811         const char *name;
812         int i, ret;
813
814         if (selector >= info->ngroups)
815                 return;
816
817         grp = &info->groups[selector];
818
819         seq_putc(s, '\n');
820         for (i = 0; i < grp->npins; i++, config++) {
821                 unsigned int pin_id = grp->pins[i];
822
823                 name = pin_get_name(pctldev, pin_id);
824                 ret = sprd_pinconf_get_config(pctldev, pin_id, &config);
825                 if (ret)
826                         return;
827
828                 seq_printf(s, "%s: 0x%lx ", name, config);
829         }
830 }
831
832 static const struct pinconf_ops sprd_pinconf_ops = {
833         .is_generic = true,
834         .pin_config_get = sprd_pinconf_get,
835         .pin_config_set = sprd_pinconf_set,
836         .pin_config_group_get = sprd_pinconf_group_get,
837         .pin_config_group_set = sprd_pinconf_group_set,
838         .pin_config_dbg_show = sprd_pinconf_dbg_show,
839         .pin_config_group_dbg_show = sprd_pinconf_group_dbg_show,
840 };
841
842 static const struct pinconf_generic_params sprd_dt_params[] = {
843         {"sprd,control", SPRD_PIN_CONFIG_CONTROL, 0},
844         {"sprd,sleep-mode", SPRD_PIN_CONFIG_SLEEP_MODE, 0},
845 };
846
847 #ifdef CONFIG_DEBUG_FS
848 static const struct pin_config_item sprd_conf_items[] = {
849         PCONFDUMP(SPRD_PIN_CONFIG_CONTROL, "global control", NULL, true),
850         PCONFDUMP(SPRD_PIN_CONFIG_SLEEP_MODE, "sleep mode", NULL, true),
851 };
852 #endif
853
854 static struct pinctrl_desc sprd_pinctrl_desc = {
855         .pctlops = &sprd_pctrl_ops,
856         .pmxops = &sprd_pmx_ops,
857         .confops = &sprd_pinconf_ops,
858         .num_custom_params = ARRAY_SIZE(sprd_dt_params),
859         .custom_params = sprd_dt_params,
860 #ifdef CONFIG_DEBUG_FS
861         .custom_conf_items = sprd_conf_items,
862 #endif
863         .owner = THIS_MODULE,
864 };
865
866 static int sprd_pinctrl_parse_groups(struct device_node *np,
867                                      struct sprd_pinctrl *sprd_pctl,
868                                      struct sprd_pin_group *grp)
869 {
870         struct property *prop;
871         const char *pin_name;
872         int ret, i = 0;
873
874         ret = of_property_count_strings(np, "pins");
875         if (ret < 0)
876                 return ret;
877
878         grp->name = np->name;
879         grp->npins = ret;
880         grp->pins = devm_kcalloc(sprd_pctl->dev,
881                                  grp->npins, sizeof(unsigned int),
882                                  GFP_KERNEL);
883         if (!grp->pins)
884                 return -ENOMEM;
885
886         of_property_for_each_string(np, "pins", prop, pin_name) {
887                 ret = sprd_pinctrl_get_id_by_name(sprd_pctl, pin_name);
888                 if (ret >= 0)
889                         grp->pins[i++] = ret;
890         }
891
892         for (i = 0; i < grp->npins; i++) {
893                 dev_dbg(sprd_pctl->dev,
894                         "Group[%s] contains [%d] pins: id = %d\n",
895                         grp->name, grp->npins, grp->pins[i]);
896         }
897
898         return 0;
899 }
900
901 static unsigned int sprd_pinctrl_get_groups(struct device_node *np)
902 {
903         struct device_node *child;
904         unsigned int group_cnt, cnt;
905
906         group_cnt = of_get_child_count(np);
907
908         for_each_child_of_node(np, child) {
909                 cnt = of_get_child_count(child);
910                 if (cnt > 0)
911                         group_cnt += cnt;
912         }
913
914         return group_cnt;
915 }
916
917 static int sprd_pinctrl_parse_dt(struct sprd_pinctrl *sprd_pctl)
918 {
919         struct sprd_pinctrl_soc_info *info = sprd_pctl->info;
920         struct device_node *np = sprd_pctl->dev->of_node;
921         struct device_node *child, *sub_child;
922         struct sprd_pin_group *grp;
923         const char **temp;
924         int ret;
925
926         if (!np)
927                 return -ENODEV;
928
929         info->ngroups = sprd_pinctrl_get_groups(np);
930         if (!info->ngroups)
931                 return 0;
932
933         info->groups = devm_kcalloc(sprd_pctl->dev,
934                                     info->ngroups,
935                                     sizeof(struct sprd_pin_group),
936                                     GFP_KERNEL);
937         if (!info->groups)
938                 return -ENOMEM;
939
940         info->grp_names = devm_kcalloc(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
973 static 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_kcalloc(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
1024 int 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_kcalloc(&pdev->dev,
1061                                 pinctrl_info->npins,
1062                                 sizeof(struct pinctrl_pin_desc),
1063                                 GFP_KERNEL);
1064         if (!pin_desc)
1065                 return -ENOMEM;
1066
1067         for (i = 0; i < pinctrl_info->npins; i++) {
1068                 pin_desc[i].number = pinctrl_info->pins[i].number;
1069                 pin_desc[i].name = pinctrl_info->pins[i].name;
1070                 pin_desc[i].drv_data = pinctrl_info;
1071         }
1072
1073         sprd_pinctrl_desc.pins = pin_desc;
1074         sprd_pinctrl_desc.name = dev_name(&pdev->dev);
1075         sprd_pinctrl_desc.npins = pinctrl_info->npins;
1076
1077         sprd_pctl->pctl = pinctrl_register(&sprd_pinctrl_desc,
1078                                            &pdev->dev, (void *)sprd_pctl);
1079         if (IS_ERR(sprd_pctl->pctl)) {
1080                 dev_err(&pdev->dev, "could not register pinctrl driver\n");
1081                 return PTR_ERR(sprd_pctl->pctl);
1082         }
1083
1084         ret = sprd_pinctrl_parse_dt(sprd_pctl);
1085         if (ret) {
1086                 dev_err(&pdev->dev, "fail to parse dt properties\n");
1087                 pinctrl_unregister(sprd_pctl->pctl);
1088                 return ret;
1089         }
1090
1091         return 0;
1092 }
1093
1094 int sprd_pinctrl_remove(struct platform_device *pdev)
1095 {
1096         struct sprd_pinctrl *sprd_pctl = platform_get_drvdata(pdev);
1097
1098         pinctrl_unregister(sprd_pctl->pctl);
1099         return 0;
1100 }
1101
1102 void sprd_pinctrl_shutdown(struct platform_device *pdev)
1103 {
1104         struct pinctrl *pinctl;
1105         struct pinctrl_state *state;
1106
1107         pinctl = devm_pinctrl_get(&pdev->dev);
1108         if (IS_ERR(pinctl))
1109                 return;
1110         state = pinctrl_lookup_state(pinctl, "shutdown");
1111         if (IS_ERR(state))
1112                 return;
1113         pinctrl_select_state(pinctl, state);
1114 }
1115
1116 MODULE_DESCRIPTION("SPREADTRUM Pin Controller Driver");
1117 MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");
1118 MODULE_LICENSE("GPL v2");