xref: /openbmc/linux/drivers/pinctrl/nxp/pinctrl-s32cc.c (revision 060f35a317ef09101b128f399dce7ed13d019461)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Core driver for the S32 CC (Common Chassis) pin controller
4  *
5  * Copyright 2017-2022 NXP
6  * Copyright (C) 2022 SUSE LLC
7  * Copyright 2015-2016 Freescale Semiconductor, Inc.
8  */
9 
10 #include <linux/bitops.h>
11 #include <linux/err.h>
12 #include <linux/gpio/driver.h>
13 #include <linux/init.h>
14 #include <linux/io.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/pinctrl/machine.h>
19 #include <linux/pinctrl/pinconf.h>
20 #include <linux/pinctrl/pinctrl.h>
21 #include <linux/pinctrl/pinmux.h>
22 #include <linux/regmap.h>
23 #include <linux/seq_file.h>
24 #include <linux/slab.h>
25 
26 #include "../core.h"
27 #include "../pinconf.h"
28 #include "../pinctrl-utils.h"
29 #include "pinctrl-s32.h"
30 
31 #define S32_PIN_ID_SHIFT	4
32 #define S32_PIN_ID_MASK		GENMASK(31, S32_PIN_ID_SHIFT)
33 
34 #define S32_MSCR_SSS_MASK	GENMASK(2, 0)
35 #define S32_MSCR_PUS		BIT(12)
36 #define S32_MSCR_PUE		BIT(13)
37 #define S32_MSCR_SRE(X)		(((X) & GENMASK(3, 0)) << 14)
38 #define S32_MSCR_IBE		BIT(19)
39 #define S32_MSCR_ODE		BIT(20)
40 #define S32_MSCR_OBE		BIT(21)
41 
42 static struct regmap_config s32_regmap_config = {
43 	.reg_bits = 32,
44 	.val_bits = 32,
45 	.reg_stride = 4,
46 };
47 
get_pin_no(u32 pinmux)48 static u32 get_pin_no(u32 pinmux)
49 {
50 	return (pinmux & S32_PIN_ID_MASK) >> S32_PIN_ID_SHIFT;
51 }
52 
get_pin_func(u32 pinmux)53 static u32 get_pin_func(u32 pinmux)
54 {
55 	return pinmux & GENMASK(3, 0);
56 }
57 
58 struct s32_pinctrl_mem_region {
59 	struct regmap *map;
60 	const struct s32_pin_range *pin_range;
61 	char name[8];
62 };
63 
64 /*
65  * Holds pin configuration for GPIO's.
66  * @pin_id: Pin ID for this GPIO
67  * @config: Pin settings
68  * @list: Linked list entry for each gpio pin
69  */
70 struct gpio_pin_config {
71 	unsigned int pin_id;
72 	unsigned int config;
73 	struct list_head list;
74 };
75 
76 /*
77  * Pad config save/restore for power suspend/resume.
78  */
79 struct s32_pinctrl_context {
80 	unsigned int *pads;
81 };
82 
83 /*
84  * @dev: a pointer back to containing device
85  * @pctl: a pointer to the pinctrl device structure
86  * @regions: reserved memory regions with start/end pin
87  * @info: structure containing information about the pin
88  * @gpio_configs: Saved configurations for GPIO pins
89  * @gpiop_configs_lock: lock for the `gpio_configs` list
90  * @s32_pinctrl_context: Configuration saved over system sleep
91  */
92 struct s32_pinctrl {
93 	struct device *dev;
94 	struct pinctrl_dev *pctl;
95 	struct s32_pinctrl_mem_region *regions;
96 	struct s32_pinctrl_soc_info *info;
97 	struct list_head gpio_configs;
98 	spinlock_t gpio_configs_lock;
99 #ifdef CONFIG_PM_SLEEP
100 	struct s32_pinctrl_context saved_context;
101 #endif
102 };
103 
104 static struct s32_pinctrl_mem_region *
s32_get_region(struct pinctrl_dev * pctldev,unsigned int pin)105 s32_get_region(struct pinctrl_dev *pctldev, unsigned int pin)
106 {
107 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
108 	const struct s32_pin_range *pin_range;
109 	unsigned int mem_regions = ipctl->info->soc_data->mem_regions;
110 	unsigned int i;
111 
112 	for (i = 0; i < mem_regions; i++) {
113 		pin_range = ipctl->regions[i].pin_range;
114 		if (pin >= pin_range->start && pin <= pin_range->end)
115 			return &ipctl->regions[i];
116 	}
117 
118 	return NULL;
119 }
120 
s32_check_pin(struct pinctrl_dev * pctldev,unsigned int pin)121 static inline int s32_check_pin(struct pinctrl_dev *pctldev,
122 				unsigned int pin)
123 {
124 	return s32_get_region(pctldev, pin) ? 0 : -EINVAL;
125 }
126 
s32_regmap_read(struct pinctrl_dev * pctldev,unsigned int pin,unsigned int * val)127 static inline int s32_regmap_read(struct pinctrl_dev *pctldev,
128 			   unsigned int pin, unsigned int *val)
129 {
130 	struct s32_pinctrl_mem_region *region;
131 	unsigned int offset;
132 
133 	region = s32_get_region(pctldev, pin);
134 	if (!region)
135 		return -EINVAL;
136 
137 	offset = (pin - region->pin_range->start) *
138 			regmap_get_reg_stride(region->map);
139 
140 	return regmap_read(region->map, offset, val);
141 }
142 
s32_regmap_write(struct pinctrl_dev * pctldev,unsigned int pin,unsigned int val)143 static inline int s32_regmap_write(struct pinctrl_dev *pctldev,
144 			    unsigned int pin,
145 			    unsigned int val)
146 {
147 	struct s32_pinctrl_mem_region *region;
148 	unsigned int offset;
149 
150 	region = s32_get_region(pctldev, pin);
151 	if (!region)
152 		return -EINVAL;
153 
154 	offset = (pin - region->pin_range->start) *
155 			regmap_get_reg_stride(region->map);
156 
157 	return regmap_write(region->map, offset, val);
158 
159 }
160 
s32_regmap_update(struct pinctrl_dev * pctldev,unsigned int pin,unsigned int mask,unsigned int val)161 static inline int s32_regmap_update(struct pinctrl_dev *pctldev, unsigned int pin,
162 			     unsigned int mask, unsigned int val)
163 {
164 	struct s32_pinctrl_mem_region *region;
165 	unsigned int offset;
166 
167 	region = s32_get_region(pctldev, pin);
168 	if (!region)
169 		return -EINVAL;
170 
171 	offset = (pin - region->pin_range->start) *
172 			regmap_get_reg_stride(region->map);
173 
174 	return regmap_update_bits(region->map, offset, mask, val);
175 }
176 
s32_get_groups_count(struct pinctrl_dev * pctldev)177 static int s32_get_groups_count(struct pinctrl_dev *pctldev)
178 {
179 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
180 	const struct s32_pinctrl_soc_info *info = ipctl->info;
181 
182 	return info->ngroups;
183 }
184 
s32_get_group_name(struct pinctrl_dev * pctldev,unsigned int selector)185 static const char *s32_get_group_name(struct pinctrl_dev *pctldev,
186 				      unsigned int selector)
187 {
188 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
189 	const struct s32_pinctrl_soc_info *info = ipctl->info;
190 
191 	return info->groups[selector].data.name;
192 }
193 
s32_get_group_pins(struct pinctrl_dev * pctldev,unsigned int selector,const unsigned int ** pins,unsigned int * npins)194 static int s32_get_group_pins(struct pinctrl_dev *pctldev,
195 			      unsigned int selector, const unsigned int **pins,
196 			      unsigned int *npins)
197 {
198 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
199 	const struct s32_pinctrl_soc_info *info = ipctl->info;
200 
201 	*pins = info->groups[selector].data.pins;
202 	*npins = info->groups[selector].data.npins;
203 
204 	return 0;
205 }
206 
s32_pin_dbg_show(struct pinctrl_dev * pctldev,struct seq_file * s,unsigned int offset)207 static void s32_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
208 			     unsigned int offset)
209 {
210 	seq_printf(s, "%s", dev_name(pctldev->dev));
211 }
212 
s32_dt_group_node_to_map(struct pinctrl_dev * pctldev,struct device_node * np,struct pinctrl_map ** map,unsigned int * reserved_maps,unsigned int * num_maps,const char * func_name)213 static int s32_dt_group_node_to_map(struct pinctrl_dev *pctldev,
214 				    struct device_node *np,
215 				    struct pinctrl_map **map,
216 				    unsigned int *reserved_maps,
217 				    unsigned int *num_maps,
218 				    const char *func_name)
219 {
220 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
221 	struct device *dev = ipctl->dev;
222 	unsigned long *cfgs = NULL;
223 	unsigned int n_cfgs, reserve = 1;
224 	int n_pins, ret;
225 
226 	n_pins = of_property_count_elems_of_size(np, "pinmux", sizeof(u32));
227 	if (n_pins < 0) {
228 		dev_warn(dev, "Can't find 'pinmux' property in node %pOFn\n", np);
229 	} else if (!n_pins) {
230 		return -EINVAL;
231 	}
232 
233 	ret = pinconf_generic_parse_dt_config(np, pctldev, &cfgs, &n_cfgs);
234 	if (ret) {
235 		dev_err(dev, "%pOF: could not parse node property\n", np);
236 		return ret;
237 	}
238 
239 	if (n_cfgs)
240 		reserve++;
241 
242 	ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps, num_maps,
243 					reserve);
244 	if (ret < 0)
245 		goto free_cfgs;
246 
247 	ret = pinctrl_utils_add_map_mux(pctldev, map, reserved_maps, num_maps,
248 					np->name, func_name);
249 	if (ret < 0)
250 		goto free_cfgs;
251 
252 	if (n_cfgs) {
253 		ret = pinctrl_utils_add_map_configs(pctldev, map, reserved_maps,
254 						    num_maps, np->name, cfgs, n_cfgs,
255 						    PIN_MAP_TYPE_CONFIGS_GROUP);
256 		if (ret < 0)
257 			goto free_cfgs;
258 	}
259 
260 free_cfgs:
261 	kfree(cfgs);
262 	return ret;
263 }
264 
s32_dt_node_to_map(struct pinctrl_dev * pctldev,struct device_node * np_config,struct pinctrl_map ** map,unsigned int * num_maps)265 static int s32_dt_node_to_map(struct pinctrl_dev *pctldev,
266 			      struct device_node *np_config,
267 			      struct pinctrl_map **map,
268 			      unsigned int *num_maps)
269 {
270 	unsigned int reserved_maps;
271 	struct device_node *np;
272 	int ret = 0;
273 
274 	reserved_maps = 0;
275 	*map = NULL;
276 	*num_maps = 0;
277 
278 	for_each_available_child_of_node(np_config, np) {
279 		ret = s32_dt_group_node_to_map(pctldev, np, map,
280 					       &reserved_maps, num_maps,
281 					       np_config->name);
282 		if (ret < 0) {
283 			of_node_put(np);
284 			break;
285 		}
286 	}
287 
288 	if (ret)
289 		pinctrl_utils_free_map(pctldev, *map, *num_maps);
290 
291 	return ret;
292 
293 }
294 
295 static const struct pinctrl_ops s32_pctrl_ops = {
296 	.get_groups_count = s32_get_groups_count,
297 	.get_group_name = s32_get_group_name,
298 	.get_group_pins = s32_get_group_pins,
299 	.pin_dbg_show = s32_pin_dbg_show,
300 	.dt_node_to_map = s32_dt_node_to_map,
301 	.dt_free_map = pinctrl_utils_free_map,
302 };
303 
s32_pmx_set(struct pinctrl_dev * pctldev,unsigned int selector,unsigned int group)304 static int s32_pmx_set(struct pinctrl_dev *pctldev, unsigned int selector,
305 		       unsigned int group)
306 {
307 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
308 	const struct s32_pinctrl_soc_info *info = ipctl->info;
309 	int i, ret;
310 	struct s32_pin_group *grp;
311 
312 	/*
313 	 * Configure the mux mode for each pin in the group for a specific
314 	 * function.
315 	 */
316 	grp = &info->groups[group];
317 
318 	dev_dbg(ipctl->dev, "set mux for function %s group %s\n",
319 		info->functions[selector].name, grp->data.name);
320 
321 	/* Check beforehand so we don't have a partial config. */
322 	for (i = 0; i < grp->data.npins; i++) {
323 		if (s32_check_pin(pctldev, grp->data.pins[i]) != 0) {
324 			dev_err(info->dev, "invalid pin: %u in group: %u\n",
325 				grp->data.pins[i], group);
326 			return -EINVAL;
327 		}
328 	}
329 
330 	for (i = 0, ret = 0; i < grp->data.npins && !ret; i++) {
331 		ret = s32_regmap_update(pctldev, grp->data.pins[i],
332 					S32_MSCR_SSS_MASK, grp->pin_sss[i]);
333 		if (ret) {
334 			dev_err(info->dev, "Failed to set pin %u\n",
335 				grp->data.pins[i]);
336 			return ret;
337 		}
338 	}
339 
340 	return 0;
341 }
342 
s32_pmx_get_funcs_count(struct pinctrl_dev * pctldev)343 static int s32_pmx_get_funcs_count(struct pinctrl_dev *pctldev)
344 {
345 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
346 	const struct s32_pinctrl_soc_info *info = ipctl->info;
347 
348 	return info->nfunctions;
349 }
350 
s32_pmx_get_func_name(struct pinctrl_dev * pctldev,unsigned int selector)351 static const char *s32_pmx_get_func_name(struct pinctrl_dev *pctldev,
352 					 unsigned int selector)
353 {
354 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
355 	const struct s32_pinctrl_soc_info *info = ipctl->info;
356 
357 	return info->functions[selector].name;
358 }
359 
s32_pmx_get_groups(struct pinctrl_dev * pctldev,unsigned int selector,const char * const ** groups,unsigned int * const num_groups)360 static int s32_pmx_get_groups(struct pinctrl_dev *pctldev,
361 			      unsigned int selector,
362 			      const char * const **groups,
363 			      unsigned int * const num_groups)
364 {
365 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
366 	const struct s32_pinctrl_soc_info *info = ipctl->info;
367 
368 	*groups = info->functions[selector].groups;
369 	*num_groups = info->functions[selector].ngroups;
370 
371 	return 0;
372 }
373 
s32_pmx_gpio_request_enable(struct pinctrl_dev * pctldev,struct pinctrl_gpio_range * range,unsigned int offset)374 static int s32_pmx_gpio_request_enable(struct pinctrl_dev *pctldev,
375 				       struct pinctrl_gpio_range *range,
376 				       unsigned int offset)
377 {
378 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
379 	struct gpio_pin_config *gpio_pin;
380 	unsigned int config;
381 	unsigned long flags;
382 	int ret;
383 
384 	ret = s32_regmap_read(pctldev, offset, &config);
385 	if (ret)
386 		return ret;
387 
388 	/* Save current configuration */
389 	gpio_pin = kmalloc(sizeof(*gpio_pin), GFP_KERNEL);
390 	if (!gpio_pin)
391 		return -ENOMEM;
392 
393 	gpio_pin->pin_id = offset;
394 	gpio_pin->config = config;
395 
396 	spin_lock_irqsave(&ipctl->gpio_configs_lock, flags);
397 	list_add(&gpio_pin->list, &ipctl->gpio_configs);
398 	spin_unlock_irqrestore(&ipctl->gpio_configs_lock, flags);
399 
400 	/* GPIO pin means SSS = 0 */
401 	config &= ~S32_MSCR_SSS_MASK;
402 
403 	return s32_regmap_write(pctldev, offset, config);
404 }
405 
s32_pmx_gpio_disable_free(struct pinctrl_dev * pctldev,struct pinctrl_gpio_range * range,unsigned int offset)406 static void s32_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
407 				      struct pinctrl_gpio_range *range,
408 				      unsigned int offset)
409 {
410 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
411 	struct gpio_pin_config *gpio_pin, *tmp;
412 	unsigned long flags;
413 	int ret;
414 
415 	spin_lock_irqsave(&ipctl->gpio_configs_lock, flags);
416 
417 	list_for_each_entry_safe(gpio_pin, tmp, &ipctl->gpio_configs, list) {
418 		if (gpio_pin->pin_id == offset) {
419 			ret = s32_regmap_write(pctldev, gpio_pin->pin_id,
420 						 gpio_pin->config);
421 			if (ret != 0)
422 				goto unlock;
423 
424 			list_del(&gpio_pin->list);
425 			kfree(gpio_pin);
426 			break;
427 		}
428 	}
429 
430 unlock:
431 	spin_unlock_irqrestore(&ipctl->gpio_configs_lock, flags);
432 }
433 
s32_pmx_gpio_set_direction(struct pinctrl_dev * pctldev,struct pinctrl_gpio_range * range,unsigned int offset,bool input)434 static int s32_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
435 				      struct pinctrl_gpio_range *range,
436 				      unsigned int offset,
437 				      bool input)
438 {
439 	unsigned int config;
440 	unsigned int mask = S32_MSCR_IBE | S32_MSCR_OBE;
441 
442 	if (input) {
443 		/* Disable output buffer and enable input buffer */
444 		config = S32_MSCR_IBE;
445 	} else {
446 		/* Disable input buffer and enable output buffer */
447 		config = S32_MSCR_OBE;
448 	}
449 
450 	return s32_regmap_update(pctldev, offset, mask, config);
451 }
452 
453 static const struct pinmux_ops s32_pmx_ops = {
454 	.get_functions_count = s32_pmx_get_funcs_count,
455 	.get_function_name = s32_pmx_get_func_name,
456 	.get_function_groups = s32_pmx_get_groups,
457 	.set_mux = s32_pmx_set,
458 	.gpio_request_enable = s32_pmx_gpio_request_enable,
459 	.gpio_disable_free = s32_pmx_gpio_disable_free,
460 	.gpio_set_direction = s32_pmx_gpio_set_direction,
461 };
462 
463 /* Set the reserved elements as -1 */
464 static const int support_slew[] = {208, -1, -1, -1, 166, 150, 133, 83};
465 
s32_get_slew_regval(int arg)466 static int s32_get_slew_regval(int arg)
467 {
468 	unsigned int i;
469 
470 	/* Translate a real slew rate (MHz) to a register value */
471 	for (i = 0; i < ARRAY_SIZE(support_slew); i++) {
472 		if (arg == support_slew[i])
473 			return i;
474 	}
475 
476 	return -EINVAL;
477 }
478 
s32_pin_set_pull(enum pin_config_param param,unsigned int * mask,unsigned int * config)479 static inline void s32_pin_set_pull(enum pin_config_param param,
480 				   unsigned int *mask, unsigned int *config)
481 {
482 	switch (param) {
483 	case PIN_CONFIG_BIAS_DISABLE:
484 	case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
485 		*config &= ~(S32_MSCR_PUS | S32_MSCR_PUE);
486 		break;
487 	case PIN_CONFIG_BIAS_PULL_UP:
488 		*config |= S32_MSCR_PUS | S32_MSCR_PUE;
489 		break;
490 	case PIN_CONFIG_BIAS_PULL_DOWN:
491 		*config &= ~S32_MSCR_PUS;
492 		*config |= S32_MSCR_PUE;
493 		break;
494 	default:
495 		return;
496 	}
497 
498 	*mask |= S32_MSCR_PUS | S32_MSCR_PUE;
499 }
500 
s32_parse_pincfg(unsigned long pincfg,unsigned int * mask,unsigned int * config)501 static int s32_parse_pincfg(unsigned long pincfg, unsigned int *mask,
502 			    unsigned int *config)
503 {
504 	enum pin_config_param param;
505 	u32 arg;
506 	int ret;
507 
508 	param = pinconf_to_config_param(pincfg);
509 	arg = pinconf_to_config_argument(pincfg);
510 
511 	switch (param) {
512 	/* All pins are persistent over suspend */
513 	case PIN_CONFIG_PERSIST_STATE:
514 		return 0;
515 	case PIN_CONFIG_DRIVE_OPEN_DRAIN:
516 		*config |= S32_MSCR_ODE;
517 		*mask |= S32_MSCR_ODE;
518 		break;
519 	case PIN_CONFIG_OUTPUT_ENABLE:
520 		if (arg)
521 			*config |= S32_MSCR_OBE;
522 		else
523 			*config &= ~S32_MSCR_OBE;
524 		*mask |= S32_MSCR_OBE;
525 		break;
526 	case PIN_CONFIG_INPUT_ENABLE:
527 		if (arg)
528 			*config |= S32_MSCR_IBE;
529 		else
530 			*config &= ~S32_MSCR_IBE;
531 		*mask |= S32_MSCR_IBE;
532 		break;
533 	case PIN_CONFIG_SLEW_RATE:
534 		ret = s32_get_slew_regval(arg);
535 		if (ret < 0)
536 			return ret;
537 		*config |= S32_MSCR_SRE((u32)ret);
538 		*mask |= S32_MSCR_SRE(~0);
539 		break;
540 	case PIN_CONFIG_BIAS_DISABLE:
541 	case PIN_CONFIG_BIAS_PULL_UP:
542 	case PIN_CONFIG_BIAS_PULL_DOWN:
543 		s32_pin_set_pull(param, mask, config);
544 		break;
545 	case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
546 		*config &= ~(S32_MSCR_ODE | S32_MSCR_OBE | S32_MSCR_IBE);
547 		*mask |= S32_MSCR_ODE | S32_MSCR_OBE | S32_MSCR_IBE;
548 		s32_pin_set_pull(param, mask, config);
549 		break;
550 	default:
551 		return -EOPNOTSUPP;
552 	}
553 
554 	return 0;
555 }
556 
s32_pinconf_mscr_update(struct pinctrl_dev * pctldev,unsigned int pin_id,unsigned long * configs,unsigned int num_configs)557 static int s32_pinconf_mscr_update(struct pinctrl_dev *pctldev,
558 				   unsigned int pin_id,
559 				   unsigned long *configs,
560 				   unsigned int num_configs)
561 {
562 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
563 	unsigned int config = 0, mask = 0;
564 	int i, ret;
565 
566 	ret = s32_check_pin(pctldev, pin_id);
567 	if (ret)
568 		return ret;
569 
570 	dev_dbg(ipctl->dev, "pinconf set pin %s with %u configs\n",
571 		pin_get_name(pctldev, pin_id), num_configs);
572 
573 	for (i = 0; i < num_configs; i++) {
574 		ret = s32_parse_pincfg(configs[i], &mask, &config);
575 		if (ret)
576 			return ret;
577 	}
578 
579 	if (!config && !mask)
580 		return 0;
581 
582 	dev_dbg(ipctl->dev, "update: pin %u cfg 0x%x\n", pin_id, config);
583 
584 	return s32_regmap_update(pctldev, pin_id, mask, config);
585 }
586 
s32_pinconf_get(struct pinctrl_dev * pctldev,unsigned int pin_id,unsigned long * config)587 static int s32_pinconf_get(struct pinctrl_dev *pctldev,
588 			   unsigned int pin_id,
589 			   unsigned long *config)
590 {
591 	return s32_regmap_read(pctldev, pin_id, (unsigned int *)config);
592 }
593 
s32_pinconf_set(struct pinctrl_dev * pctldev,unsigned int pin_id,unsigned long * configs,unsigned int num_configs)594 static int s32_pinconf_set(struct pinctrl_dev *pctldev,
595 			   unsigned int pin_id, unsigned long *configs,
596 			   unsigned int num_configs)
597 {
598 	return s32_pinconf_mscr_update(pctldev, pin_id, configs,
599 				       num_configs);
600 }
601 
s32_pconf_group_set(struct pinctrl_dev * pctldev,unsigned int selector,unsigned long * configs,unsigned int num_configs)602 static int s32_pconf_group_set(struct pinctrl_dev *pctldev, unsigned int selector,
603 			       unsigned long *configs, unsigned int num_configs)
604 {
605 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
606 	const struct s32_pinctrl_soc_info *info = ipctl->info;
607 	struct s32_pin_group *grp;
608 	int i, ret;
609 
610 	grp = &info->groups[selector];
611 	for (i = 0; i < grp->data.npins; i++) {
612 		ret = s32_pinconf_mscr_update(pctldev, grp->data.pins[i],
613 					      configs, num_configs);
614 		if (ret)
615 			return ret;
616 	}
617 
618 	return 0;
619 }
620 
s32_pinconf_dbg_show(struct pinctrl_dev * pctldev,struct seq_file * s,unsigned int pin_id)621 static void s32_pinconf_dbg_show(struct pinctrl_dev *pctldev,
622 				 struct seq_file *s, unsigned int pin_id)
623 {
624 	unsigned int config;
625 	int ret;
626 
627 	ret = s32_regmap_read(pctldev, pin_id, &config);
628 	if (ret)
629 		return;
630 
631 	seq_printf(s, "0x%x", config);
632 }
633 
s32_pinconf_group_dbg_show(struct pinctrl_dev * pctldev,struct seq_file * s,unsigned int selector)634 static void s32_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
635 				       struct seq_file *s, unsigned int selector)
636 {
637 	struct s32_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
638 	const struct s32_pinctrl_soc_info *info = ipctl->info;
639 	struct s32_pin_group *grp;
640 	unsigned int config;
641 	const char *name;
642 	int i, ret;
643 
644 	seq_puts(s, "\n");
645 	grp = &info->groups[selector];
646 	for (i = 0; i < grp->data.npins; i++) {
647 		name = pin_get_name(pctldev, grp->data.pins[i]);
648 		ret = s32_regmap_read(pctldev, grp->data.pins[i], &config);
649 		if (ret)
650 			return;
651 		seq_printf(s, "%s: 0x%x\n", name, config);
652 	}
653 }
654 
655 static const struct pinconf_ops s32_pinconf_ops = {
656 	.pin_config_get = s32_pinconf_get,
657 	.pin_config_set	= s32_pinconf_set,
658 	.pin_config_group_set = s32_pconf_group_set,
659 	.pin_config_dbg_show = s32_pinconf_dbg_show,
660 	.pin_config_group_dbg_show = s32_pinconf_group_dbg_show,
661 };
662 
663 #ifdef CONFIG_PM_SLEEP
s32_pinctrl_should_save(struct s32_pinctrl * ipctl,unsigned int pin)664 static bool s32_pinctrl_should_save(struct s32_pinctrl *ipctl,
665 				    unsigned int pin)
666 {
667 	const struct pin_desc *pd = pin_desc_get(ipctl->pctl, pin);
668 
669 	if (!pd)
670 		return false;
671 
672 	/*
673 	 * Only restore the pin if it is actually in use by the kernel (or
674 	 * by userspace).
675 	 */
676 	if (pd->mux_owner || pd->gpio_owner)
677 		return true;
678 
679 	return false;
680 }
681 
s32_pinctrl_suspend(struct device * dev)682 int s32_pinctrl_suspend(struct device *dev)
683 {
684 	struct platform_device *pdev = to_platform_device(dev);
685 	struct s32_pinctrl *ipctl = platform_get_drvdata(pdev);
686 	const struct pinctrl_pin_desc *pin;
687 	const struct s32_pinctrl_soc_info *info = ipctl->info;
688 	struct s32_pinctrl_context *saved_context = &ipctl->saved_context;
689 	int i;
690 	int ret;
691 	unsigned int config;
692 
693 	for (i = 0; i < info->soc_data->npins; i++) {
694 		pin = &info->soc_data->pins[i];
695 
696 		if (!s32_pinctrl_should_save(ipctl, pin->number))
697 			continue;
698 
699 		ret = s32_regmap_read(ipctl->pctl, pin->number, &config);
700 		if (ret)
701 			return -EINVAL;
702 
703 		saved_context->pads[i] = config;
704 	}
705 
706 	return 0;
707 }
708 
s32_pinctrl_resume(struct device * dev)709 int s32_pinctrl_resume(struct device *dev)
710 {
711 	struct platform_device *pdev = to_platform_device(dev);
712 	struct s32_pinctrl *ipctl = platform_get_drvdata(pdev);
713 	const struct s32_pinctrl_soc_info *info = ipctl->info;
714 	const struct pinctrl_pin_desc *pin;
715 	struct s32_pinctrl_context *saved_context = &ipctl->saved_context;
716 	int ret, i;
717 
718 	for (i = 0; i < info->soc_data->npins; i++) {
719 		pin = &info->soc_data->pins[i];
720 
721 		if (!s32_pinctrl_should_save(ipctl, pin->number))
722 			continue;
723 
724 		ret = s32_regmap_write(ipctl->pctl, pin->number,
725 					 saved_context->pads[i]);
726 		if (ret)
727 			return ret;
728 	}
729 
730 	return 0;
731 }
732 #endif
733 
s32_pinctrl_parse_groups(struct device_node * np,struct s32_pin_group * grp,struct s32_pinctrl_soc_info * info)734 static int s32_pinctrl_parse_groups(struct device_node *np,
735 				     struct s32_pin_group *grp,
736 				     struct s32_pinctrl_soc_info *info)
737 {
738 	struct device *dev;
739 	unsigned int *pins, *sss;
740 	int i, npins;
741 	u32 pinmux;
742 
743 	dev = info->dev;
744 
745 	dev_dbg(dev, "group: %pOFn\n", np);
746 
747 	/* Initialise group */
748 	grp->data.name = np->name;
749 
750 	npins = of_property_count_elems_of_size(np, "pinmux", sizeof(u32));
751 	if (npins < 0) {
752 		dev_err(dev, "Failed to read 'pinmux' property in node %s.\n",
753 			grp->data.name);
754 		return -EINVAL;
755 	}
756 	if (!npins) {
757 		dev_err(dev, "The group %s has no pins.\n", grp->data.name);
758 		return -EINVAL;
759 	}
760 
761 	grp->data.npins = npins;
762 
763 	pins = devm_kcalloc(info->dev, npins, sizeof(*pins), GFP_KERNEL);
764 	sss = devm_kcalloc(info->dev, npins, sizeof(*sss), GFP_KERNEL);
765 	if (!pins || !sss)
766 		return -ENOMEM;
767 
768 	i = 0;
769 	of_property_for_each_u32(np, "pinmux", pinmux) {
770 		pins[i] = get_pin_no(pinmux);
771 		sss[i] = get_pin_func(pinmux);
772 
773 		dev_dbg(info->dev, "pin: 0x%x, sss: 0x%x", pins[i], sss[i]);
774 		i++;
775 	}
776 
777 	grp->data.pins = pins;
778 	grp->pin_sss = sss;
779 
780 	return 0;
781 }
782 
s32_pinctrl_parse_functions(struct device_node * np,struct s32_pinctrl_soc_info * info,u32 index)783 static int s32_pinctrl_parse_functions(struct device_node *np,
784 					struct s32_pinctrl_soc_info *info,
785 					u32 index)
786 {
787 	struct device_node *child;
788 	struct pinfunction *func;
789 	struct s32_pin_group *grp;
790 	const char **groups;
791 	u32 i = 0;
792 	int ret = 0;
793 
794 	dev_dbg(info->dev, "parse function(%u): %pOFn\n", index, np);
795 
796 	func = &info->functions[index];
797 
798 	/* Initialise function */
799 	func->name = np->name;
800 	func->ngroups = of_get_child_count(np);
801 	if (func->ngroups == 0) {
802 		dev_err(info->dev, "no groups defined in %pOF\n", np);
803 		return -EINVAL;
804 	}
805 
806 	groups = devm_kcalloc(info->dev, func->ngroups,
807 				    sizeof(*func->groups), GFP_KERNEL);
808 	if (!groups)
809 		return -ENOMEM;
810 
811 	for_each_child_of_node(np, child) {
812 		groups[i] = child->name;
813 		grp = &info->groups[info->grp_index++];
814 		ret = s32_pinctrl_parse_groups(child, grp, info);
815 		if (ret) {
816 			of_node_put(child);
817 			return ret;
818 		}
819 		i++;
820 	}
821 
822 	func->groups = groups;
823 
824 	return 0;
825 }
826 
s32_pinctrl_probe_dt(struct platform_device * pdev,struct s32_pinctrl * ipctl)827 static int s32_pinctrl_probe_dt(struct platform_device *pdev,
828 				struct s32_pinctrl *ipctl)
829 {
830 	struct s32_pinctrl_soc_info *info = ipctl->info;
831 	struct device_node *np = pdev->dev.of_node;
832 	struct device_node *child;
833 	struct resource *res;
834 	struct regmap *map;
835 	void __iomem *base;
836 	unsigned int mem_regions = info->soc_data->mem_regions;
837 	int ret;
838 	u32 nfuncs = 0;
839 	u32 i = 0;
840 
841 	if (!np)
842 		return -ENODEV;
843 
844 	if (mem_regions == 0 || mem_regions >= 10000) {
845 		dev_err(&pdev->dev, "mem_regions is invalid: %u\n", mem_regions);
846 		return -EINVAL;
847 	}
848 
849 	ipctl->regions = devm_kcalloc(&pdev->dev, mem_regions,
850 				      sizeof(*ipctl->regions), GFP_KERNEL);
851 	if (!ipctl->regions)
852 		return -ENOMEM;
853 
854 	for (i = 0; i < mem_regions; i++) {
855 		base = devm_platform_get_and_ioremap_resource(pdev, i, &res);
856 		if (IS_ERR(base))
857 			return PTR_ERR(base);
858 
859 		snprintf(ipctl->regions[i].name,
860 			 sizeof(ipctl->regions[i].name), "map%u", i);
861 
862 		s32_regmap_config.name = ipctl->regions[i].name;
863 		s32_regmap_config.max_register = resource_size(res) -
864 						 s32_regmap_config.reg_stride;
865 
866 		map = devm_regmap_init_mmio(&pdev->dev, base,
867 						&s32_regmap_config);
868 		if (IS_ERR(map)) {
869 			dev_err(&pdev->dev, "Failed to init regmap[%u]\n", i);
870 			return PTR_ERR(map);
871 		}
872 
873 		ipctl->regions[i].map = map;
874 		ipctl->regions[i].pin_range = &info->soc_data->mem_pin_ranges[i];
875 	}
876 
877 	nfuncs = of_get_child_count(np);
878 	if (nfuncs <= 0) {
879 		dev_err(&pdev->dev, "no functions defined\n");
880 		return -EINVAL;
881 	}
882 
883 	info->nfunctions = nfuncs;
884 	info->functions = devm_kcalloc(&pdev->dev, nfuncs,
885 				       sizeof(*info->functions), GFP_KERNEL);
886 	if (!info->functions)
887 		return -ENOMEM;
888 
889 	info->ngroups = 0;
890 	for_each_child_of_node(np, child)
891 		info->ngroups += of_get_child_count(child);
892 
893 	info->groups = devm_kcalloc(&pdev->dev, info->ngroups,
894 				    sizeof(*info->groups), GFP_KERNEL);
895 	if (!info->groups)
896 		return -ENOMEM;
897 
898 	i = 0;
899 	for_each_child_of_node(np, child) {
900 		ret = s32_pinctrl_parse_functions(child, info, i++);
901 		if (ret) {
902 			of_node_put(child);
903 			return ret;
904 		}
905 	}
906 
907 	return 0;
908 }
909 
s32_pinctrl_probe(struct platform_device * pdev,const struct s32_pinctrl_soc_data * soc_data)910 int s32_pinctrl_probe(struct platform_device *pdev,
911 		      const struct s32_pinctrl_soc_data *soc_data)
912 {
913 	struct s32_pinctrl *ipctl;
914 	int ret;
915 	struct pinctrl_desc *s32_pinctrl_desc;
916 	struct s32_pinctrl_soc_info *info;
917 #ifdef CONFIG_PM_SLEEP
918 	struct s32_pinctrl_context *saved_context;
919 #endif
920 
921 	if (!soc_data || !soc_data->pins || !soc_data->npins) {
922 		dev_err(&pdev->dev, "wrong pinctrl info\n");
923 		return -EINVAL;
924 	}
925 
926 	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
927 	if (!info)
928 		return -ENOMEM;
929 
930 	info->soc_data = soc_data;
931 	info->dev = &pdev->dev;
932 
933 	/* Create state holders etc for this driver */
934 	ipctl = devm_kzalloc(&pdev->dev, sizeof(*ipctl), GFP_KERNEL);
935 	if (!ipctl)
936 		return -ENOMEM;
937 
938 	ipctl->info = info;
939 	ipctl->dev = info->dev;
940 	platform_set_drvdata(pdev, ipctl);
941 
942 	INIT_LIST_HEAD(&ipctl->gpio_configs);
943 	spin_lock_init(&ipctl->gpio_configs_lock);
944 
945 	s32_pinctrl_desc =
946 		devm_kmalloc(&pdev->dev, sizeof(*s32_pinctrl_desc), GFP_KERNEL);
947 	if (!s32_pinctrl_desc)
948 		return -ENOMEM;
949 
950 	s32_pinctrl_desc->name = dev_name(&pdev->dev);
951 	s32_pinctrl_desc->pins = info->soc_data->pins;
952 	s32_pinctrl_desc->npins = info->soc_data->npins;
953 	s32_pinctrl_desc->pctlops = &s32_pctrl_ops;
954 	s32_pinctrl_desc->pmxops = &s32_pmx_ops;
955 	s32_pinctrl_desc->confops = &s32_pinconf_ops;
956 	s32_pinctrl_desc->owner = THIS_MODULE;
957 
958 	ret = s32_pinctrl_probe_dt(pdev, ipctl);
959 	if (ret) {
960 		dev_err(&pdev->dev, "fail to probe dt properties\n");
961 		return ret;
962 	}
963 
964 	ipctl->pctl = devm_pinctrl_register(&pdev->dev, s32_pinctrl_desc,
965 					    ipctl);
966 	if (IS_ERR(ipctl->pctl))
967 		return dev_err_probe(&pdev->dev, PTR_ERR(ipctl->pctl),
968 				     "could not register s32 pinctrl driver\n");
969 
970 #ifdef CONFIG_PM_SLEEP
971 	saved_context = &ipctl->saved_context;
972 	saved_context->pads =
973 		devm_kcalloc(&pdev->dev, info->soc_data->npins,
974 			     sizeof(*saved_context->pads),
975 			     GFP_KERNEL);
976 	if (!saved_context->pads)
977 		return -ENOMEM;
978 #endif
979 
980 	dev_info(&pdev->dev, "initialized s32 pinctrl driver\n");
981 
982 	return 0;
983 }
984