1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2016 IBM Corp.
4  */
5 
6 #include <linux/mfd/syscon.h>
7 #include <linux/platform_device.h>
8 #include <linux/slab.h>
9 #include <linux/string.h>
10 #include "../core.h"
11 #include "pinctrl-aspeed.h"
12 
13 int aspeed_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
14 {
15 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
16 
17 	return pdata->pinmux.ngroups;
18 }
19 
20 const char *aspeed_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
21 		unsigned int group)
22 {
23 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
24 
25 	return pdata->pinmux.groups[group].name;
26 }
27 
28 int aspeed_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
29 				  unsigned int group, const unsigned int **pins,
30 				  unsigned int *npins)
31 {
32 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
33 
34 	*pins = &pdata->pinmux.groups[group].pins[0];
35 	*npins = pdata->pinmux.groups[group].npins;
36 
37 	return 0;
38 }
39 
40 void aspeed_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
41 				 struct seq_file *s, unsigned int offset)
42 {
43 	seq_printf(s, " %s", dev_name(pctldev->dev));
44 }
45 
46 int aspeed_pinmux_get_fn_count(struct pinctrl_dev *pctldev)
47 {
48 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
49 
50 	return pdata->pinmux.nfunctions;
51 }
52 
53 const char *aspeed_pinmux_get_fn_name(struct pinctrl_dev *pctldev,
54 				      unsigned int function)
55 {
56 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
57 
58 	return pdata->pinmux.functions[function].name;
59 }
60 
61 int aspeed_pinmux_get_fn_groups(struct pinctrl_dev *pctldev,
62 				unsigned int function,
63 				const char * const **groups,
64 				unsigned int * const num_groups)
65 {
66 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
67 
68 	*groups = pdata->pinmux.functions[function].groups;
69 	*num_groups = pdata->pinmux.functions[function].ngroups;
70 
71 	return 0;
72 }
73 
74 static int aspeed_sig_expr_enable(struct aspeed_pinmux_data *ctx,
75 				  const struct aspeed_sig_expr *expr)
76 {
77 	int ret;
78 
79 	ret = aspeed_sig_expr_eval(ctx, expr, true);
80 	if (ret < 0)
81 		return ret;
82 
83 	if (!ret)
84 		return aspeed_sig_expr_set(ctx, expr, true);
85 
86 	return 0;
87 }
88 
89 static int aspeed_sig_expr_disable(struct aspeed_pinmux_data *ctx,
90 				   const struct aspeed_sig_expr *expr)
91 {
92 	int ret;
93 
94 	ret = aspeed_sig_expr_eval(ctx, expr, true);
95 	if (ret < 0)
96 		return ret;
97 
98 	if (ret)
99 		return aspeed_sig_expr_set(ctx, expr, false);
100 
101 	return 0;
102 }
103 
104 /**
105  * Disable a signal on a pin by disabling all provided signal expressions.
106  *
107  * @ctx: The pinmux context
108  * @exprs: The list of signal expressions (from a priority level on a pin)
109  *
110  * Return: 0 if all expressions are disabled, otherwise a negative error code
111  */
112 static int aspeed_disable_sig(struct aspeed_pinmux_data *ctx,
113 			      const struct aspeed_sig_expr **exprs)
114 {
115 	int ret = 0;
116 
117 	if (!exprs)
118 		return true;
119 
120 	while (*exprs && !ret) {
121 		ret = aspeed_sig_expr_disable(ctx, *exprs);
122 		exprs++;
123 	}
124 
125 	return ret;
126 }
127 
128 /**
129  * Search for the signal expression needed to enable the pin's signal for the
130  * requested function.
131  *
132  * @exprs: List of signal expressions (haystack)
133  * @name: The name of the requested function (needle)
134  *
135  * Return: A pointer to the signal expression whose function tag matches the
136  * provided name, otherwise NULL.
137  *
138  */
139 static const struct aspeed_sig_expr *aspeed_find_expr_by_name(
140 		const struct aspeed_sig_expr **exprs, const char *name)
141 {
142 	while (*exprs) {
143 		if (strcmp((*exprs)->function, name) == 0)
144 			return *exprs;
145 		exprs++;
146 	}
147 
148 	return NULL;
149 }
150 
151 static char *get_defined_attribute(const struct aspeed_pin_desc *pdesc,
152 				   const char *(*get)(
153 					   const struct aspeed_sig_expr *))
154 {
155 	char *found = NULL;
156 	size_t len = 0;
157 	const struct aspeed_sig_expr ***prios, **funcs, *expr;
158 
159 	prios = pdesc->prios;
160 
161 	while ((funcs = *prios)) {
162 		while ((expr = *funcs)) {
163 			const char *str = get(expr);
164 			size_t delta = strlen(str) + 2;
165 			char *expanded;
166 
167 			expanded = krealloc(found, len + delta + 1, GFP_KERNEL);
168 			if (!expanded) {
169 				kfree(found);
170 				return expanded;
171 			}
172 
173 			found = expanded;
174 			found[len] = '\0';
175 			len += delta;
176 
177 			strcat(found, str);
178 			strcat(found, ", ");
179 
180 			funcs++;
181 		}
182 		prios++;
183 	}
184 
185 	if (len < 2) {
186 		kfree(found);
187 		return NULL;
188 	}
189 
190 	found[len - 2] = '\0';
191 
192 	return found;
193 }
194 
195 static const char *aspeed_sig_expr_function(const struct aspeed_sig_expr *expr)
196 {
197 	return expr->function;
198 }
199 
200 static char *get_defined_functions(const struct aspeed_pin_desc *pdesc)
201 {
202 	return get_defined_attribute(pdesc, aspeed_sig_expr_function);
203 }
204 
205 static const char *aspeed_sig_expr_signal(const struct aspeed_sig_expr *expr)
206 {
207 	return expr->signal;
208 }
209 
210 static char *get_defined_signals(const struct aspeed_pin_desc *pdesc)
211 {
212 	return get_defined_attribute(pdesc, aspeed_sig_expr_signal);
213 }
214 
215 int aspeed_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned int function,
216 			  unsigned int group)
217 {
218 	int i;
219 	int ret;
220 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
221 	const struct aspeed_pin_group *pgroup = &pdata->pinmux.groups[group];
222 	const struct aspeed_pin_function *pfunc =
223 		&pdata->pinmux.functions[function];
224 
225 	for (i = 0; i < pgroup->npins; i++) {
226 		int pin = pgroup->pins[i];
227 		const struct aspeed_pin_desc *pdesc = pdata->pins[pin].drv_data;
228 		const struct aspeed_sig_expr *expr = NULL;
229 		const struct aspeed_sig_expr **funcs;
230 		const struct aspeed_sig_expr ***prios;
231 
232 		pr_debug("Muxing pin %d for %s\n", pin, pfunc->name);
233 
234 		if (!pdesc)
235 			return -EINVAL;
236 
237 		prios = pdesc->prios;
238 
239 		if (!prios)
240 			continue;
241 
242 		/* Disable functions at a higher priority than that requested */
243 		while ((funcs = *prios)) {
244 			expr = aspeed_find_expr_by_name(funcs, pfunc->name);
245 
246 			if (expr)
247 				break;
248 
249 			ret = aspeed_disable_sig(&pdata->pinmux, funcs);
250 			if (ret)
251 				return ret;
252 
253 			prios++;
254 		}
255 
256 		if (!expr) {
257 			char *functions = get_defined_functions(pdesc);
258 			char *signals = get_defined_signals(pdesc);
259 
260 			pr_warn("No function %s found on pin %s (%d). Found signal(s) %s for function(s) %s\n",
261 				pfunc->name, pdesc->name, pin, signals,
262 				functions);
263 			kfree(signals);
264 			kfree(functions);
265 
266 			return -ENXIO;
267 		}
268 
269 		ret = aspeed_sig_expr_enable(&pdata->pinmux, expr);
270 		if (ret)
271 			return ret;
272 	}
273 
274 	return 0;
275 }
276 
277 static bool aspeed_expr_is_gpio(const struct aspeed_sig_expr *expr)
278 {
279 	/*
280 	 * The signal type is GPIO if the signal name has "GPIO" as a prefix.
281 	 * strncmp (rather than strcmp) is used to implement the prefix
282 	 * requirement.
283 	 *
284 	 * expr->signal might look like "GPIOT3" in the GPIO case.
285 	 */
286 	return strncmp(expr->signal, "GPIO", 4) == 0;
287 }
288 
289 static bool aspeed_gpio_in_exprs(const struct aspeed_sig_expr **exprs)
290 {
291 	if (!exprs)
292 		return false;
293 
294 	while (*exprs) {
295 		if (aspeed_expr_is_gpio(*exprs))
296 			return true;
297 		exprs++;
298 	}
299 
300 	return false;
301 }
302 
303 int aspeed_gpio_request_enable(struct pinctrl_dev *pctldev,
304 			       struct pinctrl_gpio_range *range,
305 			       unsigned int offset)
306 {
307 	int ret;
308 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
309 	const struct aspeed_pin_desc *pdesc = pdata->pins[offset].drv_data;
310 	const struct aspeed_sig_expr ***prios, **funcs, *expr;
311 
312 	if (!pdesc)
313 		return -EINVAL;
314 
315 	prios = pdesc->prios;
316 
317 	if (!prios)
318 		return -ENXIO;
319 
320 	/* Disable any functions of higher priority than GPIO */
321 	while ((funcs = *prios)) {
322 		if (aspeed_gpio_in_exprs(funcs))
323 			break;
324 
325 		ret = aspeed_disable_sig(&pdata->pinmux, funcs);
326 		if (ret)
327 			return ret;
328 
329 		prios++;
330 	}
331 
332 	if (!funcs) {
333 		char *signals = get_defined_signals(pdesc);
334 
335 		pr_warn("No GPIO signal type found on pin %s (%d). Found: %s\n",
336 			pdesc->name, offset, signals);
337 		kfree(signals);
338 
339 		return -ENXIO;
340 	}
341 
342 	expr = *funcs;
343 
344 	/*
345 	 * Disabling all higher-priority expressions is enough to enable the
346 	 * lowest-priority signal type. As such it has no associated
347 	 * expression.
348 	 */
349 	if (!expr)
350 		return 0;
351 
352 	/*
353 	 * If GPIO is not the lowest priority signal type, assume there is only
354 	 * one expression defined to enable the GPIO function
355 	 */
356 	return aspeed_sig_expr_enable(&pdata->pinmux, expr);
357 }
358 
359 int aspeed_pinctrl_probe(struct platform_device *pdev,
360 			 struct pinctrl_desc *pdesc,
361 			 struct aspeed_pinctrl_data *pdata)
362 {
363 	struct device *parent;
364 	struct pinctrl_dev *pctl;
365 
366 	parent = pdev->dev.parent;
367 	if (!parent) {
368 		dev_err(&pdev->dev, "No parent for syscon pincontroller\n");
369 		return -ENODEV;
370 	}
371 
372 	pdata->scu = syscon_node_to_regmap(parent->of_node);
373 	if (IS_ERR(pdata->scu)) {
374 		dev_err(&pdev->dev, "No regmap for syscon pincontroller parent\n");
375 		return PTR_ERR(pdata->scu);
376 	}
377 
378 	pdata->pinmux.maps[ASPEED_IP_SCU] = pdata->scu;
379 
380 	pctl = pinctrl_register(pdesc, &pdev->dev, pdata);
381 
382 	if (IS_ERR(pctl)) {
383 		dev_err(&pdev->dev, "Failed to register pinctrl\n");
384 		return PTR_ERR(pctl);
385 	}
386 
387 	platform_set_drvdata(pdev, pdata);
388 
389 	return 0;
390 }
391 
392 static inline bool pin_in_config_range(unsigned int offset,
393 		const struct aspeed_pin_config *config)
394 {
395 	return offset >= config->pins[0] && offset <= config->pins[1];
396 }
397 
398 static inline const struct aspeed_pin_config *find_pinconf_config(
399 		const struct aspeed_pinctrl_data *pdata,
400 		unsigned int offset,
401 		enum pin_config_param param)
402 {
403 	unsigned int i;
404 
405 	for (i = 0; i < pdata->nconfigs; i++) {
406 		if (param == pdata->configs[i].param &&
407 				pin_in_config_range(offset, &pdata->configs[i]))
408 			return &pdata->configs[i];
409 	}
410 
411 	return NULL;
412 }
413 
414 /*
415  * Aspeed pin configuration description.
416  *
417  * @param: pinconf configuration parameter
418  * @arg: The supported argument for @param, or -1 if any value is supported
419  * @val: The register value to write to configure @arg for @param
420  *
421  * The map is to be used in conjunction with the configuration array supplied
422  * by the driver implementation.
423  */
424 struct aspeed_pin_config_map {
425 	enum pin_config_param param;
426 	s32 arg;
427 	u32 val;
428 };
429 
430 enum aspeed_pin_config_map_type { MAP_TYPE_ARG, MAP_TYPE_VAL };
431 
432 /* Aspeed consistently both:
433  *
434  * 1. Defines "disable bits" for internal pull-downs
435  * 2. Uses 8mA or 16mA drive strengths
436  */
437 static const struct aspeed_pin_config_map pin_config_map[] = {
438 	{ PIN_CONFIG_BIAS_PULL_DOWN,  0, 1 },
439 	{ PIN_CONFIG_BIAS_PULL_DOWN, -1, 0 },
440 	{ PIN_CONFIG_BIAS_DISABLE,   -1, 1 },
441 	{ PIN_CONFIG_DRIVE_STRENGTH,  8, 0 },
442 	{ PIN_CONFIG_DRIVE_STRENGTH, 16, 1 },
443 };
444 
445 static const struct aspeed_pin_config_map *find_pinconf_map(
446 		enum pin_config_param param,
447 		enum aspeed_pin_config_map_type type,
448 		s64 value)
449 {
450 	int i;
451 
452 	for (i = 0; i < ARRAY_SIZE(pin_config_map); i++) {
453 		const struct aspeed_pin_config_map *elem;
454 		bool match;
455 
456 		elem = &pin_config_map[i];
457 
458 		switch (type) {
459 		case MAP_TYPE_ARG:
460 			match = (elem->arg == -1 || elem->arg == value);
461 			break;
462 		case MAP_TYPE_VAL:
463 			match = (elem->val == value);
464 			break;
465 		}
466 
467 		if (param == elem->param && match)
468 			return elem;
469 	}
470 
471 	return NULL;
472 }
473 
474 int aspeed_pin_config_get(struct pinctrl_dev *pctldev, unsigned int offset,
475 		unsigned long *config)
476 {
477 	const enum pin_config_param param = pinconf_to_config_param(*config);
478 	const struct aspeed_pin_config_map *pmap;
479 	const struct aspeed_pinctrl_data *pdata;
480 	const struct aspeed_pin_config *pconf;
481 	unsigned int val;
482 	int rc = 0;
483 	u32 arg;
484 
485 	pdata = pinctrl_dev_get_drvdata(pctldev);
486 	pconf = find_pinconf_config(pdata, offset, param);
487 	if (!pconf)
488 		return -ENOTSUPP;
489 
490 	rc = regmap_read(pdata->scu, pconf->reg, &val);
491 	if (rc < 0)
492 		return rc;
493 
494 	pmap = find_pinconf_map(param, MAP_TYPE_VAL,
495 			(val & BIT(pconf->bit)) >> pconf->bit);
496 
497 	if (!pmap)
498 		return -EINVAL;
499 
500 	if (param == PIN_CONFIG_DRIVE_STRENGTH)
501 		arg = (u32) pmap->arg;
502 	else if (param == PIN_CONFIG_BIAS_PULL_DOWN)
503 		arg = !!pmap->arg;
504 	else
505 		arg = 1;
506 
507 	if (!arg)
508 		return -EINVAL;
509 
510 	*config = pinconf_to_config_packed(param, arg);
511 
512 	return 0;
513 }
514 
515 int aspeed_pin_config_set(struct pinctrl_dev *pctldev, unsigned int offset,
516 		unsigned long *configs, unsigned int num_configs)
517 {
518 	const struct aspeed_pinctrl_data *pdata;
519 	unsigned int i;
520 	int rc = 0;
521 
522 	pdata = pinctrl_dev_get_drvdata(pctldev);
523 
524 	for (i = 0; i < num_configs; i++) {
525 		const struct aspeed_pin_config_map *pmap;
526 		const struct aspeed_pin_config *pconf;
527 		enum pin_config_param param;
528 		unsigned int val;
529 		u32 arg;
530 
531 		param = pinconf_to_config_param(configs[i]);
532 		arg = pinconf_to_config_argument(configs[i]);
533 
534 		pconf = find_pinconf_config(pdata, offset, param);
535 		if (!pconf)
536 			return -ENOTSUPP;
537 
538 		pmap = find_pinconf_map(param, MAP_TYPE_ARG, arg);
539 
540 		if (WARN_ON(!pmap))
541 			return -EINVAL;
542 
543 		val = pmap->val << pconf->bit;
544 
545 		rc = regmap_update_bits(pdata->scu, pconf->reg,
546 					BIT(pconf->bit), val);
547 
548 		if (rc < 0)
549 			return rc;
550 
551 		pr_debug("%s: Set SCU%02X[%d]=%d for param %d(=%d) on pin %d\n",
552 				__func__, pconf->reg, pconf->bit, pmap->val,
553 				param, arg, offset);
554 	}
555 
556 	return 0;
557 }
558 
559 int aspeed_pin_config_group_get(struct pinctrl_dev *pctldev,
560 		unsigned int selector,
561 		unsigned long *config)
562 {
563 	const unsigned int *pins;
564 	unsigned int npins;
565 	int rc;
566 
567 	rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
568 	if (rc < 0)
569 		return rc;
570 
571 	if (!npins)
572 		return -ENODEV;
573 
574 	rc = aspeed_pin_config_get(pctldev, pins[0], config);
575 
576 	return rc;
577 }
578 
579 int aspeed_pin_config_group_set(struct pinctrl_dev *pctldev,
580 		unsigned int selector,
581 		unsigned long *configs,
582 		unsigned int num_configs)
583 {
584 	const unsigned int *pins;
585 	unsigned int npins;
586 	int rc;
587 	int i;
588 
589 	pr_debug("%s: Fetching pins for group selector %d\n",
590 			__func__, selector);
591 	rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
592 	if (rc < 0)
593 		return rc;
594 
595 	for (i = 0; i < npins; i++) {
596 		rc = aspeed_pin_config_set(pctldev, pins[i], configs,
597 				num_configs);
598 		if (rc < 0)
599 			return rc;
600 	}
601 
602 	return 0;
603 }
604