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