1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Core driver for the pin muxing portions of the pin control subsystem
4  *
5  * Copyright (C) 2011-2012 ST-Ericsson SA
6  * Written on behalf of Linaro for ST-Ericsson
7  * Based on bits of regulator core, gpio core and clk core
8  *
9  * Author: Linus Walleij <linus.walleij@linaro.org>
10  *
11  * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
12  */
13 #define pr_fmt(fmt) "pinmux core: " fmt
14 
15 #include <linux/array_size.h>
16 #include <linux/ctype.h>
17 #include <linux/debugfs.h>
18 #include <linux/device.h>
19 #include <linux/err.h>
20 #include <linux/init.h>
21 #include <linux/list.h>
22 #include <linux/module.h>
23 #include <linux/radix-tree.h>
24 #include <linux/seq_file.h>
25 #include <linux/slab.h>
26 #include <linux/string.h>
27 
28 #include <linux/pinctrl/machine.h>
29 #include <linux/pinctrl/pinctrl.h>
30 #include <linux/pinctrl/pinmux.h>
31 
32 #include "core.h"
33 #include "pinmux.h"
34 
pinmux_check_ops(struct pinctrl_dev * pctldev)35 int pinmux_check_ops(struct pinctrl_dev *pctldev)
36 {
37 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
38 	unsigned int nfuncs;
39 	unsigned int selector = 0;
40 
41 	/* Check that we implement required operations */
42 	if (!ops ||
43 	    !ops->get_functions_count ||
44 	    !ops->get_function_name ||
45 	    !ops->get_function_groups ||
46 	    !ops->set_mux) {
47 		dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n");
48 		return -EINVAL;
49 	}
50 	/* Check that all functions registered have names */
51 	nfuncs = ops->get_functions_count(pctldev);
52 	while (selector < nfuncs) {
53 		const char *fname = ops->get_function_name(pctldev,
54 							   selector);
55 		if (!fname) {
56 			dev_err(pctldev->dev, "pinmux ops has no name for function%u\n",
57 				selector);
58 			return -EINVAL;
59 		}
60 		selector++;
61 	}
62 
63 	return 0;
64 }
65 
pinmux_validate_map(const struct pinctrl_map * map,int i)66 int pinmux_validate_map(const struct pinctrl_map *map, int i)
67 {
68 	if (!map->data.mux.function) {
69 		pr_err("failed to register map %s (%d): no function given\n",
70 		       map->name, i);
71 		return -EINVAL;
72 	}
73 
74 	return 0;
75 }
76 
77 /**
78  * pinmux_can_be_used_for_gpio() - check if a specific pin
79  *	is either muxed to a different function or used as gpio.
80  *
81  * @pctldev: the associated pin controller device
82  * @pin: the pin number in the global pin space
83  *
84  * Controllers not defined as strict will always return true,
85  * menaning that the gpio can be used.
86  */
pinmux_can_be_used_for_gpio(struct pinctrl_dev * pctldev,unsigned int pin)87 bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned int pin)
88 {
89 	struct pin_desc *desc = pin_desc_get(pctldev, pin);
90 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
91 
92 	/* Can't inspect pin, assume it can be used */
93 	if (!desc || !ops)
94 		return true;
95 
96 	if (ops->strict && desc->mux_usecount)
97 		return false;
98 
99 	return !(ops->strict && !!desc->gpio_owner);
100 }
101 
102 /**
103  * pin_request() - request a single pin to be muxed in, typically for GPIO
104  * @pctldev: the associated pin controller device
105  * @pin: the pin number in the global pin space
106  * @owner: a representation of the owner of this pin; typically the device
107  *	name that controls its mux function, or the requested GPIO name
108  * @gpio_range: the range matching the GPIO pin if this is a request for a
109  *	single GPIO pin
110  */
pin_request(struct pinctrl_dev * pctldev,int pin,const char * owner,struct pinctrl_gpio_range * gpio_range)111 static int pin_request(struct pinctrl_dev *pctldev,
112 		       int pin, const char *owner,
113 		       struct pinctrl_gpio_range *gpio_range)
114 {
115 	struct pin_desc *desc;
116 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
117 	int status = -EINVAL;
118 
119 	desc = pin_desc_get(pctldev, pin);
120 	if (desc == NULL) {
121 		dev_err(pctldev->dev,
122 			"pin %d is not registered so it cannot be requested\n",
123 			pin);
124 		goto out;
125 	}
126 
127 	dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n",
128 		pin, desc->name, owner);
129 
130 	if ((!gpio_range || ops->strict) &&
131 	    desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
132 		dev_err(pctldev->dev,
133 			"pin %s already requested by %s; cannot claim for %s\n",
134 			desc->name, desc->mux_owner, owner);
135 		goto out;
136 	}
137 
138 	if ((gpio_range || ops->strict) && desc->gpio_owner) {
139 		dev_err(pctldev->dev,
140 			"pin %s already requested by %s; cannot claim for %s\n",
141 			desc->name, desc->gpio_owner, owner);
142 		goto out;
143 	}
144 
145 	if (gpio_range) {
146 		desc->gpio_owner = owner;
147 	} else {
148 		desc->mux_usecount++;
149 		if (desc->mux_usecount > 1)
150 			return 0;
151 
152 		desc->mux_owner = owner;
153 	}
154 
155 	/* Let each pin increase references to this module */
156 	if (!try_module_get(pctldev->owner)) {
157 		dev_err(pctldev->dev,
158 			"could not increase module refcount for pin %d\n",
159 			pin);
160 		status = -EINVAL;
161 		goto out_free_pin;
162 	}
163 
164 	/*
165 	 * If there is no kind of request function for the pin we just assume
166 	 * we got it by default and proceed.
167 	 */
168 	if (gpio_range && ops->gpio_request_enable)
169 		/* This requests and enables a single GPIO pin */
170 		status = ops->gpio_request_enable(pctldev, gpio_range, pin);
171 	else if (ops->request)
172 		status = ops->request(pctldev, pin);
173 	else
174 		status = 0;
175 
176 	if (status)
177 		module_put(pctldev->owner);
178 
179 out_free_pin:
180 	if (status) {
181 		if (gpio_range) {
182 			desc->gpio_owner = NULL;
183 		} else {
184 			desc->mux_usecount--;
185 			if (!desc->mux_usecount)
186 				desc->mux_owner = NULL;
187 		}
188 	}
189 out:
190 	if (status)
191 		dev_err_probe(pctldev->dev, status, "pin-%d (%s)\n",
192 			      pin, owner);
193 
194 	return status;
195 }
196 
197 /**
198  * pin_free() - release a single muxed in pin so something else can be muxed
199  * @pctldev: pin controller device handling this pin
200  * @pin: the pin to free
201  * @gpio_range: the range matching the GPIO pin if this is a request for a
202  *	single GPIO pin
203  *
204  * This function returns a pointer to the previous owner. This is used
205  * for callers that dynamically allocate an owner name so it can be freed
206  * once the pin is free. This is done for GPIO request functions.
207  */
pin_free(struct pinctrl_dev * pctldev,int pin,struct pinctrl_gpio_range * gpio_range)208 static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
209 			    struct pinctrl_gpio_range *gpio_range)
210 {
211 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
212 	struct pin_desc *desc;
213 	const char *owner;
214 
215 	desc = pin_desc_get(pctldev, pin);
216 	if (desc == NULL) {
217 		dev_err(pctldev->dev,
218 			"pin is not registered so it cannot be freed\n");
219 		return NULL;
220 	}
221 
222 	if (!gpio_range) {
223 		/*
224 		 * A pin should not be freed more times than allocated.
225 		 */
226 		if (WARN_ON(!desc->mux_usecount))
227 			return NULL;
228 		desc->mux_usecount--;
229 		if (desc->mux_usecount)
230 			return NULL;
231 	}
232 
233 	/*
234 	 * If there is no kind of request function for the pin we just assume
235 	 * we got it by default and proceed.
236 	 */
237 	if (gpio_range && ops->gpio_disable_free)
238 		ops->gpio_disable_free(pctldev, gpio_range, pin);
239 	else if (ops->free)
240 		ops->free(pctldev, pin);
241 
242 	if (gpio_range) {
243 		owner = desc->gpio_owner;
244 		desc->gpio_owner = NULL;
245 	} else {
246 		owner = desc->mux_owner;
247 		desc->mux_owner = NULL;
248 		desc->mux_setting = NULL;
249 	}
250 
251 	module_put(pctldev->owner);
252 
253 	return owner;
254 }
255 
256 /**
257  * pinmux_request_gpio() - request pinmuxing for a GPIO pin
258  * @pctldev: pin controller device affected
259  * @pin: the pin to mux in for GPIO
260  * @range: the applicable GPIO range
261  * @gpio: number of requested GPIO
262  */
pinmux_request_gpio(struct pinctrl_dev * pctldev,struct pinctrl_gpio_range * range,unsigned int pin,unsigned int gpio)263 int pinmux_request_gpio(struct pinctrl_dev *pctldev,
264 			struct pinctrl_gpio_range *range,
265 			unsigned int pin, unsigned int gpio)
266 {
267 	const char *owner;
268 	int ret;
269 
270 	/* Conjure some name stating what chip and pin this is taken by */
271 	owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
272 	if (!owner)
273 		return -ENOMEM;
274 
275 	ret = pin_request(pctldev, pin, owner, range);
276 	if (ret < 0)
277 		kfree(owner);
278 
279 	return ret;
280 }
281 
282 /**
283  * pinmux_free_gpio() - release a pin from GPIO muxing
284  * @pctldev: the pin controller device for the pin
285  * @pin: the affected currently GPIO-muxed in pin
286  * @range: applicable GPIO range
287  */
pinmux_free_gpio(struct pinctrl_dev * pctldev,unsigned int pin,struct pinctrl_gpio_range * range)288 void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned int pin,
289 		      struct pinctrl_gpio_range *range)
290 {
291 	const char *owner;
292 
293 	owner = pin_free(pctldev, pin, range);
294 	kfree(owner);
295 }
296 
297 /**
298  * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
299  * @pctldev: the pin controller handling this pin
300  * @range: applicable GPIO range
301  * @pin: the affected GPIO pin in this controller
302  * @input: true if we set the pin as input, false for output
303  */
pinmux_gpio_direction(struct pinctrl_dev * pctldev,struct pinctrl_gpio_range * range,unsigned int pin,bool input)304 int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
305 			  struct pinctrl_gpio_range *range,
306 			  unsigned int pin, bool input)
307 {
308 	const struct pinmux_ops *ops;
309 	int ret;
310 
311 	ops = pctldev->desc->pmxops;
312 
313 	if (ops->gpio_set_direction)
314 		ret = ops->gpio_set_direction(pctldev, range, pin, input);
315 	else
316 		ret = 0;
317 
318 	return ret;
319 }
320 
pinmux_func_name_to_selector(struct pinctrl_dev * pctldev,const char * function)321 static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
322 					const char *function)
323 {
324 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
325 	unsigned int nfuncs = ops->get_functions_count(pctldev);
326 	unsigned int selector = 0;
327 
328 	/* See if this pctldev has this function */
329 	while (selector < nfuncs) {
330 		const char *fname = ops->get_function_name(pctldev, selector);
331 
332 		if (!strcmp(function, fname))
333 			return selector;
334 
335 		selector++;
336 	}
337 
338 	return -EINVAL;
339 }
340 
pinmux_map_to_setting(const struct pinctrl_map * map,struct pinctrl_setting * setting)341 int pinmux_map_to_setting(const struct pinctrl_map *map,
342 			  struct pinctrl_setting *setting)
343 {
344 	struct pinctrl_dev *pctldev = setting->pctldev;
345 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
346 	char const * const *groups;
347 	unsigned int num_groups;
348 	int ret;
349 	const char *group;
350 
351 	if (!pmxops) {
352 		dev_err(pctldev->dev, "does not support mux function\n");
353 		return -EINVAL;
354 	}
355 
356 	ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
357 	if (ret < 0) {
358 		dev_err(pctldev->dev, "invalid function %s in map table\n",
359 			map->data.mux.function);
360 		return ret;
361 	}
362 	setting->data.mux.func = ret;
363 
364 	ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
365 					  &groups, &num_groups);
366 	if (ret < 0) {
367 		dev_err(pctldev->dev, "can't query groups for function %s\n",
368 			map->data.mux.function);
369 		return ret;
370 	}
371 	if (!num_groups) {
372 		dev_err(pctldev->dev,
373 			"function %s can't be selected on any group\n",
374 			map->data.mux.function);
375 		return -EINVAL;
376 	}
377 	if (map->data.mux.group) {
378 		group = map->data.mux.group;
379 		ret = match_string(groups, num_groups, group);
380 		if (ret < 0) {
381 			dev_err(pctldev->dev,
382 				"invalid group \"%s\" for function \"%s\"\n",
383 				group, map->data.mux.function);
384 			return ret;
385 		}
386 	} else {
387 		group = groups[0];
388 	}
389 
390 	ret = pinctrl_get_group_selector(pctldev, group);
391 	if (ret < 0) {
392 		dev_err(pctldev->dev, "invalid group %s in map table\n",
393 			map->data.mux.group);
394 		return ret;
395 	}
396 	setting->data.mux.group = ret;
397 
398 	return 0;
399 }
400 
pinmux_free_setting(const struct pinctrl_setting * setting)401 void pinmux_free_setting(const struct pinctrl_setting *setting)
402 {
403 	/* This function is currently unused */
404 }
405 
pinmux_enable_setting(const struct pinctrl_setting * setting)406 int pinmux_enable_setting(const struct pinctrl_setting *setting)
407 {
408 	struct pinctrl_dev *pctldev = setting->pctldev;
409 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
410 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
411 	int ret = 0;
412 	const unsigned int *pins = NULL;
413 	unsigned int num_pins = 0;
414 	int i;
415 	struct pin_desc *desc;
416 
417 	if (pctlops->get_group_pins)
418 		ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
419 					      &pins, &num_pins);
420 
421 	if (ret) {
422 		const char *gname;
423 
424 		/* errors only affect debug data, so just warn */
425 		gname = pctlops->get_group_name(pctldev,
426 						setting->data.mux.group);
427 		dev_warn(pctldev->dev,
428 			 "could not get pins for group %s\n",
429 			 gname);
430 		num_pins = 0;
431 	}
432 
433 	/* Try to allocate all pins in this group, one by one */
434 	for (i = 0; i < num_pins; i++) {
435 		ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
436 		if (ret) {
437 			const char *gname;
438 			const char *pname;
439 
440 			desc = pin_desc_get(pctldev, pins[i]);
441 			pname = desc ? desc->name : "non-existing";
442 			gname = pctlops->get_group_name(pctldev,
443 						setting->data.mux.group);
444 			dev_err_probe(pctldev->dev, ret,
445 				"could not request pin %d (%s) from group %s on device %s\n",
446 				pins[i], pname, gname,
447 				pinctrl_dev_get_name(pctldev));
448 			goto err_pin_request;
449 		}
450 	}
451 
452 	/* Now that we have acquired the pins, encode the mux setting */
453 	for (i = 0; i < num_pins; i++) {
454 		desc = pin_desc_get(pctldev, pins[i]);
455 		if (desc == NULL) {
456 			dev_warn(pctldev->dev,
457 				 "could not get pin desc for pin %d\n",
458 				 pins[i]);
459 			continue;
460 		}
461 		desc->mux_setting = &(setting->data.mux);
462 	}
463 
464 	ret = ops->set_mux(pctldev, setting->data.mux.func,
465 			   setting->data.mux.group);
466 
467 	if (ret)
468 		goto err_set_mux;
469 
470 	return 0;
471 
472 err_set_mux:
473 	for (i = 0; i < num_pins; i++) {
474 		desc = pin_desc_get(pctldev, pins[i]);
475 		if (desc)
476 			desc->mux_setting = NULL;
477 	}
478 err_pin_request:
479 	/* On error release all taken pins */
480 	while (--i >= 0)
481 		pin_free(pctldev, pins[i], NULL);
482 
483 	return ret;
484 }
485 
pinmux_disable_setting(const struct pinctrl_setting * setting)486 void pinmux_disable_setting(const struct pinctrl_setting *setting)
487 {
488 	struct pinctrl_dev *pctldev = setting->pctldev;
489 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
490 	int ret = 0;
491 	const unsigned int *pins = NULL;
492 	unsigned int num_pins = 0;
493 	int i;
494 	struct pin_desc *desc;
495 
496 	if (pctlops->get_group_pins)
497 		ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
498 					      &pins, &num_pins);
499 	if (ret) {
500 		const char *gname;
501 
502 		/* errors only affect debug data, so just warn */
503 		gname = pctlops->get_group_name(pctldev,
504 						setting->data.mux.group);
505 		dev_warn(pctldev->dev,
506 			 "could not get pins for group %s\n",
507 			 gname);
508 		num_pins = 0;
509 	}
510 
511 	/* Flag the descs that no setting is active */
512 	for (i = 0; i < num_pins; i++) {
513 		desc = pin_desc_get(pctldev, pins[i]);
514 		if (desc == NULL) {
515 			dev_warn(pctldev->dev,
516 				 "could not get pin desc for pin %d\n",
517 				 pins[i]);
518 			continue;
519 		}
520 		if (desc->mux_setting == &(setting->data.mux)) {
521 			pin_free(pctldev, pins[i], NULL);
522 		} else {
523 			const char *gname;
524 
525 			gname = pctlops->get_group_name(pctldev,
526 						setting->data.mux.group);
527 			dev_warn(pctldev->dev,
528 				 "not freeing pin %d (%s) as part of deactivating group %s - it is already used for some other setting",
529 				 pins[i], desc->name, gname);
530 		}
531 	}
532 }
533 
534 #ifdef CONFIG_DEBUG_FS
535 
536 /* Called from pincontrol core */
pinmux_functions_show(struct seq_file * s,void * what)537 static int pinmux_functions_show(struct seq_file *s, void *what)
538 {
539 	struct pinctrl_dev *pctldev = s->private;
540 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
541 	unsigned int nfuncs;
542 	unsigned int func_selector = 0;
543 
544 	if (!pmxops)
545 		return 0;
546 
547 	mutex_lock(&pctldev->mutex);
548 	nfuncs = pmxops->get_functions_count(pctldev);
549 	while (func_selector < nfuncs) {
550 		const char *func = pmxops->get_function_name(pctldev,
551 							  func_selector);
552 		const char * const *groups;
553 		unsigned int num_groups;
554 		int ret;
555 		int i;
556 
557 		ret = pmxops->get_function_groups(pctldev, func_selector,
558 						  &groups, &num_groups);
559 		if (ret) {
560 			seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
561 				   func);
562 			func_selector++;
563 			continue;
564 		}
565 
566 		seq_printf(s, "function %d: %s, groups = [ ", func_selector, func);
567 		for (i = 0; i < num_groups; i++)
568 			seq_printf(s, "%s ", groups[i]);
569 		seq_puts(s, "]\n");
570 
571 		func_selector++;
572 	}
573 
574 	mutex_unlock(&pctldev->mutex);
575 
576 	return 0;
577 }
578 DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
579 
pinmux_pins_show(struct seq_file * s,void * what)580 static int pinmux_pins_show(struct seq_file *s, void *what)
581 {
582 	struct pinctrl_dev *pctldev = s->private;
583 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
584 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
585 	unsigned int i, pin;
586 
587 	if (!pmxops)
588 		return 0;
589 
590 	seq_puts(s, "Pinmux settings per pin\n");
591 	if (pmxops->strict)
592 		seq_puts(s,
593 		 "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n");
594 	else
595 		seq_puts(s,
596 		"Format: pin (name): mux_owner gpio_owner hog?\n");
597 
598 	mutex_lock(&pctldev->mutex);
599 
600 	/* The pin number can be retrived from the pin controller descriptor */
601 	for (i = 0; i < pctldev->desc->npins; i++) {
602 		struct pin_desc *desc;
603 		bool is_hog = false;
604 
605 		pin = pctldev->desc->pins[i].number;
606 		desc = pin_desc_get(pctldev, pin);
607 		/* Skip if we cannot search the pin */
608 		if (desc == NULL)
609 			continue;
610 
611 		if (desc->mux_owner &&
612 		    !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
613 			is_hog = true;
614 
615 		if (pmxops->strict) {
616 			if (desc->mux_owner)
617 				seq_printf(s, "pin %d (%s): device %s%s",
618 					   pin, desc->name, desc->mux_owner,
619 					   is_hog ? " (HOG)" : "");
620 			else if (desc->gpio_owner)
621 				seq_printf(s, "pin %d (%s): GPIO %s",
622 					   pin, desc->name, desc->gpio_owner);
623 			else
624 				seq_printf(s, "pin %d (%s): UNCLAIMED",
625 					   pin, desc->name);
626 		} else {
627 			/* For non-strict controllers */
628 			seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name,
629 				   desc->mux_owner ? desc->mux_owner
630 				   : "(MUX UNCLAIMED)",
631 				   desc->gpio_owner ? desc->gpio_owner
632 				   : "(GPIO UNCLAIMED)",
633 				   is_hog ? " (HOG)" : "");
634 		}
635 
636 		/* If mux: print function+group claiming the pin */
637 		if (desc->mux_setting)
638 			seq_printf(s, " function %s group %s\n",
639 				   pmxops->get_function_name(pctldev,
640 					desc->mux_setting->func),
641 				   pctlops->get_group_name(pctldev,
642 					desc->mux_setting->group));
643 		else
644 			seq_putc(s, '\n');
645 	}
646 
647 	mutex_unlock(&pctldev->mutex);
648 
649 	return 0;
650 }
651 DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
652 
pinmux_show_map(struct seq_file * s,const struct pinctrl_map * map)653 void pinmux_show_map(struct seq_file *s, const struct pinctrl_map *map)
654 {
655 	seq_printf(s, "group %s\nfunction %s\n",
656 		map->data.mux.group ? map->data.mux.group : "(default)",
657 		map->data.mux.function);
658 }
659 
pinmux_show_setting(struct seq_file * s,const struct pinctrl_setting * setting)660 void pinmux_show_setting(struct seq_file *s,
661 			 const struct pinctrl_setting *setting)
662 {
663 	struct pinctrl_dev *pctldev = setting->pctldev;
664 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
665 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
666 
667 	seq_printf(s, "group: %s (%u) function: %s (%u)\n",
668 		   pctlops->get_group_name(pctldev, setting->data.mux.group),
669 		   setting->data.mux.group,
670 		   pmxops->get_function_name(pctldev, setting->data.mux.func),
671 		   setting->data.mux.func);
672 }
673 
pinmux_select_show(struct seq_file * s,void * unused)674 static int pinmux_select_show(struct seq_file *s, void *unused)
675 {
676 	return -EPERM;
677 }
678 
pinmux_select_write(struct file * file,const char __user * user_buf,size_t len,loff_t * ppos)679 static ssize_t pinmux_select_write(struct file *file, const char __user *user_buf,
680 				   size_t len, loff_t *ppos)
681 {
682 	struct seq_file *sfile = file->private_data;
683 	struct pinctrl_dev *pctldev = sfile->private;
684 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
685 	const char *const *groups;
686 	char *buf, *gname, *fname;
687 	unsigned int num_groups;
688 	int fsel, gsel, ret;
689 
690 	buf = memdup_user_nul(user_buf, len);
691 	if (IS_ERR(buf))
692 		return PTR_ERR(buf);
693 
694 	/* remove leading and trailing spaces of input buffer */
695 	gname = strstrip(buf);
696 	if (*gname == '\0') {
697 		ret = -EINVAL;
698 		goto exit_free_buf;
699 	}
700 
701 	/* find a separator which is a spacelike character */
702 	for (fname = gname; !isspace(*fname); fname++) {
703 		if (*fname == '\0') {
704 			ret = -EINVAL;
705 			goto exit_free_buf;
706 		}
707 	}
708 	*fname = '\0';
709 
710 	/* drop extra spaces between function and group names */
711 	fname = skip_spaces(fname + 1);
712 	if (*fname == '\0') {
713 		ret = -EINVAL;
714 		goto exit_free_buf;
715 	}
716 
717 	ret = pinmux_func_name_to_selector(pctldev, fname);
718 	if (ret < 0) {
719 		dev_err(pctldev->dev, "invalid function %s in map table\n", fname);
720 		goto exit_free_buf;
721 	}
722 	fsel = ret;
723 
724 	ret = pmxops->get_function_groups(pctldev, fsel, &groups, &num_groups);
725 	if (ret) {
726 		dev_err(pctldev->dev, "no groups for function %d (%s)", fsel, fname);
727 		goto exit_free_buf;
728 	}
729 
730 	ret = match_string(groups, num_groups, gname);
731 	if (ret < 0) {
732 		dev_err(pctldev->dev, "invalid group %s", gname);
733 		goto exit_free_buf;
734 	}
735 
736 	ret = pinctrl_get_group_selector(pctldev, gname);
737 	if (ret < 0)
738 		goto exit_free_buf;
739 	gsel = ret;
740 
741 	ret = pmxops->set_mux(pctldev, fsel, gsel);
742 	if (ret) {
743 		dev_err(pctldev->dev, "set_mux() failed: %d", ret);
744 		goto exit_free_buf;
745 	}
746 	ret = len;
747 
748 exit_free_buf:
749 	kfree(buf);
750 
751 	return ret;
752 }
753 DEFINE_SHOW_STORE_ATTRIBUTE(pinmux_select);
754 
pinmux_init_device_debugfs(struct dentry * devroot,struct pinctrl_dev * pctldev)755 void pinmux_init_device_debugfs(struct dentry *devroot,
756 			 struct pinctrl_dev *pctldev)
757 {
758 	debugfs_create_file("pinmux-functions", 0444,
759 			    devroot, pctldev, &pinmux_functions_fops);
760 	debugfs_create_file("pinmux-pins", 0444,
761 			    devroot, pctldev, &pinmux_pins_fops);
762 	debugfs_create_file("pinmux-select", 0200,
763 			    devroot, pctldev, &pinmux_select_fops);
764 }
765 
766 #endif /* CONFIG_DEBUG_FS */
767 
768 #ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
769 
770 /**
771  * pinmux_generic_get_function_count() - returns number of functions
772  * @pctldev: pin controller device
773  */
pinmux_generic_get_function_count(struct pinctrl_dev * pctldev)774 int pinmux_generic_get_function_count(struct pinctrl_dev *pctldev)
775 {
776 	return pctldev->num_functions;
777 }
778 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_count);
779 
780 /**
781  * pinmux_generic_get_function_name() - returns the function name
782  * @pctldev: pin controller device
783  * @selector: function number
784  */
785 const char *
pinmux_generic_get_function_name(struct pinctrl_dev * pctldev,unsigned int selector)786 pinmux_generic_get_function_name(struct pinctrl_dev *pctldev,
787 				 unsigned int selector)
788 {
789 	struct function_desc *function;
790 
791 	function = radix_tree_lookup(&pctldev->pin_function_tree,
792 				     selector);
793 	if (!function)
794 		return NULL;
795 
796 	return function->func.name;
797 }
798 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_name);
799 
800 /**
801  * pinmux_generic_get_function_groups() - gets the function groups
802  * @pctldev: pin controller device
803  * @selector: function number
804  * @groups: array of pin groups
805  * @ngroups: number of pin groups
806  */
pinmux_generic_get_function_groups(struct pinctrl_dev * pctldev,unsigned int selector,const char * const ** groups,unsigned int * const ngroups)807 int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev,
808 				       unsigned int selector,
809 				       const char * const **groups,
810 				       unsigned int * const ngroups)
811 {
812 	struct function_desc *function;
813 
814 	function = radix_tree_lookup(&pctldev->pin_function_tree,
815 				     selector);
816 	if (!function) {
817 		dev_err(pctldev->dev, "%s could not find function%i\n",
818 			__func__, selector);
819 		return -EINVAL;
820 	}
821 	*groups = function->func.groups;
822 	*ngroups = function->func.ngroups;
823 
824 	return 0;
825 }
826 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_groups);
827 
828 /**
829  * pinmux_generic_get_function() - returns a function based on the number
830  * @pctldev: pin controller device
831  * @selector: function number
832  */
pinmux_generic_get_function(struct pinctrl_dev * pctldev,unsigned int selector)833 struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev,
834 						  unsigned int selector)
835 {
836 	struct function_desc *function;
837 
838 	function = radix_tree_lookup(&pctldev->pin_function_tree,
839 				     selector);
840 	if (!function)
841 		return NULL;
842 
843 	return function;
844 }
845 EXPORT_SYMBOL_GPL(pinmux_generic_get_function);
846 
847 /**
848  * pinmux_generic_add_function() - adds a function group
849  * @pctldev: pin controller device
850  * @name: name of the function
851  * @groups: array of pin groups
852  * @ngroups: number of pin groups
853  * @data: pin controller driver specific data
854  */
pinmux_generic_add_function(struct pinctrl_dev * pctldev,const char * name,const char * const * groups,const unsigned int ngroups,void * data)855 int pinmux_generic_add_function(struct pinctrl_dev *pctldev,
856 				const char *name,
857 				const char * const *groups,
858 				const unsigned int ngroups,
859 				void *data)
860 {
861 	struct function_desc *function;
862 	int selector, error;
863 
864 	if (!name)
865 		return -EINVAL;
866 
867 	selector = pinmux_func_name_to_selector(pctldev, name);
868 	if (selector >= 0)
869 		return selector;
870 
871 	selector = pctldev->num_functions;
872 
873 	function = devm_kzalloc(pctldev->dev, sizeof(*function), GFP_KERNEL);
874 	if (!function)
875 		return -ENOMEM;
876 
877 	*function = PINCTRL_FUNCTION_DESC(name, groups, ngroups, data);
878 
879 	error = radix_tree_insert(&pctldev->pin_function_tree, selector, function);
880 	if (error)
881 		return error;
882 
883 	pctldev->num_functions++;
884 
885 	return selector;
886 }
887 EXPORT_SYMBOL_GPL(pinmux_generic_add_function);
888 
889 /**
890  * pinmux_generic_remove_function() - removes a numbered function
891  * @pctldev: pin controller device
892  * @selector: function number
893  *
894  * Note that the caller must take care of locking.
895  */
pinmux_generic_remove_function(struct pinctrl_dev * pctldev,unsigned int selector)896 int pinmux_generic_remove_function(struct pinctrl_dev *pctldev,
897 				   unsigned int selector)
898 {
899 	struct function_desc *function;
900 
901 	function = radix_tree_lookup(&pctldev->pin_function_tree,
902 				     selector);
903 	if (!function)
904 		return -ENOENT;
905 
906 	radix_tree_delete(&pctldev->pin_function_tree, selector);
907 	devm_kfree(pctldev->dev, function);
908 
909 	pctldev->num_functions--;
910 
911 	return 0;
912 }
913 EXPORT_SYMBOL_GPL(pinmux_generic_remove_function);
914 
915 /**
916  * pinmux_generic_free_functions() - removes all functions
917  * @pctldev: pin controller device
918  *
919  * Note that the caller must take care of locking. The pinctrl
920  * functions are allocated with devm_kzalloc() so no need to free
921  * them here.
922  */
pinmux_generic_free_functions(struct pinctrl_dev * pctldev)923 void pinmux_generic_free_functions(struct pinctrl_dev *pctldev)
924 {
925 	struct radix_tree_iter iter;
926 	void __rcu **slot;
927 
928 	radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0)
929 		radix_tree_delete(&pctldev->pin_function_tree, iter.index);
930 
931 	pctldev->num_functions = 0;
932 }
933 
934 #endif /* CONFIG_GENERIC_PINMUX_FUNCTIONS */
935