xref: /openbmc/linux/drivers/pinctrl/core.c (revision 92a76f6d)
1 /*
2  * Core driver for 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) "pinctrl core: " fmt
15 
16 #include <linux/kernel.h>
17 #include <linux/kref.h>
18 #include <linux/export.h>
19 #include <linux/init.h>
20 #include <linux/device.h>
21 #include <linux/slab.h>
22 #include <linux/err.h>
23 #include <linux/list.h>
24 #include <linux/sysfs.h>
25 #include <linux/debugfs.h>
26 #include <linux/seq_file.h>
27 #include <linux/pinctrl/consumer.h>
28 #include <linux/pinctrl/pinctrl.h>
29 #include <linux/pinctrl/machine.h>
30 
31 #ifdef CONFIG_GPIOLIB
32 #include <asm-generic/gpio.h>
33 #endif
34 
35 #include "core.h"
36 #include "devicetree.h"
37 #include "pinmux.h"
38 #include "pinconf.h"
39 
40 
41 static bool pinctrl_dummy_state;
42 
43 /* Mutex taken to protect pinctrl_list */
44 static DEFINE_MUTEX(pinctrl_list_mutex);
45 
46 /* Mutex taken to protect pinctrl_maps */
47 DEFINE_MUTEX(pinctrl_maps_mutex);
48 
49 /* Mutex taken to protect pinctrldev_list */
50 static DEFINE_MUTEX(pinctrldev_list_mutex);
51 
52 /* Global list of pin control devices (struct pinctrl_dev) */
53 static LIST_HEAD(pinctrldev_list);
54 
55 /* List of pin controller handles (struct pinctrl) */
56 static LIST_HEAD(pinctrl_list);
57 
58 /* List of pinctrl maps (struct pinctrl_maps) */
59 LIST_HEAD(pinctrl_maps);
60 
61 
62 /**
63  * pinctrl_provide_dummies() - indicate if pinctrl provides dummy state support
64  *
65  * Usually this function is called by platforms without pinctrl driver support
66  * but run with some shared drivers using pinctrl APIs.
67  * After calling this function, the pinctrl core will return successfully
68  * with creating a dummy state for the driver to keep going smoothly.
69  */
70 void pinctrl_provide_dummies(void)
71 {
72 	pinctrl_dummy_state = true;
73 }
74 
75 const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev)
76 {
77 	/* We're not allowed to register devices without name */
78 	return pctldev->desc->name;
79 }
80 EXPORT_SYMBOL_GPL(pinctrl_dev_get_name);
81 
82 const char *pinctrl_dev_get_devname(struct pinctrl_dev *pctldev)
83 {
84 	return dev_name(pctldev->dev);
85 }
86 EXPORT_SYMBOL_GPL(pinctrl_dev_get_devname);
87 
88 void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev)
89 {
90 	return pctldev->driver_data;
91 }
92 EXPORT_SYMBOL_GPL(pinctrl_dev_get_drvdata);
93 
94 /**
95  * get_pinctrl_dev_from_devname() - look up pin controller device
96  * @devname: the name of a device instance, as returned by dev_name()
97  *
98  * Looks up a pin control device matching a certain device name or pure device
99  * pointer, the pure device pointer will take precedence.
100  */
101 struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *devname)
102 {
103 	struct pinctrl_dev *pctldev = NULL;
104 
105 	if (!devname)
106 		return NULL;
107 
108 	mutex_lock(&pinctrldev_list_mutex);
109 
110 	list_for_each_entry(pctldev, &pinctrldev_list, node) {
111 		if (!strcmp(dev_name(pctldev->dev), devname)) {
112 			/* Matched on device name */
113 			mutex_unlock(&pinctrldev_list_mutex);
114 			return pctldev;
115 		}
116 	}
117 
118 	mutex_unlock(&pinctrldev_list_mutex);
119 
120 	return NULL;
121 }
122 
123 struct pinctrl_dev *get_pinctrl_dev_from_of_node(struct device_node *np)
124 {
125 	struct pinctrl_dev *pctldev;
126 
127 	mutex_lock(&pinctrldev_list_mutex);
128 
129 	list_for_each_entry(pctldev, &pinctrldev_list, node)
130 		if (pctldev->dev->of_node == np) {
131 			mutex_unlock(&pinctrldev_list_mutex);
132 			return pctldev;
133 		}
134 
135 	mutex_unlock(&pinctrldev_list_mutex);
136 
137 	return NULL;
138 }
139 
140 /**
141  * pin_get_from_name() - look up a pin number from a name
142  * @pctldev: the pin control device to lookup the pin on
143  * @name: the name of the pin to look up
144  */
145 int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name)
146 {
147 	unsigned i, pin;
148 
149 	/* The pin number can be retrived from the pin controller descriptor */
150 	for (i = 0; i < pctldev->desc->npins; i++) {
151 		struct pin_desc *desc;
152 
153 		pin = pctldev->desc->pins[i].number;
154 		desc = pin_desc_get(pctldev, pin);
155 		/* Pin space may be sparse */
156 		if (desc && !strcmp(name, desc->name))
157 			return pin;
158 	}
159 
160 	return -EINVAL;
161 }
162 
163 /**
164  * pin_get_name_from_id() - look up a pin name from a pin id
165  * @pctldev: the pin control device to lookup the pin on
166  * @name: the name of the pin to look up
167  */
168 const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned pin)
169 {
170 	const struct pin_desc *desc;
171 
172 	desc = pin_desc_get(pctldev, pin);
173 	if (desc == NULL) {
174 		dev_err(pctldev->dev, "failed to get pin(%d) name\n",
175 			pin);
176 		return NULL;
177 	}
178 
179 	return desc->name;
180 }
181 
182 /**
183  * pin_is_valid() - check if pin exists on controller
184  * @pctldev: the pin control device to check the pin on
185  * @pin: pin to check, use the local pin controller index number
186  *
187  * This tells us whether a certain pin exist on a certain pin controller or
188  * not. Pin lists may be sparse, so some pins may not exist.
189  */
190 bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
191 {
192 	struct pin_desc *pindesc;
193 
194 	if (pin < 0)
195 		return false;
196 
197 	mutex_lock(&pctldev->mutex);
198 	pindesc = pin_desc_get(pctldev, pin);
199 	mutex_unlock(&pctldev->mutex);
200 
201 	return pindesc != NULL;
202 }
203 EXPORT_SYMBOL_GPL(pin_is_valid);
204 
205 /* Deletes a range of pin descriptors */
206 static void pinctrl_free_pindescs(struct pinctrl_dev *pctldev,
207 				  const struct pinctrl_pin_desc *pins,
208 				  unsigned num_pins)
209 {
210 	int i;
211 
212 	for (i = 0; i < num_pins; i++) {
213 		struct pin_desc *pindesc;
214 
215 		pindesc = radix_tree_lookup(&pctldev->pin_desc_tree,
216 					    pins[i].number);
217 		if (pindesc != NULL) {
218 			radix_tree_delete(&pctldev->pin_desc_tree,
219 					  pins[i].number);
220 			if (pindesc->dynamic_name)
221 				kfree(pindesc->name);
222 		}
223 		kfree(pindesc);
224 	}
225 }
226 
227 static int pinctrl_register_one_pin(struct pinctrl_dev *pctldev,
228 				    unsigned number, const char *name)
229 {
230 	struct pin_desc *pindesc;
231 
232 	pindesc = pin_desc_get(pctldev, number);
233 	if (pindesc != NULL) {
234 		dev_err(pctldev->dev, "pin %d already registered\n", number);
235 		return -EINVAL;
236 	}
237 
238 	pindesc = kzalloc(sizeof(*pindesc), GFP_KERNEL);
239 	if (pindesc == NULL) {
240 		dev_err(pctldev->dev, "failed to alloc struct pin_desc\n");
241 		return -ENOMEM;
242 	}
243 
244 	/* Set owner */
245 	pindesc->pctldev = pctldev;
246 
247 	/* Copy basic pin info */
248 	if (name) {
249 		pindesc->name = name;
250 	} else {
251 		pindesc->name = kasprintf(GFP_KERNEL, "PIN%u", number);
252 		if (pindesc->name == NULL) {
253 			kfree(pindesc);
254 			return -ENOMEM;
255 		}
256 		pindesc->dynamic_name = true;
257 	}
258 
259 	radix_tree_insert(&pctldev->pin_desc_tree, number, pindesc);
260 	pr_debug("registered pin %d (%s) on %s\n",
261 		 number, pindesc->name, pctldev->desc->name);
262 	return 0;
263 }
264 
265 static int pinctrl_register_pins(struct pinctrl_dev *pctldev,
266 				 struct pinctrl_pin_desc const *pins,
267 				 unsigned num_descs)
268 {
269 	unsigned i;
270 	int ret = 0;
271 
272 	for (i = 0; i < num_descs; i++) {
273 		ret = pinctrl_register_one_pin(pctldev,
274 					       pins[i].number, pins[i].name);
275 		if (ret)
276 			return ret;
277 	}
278 
279 	return 0;
280 }
281 
282 /**
283  * gpio_to_pin() - GPIO range GPIO number to pin number translation
284  * @range: GPIO range used for the translation
285  * @gpio: gpio pin to translate to a pin number
286  *
287  * Finds the pin number for a given GPIO using the specified GPIO range
288  * as a base for translation. The distinction between linear GPIO ranges
289  * and pin list based GPIO ranges is managed correctly by this function.
290  *
291  * This function assumes the gpio is part of the specified GPIO range, use
292  * only after making sure this is the case (e.g. by calling it on the
293  * result of successful pinctrl_get_device_gpio_range calls)!
294  */
295 static inline int gpio_to_pin(struct pinctrl_gpio_range *range,
296 				unsigned int gpio)
297 {
298 	unsigned int offset = gpio - range->base;
299 	if (range->pins)
300 		return range->pins[offset];
301 	else
302 		return range->pin_base + offset;
303 }
304 
305 /**
306  * pinctrl_match_gpio_range() - check if a certain GPIO pin is in range
307  * @pctldev: pin controller device to check
308  * @gpio: gpio pin to check taken from the global GPIO pin space
309  *
310  * Tries to match a GPIO pin number to the ranges handled by a certain pin
311  * controller, return the range or NULL
312  */
313 static struct pinctrl_gpio_range *
314 pinctrl_match_gpio_range(struct pinctrl_dev *pctldev, unsigned gpio)
315 {
316 	struct pinctrl_gpio_range *range = NULL;
317 
318 	mutex_lock(&pctldev->mutex);
319 	/* Loop over the ranges */
320 	list_for_each_entry(range, &pctldev->gpio_ranges, node) {
321 		/* Check if we're in the valid range */
322 		if (gpio >= range->base &&
323 		    gpio < range->base + range->npins) {
324 			mutex_unlock(&pctldev->mutex);
325 			return range;
326 		}
327 	}
328 	mutex_unlock(&pctldev->mutex);
329 	return NULL;
330 }
331 
332 /**
333  * pinctrl_ready_for_gpio_range() - check if other GPIO pins of
334  * the same GPIO chip are in range
335  * @gpio: gpio pin to check taken from the global GPIO pin space
336  *
337  * This function is complement of pinctrl_match_gpio_range(). If the return
338  * value of pinctrl_match_gpio_range() is NULL, this function could be used
339  * to check whether pinctrl device is ready or not. Maybe some GPIO pins
340  * of the same GPIO chip don't have back-end pinctrl interface.
341  * If the return value is true, it means that pinctrl device is ready & the
342  * certain GPIO pin doesn't have back-end pinctrl device. If the return value
343  * is false, it means that pinctrl device may not be ready.
344  */
345 #ifdef CONFIG_GPIOLIB
346 static bool pinctrl_ready_for_gpio_range(unsigned gpio)
347 {
348 	struct pinctrl_dev *pctldev;
349 	struct pinctrl_gpio_range *range = NULL;
350 	struct gpio_chip *chip = gpio_to_chip(gpio);
351 
352 	if (WARN(!chip, "no gpio_chip for gpio%i?", gpio))
353 		return false;
354 
355 	mutex_lock(&pinctrldev_list_mutex);
356 
357 	/* Loop over the pin controllers */
358 	list_for_each_entry(pctldev, &pinctrldev_list, node) {
359 		/* Loop over the ranges */
360 		mutex_lock(&pctldev->mutex);
361 		list_for_each_entry(range, &pctldev->gpio_ranges, node) {
362 			/* Check if any gpio range overlapped with gpio chip */
363 			if (range->base + range->npins - 1 < chip->base ||
364 			    range->base > chip->base + chip->ngpio - 1)
365 				continue;
366 			mutex_unlock(&pctldev->mutex);
367 			mutex_unlock(&pinctrldev_list_mutex);
368 			return true;
369 		}
370 		mutex_unlock(&pctldev->mutex);
371 	}
372 
373 	mutex_unlock(&pinctrldev_list_mutex);
374 
375 	return false;
376 }
377 #else
378 static bool pinctrl_ready_for_gpio_range(unsigned gpio) { return true; }
379 #endif
380 
381 /**
382  * pinctrl_get_device_gpio_range() - find device for GPIO range
383  * @gpio: the pin to locate the pin controller for
384  * @outdev: the pin control device if found
385  * @outrange: the GPIO range if found
386  *
387  * Find the pin controller handling a certain GPIO pin from the pinspace of
388  * the GPIO subsystem, return the device and the matching GPIO range. Returns
389  * -EPROBE_DEFER if the GPIO range could not be found in any device since it
390  * may still have not been registered.
391  */
392 static int pinctrl_get_device_gpio_range(unsigned gpio,
393 					 struct pinctrl_dev **outdev,
394 					 struct pinctrl_gpio_range **outrange)
395 {
396 	struct pinctrl_dev *pctldev = NULL;
397 
398 	mutex_lock(&pinctrldev_list_mutex);
399 
400 	/* Loop over the pin controllers */
401 	list_for_each_entry(pctldev, &pinctrldev_list, node) {
402 		struct pinctrl_gpio_range *range;
403 
404 		range = pinctrl_match_gpio_range(pctldev, gpio);
405 		if (range != NULL) {
406 			*outdev = pctldev;
407 			*outrange = range;
408 			mutex_unlock(&pinctrldev_list_mutex);
409 			return 0;
410 		}
411 	}
412 
413 	mutex_unlock(&pinctrldev_list_mutex);
414 
415 	return -EPROBE_DEFER;
416 }
417 
418 /**
419  * pinctrl_add_gpio_range() - register a GPIO range for a controller
420  * @pctldev: pin controller device to add the range to
421  * @range: the GPIO range to add
422  *
423  * This adds a range of GPIOs to be handled by a certain pin controller. Call
424  * this to register handled ranges after registering your pin controller.
425  */
426 void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
427 			    struct pinctrl_gpio_range *range)
428 {
429 	mutex_lock(&pctldev->mutex);
430 	list_add_tail(&range->node, &pctldev->gpio_ranges);
431 	mutex_unlock(&pctldev->mutex);
432 }
433 EXPORT_SYMBOL_GPL(pinctrl_add_gpio_range);
434 
435 void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev,
436 			     struct pinctrl_gpio_range *ranges,
437 			     unsigned nranges)
438 {
439 	int i;
440 
441 	for (i = 0; i < nranges; i++)
442 		pinctrl_add_gpio_range(pctldev, &ranges[i]);
443 }
444 EXPORT_SYMBOL_GPL(pinctrl_add_gpio_ranges);
445 
446 struct pinctrl_dev *pinctrl_find_and_add_gpio_range(const char *devname,
447 		struct pinctrl_gpio_range *range)
448 {
449 	struct pinctrl_dev *pctldev;
450 
451 	pctldev = get_pinctrl_dev_from_devname(devname);
452 
453 	/*
454 	 * If we can't find this device, let's assume that is because
455 	 * it has not probed yet, so the driver trying to register this
456 	 * range need to defer probing.
457 	 */
458 	if (!pctldev) {
459 		return ERR_PTR(-EPROBE_DEFER);
460 	}
461 	pinctrl_add_gpio_range(pctldev, range);
462 
463 	return pctldev;
464 }
465 EXPORT_SYMBOL_GPL(pinctrl_find_and_add_gpio_range);
466 
467 int pinctrl_get_group_pins(struct pinctrl_dev *pctldev, const char *pin_group,
468 				const unsigned **pins, unsigned *num_pins)
469 {
470 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
471 	int gs;
472 
473 	if (!pctlops->get_group_pins)
474 		return -EINVAL;
475 
476 	gs = pinctrl_get_group_selector(pctldev, pin_group);
477 	if (gs < 0)
478 		return gs;
479 
480 	return pctlops->get_group_pins(pctldev, gs, pins, num_pins);
481 }
482 EXPORT_SYMBOL_GPL(pinctrl_get_group_pins);
483 
484 struct pinctrl_gpio_range *
485 pinctrl_find_gpio_range_from_pin_nolock(struct pinctrl_dev *pctldev,
486 					unsigned int pin)
487 {
488 	struct pinctrl_gpio_range *range;
489 
490 	/* Loop over the ranges */
491 	list_for_each_entry(range, &pctldev->gpio_ranges, node) {
492 		/* Check if we're in the valid range */
493 		if (range->pins) {
494 			int a;
495 			for (a = 0; a < range->npins; a++) {
496 				if (range->pins[a] == pin)
497 					return range;
498 			}
499 		} else if (pin >= range->pin_base &&
500 			   pin < range->pin_base + range->npins)
501 			return range;
502 	}
503 
504 	return NULL;
505 }
506 EXPORT_SYMBOL_GPL(pinctrl_find_gpio_range_from_pin_nolock);
507 
508 /**
509  * pinctrl_find_gpio_range_from_pin() - locate the GPIO range for a pin
510  * @pctldev: the pin controller device to look in
511  * @pin: a controller-local number to find the range for
512  */
513 struct pinctrl_gpio_range *
514 pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev,
515 				 unsigned int pin)
516 {
517 	struct pinctrl_gpio_range *range;
518 
519 	mutex_lock(&pctldev->mutex);
520 	range = pinctrl_find_gpio_range_from_pin_nolock(pctldev, pin);
521 	mutex_unlock(&pctldev->mutex);
522 
523 	return range;
524 }
525 EXPORT_SYMBOL_GPL(pinctrl_find_gpio_range_from_pin);
526 
527 /**
528  * pinctrl_remove_gpio_range() - remove a range of GPIOs fro a pin controller
529  * @pctldev: pin controller device to remove the range from
530  * @range: the GPIO range to remove
531  */
532 void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
533 			       struct pinctrl_gpio_range *range)
534 {
535 	mutex_lock(&pctldev->mutex);
536 	list_del(&range->node);
537 	mutex_unlock(&pctldev->mutex);
538 }
539 EXPORT_SYMBOL_GPL(pinctrl_remove_gpio_range);
540 
541 /**
542  * pinctrl_get_group_selector() - returns the group selector for a group
543  * @pctldev: the pin controller handling the group
544  * @pin_group: the pin group to look up
545  */
546 int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
547 			       const char *pin_group)
548 {
549 	const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
550 	unsigned ngroups = pctlops->get_groups_count(pctldev);
551 	unsigned group_selector = 0;
552 
553 	while (group_selector < ngroups) {
554 		const char *gname = pctlops->get_group_name(pctldev,
555 							    group_selector);
556 		if (!strcmp(gname, pin_group)) {
557 			dev_dbg(pctldev->dev,
558 				"found group selector %u for %s\n",
559 				group_selector,
560 				pin_group);
561 			return group_selector;
562 		}
563 
564 		group_selector++;
565 	}
566 
567 	dev_err(pctldev->dev, "does not have pin group %s\n",
568 		pin_group);
569 
570 	return -EINVAL;
571 }
572 
573 /**
574  * pinctrl_request_gpio() - request a single pin to be used as GPIO
575  * @gpio: the GPIO pin number from the GPIO subsystem number space
576  *
577  * This function should *ONLY* be used from gpiolib-based GPIO drivers,
578  * as part of their gpio_request() semantics, platforms and individual drivers
579  * shall *NOT* request GPIO pins to be muxed in.
580  */
581 int pinctrl_request_gpio(unsigned gpio)
582 {
583 	struct pinctrl_dev *pctldev;
584 	struct pinctrl_gpio_range *range;
585 	int ret;
586 	int pin;
587 
588 	ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
589 	if (ret) {
590 		if (pinctrl_ready_for_gpio_range(gpio))
591 			ret = 0;
592 		return ret;
593 	}
594 
595 	mutex_lock(&pctldev->mutex);
596 
597 	/* Convert to the pin controllers number space */
598 	pin = gpio_to_pin(range, gpio);
599 
600 	ret = pinmux_request_gpio(pctldev, range, pin, gpio);
601 
602 	mutex_unlock(&pctldev->mutex);
603 
604 	return ret;
605 }
606 EXPORT_SYMBOL_GPL(pinctrl_request_gpio);
607 
608 /**
609  * pinctrl_free_gpio() - free control on a single pin, currently used as GPIO
610  * @gpio: the GPIO pin number from the GPIO subsystem number space
611  *
612  * This function should *ONLY* be used from gpiolib-based GPIO drivers,
613  * as part of their gpio_free() semantics, platforms and individual drivers
614  * shall *NOT* request GPIO pins to be muxed out.
615  */
616 void pinctrl_free_gpio(unsigned gpio)
617 {
618 	struct pinctrl_dev *pctldev;
619 	struct pinctrl_gpio_range *range;
620 	int ret;
621 	int pin;
622 
623 	ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
624 	if (ret) {
625 		return;
626 	}
627 	mutex_lock(&pctldev->mutex);
628 
629 	/* Convert to the pin controllers number space */
630 	pin = gpio_to_pin(range, gpio);
631 
632 	pinmux_free_gpio(pctldev, pin, range);
633 
634 	mutex_unlock(&pctldev->mutex);
635 }
636 EXPORT_SYMBOL_GPL(pinctrl_free_gpio);
637 
638 static int pinctrl_gpio_direction(unsigned gpio, bool input)
639 {
640 	struct pinctrl_dev *pctldev;
641 	struct pinctrl_gpio_range *range;
642 	int ret;
643 	int pin;
644 
645 	ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
646 	if (ret) {
647 		return ret;
648 	}
649 
650 	mutex_lock(&pctldev->mutex);
651 
652 	/* Convert to the pin controllers number space */
653 	pin = gpio_to_pin(range, gpio);
654 	ret = pinmux_gpio_direction(pctldev, range, pin, input);
655 
656 	mutex_unlock(&pctldev->mutex);
657 
658 	return ret;
659 }
660 
661 /**
662  * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode
663  * @gpio: the GPIO pin number from the GPIO subsystem number space
664  *
665  * This function should *ONLY* be used from gpiolib-based GPIO drivers,
666  * as part of their gpio_direction_input() semantics, platforms and individual
667  * drivers shall *NOT* touch pin control GPIO calls.
668  */
669 int pinctrl_gpio_direction_input(unsigned gpio)
670 {
671 	return pinctrl_gpio_direction(gpio, true);
672 }
673 EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_input);
674 
675 /**
676  * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode
677  * @gpio: the GPIO pin number from the GPIO subsystem number space
678  *
679  * This function should *ONLY* be used from gpiolib-based GPIO drivers,
680  * as part of their gpio_direction_output() semantics, platforms and individual
681  * drivers shall *NOT* touch pin control GPIO calls.
682  */
683 int pinctrl_gpio_direction_output(unsigned gpio)
684 {
685 	return pinctrl_gpio_direction(gpio, false);
686 }
687 EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_output);
688 
689 static struct pinctrl_state *find_state(struct pinctrl *p,
690 					const char *name)
691 {
692 	struct pinctrl_state *state;
693 
694 	list_for_each_entry(state, &p->states, node)
695 		if (!strcmp(state->name, name))
696 			return state;
697 
698 	return NULL;
699 }
700 
701 static struct pinctrl_state *create_state(struct pinctrl *p,
702 					  const char *name)
703 {
704 	struct pinctrl_state *state;
705 
706 	state = kzalloc(sizeof(*state), GFP_KERNEL);
707 	if (state == NULL) {
708 		dev_err(p->dev,
709 			"failed to alloc struct pinctrl_state\n");
710 		return ERR_PTR(-ENOMEM);
711 	}
712 
713 	state->name = name;
714 	INIT_LIST_HEAD(&state->settings);
715 
716 	list_add_tail(&state->node, &p->states);
717 
718 	return state;
719 }
720 
721 static int add_setting(struct pinctrl *p, struct pinctrl_map const *map)
722 {
723 	struct pinctrl_state *state;
724 	struct pinctrl_setting *setting;
725 	int ret;
726 
727 	state = find_state(p, map->name);
728 	if (!state)
729 		state = create_state(p, map->name);
730 	if (IS_ERR(state))
731 		return PTR_ERR(state);
732 
733 	if (map->type == PIN_MAP_TYPE_DUMMY_STATE)
734 		return 0;
735 
736 	setting = kzalloc(sizeof(*setting), GFP_KERNEL);
737 	if (setting == NULL) {
738 		dev_err(p->dev,
739 			"failed to alloc struct pinctrl_setting\n");
740 		return -ENOMEM;
741 	}
742 
743 	setting->type = map->type;
744 
745 	setting->pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name);
746 	if (setting->pctldev == NULL) {
747 		kfree(setting);
748 		/* Do not defer probing of hogs (circular loop) */
749 		if (!strcmp(map->ctrl_dev_name, map->dev_name))
750 			return -ENODEV;
751 		/*
752 		 * OK let us guess that the driver is not there yet, and
753 		 * let's defer obtaining this pinctrl handle to later...
754 		 */
755 		dev_info(p->dev, "unknown pinctrl device %s in map entry, deferring probe",
756 			map->ctrl_dev_name);
757 		return -EPROBE_DEFER;
758 	}
759 
760 	setting->dev_name = map->dev_name;
761 
762 	switch (map->type) {
763 	case PIN_MAP_TYPE_MUX_GROUP:
764 		ret = pinmux_map_to_setting(map, setting);
765 		break;
766 	case PIN_MAP_TYPE_CONFIGS_PIN:
767 	case PIN_MAP_TYPE_CONFIGS_GROUP:
768 		ret = pinconf_map_to_setting(map, setting);
769 		break;
770 	default:
771 		ret = -EINVAL;
772 		break;
773 	}
774 	if (ret < 0) {
775 		kfree(setting);
776 		return ret;
777 	}
778 
779 	list_add_tail(&setting->node, &state->settings);
780 
781 	return 0;
782 }
783 
784 static struct pinctrl *find_pinctrl(struct device *dev)
785 {
786 	struct pinctrl *p;
787 
788 	mutex_lock(&pinctrl_list_mutex);
789 	list_for_each_entry(p, &pinctrl_list, node)
790 		if (p->dev == dev) {
791 			mutex_unlock(&pinctrl_list_mutex);
792 			return p;
793 		}
794 
795 	mutex_unlock(&pinctrl_list_mutex);
796 	return NULL;
797 }
798 
799 static void pinctrl_free(struct pinctrl *p, bool inlist);
800 
801 static struct pinctrl *create_pinctrl(struct device *dev)
802 {
803 	struct pinctrl *p;
804 	const char *devname;
805 	struct pinctrl_maps *maps_node;
806 	int i;
807 	struct pinctrl_map const *map;
808 	int ret;
809 
810 	/*
811 	 * create the state cookie holder struct pinctrl for each
812 	 * mapping, this is what consumers will get when requesting
813 	 * a pin control handle with pinctrl_get()
814 	 */
815 	p = kzalloc(sizeof(*p), GFP_KERNEL);
816 	if (p == NULL) {
817 		dev_err(dev, "failed to alloc struct pinctrl\n");
818 		return ERR_PTR(-ENOMEM);
819 	}
820 	p->dev = dev;
821 	INIT_LIST_HEAD(&p->states);
822 	INIT_LIST_HEAD(&p->dt_maps);
823 
824 	ret = pinctrl_dt_to_map(p);
825 	if (ret < 0) {
826 		kfree(p);
827 		return ERR_PTR(ret);
828 	}
829 
830 	devname = dev_name(dev);
831 
832 	mutex_lock(&pinctrl_maps_mutex);
833 	/* Iterate over the pin control maps to locate the right ones */
834 	for_each_maps(maps_node, i, map) {
835 		/* Map must be for this device */
836 		if (strcmp(map->dev_name, devname))
837 			continue;
838 
839 		ret = add_setting(p, map);
840 		/*
841 		 * At this point the adding of a setting may:
842 		 *
843 		 * - Defer, if the pinctrl device is not yet available
844 		 * - Fail, if the pinctrl device is not yet available,
845 		 *   AND the setting is a hog. We cannot defer that, since
846 		 *   the hog will kick in immediately after the device
847 		 *   is registered.
848 		 *
849 		 * If the error returned was not -EPROBE_DEFER then we
850 		 * accumulate the errors to see if we end up with
851 		 * an -EPROBE_DEFER later, as that is the worst case.
852 		 */
853 		if (ret == -EPROBE_DEFER) {
854 			pinctrl_free(p, false);
855 			mutex_unlock(&pinctrl_maps_mutex);
856 			return ERR_PTR(ret);
857 		}
858 	}
859 	mutex_unlock(&pinctrl_maps_mutex);
860 
861 	if (ret < 0) {
862 		/* If some other error than deferral occured, return here */
863 		pinctrl_free(p, false);
864 		return ERR_PTR(ret);
865 	}
866 
867 	kref_init(&p->users);
868 
869 	/* Add the pinctrl handle to the global list */
870 	mutex_lock(&pinctrl_list_mutex);
871 	list_add_tail(&p->node, &pinctrl_list);
872 	mutex_unlock(&pinctrl_list_mutex);
873 
874 	return p;
875 }
876 
877 /**
878  * pinctrl_get() - retrieves the pinctrl handle for a device
879  * @dev: the device to obtain the handle for
880  */
881 struct pinctrl *pinctrl_get(struct device *dev)
882 {
883 	struct pinctrl *p;
884 
885 	if (WARN_ON(!dev))
886 		return ERR_PTR(-EINVAL);
887 
888 	/*
889 	 * See if somebody else (such as the device core) has already
890 	 * obtained a handle to the pinctrl for this device. In that case,
891 	 * return another pointer to it.
892 	 */
893 	p = find_pinctrl(dev);
894 	if (p != NULL) {
895 		dev_dbg(dev, "obtain a copy of previously claimed pinctrl\n");
896 		kref_get(&p->users);
897 		return p;
898 	}
899 
900 	return create_pinctrl(dev);
901 }
902 EXPORT_SYMBOL_GPL(pinctrl_get);
903 
904 static void pinctrl_free_setting(bool disable_setting,
905 				 struct pinctrl_setting *setting)
906 {
907 	switch (setting->type) {
908 	case PIN_MAP_TYPE_MUX_GROUP:
909 		if (disable_setting)
910 			pinmux_disable_setting(setting);
911 		pinmux_free_setting(setting);
912 		break;
913 	case PIN_MAP_TYPE_CONFIGS_PIN:
914 	case PIN_MAP_TYPE_CONFIGS_GROUP:
915 		pinconf_free_setting(setting);
916 		break;
917 	default:
918 		break;
919 	}
920 }
921 
922 static void pinctrl_free(struct pinctrl *p, bool inlist)
923 {
924 	struct pinctrl_state *state, *n1;
925 	struct pinctrl_setting *setting, *n2;
926 
927 	mutex_lock(&pinctrl_list_mutex);
928 	list_for_each_entry_safe(state, n1, &p->states, node) {
929 		list_for_each_entry_safe(setting, n2, &state->settings, node) {
930 			pinctrl_free_setting(state == p->state, setting);
931 			list_del(&setting->node);
932 			kfree(setting);
933 		}
934 		list_del(&state->node);
935 		kfree(state);
936 	}
937 
938 	pinctrl_dt_free_maps(p);
939 
940 	if (inlist)
941 		list_del(&p->node);
942 	kfree(p);
943 	mutex_unlock(&pinctrl_list_mutex);
944 }
945 
946 /**
947  * pinctrl_release() - release the pinctrl handle
948  * @kref: the kref in the pinctrl being released
949  */
950 static void pinctrl_release(struct kref *kref)
951 {
952 	struct pinctrl *p = container_of(kref, struct pinctrl, users);
953 
954 	pinctrl_free(p, true);
955 }
956 
957 /**
958  * pinctrl_put() - decrease use count on a previously claimed pinctrl handle
959  * @p: the pinctrl handle to release
960  */
961 void pinctrl_put(struct pinctrl *p)
962 {
963 	kref_put(&p->users, pinctrl_release);
964 }
965 EXPORT_SYMBOL_GPL(pinctrl_put);
966 
967 /**
968  * pinctrl_lookup_state() - retrieves a state handle from a pinctrl handle
969  * @p: the pinctrl handle to retrieve the state from
970  * @name: the state name to retrieve
971  */
972 struct pinctrl_state *pinctrl_lookup_state(struct pinctrl *p,
973 						 const char *name)
974 {
975 	struct pinctrl_state *state;
976 
977 	state = find_state(p, name);
978 	if (!state) {
979 		if (pinctrl_dummy_state) {
980 			/* create dummy state */
981 			dev_dbg(p->dev, "using pinctrl dummy state (%s)\n",
982 				name);
983 			state = create_state(p, name);
984 		} else
985 			state = ERR_PTR(-ENODEV);
986 	}
987 
988 	return state;
989 }
990 EXPORT_SYMBOL_GPL(pinctrl_lookup_state);
991 
992 /**
993  * pinctrl_select_state() - select/activate/program a pinctrl state to HW
994  * @p: the pinctrl handle for the device that requests configuration
995  * @state: the state handle to select/activate/program
996  */
997 int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *state)
998 {
999 	struct pinctrl_setting *setting, *setting2;
1000 	struct pinctrl_state *old_state = p->state;
1001 	int ret;
1002 
1003 	if (p->state == state)
1004 		return 0;
1005 
1006 	if (p->state) {
1007 		/*
1008 		 * For each pinmux setting in the old state, forget SW's record
1009 		 * of mux owner for that pingroup. Any pingroups which are
1010 		 * still owned by the new state will be re-acquired by the call
1011 		 * to pinmux_enable_setting() in the loop below.
1012 		 */
1013 		list_for_each_entry(setting, &p->state->settings, node) {
1014 			if (setting->type != PIN_MAP_TYPE_MUX_GROUP)
1015 				continue;
1016 			pinmux_disable_setting(setting);
1017 		}
1018 	}
1019 
1020 	p->state = NULL;
1021 
1022 	/* Apply all the settings for the new state */
1023 	list_for_each_entry(setting, &state->settings, node) {
1024 		switch (setting->type) {
1025 		case PIN_MAP_TYPE_MUX_GROUP:
1026 			ret = pinmux_enable_setting(setting);
1027 			break;
1028 		case PIN_MAP_TYPE_CONFIGS_PIN:
1029 		case PIN_MAP_TYPE_CONFIGS_GROUP:
1030 			ret = pinconf_apply_setting(setting);
1031 			break;
1032 		default:
1033 			ret = -EINVAL;
1034 			break;
1035 		}
1036 
1037 		if (ret < 0) {
1038 			goto unapply_new_state;
1039 		}
1040 	}
1041 
1042 	p->state = state;
1043 
1044 	return 0;
1045 
1046 unapply_new_state:
1047 	dev_err(p->dev, "Error applying setting, reverse things back\n");
1048 
1049 	list_for_each_entry(setting2, &state->settings, node) {
1050 		if (&setting2->node == &setting->node)
1051 			break;
1052 		/*
1053 		 * All we can do here is pinmux_disable_setting.
1054 		 * That means that some pins are muxed differently now
1055 		 * than they were before applying the setting (We can't
1056 		 * "unmux a pin"!), but it's not a big deal since the pins
1057 		 * are free to be muxed by another apply_setting.
1058 		 */
1059 		if (setting2->type == PIN_MAP_TYPE_MUX_GROUP)
1060 			pinmux_disable_setting(setting2);
1061 	}
1062 
1063 	/* There's no infinite recursive loop here because p->state is NULL */
1064 	if (old_state)
1065 		pinctrl_select_state(p, old_state);
1066 
1067 	return ret;
1068 }
1069 EXPORT_SYMBOL_GPL(pinctrl_select_state);
1070 
1071 static void devm_pinctrl_release(struct device *dev, void *res)
1072 {
1073 	pinctrl_put(*(struct pinctrl **)res);
1074 }
1075 
1076 /**
1077  * struct devm_pinctrl_get() - Resource managed pinctrl_get()
1078  * @dev: the device to obtain the handle for
1079  *
1080  * If there is a need to explicitly destroy the returned struct pinctrl,
1081  * devm_pinctrl_put() should be used, rather than plain pinctrl_put().
1082  */
1083 struct pinctrl *devm_pinctrl_get(struct device *dev)
1084 {
1085 	struct pinctrl **ptr, *p;
1086 
1087 	ptr = devres_alloc(devm_pinctrl_release, sizeof(*ptr), GFP_KERNEL);
1088 	if (!ptr)
1089 		return ERR_PTR(-ENOMEM);
1090 
1091 	p = pinctrl_get(dev);
1092 	if (!IS_ERR(p)) {
1093 		*ptr = p;
1094 		devres_add(dev, ptr);
1095 	} else {
1096 		devres_free(ptr);
1097 	}
1098 
1099 	return p;
1100 }
1101 EXPORT_SYMBOL_GPL(devm_pinctrl_get);
1102 
1103 static int devm_pinctrl_match(struct device *dev, void *res, void *data)
1104 {
1105 	struct pinctrl **p = res;
1106 
1107 	return *p == data;
1108 }
1109 
1110 /**
1111  * devm_pinctrl_put() - Resource managed pinctrl_put()
1112  * @p: the pinctrl handle to release
1113  *
1114  * Deallocate a struct pinctrl obtained via devm_pinctrl_get(). Normally
1115  * this function will not need to be called and the resource management
1116  * code will ensure that the resource is freed.
1117  */
1118 void devm_pinctrl_put(struct pinctrl *p)
1119 {
1120 	WARN_ON(devres_release(p->dev, devm_pinctrl_release,
1121 			       devm_pinctrl_match, p));
1122 }
1123 EXPORT_SYMBOL_GPL(devm_pinctrl_put);
1124 
1125 int pinctrl_register_map(struct pinctrl_map const *maps, unsigned num_maps,
1126 			 bool dup)
1127 {
1128 	int i, ret;
1129 	struct pinctrl_maps *maps_node;
1130 
1131 	pr_debug("add %u pinctrl maps\n", num_maps);
1132 
1133 	/* First sanity check the new mapping */
1134 	for (i = 0; i < num_maps; i++) {
1135 		if (!maps[i].dev_name) {
1136 			pr_err("failed to register map %s (%d): no device given\n",
1137 			       maps[i].name, i);
1138 			return -EINVAL;
1139 		}
1140 
1141 		if (!maps[i].name) {
1142 			pr_err("failed to register map %d: no map name given\n",
1143 			       i);
1144 			return -EINVAL;
1145 		}
1146 
1147 		if (maps[i].type != PIN_MAP_TYPE_DUMMY_STATE &&
1148 				!maps[i].ctrl_dev_name) {
1149 			pr_err("failed to register map %s (%d): no pin control device given\n",
1150 			       maps[i].name, i);
1151 			return -EINVAL;
1152 		}
1153 
1154 		switch (maps[i].type) {
1155 		case PIN_MAP_TYPE_DUMMY_STATE:
1156 			break;
1157 		case PIN_MAP_TYPE_MUX_GROUP:
1158 			ret = pinmux_validate_map(&maps[i], i);
1159 			if (ret < 0)
1160 				return ret;
1161 			break;
1162 		case PIN_MAP_TYPE_CONFIGS_PIN:
1163 		case PIN_MAP_TYPE_CONFIGS_GROUP:
1164 			ret = pinconf_validate_map(&maps[i], i);
1165 			if (ret < 0)
1166 				return ret;
1167 			break;
1168 		default:
1169 			pr_err("failed to register map %s (%d): invalid type given\n",
1170 			       maps[i].name, i);
1171 			return -EINVAL;
1172 		}
1173 	}
1174 
1175 	maps_node = kzalloc(sizeof(*maps_node), GFP_KERNEL);
1176 	if (!maps_node) {
1177 		pr_err("failed to alloc struct pinctrl_maps\n");
1178 		return -ENOMEM;
1179 	}
1180 
1181 	maps_node->num_maps = num_maps;
1182 	if (dup) {
1183 		maps_node->maps = kmemdup(maps, sizeof(*maps) * num_maps,
1184 					  GFP_KERNEL);
1185 		if (!maps_node->maps) {
1186 			pr_err("failed to duplicate mapping table\n");
1187 			kfree(maps_node);
1188 			return -ENOMEM;
1189 		}
1190 	} else {
1191 		maps_node->maps = maps;
1192 	}
1193 
1194 	mutex_lock(&pinctrl_maps_mutex);
1195 	list_add_tail(&maps_node->node, &pinctrl_maps);
1196 	mutex_unlock(&pinctrl_maps_mutex);
1197 
1198 	return 0;
1199 }
1200 
1201 /**
1202  * pinctrl_register_mappings() - register a set of pin controller mappings
1203  * @maps: the pincontrol mappings table to register. This should probably be
1204  *	marked with __initdata so it can be discarded after boot. This
1205  *	function will perform a shallow copy for the mapping entries.
1206  * @num_maps: the number of maps in the mapping table
1207  */
1208 int pinctrl_register_mappings(struct pinctrl_map const *maps,
1209 			      unsigned num_maps)
1210 {
1211 	return pinctrl_register_map(maps, num_maps, true);
1212 }
1213 
1214 void pinctrl_unregister_map(struct pinctrl_map const *map)
1215 {
1216 	struct pinctrl_maps *maps_node;
1217 
1218 	mutex_lock(&pinctrl_maps_mutex);
1219 	list_for_each_entry(maps_node, &pinctrl_maps, node) {
1220 		if (maps_node->maps == map) {
1221 			list_del(&maps_node->node);
1222 			kfree(maps_node);
1223 			mutex_unlock(&pinctrl_maps_mutex);
1224 			return;
1225 		}
1226 	}
1227 	mutex_unlock(&pinctrl_maps_mutex);
1228 }
1229 
1230 /**
1231  * pinctrl_force_sleep() - turn a given controller device into sleep state
1232  * @pctldev: pin controller device
1233  */
1234 int pinctrl_force_sleep(struct pinctrl_dev *pctldev)
1235 {
1236 	if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_sleep))
1237 		return pinctrl_select_state(pctldev->p, pctldev->hog_sleep);
1238 	return 0;
1239 }
1240 EXPORT_SYMBOL_GPL(pinctrl_force_sleep);
1241 
1242 /**
1243  * pinctrl_force_default() - turn a given controller device into default state
1244  * @pctldev: pin controller device
1245  */
1246 int pinctrl_force_default(struct pinctrl_dev *pctldev)
1247 {
1248 	if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_default))
1249 		return pinctrl_select_state(pctldev->p, pctldev->hog_default);
1250 	return 0;
1251 }
1252 EXPORT_SYMBOL_GPL(pinctrl_force_default);
1253 
1254 /**
1255  * pinctrl_init_done() - tell pinctrl probe is done
1256  *
1257  * We'll use this time to switch the pins from "init" to "default" unless the
1258  * driver selected some other state.
1259  *
1260  * @dev: device to that's done probing
1261  */
1262 int pinctrl_init_done(struct device *dev)
1263 {
1264 	struct dev_pin_info *pins = dev->pins;
1265 	int ret;
1266 
1267 	if (!pins)
1268 		return 0;
1269 
1270 	if (IS_ERR(pins->init_state))
1271 		return 0; /* No such state */
1272 
1273 	if (pins->p->state != pins->init_state)
1274 		return 0; /* Not at init anyway */
1275 
1276 	if (IS_ERR(pins->default_state))
1277 		return 0; /* No default state */
1278 
1279 	ret = pinctrl_select_state(pins->p, pins->default_state);
1280 	if (ret)
1281 		dev_err(dev, "failed to activate default pinctrl state\n");
1282 
1283 	return ret;
1284 }
1285 
1286 #ifdef CONFIG_PM
1287 
1288 /**
1289  * pinctrl_pm_select_state() - select pinctrl state for PM
1290  * @dev: device to select default state for
1291  * @state: state to set
1292  */
1293 static int pinctrl_pm_select_state(struct device *dev,
1294 				   struct pinctrl_state *state)
1295 {
1296 	struct dev_pin_info *pins = dev->pins;
1297 	int ret;
1298 
1299 	if (IS_ERR(state))
1300 		return 0; /* No such state */
1301 	ret = pinctrl_select_state(pins->p, state);
1302 	if (ret)
1303 		dev_err(dev, "failed to activate pinctrl state %s\n",
1304 			state->name);
1305 	return ret;
1306 }
1307 
1308 /**
1309  * pinctrl_pm_select_default_state() - select default pinctrl state for PM
1310  * @dev: device to select default state for
1311  */
1312 int pinctrl_pm_select_default_state(struct device *dev)
1313 {
1314 	if (!dev->pins)
1315 		return 0;
1316 
1317 	return pinctrl_pm_select_state(dev, dev->pins->default_state);
1318 }
1319 EXPORT_SYMBOL_GPL(pinctrl_pm_select_default_state);
1320 
1321 /**
1322  * pinctrl_pm_select_sleep_state() - select sleep pinctrl state for PM
1323  * @dev: device to select sleep state for
1324  */
1325 int pinctrl_pm_select_sleep_state(struct device *dev)
1326 {
1327 	if (!dev->pins)
1328 		return 0;
1329 
1330 	return pinctrl_pm_select_state(dev, dev->pins->sleep_state);
1331 }
1332 EXPORT_SYMBOL_GPL(pinctrl_pm_select_sleep_state);
1333 
1334 /**
1335  * pinctrl_pm_select_idle_state() - select idle pinctrl state for PM
1336  * @dev: device to select idle state for
1337  */
1338 int pinctrl_pm_select_idle_state(struct device *dev)
1339 {
1340 	if (!dev->pins)
1341 		return 0;
1342 
1343 	return pinctrl_pm_select_state(dev, dev->pins->idle_state);
1344 }
1345 EXPORT_SYMBOL_GPL(pinctrl_pm_select_idle_state);
1346 #endif
1347 
1348 #ifdef CONFIG_DEBUG_FS
1349 
1350 static int pinctrl_pins_show(struct seq_file *s, void *what)
1351 {
1352 	struct pinctrl_dev *pctldev = s->private;
1353 	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1354 	unsigned i, pin;
1355 
1356 	seq_printf(s, "registered pins: %d\n", pctldev->desc->npins);
1357 
1358 	mutex_lock(&pctldev->mutex);
1359 
1360 	/* The pin number can be retrived from the pin controller descriptor */
1361 	for (i = 0; i < pctldev->desc->npins; i++) {
1362 		struct pin_desc *desc;
1363 
1364 		pin = pctldev->desc->pins[i].number;
1365 		desc = pin_desc_get(pctldev, pin);
1366 		/* Pin space may be sparse */
1367 		if (desc == NULL)
1368 			continue;
1369 
1370 		seq_printf(s, "pin %d (%s) ", pin,
1371 			   desc->name ? desc->name : "unnamed");
1372 
1373 		/* Driver-specific info per pin */
1374 		if (ops->pin_dbg_show)
1375 			ops->pin_dbg_show(pctldev, s, pin);
1376 
1377 		seq_puts(s, "\n");
1378 	}
1379 
1380 	mutex_unlock(&pctldev->mutex);
1381 
1382 	return 0;
1383 }
1384 
1385 static int pinctrl_groups_show(struct seq_file *s, void *what)
1386 {
1387 	struct pinctrl_dev *pctldev = s->private;
1388 	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1389 	unsigned ngroups, selector = 0;
1390 
1391 	mutex_lock(&pctldev->mutex);
1392 
1393 	ngroups = ops->get_groups_count(pctldev);
1394 
1395 	seq_puts(s, "registered pin groups:\n");
1396 	while (selector < ngroups) {
1397 		const unsigned *pins = NULL;
1398 		unsigned num_pins = 0;
1399 		const char *gname = ops->get_group_name(pctldev, selector);
1400 		const char *pname;
1401 		int ret = 0;
1402 		int i;
1403 
1404 		if (ops->get_group_pins)
1405 			ret = ops->get_group_pins(pctldev, selector,
1406 						  &pins, &num_pins);
1407 		if (ret)
1408 			seq_printf(s, "%s [ERROR GETTING PINS]\n",
1409 				   gname);
1410 		else {
1411 			seq_printf(s, "group: %s\n", gname);
1412 			for (i = 0; i < num_pins; i++) {
1413 				pname = pin_get_name(pctldev, pins[i]);
1414 				if (WARN_ON(!pname)) {
1415 					mutex_unlock(&pctldev->mutex);
1416 					return -EINVAL;
1417 				}
1418 				seq_printf(s, "pin %d (%s)\n", pins[i], pname);
1419 			}
1420 			seq_puts(s, "\n");
1421 		}
1422 		selector++;
1423 	}
1424 
1425 	mutex_unlock(&pctldev->mutex);
1426 
1427 	return 0;
1428 }
1429 
1430 static int pinctrl_gpioranges_show(struct seq_file *s, void *what)
1431 {
1432 	struct pinctrl_dev *pctldev = s->private;
1433 	struct pinctrl_gpio_range *range = NULL;
1434 
1435 	seq_puts(s, "GPIO ranges handled:\n");
1436 
1437 	mutex_lock(&pctldev->mutex);
1438 
1439 	/* Loop over the ranges */
1440 	list_for_each_entry(range, &pctldev->gpio_ranges, node) {
1441 		if (range->pins) {
1442 			int a;
1443 			seq_printf(s, "%u: %s GPIOS [%u - %u] PINS {",
1444 				range->id, range->name,
1445 				range->base, (range->base + range->npins - 1));
1446 			for (a = 0; a < range->npins - 1; a++)
1447 				seq_printf(s, "%u, ", range->pins[a]);
1448 			seq_printf(s, "%u}\n", range->pins[a]);
1449 		}
1450 		else
1451 			seq_printf(s, "%u: %s GPIOS [%u - %u] PINS [%u - %u]\n",
1452 				range->id, range->name,
1453 				range->base, (range->base + range->npins - 1),
1454 				range->pin_base,
1455 				(range->pin_base + range->npins - 1));
1456 	}
1457 
1458 	mutex_unlock(&pctldev->mutex);
1459 
1460 	return 0;
1461 }
1462 
1463 static int pinctrl_devices_show(struct seq_file *s, void *what)
1464 {
1465 	struct pinctrl_dev *pctldev;
1466 
1467 	seq_puts(s, "name [pinmux] [pinconf]\n");
1468 
1469 	mutex_lock(&pinctrldev_list_mutex);
1470 
1471 	list_for_each_entry(pctldev, &pinctrldev_list, node) {
1472 		seq_printf(s, "%s ", pctldev->desc->name);
1473 		if (pctldev->desc->pmxops)
1474 			seq_puts(s, "yes ");
1475 		else
1476 			seq_puts(s, "no ");
1477 		if (pctldev->desc->confops)
1478 			seq_puts(s, "yes");
1479 		else
1480 			seq_puts(s, "no");
1481 		seq_puts(s, "\n");
1482 	}
1483 
1484 	mutex_unlock(&pinctrldev_list_mutex);
1485 
1486 	return 0;
1487 }
1488 
1489 static inline const char *map_type(enum pinctrl_map_type type)
1490 {
1491 	static const char * const names[] = {
1492 		"INVALID",
1493 		"DUMMY_STATE",
1494 		"MUX_GROUP",
1495 		"CONFIGS_PIN",
1496 		"CONFIGS_GROUP",
1497 	};
1498 
1499 	if (type >= ARRAY_SIZE(names))
1500 		return "UNKNOWN";
1501 
1502 	return names[type];
1503 }
1504 
1505 static int pinctrl_maps_show(struct seq_file *s, void *what)
1506 {
1507 	struct pinctrl_maps *maps_node;
1508 	int i;
1509 	struct pinctrl_map const *map;
1510 
1511 	seq_puts(s, "Pinctrl maps:\n");
1512 
1513 	mutex_lock(&pinctrl_maps_mutex);
1514 	for_each_maps(maps_node, i, map) {
1515 		seq_printf(s, "device %s\nstate %s\ntype %s (%d)\n",
1516 			   map->dev_name, map->name, map_type(map->type),
1517 			   map->type);
1518 
1519 		if (map->type != PIN_MAP_TYPE_DUMMY_STATE)
1520 			seq_printf(s, "controlling device %s\n",
1521 				   map->ctrl_dev_name);
1522 
1523 		switch (map->type) {
1524 		case PIN_MAP_TYPE_MUX_GROUP:
1525 			pinmux_show_map(s, map);
1526 			break;
1527 		case PIN_MAP_TYPE_CONFIGS_PIN:
1528 		case PIN_MAP_TYPE_CONFIGS_GROUP:
1529 			pinconf_show_map(s, map);
1530 			break;
1531 		default:
1532 			break;
1533 		}
1534 
1535 		seq_printf(s, "\n");
1536 	}
1537 	mutex_unlock(&pinctrl_maps_mutex);
1538 
1539 	return 0;
1540 }
1541 
1542 static int pinctrl_show(struct seq_file *s, void *what)
1543 {
1544 	struct pinctrl *p;
1545 	struct pinctrl_state *state;
1546 	struct pinctrl_setting *setting;
1547 
1548 	seq_puts(s, "Requested pin control handlers their pinmux maps:\n");
1549 
1550 	mutex_lock(&pinctrl_list_mutex);
1551 
1552 	list_for_each_entry(p, &pinctrl_list, node) {
1553 		seq_printf(s, "device: %s current state: %s\n",
1554 			   dev_name(p->dev),
1555 			   p->state ? p->state->name : "none");
1556 
1557 		list_for_each_entry(state, &p->states, node) {
1558 			seq_printf(s, "  state: %s\n", state->name);
1559 
1560 			list_for_each_entry(setting, &state->settings, node) {
1561 				struct pinctrl_dev *pctldev = setting->pctldev;
1562 
1563 				seq_printf(s, "    type: %s controller %s ",
1564 					   map_type(setting->type),
1565 					   pinctrl_dev_get_name(pctldev));
1566 
1567 				switch (setting->type) {
1568 				case PIN_MAP_TYPE_MUX_GROUP:
1569 					pinmux_show_setting(s, setting);
1570 					break;
1571 				case PIN_MAP_TYPE_CONFIGS_PIN:
1572 				case PIN_MAP_TYPE_CONFIGS_GROUP:
1573 					pinconf_show_setting(s, setting);
1574 					break;
1575 				default:
1576 					break;
1577 				}
1578 			}
1579 		}
1580 	}
1581 
1582 	mutex_unlock(&pinctrl_list_mutex);
1583 
1584 	return 0;
1585 }
1586 
1587 static int pinctrl_pins_open(struct inode *inode, struct file *file)
1588 {
1589 	return single_open(file, pinctrl_pins_show, inode->i_private);
1590 }
1591 
1592 static int pinctrl_groups_open(struct inode *inode, struct file *file)
1593 {
1594 	return single_open(file, pinctrl_groups_show, inode->i_private);
1595 }
1596 
1597 static int pinctrl_gpioranges_open(struct inode *inode, struct file *file)
1598 {
1599 	return single_open(file, pinctrl_gpioranges_show, inode->i_private);
1600 }
1601 
1602 static int pinctrl_devices_open(struct inode *inode, struct file *file)
1603 {
1604 	return single_open(file, pinctrl_devices_show, NULL);
1605 }
1606 
1607 static int pinctrl_maps_open(struct inode *inode, struct file *file)
1608 {
1609 	return single_open(file, pinctrl_maps_show, NULL);
1610 }
1611 
1612 static int pinctrl_open(struct inode *inode, struct file *file)
1613 {
1614 	return single_open(file, pinctrl_show, NULL);
1615 }
1616 
1617 static const struct file_operations pinctrl_pins_ops = {
1618 	.open		= pinctrl_pins_open,
1619 	.read		= seq_read,
1620 	.llseek		= seq_lseek,
1621 	.release	= single_release,
1622 };
1623 
1624 static const struct file_operations pinctrl_groups_ops = {
1625 	.open		= pinctrl_groups_open,
1626 	.read		= seq_read,
1627 	.llseek		= seq_lseek,
1628 	.release	= single_release,
1629 };
1630 
1631 static const struct file_operations pinctrl_gpioranges_ops = {
1632 	.open		= pinctrl_gpioranges_open,
1633 	.read		= seq_read,
1634 	.llseek		= seq_lseek,
1635 	.release	= single_release,
1636 };
1637 
1638 static const struct file_operations pinctrl_devices_ops = {
1639 	.open		= pinctrl_devices_open,
1640 	.read		= seq_read,
1641 	.llseek		= seq_lseek,
1642 	.release	= single_release,
1643 };
1644 
1645 static const struct file_operations pinctrl_maps_ops = {
1646 	.open		= pinctrl_maps_open,
1647 	.read		= seq_read,
1648 	.llseek		= seq_lseek,
1649 	.release	= single_release,
1650 };
1651 
1652 static const struct file_operations pinctrl_ops = {
1653 	.open		= pinctrl_open,
1654 	.read		= seq_read,
1655 	.llseek		= seq_lseek,
1656 	.release	= single_release,
1657 };
1658 
1659 static struct dentry *debugfs_root;
1660 
1661 static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
1662 {
1663 	struct dentry *device_root;
1664 
1665 	device_root = debugfs_create_dir(dev_name(pctldev->dev),
1666 					 debugfs_root);
1667 	pctldev->device_root = device_root;
1668 
1669 	if (IS_ERR(device_root) || !device_root) {
1670 		pr_warn("failed to create debugfs directory for %s\n",
1671 			dev_name(pctldev->dev));
1672 		return;
1673 	}
1674 	debugfs_create_file("pins", S_IFREG | S_IRUGO,
1675 			    device_root, pctldev, &pinctrl_pins_ops);
1676 	debugfs_create_file("pingroups", S_IFREG | S_IRUGO,
1677 			    device_root, pctldev, &pinctrl_groups_ops);
1678 	debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO,
1679 			    device_root, pctldev, &pinctrl_gpioranges_ops);
1680 	if (pctldev->desc->pmxops)
1681 		pinmux_init_device_debugfs(device_root, pctldev);
1682 	if (pctldev->desc->confops)
1683 		pinconf_init_device_debugfs(device_root, pctldev);
1684 }
1685 
1686 static void pinctrl_remove_device_debugfs(struct pinctrl_dev *pctldev)
1687 {
1688 	debugfs_remove_recursive(pctldev->device_root);
1689 }
1690 
1691 static void pinctrl_init_debugfs(void)
1692 {
1693 	debugfs_root = debugfs_create_dir("pinctrl", NULL);
1694 	if (IS_ERR(debugfs_root) || !debugfs_root) {
1695 		pr_warn("failed to create debugfs directory\n");
1696 		debugfs_root = NULL;
1697 		return;
1698 	}
1699 
1700 	debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO,
1701 			    debugfs_root, NULL, &pinctrl_devices_ops);
1702 	debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO,
1703 			    debugfs_root, NULL, &pinctrl_maps_ops);
1704 	debugfs_create_file("pinctrl-handles", S_IFREG | S_IRUGO,
1705 			    debugfs_root, NULL, &pinctrl_ops);
1706 }
1707 
1708 #else /* CONFIG_DEBUG_FS */
1709 
1710 static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
1711 {
1712 }
1713 
1714 static void pinctrl_init_debugfs(void)
1715 {
1716 }
1717 
1718 static void pinctrl_remove_device_debugfs(struct pinctrl_dev *pctldev)
1719 {
1720 }
1721 
1722 #endif
1723 
1724 static int pinctrl_check_ops(struct pinctrl_dev *pctldev)
1725 {
1726 	const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1727 
1728 	if (!ops ||
1729 	    !ops->get_groups_count ||
1730 	    !ops->get_group_name)
1731 		return -EINVAL;
1732 
1733 	if (ops->dt_node_to_map && !ops->dt_free_map)
1734 		return -EINVAL;
1735 
1736 	return 0;
1737 }
1738 
1739 /**
1740  * pinctrl_register() - register a pin controller device
1741  * @pctldesc: descriptor for this pin controller
1742  * @dev: parent device for this pin controller
1743  * @driver_data: private pin controller data for this pin controller
1744  */
1745 struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
1746 				    struct device *dev, void *driver_data)
1747 {
1748 	struct pinctrl_dev *pctldev;
1749 	int ret;
1750 
1751 	if (!pctldesc)
1752 		return ERR_PTR(-EINVAL);
1753 	if (!pctldesc->name)
1754 		return ERR_PTR(-EINVAL);
1755 
1756 	pctldev = kzalloc(sizeof(*pctldev), GFP_KERNEL);
1757 	if (pctldev == NULL) {
1758 		dev_err(dev, "failed to alloc struct pinctrl_dev\n");
1759 		return ERR_PTR(-ENOMEM);
1760 	}
1761 
1762 	/* Initialize pin control device struct */
1763 	pctldev->owner = pctldesc->owner;
1764 	pctldev->desc = pctldesc;
1765 	pctldev->driver_data = driver_data;
1766 	INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL);
1767 	INIT_LIST_HEAD(&pctldev->gpio_ranges);
1768 	pctldev->dev = dev;
1769 	mutex_init(&pctldev->mutex);
1770 
1771 	/* check core ops for sanity */
1772 	ret = pinctrl_check_ops(pctldev);
1773 	if (ret) {
1774 		dev_err(dev, "pinctrl ops lacks necessary functions\n");
1775 		goto out_err;
1776 	}
1777 
1778 	/* If we're implementing pinmuxing, check the ops for sanity */
1779 	if (pctldesc->pmxops) {
1780 		ret = pinmux_check_ops(pctldev);
1781 		if (ret)
1782 			goto out_err;
1783 	}
1784 
1785 	/* If we're implementing pinconfig, check the ops for sanity */
1786 	if (pctldesc->confops) {
1787 		ret = pinconf_check_ops(pctldev);
1788 		if (ret)
1789 			goto out_err;
1790 	}
1791 
1792 	/* Register all the pins */
1793 	dev_dbg(dev, "try to register %d pins ...\n",  pctldesc->npins);
1794 	ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);
1795 	if (ret) {
1796 		dev_err(dev, "error during pin registration\n");
1797 		pinctrl_free_pindescs(pctldev, pctldesc->pins,
1798 				      pctldesc->npins);
1799 		goto out_err;
1800 	}
1801 
1802 	mutex_lock(&pinctrldev_list_mutex);
1803 	list_add_tail(&pctldev->node, &pinctrldev_list);
1804 	mutex_unlock(&pinctrldev_list_mutex);
1805 
1806 	pctldev->p = pinctrl_get(pctldev->dev);
1807 
1808 	if (!IS_ERR(pctldev->p)) {
1809 		pctldev->hog_default =
1810 			pinctrl_lookup_state(pctldev->p, PINCTRL_STATE_DEFAULT);
1811 		if (IS_ERR(pctldev->hog_default)) {
1812 			dev_dbg(dev, "failed to lookup the default state\n");
1813 		} else {
1814 			if (pinctrl_select_state(pctldev->p,
1815 						pctldev->hog_default))
1816 				dev_err(dev,
1817 					"failed to select default state\n");
1818 		}
1819 
1820 		pctldev->hog_sleep =
1821 			pinctrl_lookup_state(pctldev->p,
1822 						    PINCTRL_STATE_SLEEP);
1823 		if (IS_ERR(pctldev->hog_sleep))
1824 			dev_dbg(dev, "failed to lookup the sleep state\n");
1825 	}
1826 
1827 	pinctrl_init_device_debugfs(pctldev);
1828 
1829 	return pctldev;
1830 
1831 out_err:
1832 	mutex_destroy(&pctldev->mutex);
1833 	kfree(pctldev);
1834 	return ERR_PTR(ret);
1835 }
1836 EXPORT_SYMBOL_GPL(pinctrl_register);
1837 
1838 /**
1839  * pinctrl_unregister() - unregister pinmux
1840  * @pctldev: pin controller to unregister
1841  *
1842  * Called by pinmux drivers to unregister a pinmux.
1843  */
1844 void pinctrl_unregister(struct pinctrl_dev *pctldev)
1845 {
1846 	struct pinctrl_gpio_range *range, *n;
1847 	if (pctldev == NULL)
1848 		return;
1849 
1850 	mutex_lock(&pctldev->mutex);
1851 	pinctrl_remove_device_debugfs(pctldev);
1852 	mutex_unlock(&pctldev->mutex);
1853 
1854 	if (!IS_ERR(pctldev->p))
1855 		pinctrl_put(pctldev->p);
1856 
1857 	mutex_lock(&pinctrldev_list_mutex);
1858 	mutex_lock(&pctldev->mutex);
1859 	/* TODO: check that no pinmuxes are still active? */
1860 	list_del(&pctldev->node);
1861 	/* Destroy descriptor tree */
1862 	pinctrl_free_pindescs(pctldev, pctldev->desc->pins,
1863 			      pctldev->desc->npins);
1864 	/* remove gpio ranges map */
1865 	list_for_each_entry_safe(range, n, &pctldev->gpio_ranges, node)
1866 		list_del(&range->node);
1867 
1868 	mutex_unlock(&pctldev->mutex);
1869 	mutex_destroy(&pctldev->mutex);
1870 	kfree(pctldev);
1871 	mutex_unlock(&pinctrldev_list_mutex);
1872 }
1873 EXPORT_SYMBOL_GPL(pinctrl_unregister);
1874 
1875 static int __init pinctrl_init(void)
1876 {
1877 	pr_info("initialized pinctrl subsystem\n");
1878 	pinctrl_init_debugfs();
1879 	return 0;
1880 }
1881 
1882 /* init early since many drivers really need to initialized pinmux early */
1883 core_initcall(pinctrl_init);
1884