2 * Core driver for the pin muxing portions of the pin control subsystem
4 * Copyright (C) 2011 ST-Ericsson SA
5 * Written on behalf of Linaro for ST-Ericsson
6 * Based on bits of regulator core, gpio core and clk core
8 * Author: Linus Walleij <linus.walleij@linaro.org>
10 * License terms: GNU General Public License (GPL) version 2
12 #define pr_fmt(fmt) "pinmux core: " fmt
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/device.h>
18 #include <linux/slab.h>
19 #include <linux/radix-tree.h>
20 #include <linux/err.h>
21 #include <linux/list.h>
22 #include <linux/mutex.h>
23 #include <linux/spinlock.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>
32 /* List of pinmuxes */
33 static DEFINE_MUTEX(pinmux_list_mutex);
34 static LIST_HEAD(pinmux_list);
36 /* Global pinmux maps */
37 static struct pinmux_map *pinmux_maps;
38 static unsigned pinmux_maps_num;
41 * struct pinmux_group - group list item for pinmux groups
42 * @node: pinmux group list node
43 * @group_selector: the group selector for this group
46 struct list_head node;
47 unsigned group_selector;
51 * struct pinmux - per-device pinmux state holder
52 * @node: global list node
53 * @dev: the device using this pinmux
54 * @usecount: the number of active users of this mux setting, used to keep
55 * track of nested use cases
56 * @pctldev: pin control device handling this pinmux
57 * @func_selector: the function selector for the pinmux device handling
59 * @groups: the group selectors for the pinmux device and
60 * selector combination handling this pinmux, this is a list that
61 * will be traversed on all pinmux operations such as
62 * get/put/enable/disable
63 * @mutex: a lock for the pinmux state holder
66 struct list_head node;
69 struct pinctrl_dev *pctldev;
70 unsigned func_selector;
71 struct list_head groups;
76 * struct pinmux_hog - a list item to stash mux hogs
77 * @node: pinmux hog list node
78 * @map: map entry responsible for this hogging
79 * @pmx: the pinmux hogged by this item
82 struct list_head node;
83 struct pinmux_map const *map;
88 * pin_request() - request a single pin to be muxed in, typically for GPIO
89 * @pin: the pin number in the global pin space
90 * @function: a functional name to give to this pin, passed to the driver
91 * so it knows what function to mux in, e.g. the string "gpioNN"
92 * means that you want to mux in the pin for use as GPIO number NN
93 * @gpio_range: the range matching the GPIO pin if this is a request for a
96 static int pin_request(struct pinctrl_dev *pctldev,
97 int pin, const char *function,
98 struct pinctrl_gpio_range *gpio_range)
100 struct pin_desc *desc;
101 const struct pinmux_ops *ops = pctldev->desc->pmxops;
102 int status = -EINVAL;
104 dev_dbg(pctldev->dev, "request pin %d for %s\n", pin, function);
106 desc = pin_desc_get(pctldev, pin);
108 dev_err(pctldev->dev,
109 "pin is not registered so it cannot be requested\n");
114 dev_err(pctldev->dev, "no function name given\n");
118 spin_lock(&desc->lock);
119 if (desc->mux_function) {
120 spin_unlock(&desc->lock);
121 dev_err(pctldev->dev,
122 "pin already requested\n");
125 desc->mux_function = function;
126 spin_unlock(&desc->lock);
128 /* Let each pin increase references to this module */
129 if (!try_module_get(pctldev->owner)) {
130 dev_err(pctldev->dev,
131 "could not increase module refcount for pin %d\n",
138 * If there is no kind of request function for the pin we just assume
139 * we got it by default and proceed.
141 if (gpio_range && ops->gpio_request_enable)
142 /* This requests and enables a single GPIO pin */
143 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
144 else if (ops->request)
145 status = ops->request(pctldev, pin);
150 dev_err(pctldev->dev, "->request on device %s failed for pin %d\n",
151 pctldev->desc->name, pin);
154 spin_lock(&desc->lock);
155 desc->mux_function = NULL;
156 spin_unlock(&desc->lock);
160 dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
161 pin, function ? : "?", status);
167 * pin_free() - release a single muxed in pin so something else can be muxed
168 * @pctldev: pin controller device handling this pin
169 * @pin: the pin to free
170 * @gpio_range: the range matching the GPIO pin if this is a request for a
173 * This function returns a pointer to the function name in use. This is used
174 * for callers that dynamically allocate a function name so it can be freed
175 * once the pin is free. This is done for GPIO request functions.
177 static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
178 struct pinctrl_gpio_range *gpio_range)
180 const struct pinmux_ops *ops = pctldev->desc->pmxops;
181 struct pin_desc *desc;
184 desc = pin_desc_get(pctldev, pin);
186 dev_err(pctldev->dev,
187 "pin is not registered so it cannot be freed\n");
192 * If there is no kind of request function for the pin we just assume
193 * we got it by default and proceed.
195 if (gpio_range && ops->gpio_disable_free)
196 ops->gpio_disable_free(pctldev, gpio_range, pin);
198 ops->free(pctldev, pin);
200 spin_lock(&desc->lock);
201 func = desc->mux_function;
202 desc->mux_function = NULL;
203 spin_unlock(&desc->lock);
204 module_put(pctldev->owner);
210 * pinmux_request_gpio() - request a single pin to be muxed in as GPIO
211 * @gpio: the GPIO pin number from the GPIO subsystem number space
213 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
214 * as part of their gpio_request() semantics, platforms and individual drivers
215 * shall *NOT* request GPIO pins to be muxed in.
217 int pinmux_request_gpio(unsigned gpio)
220 const char *function;
221 struct pinctrl_dev *pctldev;
222 struct pinctrl_gpio_range *range;
226 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
230 /* Convert to the pin controllers number space */
231 pin = gpio - range->base + range->pin_base;
233 /* Conjure some name stating what chip and pin this is taken by */
234 snprintf(gpiostr, 15, "%s:%d", range->name, gpio);
236 function = kstrdup(gpiostr, GFP_KERNEL);
240 ret = pin_request(pctldev, pin, function, range);
246 EXPORT_SYMBOL_GPL(pinmux_request_gpio);
249 * pinmux_free_gpio() - free a single pin, currently used as GPIO
250 * @gpio: the GPIO pin number from the GPIO subsystem number space
252 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
253 * as part of their gpio_free() semantics, platforms and individual drivers
254 * shall *NOT* request GPIO pins to be muxed out.
256 void pinmux_free_gpio(unsigned gpio)
258 struct pinctrl_dev *pctldev;
259 struct pinctrl_gpio_range *range;
264 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
268 /* Convert to the pin controllers number space */
269 pin = gpio - range->base + range->pin_base;
271 func = pin_free(pctldev, pin, range);
274 EXPORT_SYMBOL_GPL(pinmux_free_gpio);
276 static int pinmux_gpio_direction(unsigned gpio, bool input)
278 struct pinctrl_dev *pctldev;
279 struct pinctrl_gpio_range *range;
280 const struct pinmux_ops *ops;
284 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
288 ops = pctldev->desc->pmxops;
290 /* Convert to the pin controllers number space */
291 pin = gpio - range->base + range->pin_base;
293 if (ops->gpio_set_direction)
294 ret = ops->gpio_set_direction(pctldev, range, pin, input);
302 * pinmux_gpio_direction_input() - request a GPIO pin to go into input mode
303 * @gpio: the GPIO pin number from the GPIO subsystem number space
305 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
306 * as part of their gpio_direction_input() semantics, platforms and individual
307 * drivers shall *NOT* touch pinmux GPIO calls.
309 int pinmux_gpio_direction_input(unsigned gpio)
311 return pinmux_gpio_direction(gpio, true);
313 EXPORT_SYMBOL_GPL(pinmux_gpio_direction_input);
316 * pinmux_gpio_direction_output() - request a GPIO pin to go into output mode
317 * @gpio: the GPIO pin number from the GPIO subsystem number space
319 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
320 * as part of their gpio_direction_output() semantics, platforms and individual
321 * drivers shall *NOT* touch pinmux GPIO calls.
323 int pinmux_gpio_direction_output(unsigned gpio)
325 return pinmux_gpio_direction(gpio, false);
327 EXPORT_SYMBOL_GPL(pinmux_gpio_direction_output);
330 * pinmux_register_mappings() - register a set of pinmux mappings
331 * @maps: the pinmux mappings table to register, this should be marked with
332 * __initdata so it can be discarded after boot, this function will
333 * perform a shallow copy for the mapping entries.
334 * @num_maps: the number of maps in the mapping table
336 * Only call this once during initialization of your machine, the function is
337 * tagged as __init and won't be callable after init has completed. The map
338 * passed into this function will be owned by the pinmux core and cannot be
341 int __init pinmux_register_mappings(struct pinmux_map const *maps,
347 pr_debug("add %d pinmux maps\n", num_maps);
349 /* First sanity check the new mapping */
350 for (i = 0; i < num_maps; i++) {
352 pr_err("failed to register map %d: no map name given\n",
357 if (!maps[i].ctrl_dev && !maps[i].ctrl_dev_name) {
358 pr_err("failed to register map %s (%d): no pin control device given\n",
363 if (!maps[i].function) {
364 pr_err("failed to register map %s (%d): no function ID given\n",
369 if (!maps[i].dev && !maps[i].dev_name)
370 pr_debug("add system map %s function %s with no device\n",
374 pr_debug("register map %s, function %s\n",
380 * Make a copy of the map array - string pointers will end up in the
381 * kernel const section anyway so these do not need to be deep copied.
383 if (!pinmux_maps_num) {
384 /* On first call, just copy them */
385 tmp_maps = kmemdup(maps,
386 sizeof(struct pinmux_map) * num_maps,
391 /* Subsequent calls, reallocate array to new size */
392 size_t oldsize = sizeof(struct pinmux_map) * pinmux_maps_num;
393 size_t newsize = sizeof(struct pinmux_map) * num_maps;
395 tmp_maps = krealloc(pinmux_maps, oldsize + newsize, GFP_KERNEL);
398 memcpy((tmp_maps + oldsize), maps, newsize);
401 pinmux_maps = tmp_maps;
402 pinmux_maps_num += num_maps;
407 * acquire_pins() - acquire all the pins for a certain function on a pinmux
408 * @pctldev: the device to take the pins on
409 * @func_selector: the function selector to acquire the pins for
410 * @group_selector: the group selector containing the pins to acquire
412 static int acquire_pins(struct pinctrl_dev *pctldev,
413 unsigned func_selector,
414 unsigned group_selector)
416 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
417 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
418 const char *func = pmxops->get_function_name(pctldev,
420 const unsigned *pins;
425 ret = pctlops->get_group_pins(pctldev, group_selector,
430 dev_dbg(pctldev->dev, "requesting the %u pins from group %u\n",
431 num_pins, group_selector);
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], func, NULL);
437 dev_err(pctldev->dev,
438 "could not get pin %d for function %s on device %s - conflicting mux mappings?\n",
439 pins[i], func ? : "(undefined)",
440 pinctrl_dev_get_name(pctldev));
441 /* On error release all taken pins */
442 i--; /* this pin just failed */
444 pin_free(pctldev, pins[i], NULL);
452 * release_pins() - release pins taken by earlier acquirement
453 * @pctldev: the device to free the pins on
454 * @group_selector: the group selector containing the pins to free
456 static void release_pins(struct pinctrl_dev *pctldev,
457 unsigned group_selector)
459 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
460 const unsigned *pins;
465 ret = pctlops->get_group_pins(pctldev, group_selector,
468 dev_err(pctldev->dev, "could not get pins to release for group selector %d\n",
472 for (i = 0; i < num_pins; i++)
473 pin_free(pctldev, pins[i], NULL);
477 * pinmux_check_pin_group() - check function and pin group combo
478 * @pctldev: device to check the pin group vs function for
479 * @func_selector: the function selector to check the pin group for, we have
480 * already looked this up in the calling function
481 * @pin_group: the pin group to match to the function
483 * This function will check that the pinmux driver can supply the
484 * selected pin group for a certain function, returns the group selector if
485 * the group and function selector will work fine together, else returns
488 static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
489 unsigned func_selector,
490 const char *pin_group)
492 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
493 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
497 * If the driver does not support different pin groups for the
498 * functions, we only support group 0, and assume this exists.
500 if (!pctlops || !pctlops->list_groups)
504 * Passing NULL (no specific group) will select the first and
505 * hopefully only group of pins available for this function.
508 char const * const *groups;
511 ret = pmxops->get_function_groups(pctldev, func_selector,
512 &groups, &num_groups);
517 ret = pinctrl_get_group_selector(pctldev, groups[0]);
519 dev_err(pctldev->dev,
520 "function %s wants group %s but the pin controller does not seem to have that group\n",
521 pmxops->get_function_name(pctldev, func_selector),
527 dev_dbg(pctldev->dev,
528 "function %s support more than one group, default-selecting first group %s (%d)\n",
529 pmxops->get_function_name(pctldev, func_selector),
536 dev_dbg(pctldev->dev,
537 "check if we have pin group %s on controller %s\n",
538 pin_group, pinctrl_dev_get_name(pctldev));
540 ret = pinctrl_get_group_selector(pctldev, pin_group);
542 dev_dbg(pctldev->dev,
543 "%s does not support pin group %s with function %s\n",
544 pinctrl_dev_get_name(pctldev),
546 pmxops->get_function_name(pctldev, func_selector));
552 * pinmux_search_function() - check pin control driver for a certain function
553 * @pctldev: device to check for function and position
554 * @map: function map containing the function and position to look for
555 * @func_selector: returns the applicable function selector if found
556 * @group_selector: returns the applicable group selector if found
558 * This will search the pinmux driver for an applicable
559 * function with a specific pin group, returns 0 if these can be mapped
562 static int pinmux_search_function(struct pinctrl_dev *pctldev,
563 struct pinmux_map const *map,
564 unsigned *func_selector,
565 unsigned *group_selector)
567 const struct pinmux_ops *ops = pctldev->desc->pmxops;
568 unsigned selector = 0;
570 /* See if this pctldev has this function */
571 while (ops->list_functions(pctldev, selector) >= 0) {
572 const char *fname = ops->get_function_name(pctldev,
576 if (!strcmp(map->function, fname)) {
577 /* Found the function, check pin group */
578 ret = pinmux_check_pin_group(pctldev, selector,
583 /* This function and group selector can be used */
584 *func_selector = selector;
585 *group_selector = ret;
592 pr_err("%s does not support function %s\n",
593 pinctrl_dev_get_name(pctldev), map->function);
598 * pinmux_enable_muxmap() - enable a map entry for a certain pinmux
600 static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
604 struct pinmux_map const *map)
606 unsigned func_selector;
607 unsigned group_selector;
608 struct pinmux_group *grp;
612 * Note that we're not locking the pinmux mutex here, because
613 * this is only called at pinmux initialization time when it
614 * has not been added to any list and thus is not reachable
618 if (pmx->pctldev && pmx->pctldev != pctldev) {
619 dev_err(pctldev->dev,
620 "different pin control devices given for device %s, function %s\n",
621 devname, map->function);
625 pmx->pctldev = pctldev;
627 /* Now go into the driver and try to match a function and group */
628 ret = pinmux_search_function(pctldev, map, &func_selector,
634 * If the function selector is already set, it needs to be identical,
635 * we support several groups with one function but not several
636 * functions with one or several groups in the same pinmux.
638 if (pmx->func_selector != UINT_MAX &&
639 pmx->func_selector != func_selector) {
640 dev_err(pctldev->dev,
641 "dual function defines in the map for device %s\n",
645 pmx->func_selector = func_selector;
647 /* Now add this group selector, we may have many of them */
648 grp = kmalloc(sizeof(struct pinmux_group), GFP_KERNEL);
651 grp->group_selector = group_selector;
652 ret = acquire_pins(pctldev, func_selector, group_selector);
657 list_add(&grp->node, &pmx->groups);
662 static void pinmux_free_groups(struct pinmux *pmx)
664 struct list_head *node, *tmp;
666 list_for_each_safe(node, tmp, &pmx->groups) {
667 struct pinmux_group *grp =
668 list_entry(node, struct pinmux_group, node);
669 /* Release all pins taken by this group */
670 release_pins(pmx->pctldev, grp->group_selector);
677 * pinmux_get() - retrieves the pinmux for a certain device
678 * @dev: the device to get the pinmux for
679 * @name: an optional specific mux mapping name or NULL, the name is only
680 * needed if you want to have more than one mapping per device, or if you
681 * need an anonymous pinmux (not tied to any specific device)
683 struct pinmux *pinmux_get(struct device *dev, const char *name)
685 struct pinmux_map const *map = NULL;
686 struct pinctrl_dev *pctldev = NULL;
687 const char *devname = NULL;
690 unsigned num_maps = 0;
694 /* We must have dev or ID or both */
696 return ERR_PTR(-EINVAL);
699 devname = dev_name(dev);
701 pr_debug("get mux %s for device %s\n", name,
702 devname ? devname : "(none)");
705 * create the state cookie holder struct pinmux for each
706 * mapping, this is what consumers will get when requesting
707 * a pinmux handle with pinmux_get()
709 pmx = kzalloc(sizeof(struct pinmux), GFP_KERNEL);
711 return ERR_PTR(-ENOMEM);
712 mutex_init(&pmx->mutex);
713 pmx->func_selector = UINT_MAX;
714 INIT_LIST_HEAD(&pmx->groups);
716 /* Iterate over the pinmux maps to locate the right ones */
717 for (i = 0; i < pinmux_maps_num; i++) {
718 map = &pinmux_maps[i];
722 * First, try to find the pctldev given in the map
724 pctldev = get_pinctrl_dev_from_dev(map->ctrl_dev,
727 const char *devname = NULL;
730 devname = dev_name(map->ctrl_dev);
731 else if (map->ctrl_dev_name)
732 devname = map->ctrl_dev_name;
734 pr_warning("could not find a pinctrl device for pinmux function %s, fishy, they shall all have one\n",
736 pr_warning("given pinctrl device name: %s",
737 devname ? devname : "UNDEFINED");
739 /* Continue to check the other mappings anyway... */
743 pr_debug("in map, found pctldev %s to handle function %s",
744 dev_name(pctldev->dev), map->function);
748 * If we're looking for a specific named map, this must match,
749 * else we loop and look for the next.
752 if (map->name == NULL)
754 if (strcmp(map->name, name))
759 * This is for the case where no device name is given, we
760 * already know that the function name matches from above
763 if (!map->dev_name && (name != NULL))
766 /* If the mapping has a device set up it must match */
768 (!devname || !strcmp(map->dev_name, devname)))
772 /* If this map is applicable, then apply it */
774 ret = pinmux_enable_muxmap(pctldev, pmx, dev,
777 pinmux_free_groups(pmx);
786 /* We should have atleast one map, right */
788 pr_err("could not find any mux maps for device %s, ID %s\n",
789 devname ? devname : "(anonymous)",
790 name ? name : "(undefined)");
792 return ERR_PTR(-EINVAL);
795 pr_debug("found %u mux maps for device %s, UD %s\n",
797 devname ? devname : "(anonymous)",
798 name ? name : "(undefined)");
800 /* Add the pinmux to the global list */
801 mutex_lock(&pinmux_list_mutex);
802 list_add(&pmx->node, &pinmux_list);
803 mutex_unlock(&pinmux_list_mutex);
807 EXPORT_SYMBOL_GPL(pinmux_get);
810 * pinmux_put() - release a previously claimed pinmux
811 * @pmx: a pinmux previously claimed by pinmux_get()
813 void pinmux_put(struct pinmux *pmx)
818 mutex_lock(&pmx->mutex);
820 pr_warn("releasing pinmux with active users!\n");
821 /* Free the groups and all acquired pins */
822 pinmux_free_groups(pmx);
823 mutex_unlock(&pmx->mutex);
825 /* Remove from list */
826 mutex_lock(&pinmux_list_mutex);
827 list_del(&pmx->node);
828 mutex_unlock(&pinmux_list_mutex);
832 EXPORT_SYMBOL_GPL(pinmux_put);
835 * pinmux_enable() - enable a certain pinmux setting
836 * @pmx: the pinmux to enable, previously claimed by pinmux_get()
838 int pinmux_enable(struct pinmux *pmx)
844 mutex_lock(&pmx->mutex);
845 if (pmx->usecount++ == 0) {
846 struct pinctrl_dev *pctldev = pmx->pctldev;
847 const struct pinmux_ops *ops = pctldev->desc->pmxops;
848 struct pinmux_group *grp;
850 list_for_each_entry(grp, &pmx->groups, node) {
851 ret = ops->enable(pctldev, pmx->func_selector,
852 grp->group_selector);
855 * TODO: call disable() on all groups we called
856 * enable() on to this point?
863 mutex_unlock(&pmx->mutex);
866 EXPORT_SYMBOL_GPL(pinmux_enable);
869 * pinmux_disable() - disable a certain pinmux setting
870 * @pmx: the pinmux to disable, previously claimed by pinmux_get()
872 void pinmux_disable(struct pinmux *pmx)
877 mutex_lock(&pmx->mutex);
878 if (--pmx->usecount == 0) {
879 struct pinctrl_dev *pctldev = pmx->pctldev;
880 const struct pinmux_ops *ops = pctldev->desc->pmxops;
881 struct pinmux_group *grp;
883 list_for_each_entry(grp, &pmx->groups, node) {
884 ops->disable(pctldev, pmx->func_selector,
885 grp->group_selector);
888 mutex_unlock(&pmx->mutex);
890 EXPORT_SYMBOL_GPL(pinmux_disable);
892 int pinmux_check_ops(const struct pinmux_ops *ops)
894 /* Check that we implement required operations */
895 if (!ops->list_functions ||
896 !ops->get_function_name ||
897 !ops->get_function_groups ||
905 /* Hog a single map entry and add to the hoglist */
906 static int pinmux_hog_map(struct pinctrl_dev *pctldev,
907 struct pinmux_map const *map)
909 struct pinmux_hog *hog;
913 if (map->dev || map->dev_name) {
915 * TODO: the day we have device tree support, we can
916 * traverse the device tree and hog to specific device nodes
917 * without any problems, so then we can hog pinmuxes for
918 * all devices that just want a static pin mux at this point.
920 dev_err(pctldev->dev, "map %s wants to hog a non-system pinmux, this is not going to work\n",
925 hog = kzalloc(sizeof(struct pinmux_hog), GFP_KERNEL);
929 pmx = pinmux_get(NULL, map->name);
932 dev_err(pctldev->dev,
933 "could not get the %s pinmux mapping for hogging\n",
938 ret = pinmux_enable(pmx);
942 dev_err(pctldev->dev,
943 "could not enable the %s pinmux mapping for hogging\n",
951 dev_info(pctldev->dev, "hogged map %s, function %s\n", map->name,
953 mutex_lock(&pctldev->pinmux_hogs_lock);
954 list_add(&hog->node, &pctldev->pinmux_hogs);
955 mutex_unlock(&pctldev->pinmux_hogs_lock);
961 * pinmux_hog_maps() - hog specific map entries on controller device
962 * @pctldev: the pin control device to hog entries on
964 * When the pin controllers are registered, there may be some specific pinmux
965 * map entries that need to be hogged, i.e. get+enabled until the system shuts
968 int pinmux_hog_maps(struct pinctrl_dev *pctldev)
970 struct device *dev = pctldev->dev;
971 const char *devname = dev_name(dev);
975 INIT_LIST_HEAD(&pctldev->pinmux_hogs);
976 mutex_init(&pctldev->pinmux_hogs_lock);
978 for (i = 0; i < pinmux_maps_num; i++) {
979 struct pinmux_map const *map = &pinmux_maps[i];
981 if (((map->ctrl_dev == dev) ||
982 !strcmp(map->ctrl_dev_name, devname)) &&
984 /* OK time to hog! */
985 ret = pinmux_hog_map(pctldev, map);
994 * pinmux_unhog_maps() - unhog specific map entries on controller device
995 * @pctldev: the pin control device to unhog entries on
997 void pinmux_unhog_maps(struct pinctrl_dev *pctldev)
999 struct list_head *node, *tmp;
1001 mutex_lock(&pctldev->pinmux_hogs_lock);
1002 list_for_each_safe(node, tmp, &pctldev->pinmux_hogs) {
1003 struct pinmux_hog *hog =
1004 list_entry(node, struct pinmux_hog, node);
1005 pinmux_disable(hog->pmx);
1006 pinmux_put(hog->pmx);
1010 mutex_unlock(&pctldev->pinmux_hogs_lock);
1013 #ifdef CONFIG_DEBUG_FS
1015 /* Called from pincontrol core */
1016 static int pinmux_functions_show(struct seq_file *s, void *what)
1018 struct pinctrl_dev *pctldev = s->private;
1019 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
1020 unsigned func_selector = 0;
1022 while (pmxops->list_functions(pctldev, func_selector) >= 0) {
1023 const char *func = pmxops->get_function_name(pctldev,
1025 const char * const *groups;
1026 unsigned num_groups;
1030 ret = pmxops->get_function_groups(pctldev, func_selector,
1031 &groups, &num_groups);
1033 seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
1036 seq_printf(s, "function: %s, groups = [ ", func);
1037 for (i = 0; i < num_groups; i++)
1038 seq_printf(s, "%s ", groups[i]);
1048 static int pinmux_pins_show(struct seq_file *s, void *what)
1050 struct pinctrl_dev *pctldev = s->private;
1053 seq_puts(s, "Pinmux settings per pin\n");
1054 seq_puts(s, "Format: pin (name): pinmuxfunction\n");
1056 /* The pin number can be retrived from the pin controller descriptor */
1057 for (i = 0; i < pctldev->desc->npins; i++) {
1059 struct pin_desc *desc;
1061 pin = pctldev->desc->pins[i].number;
1062 desc = pin_desc_get(pctldev, pin);
1063 /* Skip if we cannot search the pin */
1067 seq_printf(s, "pin %d (%s): %s\n", pin,
1068 desc->name ? desc->name : "unnamed",
1069 desc->mux_function ? desc->mux_function
1076 static int pinmux_hogs_show(struct seq_file *s, void *what)
1078 struct pinctrl_dev *pctldev = s->private;
1079 struct pinmux_hog *hog;
1081 seq_puts(s, "Pinmux map hogs held by device\n");
1083 list_for_each_entry(hog, &pctldev->pinmux_hogs, node)
1084 seq_printf(s, "%s\n", hog->map->name);
1089 static int pinmux_show(struct seq_file *s, void *what)
1093 seq_puts(s, "Requested pinmuxes and their maps:\n");
1094 list_for_each_entry(pmx, &pinmux_list, node) {
1095 struct pinctrl_dev *pctldev = pmx->pctldev;
1096 const struct pinmux_ops *pmxops;
1097 const struct pinctrl_ops *pctlops;
1098 struct pinmux_group *grp;
1101 seq_puts(s, "NO PIN CONTROLLER DEVICE\n");
1105 pmxops = pctldev->desc->pmxops;
1106 pctlops = pctldev->desc->pctlops;
1108 seq_printf(s, "device: %s function: %s (%u),",
1109 pinctrl_dev_get_name(pmx->pctldev),
1110 pmxops->get_function_name(pctldev,
1111 pmx->func_selector),
1112 pmx->func_selector);
1114 seq_printf(s, " groups: [");
1115 list_for_each_entry(grp, &pmx->groups, node) {
1116 seq_printf(s, " %s (%u)",
1117 pctlops->get_group_name(pctldev,
1118 grp->group_selector),
1119 grp->group_selector);
1121 seq_printf(s, " ]");
1123 seq_printf(s, " users: %u map-> %s\n",
1125 pmx->dev ? dev_name(pmx->dev) : "(system)");
1131 static int pinmux_maps_show(struct seq_file *s, void *what)
1135 seq_puts(s, "Pinmux maps:\n");
1137 for (i = 0; i < pinmux_maps_num; i++) {
1138 struct pinmux_map const *map = &pinmux_maps[i];
1140 seq_printf(s, "%s:\n", map->name);
1141 if (map->dev || map->dev_name)
1142 seq_printf(s, " device: %s\n",
1143 map->dev ? dev_name(map->dev) :
1146 seq_printf(s, " SYSTEM MUX\n");
1147 seq_printf(s, " controlling device %s\n",
1148 map->ctrl_dev ? dev_name(map->ctrl_dev) :
1149 map->ctrl_dev_name);
1150 seq_printf(s, " function: %s\n", map->function);
1151 seq_printf(s, " group: %s\n", map->group ? map->group :
1157 static int pinmux_functions_open(struct inode *inode, struct file *file)
1159 return single_open(file, pinmux_functions_show, inode->i_private);
1162 static int pinmux_pins_open(struct inode *inode, struct file *file)
1164 return single_open(file, pinmux_pins_show, inode->i_private);
1167 static int pinmux_hogs_open(struct inode *inode, struct file *file)
1169 return single_open(file, pinmux_hogs_show, inode->i_private);
1172 static int pinmux_open(struct inode *inode, struct file *file)
1174 return single_open(file, pinmux_show, NULL);
1177 static int pinmux_maps_open(struct inode *inode, struct file *file)
1179 return single_open(file, pinmux_maps_show, NULL);
1182 static const struct file_operations pinmux_functions_ops = {
1183 .open = pinmux_functions_open,
1185 .llseek = seq_lseek,
1186 .release = single_release,
1189 static const struct file_operations pinmux_pins_ops = {
1190 .open = pinmux_pins_open,
1192 .llseek = seq_lseek,
1193 .release = single_release,
1196 static const struct file_operations pinmux_hogs_ops = {
1197 .open = pinmux_hogs_open,
1199 .llseek = seq_lseek,
1200 .release = single_release,
1203 static const struct file_operations pinmux_ops = {
1204 .open = pinmux_open,
1206 .llseek = seq_lseek,
1207 .release = single_release,
1210 static const struct file_operations pinmux_maps_ops = {
1211 .open = pinmux_maps_open,
1213 .llseek = seq_lseek,
1214 .release = single_release,
1217 void pinmux_init_device_debugfs(struct dentry *devroot,
1218 struct pinctrl_dev *pctldev)
1220 debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
1221 devroot, pctldev, &pinmux_functions_ops);
1222 debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
1223 devroot, pctldev, &pinmux_pins_ops);
1224 debugfs_create_file("pinmux-hogs", S_IFREG | S_IRUGO,
1225 devroot, pctldev, &pinmux_hogs_ops);
1228 void pinmux_init_debugfs(struct dentry *subsys_root)
1230 debugfs_create_file("pinmuxes", S_IFREG | S_IRUGO,
1231 subsys_root, NULL, &pinmux_ops);
1232 debugfs_create_file("pinmux-maps", S_IFREG | S_IRUGO,
1233 subsys_root, NULL, &pinmux_maps_ops);
1236 #endif /* CONFIG_DEBUG_FS */