xref: /linux/drivers/pinctrl/pinmux.c (revision 4c62e9764ab403d42f9b8871b1241fe7812f19d4)
1 /*
2  * Core driver for the pin muxing portions of the pin control subsystem
3  *
4  * Copyright (C) 2011-2012 ST-Ericsson SA
5  * Written on behalf of Linaro for ST-Ericsson
6  * Based on bits of regulator core, gpio core and clk core
7  *
8  * Author: Linus Walleij <linus.walleij@linaro.org>
9  *
10  * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
11  *
12  * License terms: GNU General Public License (GPL) version 2
13  */
14 #define pr_fmt(fmt) "pinmux core: " fmt
15 
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/device.h>
20 #include <linux/slab.h>
21 #include <linux/radix-tree.h>
22 #include <linux/err.h>
23 #include <linux/list.h>
24 #include <linux/string.h>
25 #include <linux/sysfs.h>
26 #include <linux/debugfs.h>
27 #include <linux/seq_file.h>
28 #include <linux/pinctrl/machine.h>
29 #include <linux/pinctrl/pinmux.h>
30 #include "core.h"
31 #include "pinmux.h"
32 
33 int pinmux_check_ops(struct pinctrl_dev *pctldev)
34 {
35 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
36 	unsigned nfuncs;
37 	unsigned selector = 0;
38 
39 	/* Check that we implement required operations */
40 	if (!ops ||
41 	    !ops->get_functions_count ||
42 	    !ops->get_function_name ||
43 	    !ops->get_function_groups ||
44 	    !ops->enable) {
45 		dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n");
46 		return -EINVAL;
47 	}
48 	/* Check that all functions registered have names */
49 	nfuncs = ops->get_functions_count(pctldev);
50 	while (selector < nfuncs) {
51 		const char *fname = ops->get_function_name(pctldev,
52 							   selector);
53 		if (!fname) {
54 			dev_err(pctldev->dev, "pinmux ops has no name for function%u\n",
55 				selector);
56 			return -EINVAL;
57 		}
58 		selector++;
59 	}
60 
61 	return 0;
62 }
63 
64 int pinmux_validate_map(struct pinctrl_map const *map, int i)
65 {
66 	if (!map->data.mux.function) {
67 		pr_err("failed to register map %s (%d): no function given\n",
68 		       map->name, i);
69 		return -EINVAL;
70 	}
71 
72 	return 0;
73 }
74 
75 /**
76  * pin_request() - request a single pin to be muxed in, typically for GPIO
77  * @pin: the pin number in the global pin space
78  * @owner: a representation of the owner of this pin; typically the device
79  *	name that controls its mux function, or the requested GPIO name
80  * @gpio_range: the range matching the GPIO pin if this is a request for a
81  *	single GPIO pin
82  */
83 static int pin_request(struct pinctrl_dev *pctldev,
84 		       int pin, const char *owner,
85 		       struct pinctrl_gpio_range *gpio_range)
86 {
87 	struct pin_desc *desc;
88 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
89 	int status = -EINVAL;
90 
91 	desc = pin_desc_get(pctldev, pin);
92 	if (desc == NULL) {
93 		dev_err(pctldev->dev,
94 			"pin %d is not registered so it cannot be requested\n",
95 			pin);
96 		goto out;
97 	}
98 
99 	dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n",
100 		pin, desc->name, owner);
101 
102 	if (gpio_range) {
103 		/* There's no need to support multiple GPIO requests */
104 		if (desc->gpio_owner) {
105 			dev_err(pctldev->dev,
106 				"pin %s already requested by %s; cannot claim for %s\n",
107 				desc->name, desc->gpio_owner, owner);
108 			goto out;
109 		}
110 
111 		desc->gpio_owner = owner;
112 	} else {
113 		if (desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
114 			dev_err(pctldev->dev,
115 				"pin %s already requested by %s; cannot claim for %s\n",
116 				desc->name, desc->mux_owner, owner);
117 			goto out;
118 		}
119 
120 		desc->mux_usecount++;
121 		if (desc->mux_usecount > 1)
122 			return 0;
123 
124 		desc->mux_owner = owner;
125 	}
126 
127 	/* Let each pin increase references to this module */
128 	if (!try_module_get(pctldev->owner)) {
129 		dev_err(pctldev->dev,
130 			"could not increase module refcount for pin %d\n",
131 			pin);
132 		status = -EINVAL;
133 		goto out_free_pin;
134 	}
135 
136 	/*
137 	 * If there is no kind of request function for the pin we just assume
138 	 * we got it by default and proceed.
139 	 */
140 	if (gpio_range && ops->gpio_request_enable)
141 		/* This requests and enables a single GPIO pin */
142 		status = ops->gpio_request_enable(pctldev, gpio_range, pin);
143 	else if (ops->request)
144 		status = ops->request(pctldev, pin);
145 	else
146 		status = 0;
147 
148 	if (status) {
149 		dev_err(pctldev->dev, "request() failed for pin %d\n", pin);
150 		module_put(pctldev->owner);
151 	}
152 
153 out_free_pin:
154 	if (status) {
155 		if (gpio_range) {
156 			desc->gpio_owner = NULL;
157 		} else {
158 			desc->mux_usecount--;
159 			if (!desc->mux_usecount)
160 				desc->mux_owner = NULL;
161 		}
162 	}
163 out:
164 	if (status)
165 		dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
166 			pin, owner, status);
167 
168 	return status;
169 }
170 
171 /**
172  * pin_free() - release a single muxed in pin so something else can be muxed
173  * @pctldev: pin controller device handling this pin
174  * @pin: the pin to free
175  * @gpio_range: the range matching the GPIO pin if this is a request for a
176  *	single GPIO pin
177  *
178  * This function returns a pointer to the previous owner. This is used
179  * for callers that dynamically allocate an owner name so it can be freed
180  * once the pin is free. This is done for GPIO request functions.
181  */
182 static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
183 			    struct pinctrl_gpio_range *gpio_range)
184 {
185 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
186 	struct pin_desc *desc;
187 	const char *owner;
188 
189 	desc = pin_desc_get(pctldev, pin);
190 	if (desc == NULL) {
191 		dev_err(pctldev->dev,
192 			"pin is not registered so it cannot be freed\n");
193 		return NULL;
194 	}
195 
196 	if (!gpio_range) {
197 		desc->mux_usecount--;
198 		if (desc->mux_usecount)
199 			return NULL;
200 	}
201 
202 	/*
203 	 * If there is no kind of request function for the pin we just assume
204 	 * we got it by default and proceed.
205 	 */
206 	if (gpio_range && ops->gpio_disable_free)
207 		ops->gpio_disable_free(pctldev, gpio_range, pin);
208 	else if (ops->free)
209 		ops->free(pctldev, pin);
210 
211 	if (gpio_range) {
212 		owner = desc->gpio_owner;
213 		desc->gpio_owner = NULL;
214 	} else {
215 		owner = desc->mux_owner;
216 		desc->mux_owner = NULL;
217 		desc->mux_setting = NULL;
218 	}
219 
220 	module_put(pctldev->owner);
221 
222 	return owner;
223 }
224 
225 /**
226  * pinmux_request_gpio() - request pinmuxing for a GPIO pin
227  * @pctldev: pin controller device affected
228  * @pin: the pin to mux in for GPIO
229  * @range: the applicable GPIO range
230  */
231 int pinmux_request_gpio(struct pinctrl_dev *pctldev,
232 			struct pinctrl_gpio_range *range,
233 			unsigned pin, unsigned gpio)
234 {
235 	const char *owner;
236 	int ret;
237 
238 	/* Conjure some name stating what chip and pin this is taken by */
239 	owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
240 	if (!owner)
241 		return -EINVAL;
242 
243 	ret = pin_request(pctldev, pin, owner, range);
244 	if (ret < 0)
245 		kfree(owner);
246 
247 	return ret;
248 }
249 
250 /**
251  * pinmux_free_gpio() - release a pin from GPIO muxing
252  * @pctldev: the pin controller device for the pin
253  * @pin: the affected currently GPIO-muxed in pin
254  * @range: applicable GPIO range
255  */
256 void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
257 		      struct pinctrl_gpio_range *range)
258 {
259 	const char *owner;
260 
261 	owner = pin_free(pctldev, pin, range);
262 	kfree(owner);
263 }
264 
265 /**
266  * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
267  * @pctldev: the pin controller handling this pin
268  * @range: applicable GPIO range
269  * @pin: the affected GPIO pin in this controller
270  * @input: true if we set the pin as input, false for output
271  */
272 int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
273 			  struct pinctrl_gpio_range *range,
274 			  unsigned pin, bool input)
275 {
276 	const struct pinmux_ops *ops;
277 	int ret;
278 
279 	ops = pctldev->desc->pmxops;
280 
281 	if (ops->gpio_set_direction)
282 		ret = ops->gpio_set_direction(pctldev, range, pin, input);
283 	else
284 		ret = 0;
285 
286 	return ret;
287 }
288 
289 static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
290 					const char *function)
291 {
292 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
293 	unsigned nfuncs = ops->get_functions_count(pctldev);
294 	unsigned selector = 0;
295 
296 	/* See if this pctldev has this function */
297 	while (selector < nfuncs) {
298 		const char *fname = ops->get_function_name(pctldev,
299 							   selector);
300 
301 		if (!strcmp(function, fname))
302 			return selector;
303 
304 		selector++;
305 	}
306 
307 	pr_err("%s does not support function %s\n",
308 	       pinctrl_dev_get_name(pctldev), function);
309 	return -EINVAL;
310 }
311 
312 int pinmux_map_to_setting(struct pinctrl_map const *map,
313 			  struct pinctrl_setting *setting)
314 {
315 	struct pinctrl_dev *pctldev = setting->pctldev;
316 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
317 	char const * const *groups;
318 	unsigned num_groups;
319 	int ret;
320 	const char *group;
321 	int i;
322 
323 	if (!pmxops) {
324 		dev_err(pctldev->dev, "does not support mux function\n");
325 		return -EINVAL;
326 	}
327 
328 	ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
329 	if (ret < 0) {
330 		dev_err(pctldev->dev, "invalid function %s in map table\n",
331 			map->data.mux.function);
332 		return ret;
333 	}
334 	setting->data.mux.func = ret;
335 
336 	ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
337 					  &groups, &num_groups);
338 	if (ret < 0) {
339 		dev_err(pctldev->dev, "can't query groups for function %s\n",
340 			map->data.mux.function);
341 		return ret;
342 	}
343 	if (!num_groups) {
344 		dev_err(pctldev->dev,
345 			"function %s can't be selected on any group\n",
346 			map->data.mux.function);
347 		return -EINVAL;
348 	}
349 	if (map->data.mux.group) {
350 		bool found = false;
351 		group = map->data.mux.group;
352 		for (i = 0; i < num_groups; i++) {
353 			if (!strcmp(group, groups[i])) {
354 				found = true;
355 				break;
356 			}
357 		}
358 		if (!found) {
359 			dev_err(pctldev->dev,
360 				"invalid group \"%s\" for function \"%s\"\n",
361 				group, map->data.mux.function);
362 			return -EINVAL;
363 		}
364 	} else {
365 		group = groups[0];
366 	}
367 
368 	ret = pinctrl_get_group_selector(pctldev, group);
369 	if (ret < 0) {
370 		dev_err(pctldev->dev, "invalid group %s in map table\n",
371 			map->data.mux.group);
372 		return ret;
373 	}
374 	setting->data.mux.group = ret;
375 
376 	return 0;
377 }
378 
379 void pinmux_free_setting(struct pinctrl_setting const *setting)
380 {
381 	/* This function is currently unused */
382 }
383 
384 int pinmux_enable_setting(struct pinctrl_setting const *setting)
385 {
386 	struct pinctrl_dev *pctldev = setting->pctldev;
387 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
388 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
389 	int ret;
390 	const unsigned *pins;
391 	unsigned num_pins;
392 	int i;
393 	struct pin_desc *desc;
394 
395 	ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
396 				      &pins, &num_pins);
397 	if (ret) {
398 		/* errors only affect debug data, so just warn */
399 		dev_warn(pctldev->dev,
400 			 "could not get pins for group selector %d\n",
401 			 setting->data.mux.group);
402 		num_pins = 0;
403 	}
404 
405 	/* Try to allocate all pins in this group, one by one */
406 	for (i = 0; i < num_pins; i++) {
407 		ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
408 		if (ret) {
409 			dev_err(pctldev->dev,
410 				"could not request pin %d on device %s\n",
411 				pins[i], pinctrl_dev_get_name(pctldev));
412 			goto err_pin_request;
413 		}
414 	}
415 
416 	/* Now that we have acquired the pins, encode the mux setting */
417 	for (i = 0; i < num_pins; i++) {
418 		desc = pin_desc_get(pctldev, pins[i]);
419 		if (desc == NULL) {
420 			dev_warn(pctldev->dev,
421 				 "could not get pin desc for pin %d\n",
422 				 pins[i]);
423 			continue;
424 		}
425 		desc->mux_setting = &(setting->data.mux);
426 	}
427 
428 	ret = ops->enable(pctldev, setting->data.mux.func,
429 			  setting->data.mux.group);
430 
431 	if (ret)
432 		goto err_enable;
433 
434 	return 0;
435 
436 err_enable:
437 	for (i = 0; i < num_pins; i++) {
438 		desc = pin_desc_get(pctldev, pins[i]);
439 		if (desc)
440 			desc->mux_setting = NULL;
441 	}
442 err_pin_request:
443 	/* On error release all taken pins */
444 	while (--i >= 0)
445 		pin_free(pctldev, pins[i], NULL);
446 
447 	return ret;
448 }
449 
450 void pinmux_disable_setting(struct pinctrl_setting const *setting)
451 {
452 	struct pinctrl_dev *pctldev = setting->pctldev;
453 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
454 	const struct pinmux_ops *ops = pctldev->desc->pmxops;
455 	int ret;
456 	const unsigned *pins;
457 	unsigned num_pins;
458 	int i;
459 	struct pin_desc *desc;
460 
461 	ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
462 				      &pins, &num_pins);
463 	if (ret) {
464 		/* errors only affect debug data, so just warn */
465 		dev_warn(pctldev->dev,
466 			 "could not get pins for group selector %d\n",
467 			 setting->data.mux.group);
468 		num_pins = 0;
469 	}
470 
471 	/* Flag the descs that no setting is active */
472 	for (i = 0; i < num_pins; i++) {
473 		desc = pin_desc_get(pctldev, pins[i]);
474 		if (desc == NULL) {
475 			dev_warn(pctldev->dev,
476 				 "could not get pin desc for pin %d\n",
477 				 pins[i]);
478 			continue;
479 		}
480 		desc->mux_setting = NULL;
481 	}
482 
483 	/* And release the pins */
484 	for (i = 0; i < num_pins; i++)
485 		pin_free(pctldev, pins[i], NULL);
486 
487 	if (ops->disable)
488 		ops->disable(pctldev, setting->data.mux.func, setting->data.mux.group);
489 }
490 
491 #ifdef CONFIG_DEBUG_FS
492 
493 /* Called from pincontrol core */
494 static int pinmux_functions_show(struct seq_file *s, void *what)
495 {
496 	struct pinctrl_dev *pctldev = s->private;
497 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
498 	unsigned nfuncs;
499 	unsigned func_selector = 0;
500 
501 	if (!pmxops)
502 		return 0;
503 
504 	mutex_lock(&pinctrl_mutex);
505 	nfuncs = pmxops->get_functions_count(pctldev);
506 	while (func_selector < nfuncs) {
507 		const char *func = pmxops->get_function_name(pctldev,
508 							  func_selector);
509 		const char * const *groups;
510 		unsigned num_groups;
511 		int ret;
512 		int i;
513 
514 		ret = pmxops->get_function_groups(pctldev, func_selector,
515 						  &groups, &num_groups);
516 		if (ret)
517 			seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
518 				   func);
519 
520 		seq_printf(s, "function: %s, groups = [ ", func);
521 		for (i = 0; i < num_groups; i++)
522 			seq_printf(s, "%s ", groups[i]);
523 		seq_puts(s, "]\n");
524 
525 		func_selector++;
526 	}
527 
528 	mutex_unlock(&pinctrl_mutex);
529 
530 	return 0;
531 }
532 
533 static int pinmux_pins_show(struct seq_file *s, void *what)
534 {
535 	struct pinctrl_dev *pctldev = s->private;
536 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
537 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
538 	unsigned i, pin;
539 
540 	if (!pmxops)
541 		return 0;
542 
543 	seq_puts(s, "Pinmux settings per pin\n");
544 	seq_puts(s, "Format: pin (name): mux_owner gpio_owner hog?\n");
545 
546 	mutex_lock(&pinctrl_mutex);
547 
548 	/* The pin number can be retrived from the pin controller descriptor */
549 	for (i = 0; i < pctldev->desc->npins; i++) {
550 		struct pin_desc *desc;
551 		bool is_hog = false;
552 
553 		pin = pctldev->desc->pins[i].number;
554 		desc = pin_desc_get(pctldev, pin);
555 		/* Skip if we cannot search the pin */
556 		if (desc == NULL)
557 			continue;
558 
559 		if (desc->mux_owner &&
560 		    !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
561 			is_hog = true;
562 
563 		seq_printf(s, "pin %d (%s): %s %s%s", pin,
564 			   desc->name ? desc->name : "unnamed",
565 			   desc->mux_owner ? desc->mux_owner
566 				: "(MUX UNCLAIMED)",
567 			   desc->gpio_owner ? desc->gpio_owner
568 				: "(GPIO UNCLAIMED)",
569 			   is_hog ? " (HOG)" : "");
570 
571 		if (desc->mux_setting)
572 			seq_printf(s, " function %s group %s\n",
573 				   pmxops->get_function_name(pctldev,
574 					desc->mux_setting->func),
575 				   pctlops->get_group_name(pctldev,
576 					desc->mux_setting->group));
577 		else
578 			seq_printf(s, "\n");
579 	}
580 
581 	mutex_unlock(&pinctrl_mutex);
582 
583 	return 0;
584 }
585 
586 void pinmux_show_map(struct seq_file *s, struct pinctrl_map const *map)
587 {
588 	seq_printf(s, "group %s\nfunction %s\n",
589 		map->data.mux.group ? map->data.mux.group : "(default)",
590 		map->data.mux.function);
591 }
592 
593 void pinmux_show_setting(struct seq_file *s,
594 			 struct pinctrl_setting const *setting)
595 {
596 	struct pinctrl_dev *pctldev = setting->pctldev;
597 	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
598 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
599 
600 	seq_printf(s, "group: %s (%u) function: %s (%u)\n",
601 		   pctlops->get_group_name(pctldev, setting->data.mux.group),
602 		   setting->data.mux.group,
603 		   pmxops->get_function_name(pctldev, setting->data.mux.func),
604 		   setting->data.mux.func);
605 }
606 
607 static int pinmux_functions_open(struct inode *inode, struct file *file)
608 {
609 	return single_open(file, pinmux_functions_show, inode->i_private);
610 }
611 
612 static int pinmux_pins_open(struct inode *inode, struct file *file)
613 {
614 	return single_open(file, pinmux_pins_show, inode->i_private);
615 }
616 
617 static const struct file_operations pinmux_functions_ops = {
618 	.open		= pinmux_functions_open,
619 	.read		= seq_read,
620 	.llseek		= seq_lseek,
621 	.release	= single_release,
622 };
623 
624 static const struct file_operations pinmux_pins_ops = {
625 	.open		= pinmux_pins_open,
626 	.read		= seq_read,
627 	.llseek		= seq_lseek,
628 	.release	= single_release,
629 };
630 
631 void pinmux_init_device_debugfs(struct dentry *devroot,
632 			 struct pinctrl_dev *pctldev)
633 {
634 	debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
635 			    devroot, pctldev, &pinmux_functions_ops);
636 	debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
637 			    devroot, pctldev, &pinmux_pins_ops);
638 }
639 
640 #endif /* CONFIG_DEBUG_FS */
641