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 	pr_debug("Enabling signal %s for %s\n", expr->signal,
80 		 expr->function);
81 
82 	ret = aspeed_sig_expr_eval(ctx, expr, true);
83 	if (ret < 0)
84 		return ret;
85 
86 	if (!ret)
87 		return aspeed_sig_expr_set(ctx, expr, true);
88 
89 	return 0;
90 }
91 
92 static int aspeed_sig_expr_disable(struct aspeed_pinmux_data *ctx,
93 				   const struct aspeed_sig_expr *expr)
94 {
95 	int ret;
96 
97 	pr_debug("Disabling signal %s for %s\n", expr->signal,
98 		 expr->function);
99 
100 	ret = aspeed_sig_expr_eval(ctx, expr, true);
101 	if (ret < 0)
102 		return ret;
103 
104 	if (ret)
105 		return aspeed_sig_expr_set(ctx, expr, false);
106 
107 	return 0;
108 }
109 
110 /**
111  * Disable a signal on a pin by disabling all provided signal expressions.
112  *
113  * @ctx: The pinmux context
114  * @exprs: The list of signal expressions (from a priority level on a pin)
115  *
116  * Return: 0 if all expressions are disabled, otherwise a negative error code
117  */
118 static int aspeed_disable_sig(struct aspeed_pinmux_data *ctx,
119 			      const struct aspeed_sig_expr **exprs)
120 {
121 	int ret = 0;
122 
123 	if (!exprs)
124 		return true;
125 
126 	while (*exprs && !ret) {
127 		ret = aspeed_sig_expr_disable(ctx, *exprs);
128 		exprs++;
129 	}
130 
131 	return ret;
132 }
133 
134 /**
135  * Search for the signal expression needed to enable the pin's signal for the
136  * requested function.
137  *
138  * @exprs: List of signal expressions (haystack)
139  * @name: The name of the requested function (needle)
140  *
141  * Return: A pointer to the signal expression whose function tag matches the
142  * provided name, otherwise NULL.
143  *
144  */
145 static const struct aspeed_sig_expr *aspeed_find_expr_by_name(
146 		const struct aspeed_sig_expr **exprs, const char *name)
147 {
148 	while (*exprs) {
149 		if (strcmp((*exprs)->function, name) == 0)
150 			return *exprs;
151 		exprs++;
152 	}
153 
154 	return NULL;
155 }
156 
157 static char *get_defined_attribute(const struct aspeed_pin_desc *pdesc,
158 				   const char *(*get)(
159 					   const struct aspeed_sig_expr *))
160 {
161 	char *found = NULL;
162 	size_t len = 0;
163 	const struct aspeed_sig_expr ***prios, **funcs, *expr;
164 
165 	prios = pdesc->prios;
166 
167 	while ((funcs = *prios)) {
168 		while ((expr = *funcs)) {
169 			const char *str = get(expr);
170 			size_t delta = strlen(str) + 2;
171 			char *expanded;
172 
173 			expanded = krealloc(found, len + delta + 1, GFP_KERNEL);
174 			if (!expanded) {
175 				kfree(found);
176 				return expanded;
177 			}
178 
179 			found = expanded;
180 			found[len] = '\0';
181 			len += delta;
182 
183 			strcat(found, str);
184 			strcat(found, ", ");
185 
186 			funcs++;
187 		}
188 		prios++;
189 	}
190 
191 	if (len < 2) {
192 		kfree(found);
193 		return NULL;
194 	}
195 
196 	found[len - 2] = '\0';
197 
198 	return found;
199 }
200 
201 static const char *aspeed_sig_expr_function(const struct aspeed_sig_expr *expr)
202 {
203 	return expr->function;
204 }
205 
206 static char *get_defined_functions(const struct aspeed_pin_desc *pdesc)
207 {
208 	return get_defined_attribute(pdesc, aspeed_sig_expr_function);
209 }
210 
211 static const char *aspeed_sig_expr_signal(const struct aspeed_sig_expr *expr)
212 {
213 	return expr->signal;
214 }
215 
216 static char *get_defined_signals(const struct aspeed_pin_desc *pdesc)
217 {
218 	return get_defined_attribute(pdesc, aspeed_sig_expr_signal);
219 }
220 
221 int aspeed_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned int function,
222 			  unsigned int group)
223 {
224 	int i;
225 	int ret;
226 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
227 	const struct aspeed_pin_group *pgroup = &pdata->pinmux.groups[group];
228 	const struct aspeed_pin_function *pfunc =
229 		&pdata->pinmux.functions[function];
230 
231 	for (i = 0; i < pgroup->npins; i++) {
232 		int pin = pgroup->pins[i];
233 		const struct aspeed_pin_desc *pdesc = pdata->pins[pin].drv_data;
234 		const struct aspeed_sig_expr *expr = NULL;
235 		const struct aspeed_sig_expr **funcs;
236 		const struct aspeed_sig_expr ***prios;
237 
238 		pr_debug("Muxing pin %s for %s\n", pdesc->name, pfunc->name);
239 
240 		if (!pdesc)
241 			return -EINVAL;
242 
243 		prios = pdesc->prios;
244 
245 		if (!prios)
246 			continue;
247 
248 		/* Disable functions at a higher priority than that requested */
249 		while ((funcs = *prios)) {
250 			expr = aspeed_find_expr_by_name(funcs, pfunc->name);
251 
252 			if (expr)
253 				break;
254 
255 			ret = aspeed_disable_sig(&pdata->pinmux, funcs);
256 			if (ret)
257 				return ret;
258 
259 			prios++;
260 		}
261 
262 		if (!expr) {
263 			char *functions = get_defined_functions(pdesc);
264 			char *signals = get_defined_signals(pdesc);
265 
266 			pr_warn("No function %s found on pin %s (%d). Found signal(s) %s for function(s) %s\n",
267 				pfunc->name, pdesc->name, pin, signals,
268 				functions);
269 			kfree(signals);
270 			kfree(functions);
271 
272 			return -ENXIO;
273 		}
274 
275 		ret = aspeed_sig_expr_enable(&pdata->pinmux, expr);
276 		if (ret)
277 			return ret;
278 
279 		pr_debug("Muxed pin %s as %s for %s\n", pdesc->name, expr->signal,
280 			 expr->function);
281 	}
282 
283 	return 0;
284 }
285 
286 static bool aspeed_expr_is_gpio(const struct aspeed_sig_expr *expr)
287 {
288 	/*
289 	 * We need to differentiate between GPIO and non-GPIO signals to
290 	 * implement the gpio_request_enable() interface. For better or worse
291 	 * the ASPEED pinctrl driver uses the expression names to determine
292 	 * whether an expression will mux a pin for GPIO.
293 	 *
294 	 * Generally we have the following - A GPIO such as B1 has:
295 	 *
296 	 *    - expr->signal set to "GPIOB1"
297 	 *    - expr->function set to "GPIOB1"
298 	 *
299 	 * Using this fact we can determine whether the provided expression is
300 	 * a GPIO expression by testing the signal name for the string prefix
301 	 * "GPIO".
302 	 *
303 	 * However, some GPIOs are input-only, and the ASPEED datasheets name
304 	 * them differently. An input-only GPIO such as T0 has:
305 	 *
306 	 *    - expr->signal set to "GPIT0"
307 	 *    - expr->function set to "GPIT0"
308 	 *
309 	 * It's tempting to generalise the prefix test from "GPIO" to "GPI" to
310 	 * account for both GPIOs and GPIs, but in doing so we run aground on
311 	 * another feature:
312 	 *
313 	 * Some pins in the ASPEED BMC SoCs have a "pass-through" GPIO
314 	 * function where the input state of one pin is replicated as the
315 	 * output state of another (as if they were shorted together - a mux
316 	 * configuration that is typically enabled by hardware strapping).
317 	 * This feature allows the BMC to pass e.g. power button state through
318 	 * to the host while the BMC is yet to boot, but take control of the
319 	 * button state once the BMC has booted by muxing each pin as a
320 	 * separate, pin-specific GPIO.
321 	 *
322 	 * Conceptually this pass-through mode is a form of GPIO and is named
323 	 * as such in the datasheets, e.g. "GPID0". This naming similarity
324 	 * trips us up with the simple GPI-prefixed-signal-name scheme
325 	 * discussed above, as the pass-through configuration is not what we
326 	 * want when muxing a pin as GPIO for the GPIO subsystem.
327 	 *
328 	 * On e.g. the AST2400, a pass-through function "GPID0" is grouped on
329 	 * balls A18 and D16, where we have:
330 	 *
331 	 *    For ball A18:
332 	 *    - expr->signal set to "GPID0IN"
333 	 *    - expr->function set to "GPID0"
334 	 *
335 	 *    For ball D16:
336 	 *    - expr->signal set to "GPID0OUT"
337 	 *    - expr->function set to "GPID0"
338 	 *
339 	 * By contrast, the pin-specific GPIO expressions for the same pins are
340 	 * as follows:
341 	 *
342 	 *    For ball A18:
343 	 *    - expr->signal looks like "GPIOD0"
344 	 *    - expr->function looks like "GPIOD0"
345 	 *
346 	 *    For ball D16:
347 	 *    - expr->signal looks like "GPIOD1"
348 	 *    - expr->function looks like "GPIOD1"
349 	 *
350 	 * Testing both the signal _and_ function names gives us the means
351 	 * differentiate the pass-through GPIO pinmux configuration from the
352 	 * pin-specific configuration that the GPIO subsystem is after: An
353 	 * expression is a pin-specific (non-pass-through) GPIO configuration
354 	 * if the signal prefix is "GPI" and the signal name matches the
355 	 * function name.
356 	 */
357 	return !strncmp(expr->signal, "GPI", 3) &&
358 			!strcmp(expr->signal, expr->function);
359 }
360 
361 static bool aspeed_gpio_in_exprs(const struct aspeed_sig_expr **exprs)
362 {
363 	if (!exprs)
364 		return false;
365 
366 	while (*exprs) {
367 		if (aspeed_expr_is_gpio(*exprs))
368 			return true;
369 		exprs++;
370 	}
371 
372 	return false;
373 }
374 
375 int aspeed_gpio_request_enable(struct pinctrl_dev *pctldev,
376 			       struct pinctrl_gpio_range *range,
377 			       unsigned int offset)
378 {
379 	int ret;
380 	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
381 	const struct aspeed_pin_desc *pdesc = pdata->pins[offset].drv_data;
382 	const struct aspeed_sig_expr ***prios, **funcs, *expr;
383 
384 	if (!pdesc)
385 		return -EINVAL;
386 
387 	prios = pdesc->prios;
388 
389 	if (!prios)
390 		return -ENXIO;
391 
392 	pr_debug("Muxing pin %s for GPIO\n", pdesc->name);
393 
394 	/* Disable any functions of higher priority than GPIO */
395 	while ((funcs = *prios)) {
396 		if (aspeed_gpio_in_exprs(funcs))
397 			break;
398 
399 		ret = aspeed_disable_sig(&pdata->pinmux, funcs);
400 		if (ret)
401 			return ret;
402 
403 		prios++;
404 	}
405 
406 	if (!funcs) {
407 		char *signals = get_defined_signals(pdesc);
408 
409 		pr_warn("No GPIO signal type found on pin %s (%d). Found: %s\n",
410 			pdesc->name, offset, signals);
411 		kfree(signals);
412 
413 		return -ENXIO;
414 	}
415 
416 	expr = *funcs;
417 
418 	/*
419 	 * Disabling all higher-priority expressions is enough to enable the
420 	 * lowest-priority signal type. As such it has no associated
421 	 * expression.
422 	 */
423 	if (!expr) {
424 		pr_debug("Muxed pin %s as GPIO\n", pdesc->name);
425 		return 0;
426 	}
427 
428 	/*
429 	 * If GPIO is not the lowest priority signal type, assume there is only
430 	 * one expression defined to enable the GPIO function
431 	 */
432 	ret = aspeed_sig_expr_enable(&pdata->pinmux, expr);
433 	if (ret)
434 		return ret;
435 
436 	pr_debug("Muxed pin %s as %s\n", pdesc->name, expr->signal);
437 
438 	return 0;
439 }
440 
441 int aspeed_pinctrl_probe(struct platform_device *pdev,
442 			 struct pinctrl_desc *pdesc,
443 			 struct aspeed_pinctrl_data *pdata)
444 {
445 	struct device *parent;
446 	struct pinctrl_dev *pctl;
447 
448 	parent = pdev->dev.parent;
449 	if (!parent) {
450 		dev_err(&pdev->dev, "No parent for syscon pincontroller\n");
451 		return -ENODEV;
452 	}
453 
454 	pdata->scu = syscon_node_to_regmap(parent->of_node);
455 	if (IS_ERR(pdata->scu)) {
456 		dev_err(&pdev->dev, "No regmap for syscon pincontroller parent\n");
457 		return PTR_ERR(pdata->scu);
458 	}
459 
460 	pdata->pinmux.maps[ASPEED_IP_SCU] = pdata->scu;
461 
462 	pctl = pinctrl_register(pdesc, &pdev->dev, pdata);
463 
464 	if (IS_ERR(pctl)) {
465 		dev_err(&pdev->dev, "Failed to register pinctrl\n");
466 		return PTR_ERR(pctl);
467 	}
468 
469 	platform_set_drvdata(pdev, pdata);
470 
471 	return 0;
472 }
473 
474 static inline bool pin_in_config_range(unsigned int offset,
475 		const struct aspeed_pin_config *config)
476 {
477 	return offset >= config->pins[0] && offset <= config->pins[1];
478 }
479 
480 static inline const struct aspeed_pin_config *find_pinconf_config(
481 		const struct aspeed_pinctrl_data *pdata,
482 		unsigned int offset,
483 		enum pin_config_param param)
484 {
485 	unsigned int i;
486 
487 	for (i = 0; i < pdata->nconfigs; i++) {
488 		if (param == pdata->configs[i].param &&
489 				pin_in_config_range(offset, &pdata->configs[i]))
490 			return &pdata->configs[i];
491 	}
492 
493 	return NULL;
494 }
495 
496 enum aspeed_pin_config_map_type { MAP_TYPE_ARG, MAP_TYPE_VAL };
497 
498 static const struct aspeed_pin_config_map *find_pinconf_map(
499 		const struct aspeed_pinctrl_data *pdata,
500 		enum pin_config_param param,
501 		enum aspeed_pin_config_map_type type,
502 		s64 value)
503 {
504 	int i;
505 
506 	for (i = 0; i < pdata->nconfmaps; i++) {
507 		const struct aspeed_pin_config_map *elem;
508 		bool match;
509 
510 		elem = &pdata->confmaps[i];
511 
512 		switch (type) {
513 		case MAP_TYPE_ARG:
514 			match = (elem->arg == -1 || elem->arg == value);
515 			break;
516 		case MAP_TYPE_VAL:
517 			match = (elem->val == value);
518 			break;
519 		}
520 
521 		if (param == elem->param && match)
522 			return elem;
523 	}
524 
525 	return NULL;
526 }
527 
528 int aspeed_pin_config_get(struct pinctrl_dev *pctldev, unsigned int offset,
529 		unsigned long *config)
530 {
531 	const enum pin_config_param param = pinconf_to_config_param(*config);
532 	const struct aspeed_pin_config_map *pmap;
533 	const struct aspeed_pinctrl_data *pdata;
534 	const struct aspeed_pin_config *pconf;
535 	unsigned int val;
536 	int rc = 0;
537 	u32 arg;
538 
539 	pdata = pinctrl_dev_get_drvdata(pctldev);
540 	pconf = find_pinconf_config(pdata, offset, param);
541 	if (!pconf)
542 		return -ENOTSUPP;
543 
544 	rc = regmap_read(pdata->scu, pconf->reg, &val);
545 	if (rc < 0)
546 		return rc;
547 
548 	pmap = find_pinconf_map(pdata, param, MAP_TYPE_VAL,
549 			(val & pconf->mask) >> __ffs(pconf->mask));
550 
551 	if (!pmap)
552 		return -EINVAL;
553 
554 	if (param == PIN_CONFIG_DRIVE_STRENGTH)
555 		arg = (u32) pmap->arg;
556 	else if (param == PIN_CONFIG_BIAS_PULL_DOWN)
557 		arg = !!pmap->arg;
558 	else
559 		arg = 1;
560 
561 	if (!arg)
562 		return -EINVAL;
563 
564 	*config = pinconf_to_config_packed(param, arg);
565 
566 	return 0;
567 }
568 
569 int aspeed_pin_config_set(struct pinctrl_dev *pctldev, unsigned int offset,
570 		unsigned long *configs, unsigned int num_configs)
571 {
572 	const struct aspeed_pinctrl_data *pdata;
573 	unsigned int i;
574 	int rc = 0;
575 
576 	pdata = pinctrl_dev_get_drvdata(pctldev);
577 
578 	for (i = 0; i < num_configs; i++) {
579 		const struct aspeed_pin_config_map *pmap;
580 		const struct aspeed_pin_config *pconf;
581 		enum pin_config_param param;
582 		unsigned int val;
583 		u32 arg;
584 
585 		param = pinconf_to_config_param(configs[i]);
586 		arg = pinconf_to_config_argument(configs[i]);
587 
588 		pconf = find_pinconf_config(pdata, offset, param);
589 		if (!pconf)
590 			return -ENOTSUPP;
591 
592 		pmap = find_pinconf_map(pdata, param, MAP_TYPE_ARG, arg);
593 
594 		if (WARN_ON(!pmap))
595 			return -EINVAL;
596 
597 		val = pmap->val << __ffs(pconf->mask);
598 
599 		rc = regmap_update_bits(pdata->scu, pconf->reg,
600 					pconf->mask, val);
601 
602 		if (rc < 0)
603 			return rc;
604 
605 		pr_debug("%s: Set SCU%02X[0x%08X]=0x%X for param %d(=%d) on pin %d\n",
606 				__func__, pconf->reg, pconf->mask,
607 				val, param, arg, offset);
608 	}
609 
610 	return 0;
611 }
612 
613 int aspeed_pin_config_group_get(struct pinctrl_dev *pctldev,
614 		unsigned int selector,
615 		unsigned long *config)
616 {
617 	const unsigned int *pins;
618 	unsigned int npins;
619 	int rc;
620 
621 	rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
622 	if (rc < 0)
623 		return rc;
624 
625 	if (!npins)
626 		return -ENODEV;
627 
628 	rc = aspeed_pin_config_get(pctldev, pins[0], config);
629 
630 	return rc;
631 }
632 
633 int aspeed_pin_config_group_set(struct pinctrl_dev *pctldev,
634 		unsigned int selector,
635 		unsigned long *configs,
636 		unsigned int num_configs)
637 {
638 	const unsigned int *pins;
639 	unsigned int npins;
640 	int rc;
641 	int i;
642 
643 	pr_debug("%s: Fetching pins for group selector %d\n",
644 			__func__, selector);
645 	rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
646 	if (rc < 0)
647 		return rc;
648 
649 	for (i = 0; i < npins; i++) {
650 		rc = aspeed_pin_config_set(pctldev, pins[i], configs,
651 				num_configs);
652 		if (rc < 0)
653 			return rc;
654 	}
655 
656 	return 0;
657 }
658