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 enum aspeed_pin_config_map_type { MAP_TYPE_ARG, MAP_TYPE_VAL };
415 
416 static const struct aspeed_pin_config_map *find_pinconf_map(
417 		const struct aspeed_pinctrl_data *pdata,
418 		enum pin_config_param param,
419 		enum aspeed_pin_config_map_type type,
420 		s64 value)
421 {
422 	int i;
423 
424 	for (i = 0; i < pdata->nconfmaps; i++) {
425 		const struct aspeed_pin_config_map *elem;
426 		bool match;
427 
428 		elem = &pdata->confmaps[i];
429 
430 		switch (type) {
431 		case MAP_TYPE_ARG:
432 			match = (elem->arg == -1 || elem->arg == value);
433 			break;
434 		case MAP_TYPE_VAL:
435 			match = (elem->val == value);
436 			break;
437 		}
438 
439 		if (param == elem->param && match)
440 			return elem;
441 	}
442 
443 	return NULL;
444 }
445 
446 int aspeed_pin_config_get(struct pinctrl_dev *pctldev, unsigned int offset,
447 		unsigned long *config)
448 {
449 	const enum pin_config_param param = pinconf_to_config_param(*config);
450 	const struct aspeed_pin_config_map *pmap;
451 	const struct aspeed_pinctrl_data *pdata;
452 	const struct aspeed_pin_config *pconf;
453 	unsigned int val;
454 	int rc = 0;
455 	u32 arg;
456 
457 	pdata = pinctrl_dev_get_drvdata(pctldev);
458 	pconf = find_pinconf_config(pdata, offset, param);
459 	if (!pconf)
460 		return -ENOTSUPP;
461 
462 	rc = regmap_read(pdata->scu, pconf->reg, &val);
463 	if (rc < 0)
464 		return rc;
465 
466 	pmap = find_pinconf_map(pdata, param, MAP_TYPE_VAL,
467 			(val & pconf->mask) >> __ffs(pconf->mask));
468 
469 	if (!pmap)
470 		return -EINVAL;
471 
472 	if (param == PIN_CONFIG_DRIVE_STRENGTH)
473 		arg = (u32) pmap->arg;
474 	else if (param == PIN_CONFIG_BIAS_PULL_DOWN)
475 		arg = !!pmap->arg;
476 	else
477 		arg = 1;
478 
479 	if (!arg)
480 		return -EINVAL;
481 
482 	*config = pinconf_to_config_packed(param, arg);
483 
484 	return 0;
485 }
486 
487 int aspeed_pin_config_set(struct pinctrl_dev *pctldev, unsigned int offset,
488 		unsigned long *configs, unsigned int num_configs)
489 {
490 	const struct aspeed_pinctrl_data *pdata;
491 	unsigned int i;
492 	int rc = 0;
493 
494 	pdata = pinctrl_dev_get_drvdata(pctldev);
495 
496 	for (i = 0; i < num_configs; i++) {
497 		const struct aspeed_pin_config_map *pmap;
498 		const struct aspeed_pin_config *pconf;
499 		enum pin_config_param param;
500 		unsigned int val;
501 		u32 arg;
502 
503 		param = pinconf_to_config_param(configs[i]);
504 		arg = pinconf_to_config_argument(configs[i]);
505 
506 		pconf = find_pinconf_config(pdata, offset, param);
507 		if (!pconf)
508 			return -ENOTSUPP;
509 
510 		pmap = find_pinconf_map(pdata, param, MAP_TYPE_ARG, arg);
511 
512 		if (WARN_ON(!pmap))
513 			return -EINVAL;
514 
515 		val = pmap->val << __ffs(pconf->mask);
516 
517 		rc = regmap_update_bits(pdata->scu, pconf->reg,
518 					pmap->mask, val);
519 
520 		if (rc < 0)
521 			return rc;
522 
523 		pr_debug("%s: Set SCU%02X[%lu]=%d for param %d(=%d) on pin %d\n",
524 				__func__, pconf->reg, __ffs(pconf->mask),
525 				pmap->val, param, arg, offset);
526 	}
527 
528 	return 0;
529 }
530 
531 int aspeed_pin_config_group_get(struct pinctrl_dev *pctldev,
532 		unsigned int selector,
533 		unsigned long *config)
534 {
535 	const unsigned int *pins;
536 	unsigned int npins;
537 	int rc;
538 
539 	rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
540 	if (rc < 0)
541 		return rc;
542 
543 	if (!npins)
544 		return -ENODEV;
545 
546 	rc = aspeed_pin_config_get(pctldev, pins[0], config);
547 
548 	return rc;
549 }
550 
551 int aspeed_pin_config_group_set(struct pinctrl_dev *pctldev,
552 		unsigned int selector,
553 		unsigned long *configs,
554 		unsigned int num_configs)
555 {
556 	const unsigned int *pins;
557 	unsigned int npins;
558 	int rc;
559 	int i;
560 
561 	pr_debug("%s: Fetching pins for group selector %d\n",
562 			__func__, selector);
563 	rc = aspeed_pinctrl_get_group_pins(pctldev, selector, &pins, &npins);
564 	if (rc < 0)
565 		return rc;
566 
567 	for (i = 0; i < npins; i++) {
568 		rc = aspeed_pin_config_set(pctldev, pins[i], configs,
569 				num_configs);
570 		if (rc < 0)
571 			return rc;
572 	}
573 
574 	return 0;
575 }
576