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 * @pins: an array of discrete physical pins used in this mapping, taken
57 * from the global pin enumeration space (copied from pinmux map)
58 * @num_pins: the number of pins in this mapping array, i.e. the number of
59 * elements in .pins so we can iterate over that array (copied from
61 * @pctldev: pin control device handling this pinmux
62 * @func_selector: the function selector for the pinmux device handling
64 * @groups: the group selectors for the pinmux device and
65 * selector combination handling this pinmux, this is a list that
66 * will be traversed on all pinmux operations such as
67 * get/put/enable/disable
68 * @mutex: a lock for the pinmux state holder
71 struct list_head node
;
74 struct pinctrl_dev
*pctldev
;
75 unsigned func_selector
;
76 struct list_head groups
;
81 * struct pinmux_hog - a list item to stash mux hogs
82 * @node: pinmux hog list node
83 * @map: map entry responsible for this hogging
84 * @pmx: the pinmux hogged by this item
87 struct list_head node
;
88 struct pinmux_map
const *map
;
93 * pin_request() - request a single pin to be muxed in, typically for GPIO
94 * @pin: the pin number in the global pin space
95 * @function: a functional name to give to this pin, passed to the driver
96 * so it knows what function to mux in, e.g. the string "gpioNN"
97 * means that you want to mux in the pin for use as GPIO number NN
98 * @gpio_range: the range matching the GPIO pin if this is a request for a
101 static int pin_request(struct pinctrl_dev
*pctldev
,
102 int pin
, const char *function
,
103 struct pinctrl_gpio_range
*gpio_range
)
105 struct pin_desc
*desc
;
106 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
107 int status
= -EINVAL
;
109 dev_dbg(pctldev
->dev
, "request pin %d for %s\n", pin
, function
);
111 desc
= pin_desc_get(pctldev
, pin
);
113 dev_err(pctldev
->dev
,
114 "pin is not registered so it cannot be requested\n");
119 dev_err(pctldev
->dev
, "no function name given\n");
123 spin_lock(&desc
->lock
);
124 if (desc
->mux_function
) {
125 spin_unlock(&desc
->lock
);
126 dev_err(pctldev
->dev
,
127 "pin already requested\n");
130 desc
->mux_function
= function
;
131 spin_unlock(&desc
->lock
);
133 /* Let each pin increase references to this module */
134 if (!try_module_get(pctldev
->owner
)) {
135 dev_err(pctldev
->dev
,
136 "could not increase module refcount for pin %d\n",
143 * If there is no kind of request function for the pin we just assume
144 * we got it by default and proceed.
146 if (gpio_range
&& ops
->gpio_request_enable
)
147 /* This requests and enables a single GPIO pin */
148 status
= ops
->gpio_request_enable(pctldev
, gpio_range
, pin
);
149 else if (ops
->request
)
150 status
= ops
->request(pctldev
, pin
);
155 dev_err(pctldev
->dev
, "->request on device %s failed "
157 pctldev
->desc
->name
, pin
);
160 spin_lock(&desc
->lock
);
161 desc
->mux_function
= NULL
;
162 spin_unlock(&desc
->lock
);
166 dev_err(pctldev
->dev
, "pin-%d (%s) status %d\n",
167 pin
, function
? : "?", status
);
173 * pin_free() - release a single muxed in pin so something else can be muxed
174 * @pctldev: pin controller device handling this pin
175 * @pin: the pin to free
176 * @gpio_range: the range matching the GPIO pin if this is a request for a
179 * This function returns a pointer to the function name in use. This is used
180 * for callers that dynamically allocate a function name so it can be freed
181 * once the pin is free. This is done for GPIO request functions.
183 static const char *pin_free(struct pinctrl_dev
*pctldev
, int pin
,
184 struct pinctrl_gpio_range
*gpio_range
)
186 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
187 struct pin_desc
*desc
;
190 desc
= pin_desc_get(pctldev
, pin
);
192 dev_err(pctldev
->dev
,
193 "pin is not registered so it cannot be freed\n");
198 * If there is no kind of request function for the pin we just assume
199 * we got it by default and proceed.
201 if (gpio_range
&& ops
->gpio_disable_free
)
202 ops
->gpio_disable_free(pctldev
, gpio_range
, pin
);
204 ops
->free(pctldev
, pin
);
206 spin_lock(&desc
->lock
);
207 func
= desc
->mux_function
;
208 desc
->mux_function
= NULL
;
209 spin_unlock(&desc
->lock
);
210 module_put(pctldev
->owner
);
216 * pinmux_request_gpio() - request a single pin to be muxed in as GPIO
217 * @gpio: the GPIO pin number from the GPIO subsystem number space
219 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
220 * as part of their gpio_request() semantics, platforms and individual drivers
221 * shall *NOT* request GPIO pins to be muxed in.
223 int pinmux_request_gpio(unsigned gpio
)
226 const char *function
;
227 struct pinctrl_dev
*pctldev
;
228 struct pinctrl_gpio_range
*range
;
232 ret
= pinctrl_get_device_gpio_range(gpio
, &pctldev
, &range
);
236 /* Convert to the pin controllers number space */
237 pin
= gpio
- range
->base
+ range
->pin_base
;
239 /* Conjure some name stating what chip and pin this is taken by */
240 snprintf(gpiostr
, 15, "%s:%d", range
->name
, gpio
);
242 function
= kstrdup(gpiostr
, GFP_KERNEL
);
246 ret
= pin_request(pctldev
, pin
, function
, range
);
252 EXPORT_SYMBOL_GPL(pinmux_request_gpio
);
255 * pinmux_free_gpio() - free a single pin, currently used as GPIO
256 * @gpio: the GPIO pin number from the GPIO subsystem number space
258 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
259 * as part of their gpio_free() semantics, platforms and individual drivers
260 * shall *NOT* request GPIO pins to be muxed out.
262 void pinmux_free_gpio(unsigned gpio
)
264 struct pinctrl_dev
*pctldev
;
265 struct pinctrl_gpio_range
*range
;
270 ret
= pinctrl_get_device_gpio_range(gpio
, &pctldev
, &range
);
274 /* Convert to the pin controllers number space */
275 pin
= gpio
- range
->base
+ range
->pin_base
;
277 func
= pin_free(pctldev
, pin
, range
);
280 EXPORT_SYMBOL_GPL(pinmux_free_gpio
);
282 static int pinmux_gpio_direction(unsigned gpio
, bool input
)
284 struct pinctrl_dev
*pctldev
;
285 struct pinctrl_gpio_range
*range
;
286 const struct pinmux_ops
*ops
;
290 ret
= pinctrl_get_device_gpio_range(gpio
, &pctldev
, &range
);
294 ops
= pctldev
->desc
->pmxops
;
296 /* Convert to the pin controllers number space */
297 pin
= gpio
- range
->base
+ range
->pin_base
;
299 if (ops
->gpio_set_direction
)
300 ret
= ops
->gpio_set_direction(pctldev
, range
, pin
, input
);
308 * pinmux_gpio_direction_input() - request a GPIO pin to go into input mode
309 * @gpio: the GPIO pin number from the GPIO subsystem number space
311 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
312 * as part of their gpio_direction_input() semantics, platforms and individual
313 * drivers shall *NOT* touch pinmux GPIO calls.
315 int pinmux_gpio_direction_input(unsigned gpio
)
317 return pinmux_gpio_direction(gpio
, true);
319 EXPORT_SYMBOL_GPL(pinmux_gpio_direction_input
);
322 * pinmux_gpio_direction_output() - request a GPIO pin to go into output mode
323 * @gpio: the GPIO pin number from the GPIO subsystem number space
325 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
326 * as part of their gpio_direction_output() semantics, platforms and individual
327 * drivers shall *NOT* touch pinmux GPIO calls.
329 int pinmux_gpio_direction_output(unsigned gpio
)
331 return pinmux_gpio_direction(gpio
, false);
333 EXPORT_SYMBOL_GPL(pinmux_gpio_direction_output
);
336 * pinmux_register_mappings() - register a set of pinmux mappings
337 * @maps: the pinmux mappings table to register, this should be marked with
338 * __initdata so it can be discarded after boot, this function will
339 * perform a shallow copy for the mapping entries.
340 * @num_maps: the number of maps in the mapping table
342 * Only call this once during initialization of your machine, the function is
343 * tagged as __init and won't be callable after init has completed. The map
344 * passed into this function will be owned by the pinmux core and cannot be
347 int __init
pinmux_register_mappings(struct pinmux_map
const *maps
,
353 pr_debug("add %d pinmux maps\n", num_maps
);
355 /* First sanity check the new mapping */
356 for (i
= 0; i
< num_maps
; i
++) {
358 pr_err("failed to register map %d: "
359 "no map name given\n", i
);
363 if (!maps
[i
].ctrl_dev
&& !maps
[i
].ctrl_dev_name
) {
364 pr_err("failed to register map %s (%d): "
365 "no pin control device given\n",
370 if (!maps
[i
].function
) {
371 pr_err("failed to register map %s (%d): "
372 "no function ID given\n", maps
[i
].name
, i
);
376 if (!maps
[i
].dev
&& !maps
[i
].dev_name
)
377 pr_debug("add system map %s function %s with no device\n",
381 pr_debug("register map %s, function %s\n",
387 * Make a copy of the map array - string pointers will end up in the
388 * kernel const section anyway so these do not need to be deep copied.
390 if (!pinmux_maps_num
) {
391 /* On first call, just copy them */
392 tmp_maps
= kmemdup(maps
,
393 sizeof(struct pinmux_map
) * num_maps
,
398 /* Subsequent calls, reallocate array to new size */
399 size_t oldsize
= sizeof(struct pinmux_map
) * pinmux_maps_num
;
400 size_t newsize
= sizeof(struct pinmux_map
) * num_maps
;
402 tmp_maps
= krealloc(pinmux_maps
, oldsize
+ newsize
, GFP_KERNEL
);
405 memcpy((tmp_maps
+ oldsize
), maps
, newsize
);
408 pinmux_maps
= tmp_maps
;
409 pinmux_maps_num
+= num_maps
;
414 * acquire_pins() - acquire all the pins for a certain funcion on a pinmux
415 * @pctldev: the device to take the pins on
416 * @func_selector: the function selector to acquire the pins for
417 * @group_selector: the group selector containing the pins to acquire
419 static int acquire_pins(struct pinctrl_dev
*pctldev
,
420 unsigned func_selector
,
421 unsigned group_selector
)
423 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
424 const struct pinmux_ops
*pmxops
= pctldev
->desc
->pmxops
;
425 const char *func
= pmxops
->get_function_name(pctldev
,
427 const unsigned *pins
;
432 ret
= pctlops
->get_group_pins(pctldev
, group_selector
,
437 dev_dbg(pctldev
->dev
, "requesting the %u pins from group %u\n",
438 num_pins
, group_selector
);
440 /* Try to allocate all pins in this group, one by one */
441 for (i
= 0; i
< num_pins
; i
++) {
442 ret
= pin_request(pctldev
, pins
[i
], func
, NULL
);
444 dev_err(pctldev
->dev
,
445 "could not get pin %d for function %s "
446 "on device %s - conflicting mux mappings?\n",
447 pins
[i
], func
? : "(undefined)",
448 pinctrl_dev_get_name(pctldev
));
449 /* On error release all taken pins */
450 i
--; /* this pin just failed */
452 pin_free(pctldev
, pins
[i
], NULL
);
460 * release_pins() - release pins taken by earlier acquirement
461 * @pctldev: the device to free the pinx on
462 * @group_selector: the group selector containing the pins to free
464 static void release_pins(struct pinctrl_dev
*pctldev
,
465 unsigned group_selector
)
467 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
468 const unsigned *pins
;
473 ret
= pctlops
->get_group_pins(pctldev
, group_selector
,
476 dev_err(pctldev
->dev
, "could not get pins to release for "
477 "group selector %d\n",
481 for (i
= 0; i
< num_pins
; i
++)
482 pin_free(pctldev
, pins
[i
], NULL
);
486 * pinmux_check_pin_group() - check function and pin group combo
487 * @pctldev: device to check the pin group vs function for
488 * @func_selector: the function selector to check the pin group for, we have
489 * already looked this up in the calling function
490 * @pin_group: the pin group to match to the function
492 * This function will check that the pinmux driver can supply the
493 * selected pin group for a certain function, returns the group selector if
494 * the group and function selector will work fine together, else returns
497 static int pinmux_check_pin_group(struct pinctrl_dev
*pctldev
,
498 unsigned func_selector
,
499 const char *pin_group
)
501 const struct pinmux_ops
*pmxops
= pctldev
->desc
->pmxops
;
502 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
506 * If the driver does not support different pin groups for the
507 * functions, we only support group 0, and assume this exists.
509 if (!pctlops
|| !pctlops
->list_groups
)
513 * Passing NULL (no specific group) will select the first and
514 * hopefully only group of pins available for this function.
517 char const * const *groups
;
520 ret
= pmxops
->get_function_groups(pctldev
, func_selector
,
521 &groups
, &num_groups
);
526 ret
= pinctrl_get_group_selector(pctldev
, groups
[0]);
528 dev_err(pctldev
->dev
,
529 "function %s wants group %s but the pin "
530 "controller does not seem to have that group\n",
531 pmxops
->get_function_name(pctldev
, func_selector
),
537 dev_dbg(pctldev
->dev
,
538 "function %s support more than one group, "
539 "default-selecting first group %s (%d)\n",
540 pmxops
->get_function_name(pctldev
, func_selector
),
547 dev_dbg(pctldev
->dev
,
548 "check if we have pin group %s on controller %s\n",
549 pin_group
, pinctrl_dev_get_name(pctldev
));
551 ret
= pinctrl_get_group_selector(pctldev
, pin_group
);
553 dev_dbg(pctldev
->dev
,
554 "%s does not support pin group %s with function %s\n",
555 pinctrl_dev_get_name(pctldev
),
557 pmxops
->get_function_name(pctldev
, func_selector
));
563 * pinmux_search_function() - check pin control driver for a certain function
564 * @pctldev: device to check for function and position
565 * @map: function map containing the function and position to look for
566 * @func_selector: returns the applicable function selector if found
567 * @group_selector: returns the applicable group selector if found
569 * This will search the pinmux driver for an applicable
570 * function with a specific pin group, returns 0 if these can be mapped
573 static int pinmux_search_function(struct pinctrl_dev
*pctldev
,
574 struct pinmux_map
const *map
,
575 unsigned *func_selector
,
576 unsigned *group_selector
)
578 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
579 unsigned selector
= 0;
581 /* See if this pctldev has this function */
582 while (ops
->list_functions(pctldev
, selector
) >= 0) {
583 const char *fname
= ops
->get_function_name(pctldev
,
587 if (!strcmp(map
->function
, fname
)) {
588 /* Found the function, check pin group */
589 ret
= pinmux_check_pin_group(pctldev
, selector
,
594 /* This function and group selector can be used */
595 *func_selector
= selector
;
596 *group_selector
= ret
;
603 pr_err("%s does not support function %s\n",
604 pinctrl_dev_get_name(pctldev
), map
->function
);
609 * pinmux_enable_muxmap() - enable a map entry for a certain pinmux
611 static int pinmux_enable_muxmap(struct pinctrl_dev
*pctldev
,
615 struct pinmux_map
const *map
)
617 unsigned func_selector
;
618 unsigned group_selector
;
619 struct pinmux_group
*grp
;
623 * Note that we're not locking the pinmux mutex here, because
624 * this is only called at pinmux initialization time when it
625 * has not been added to any list and thus is not reachable
629 if (pmx
->pctldev
&& pmx
->pctldev
!= pctldev
) {
630 dev_err(pctldev
->dev
,
631 "different pin control devices given for device %s, "
638 pmx
->pctldev
= pctldev
;
640 /* Now go into the driver and try to match a function and group */
641 ret
= pinmux_search_function(pctldev
, map
, &func_selector
,
647 * If the function selector is already set, it needs to be identical,
648 * we support several groups with one function but not several
649 * functions with one or several groups in the same pinmux.
651 if (pmx
->func_selector
!= UINT_MAX
&&
652 pmx
->func_selector
!= func_selector
) {
653 dev_err(pctldev
->dev
,
654 "dual function defines in the map for device %s\n",
658 pmx
->func_selector
= func_selector
;
660 /* Now add this group selector, we may have many of them */
661 grp
= kmalloc(sizeof(struct pinmux_group
), GFP_KERNEL
);
664 grp
->group_selector
= group_selector
;
665 ret
= acquire_pins(pctldev
, func_selector
, group_selector
);
670 list_add(&grp
->node
, &pmx
->groups
);
675 static void pinmux_free_groups(struct pinmux
*pmx
)
677 struct list_head
*node
, *tmp
;
679 list_for_each_safe(node
, tmp
, &pmx
->groups
) {
680 struct pinmux_group
*grp
=
681 list_entry(node
, struct pinmux_group
, node
);
682 /* Release all pins taken by this group */
683 release_pins(pmx
->pctldev
, grp
->group_selector
);
690 * pinmux_get() - retrieves the pinmux for a certain device
691 * @dev: the device to get the pinmux for
692 * @name: an optional specific mux mapping name or NULL, the name is only
693 * needed if you want to have more than one mapping per device, or if you
694 * need an anonymous pinmux (not tied to any specific device)
696 struct pinmux
*pinmux_get(struct device
*dev
, const char *name
)
699 struct pinmux_map
const *map
= NULL
;
700 struct pinctrl_dev
*pctldev
= NULL
;
701 const char *devname
= NULL
;
704 unsigned num_maps
= 0;
708 /* We must have dev or ID or both */
710 return ERR_PTR(-EINVAL
);
713 devname
= dev_name(dev
);
715 pr_debug("get mux %s for device %s\n", name
,
716 devname
? devname
: "(none)");
719 * create the state cookie holder struct pinmux for each
720 * mapping, this is what consumers will get when requesting
721 * a pinmux handle with pinmux_get()
723 pmx
= kzalloc(sizeof(struct pinmux
), GFP_KERNEL
);
725 return ERR_PTR(-ENOMEM
);
726 mutex_init(&pmx
->mutex
);
727 pmx
->func_selector
= UINT_MAX
;
728 INIT_LIST_HEAD(&pmx
->groups
);
730 /* Iterate over the pinmux maps to locate the right ones */
731 for (i
= 0; i
< pinmux_maps_num
; i
++) {
732 map
= &pinmux_maps
[i
];
736 * First, try to find the pctldev given in the map
738 pctldev
= get_pinctrl_dev_from_dev(map
->ctrl_dev
,
741 const char *devname
= NULL
;
744 devname
= dev_name(map
->ctrl_dev
);
745 else if (map
->ctrl_dev_name
)
746 devname
= map
->ctrl_dev_name
;
748 pr_warning("could not find a pinctrl device for pinmux "
749 "function %s, fishy, they shall all have one\n",
751 pr_warning("given pinctrl device name: %s",
752 devname
? devname
: "UNDEFINED");
754 /* Continue to check the other mappings anyway... */
758 pr_debug("in map, found pctldev %s to handle function %s",
759 dev_name(pctldev
->dev
), map
->function
);
763 * If we're looking for a specific named map, this must match,
764 * else we loop and look for the next.
767 if (map
->name
== NULL
)
769 if (strcmp(map
->name
, name
))
774 * This is for the case where no device name is given, we
775 * already know that the function name matches from above
778 if (!map
->dev_name
&& (name
!= NULL
))
781 /* If the mapping has a device set up it must match */
783 (!devname
|| !strcmp(map
->dev_name
, devname
)))
787 /* If this map is applicable, then apply it */
789 ret
= pinmux_enable_muxmap(pctldev
, pmx
, dev
,
792 pinmux_free_groups(pmx
);
801 /* We should have atleast one map, right */
803 pr_err("could not find any mux maps for device %s, ID %s\n",
804 devname
? devname
: "(anonymous)",
805 name
? name
: "(undefined)");
807 return ERR_PTR(-EINVAL
);
810 pr_debug("found %u mux maps for device %s, UD %s\n",
812 devname
? devname
: "(anonymous)",
813 name
? name
: "(undefined)");
815 /* Add the pinmux to the global list */
816 mutex_lock(&pinmux_list_mutex
);
817 list_add(&pmx
->node
, &pinmux_list
);
818 mutex_unlock(&pinmux_list_mutex
);
822 EXPORT_SYMBOL_GPL(pinmux_get
);
825 * pinmux_put() - release a previously claimed pinmux
826 * @pmx: a pinmux previously claimed by pinmux_get()
828 void pinmux_put(struct pinmux
*pmx
)
833 mutex_lock(&pmx
->mutex
);
835 pr_warn("releasing pinmux with active users!\n");
836 /* Free the groups and all acquired pins */
837 pinmux_free_groups(pmx
);
838 mutex_unlock(&pmx
->mutex
);
840 /* Remove from list */
841 mutex_lock(&pinmux_list_mutex
);
842 list_del(&pmx
->node
);
843 mutex_unlock(&pinmux_list_mutex
);
847 EXPORT_SYMBOL_GPL(pinmux_put
);
850 * pinmux_enable() - enable a certain pinmux setting
851 * @pmx: the pinmux to enable, previously claimed by pinmux_get()
853 int pinmux_enable(struct pinmux
*pmx
)
859 mutex_lock(&pmx
->mutex
);
860 if (pmx
->usecount
++ == 0) {
861 struct pinctrl_dev
*pctldev
= pmx
->pctldev
;
862 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
863 struct pinmux_group
*grp
;
865 list_for_each_entry(grp
, &pmx
->groups
, node
) {
866 ret
= ops
->enable(pctldev
, pmx
->func_selector
,
867 grp
->group_selector
);
870 * TODO: call disable() on all groups we called
871 * enable() on to this point?
878 mutex_unlock(&pmx
->mutex
);
881 EXPORT_SYMBOL_GPL(pinmux_enable
);
884 * pinmux_disable() - disable a certain pinmux setting
885 * @pmx: the pinmux to disable, previously claimed by pinmux_get()
887 void pinmux_disable(struct pinmux
*pmx
)
892 mutex_lock(&pmx
->mutex
);
893 if (--pmx
->usecount
== 0) {
894 struct pinctrl_dev
*pctldev
= pmx
->pctldev
;
895 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
896 struct pinmux_group
*grp
;
898 list_for_each_entry(grp
, &pmx
->groups
, node
) {
899 ops
->disable(pctldev
, pmx
->func_selector
,
900 grp
->group_selector
);
903 mutex_unlock(&pmx
->mutex
);
905 EXPORT_SYMBOL_GPL(pinmux_disable
);
907 int pinmux_check_ops(const struct pinmux_ops
*ops
)
909 /* Check that we implement required operations */
910 if (!ops
->list_functions
||
911 !ops
->get_function_name
||
912 !ops
->get_function_groups
||
920 /* Hog a single map entry and add to the hoglist */
921 static int pinmux_hog_map(struct pinctrl_dev
*pctldev
,
922 struct pinmux_map
const *map
)
924 struct pinmux_hog
*hog
;
928 if (map
->dev
|| map
->dev_name
) {
930 * TODO: the day we have device tree support, we can
931 * traverse the device tree and hog to specific device nodes
932 * without any problems, so then we can hog pinmuxes for
933 * all devices that just want a static pin mux at this point.
935 dev_err(pctldev
->dev
, "map %s wants to hog a non-system "
936 "pinmux, this is not going to work\n", map
->name
);
940 hog
= kzalloc(sizeof(struct pinmux_hog
), GFP_KERNEL
);
944 pmx
= pinmux_get(NULL
, map
->name
);
947 dev_err(pctldev
->dev
,
948 "could not get the %s pinmux mapping for hogging\n",
953 ret
= pinmux_enable(pmx
);
957 dev_err(pctldev
->dev
,
958 "could not enable the %s pinmux mapping for hogging\n",
966 dev_info(pctldev
->dev
, "hogged map %s, function %s\n", map
->name
,
968 mutex_lock(&pctldev
->pinmux_hogs_lock
);
969 list_add(&hog
->node
, &pctldev
->pinmux_hogs
);
970 mutex_unlock(&pctldev
->pinmux_hogs_lock
);
976 * pinmux_hog_maps() - hog specific map entries on controller device
977 * @pctldev: the pin control device to hog entries on
979 * When the pin controllers are registered, there may be some specific pinmux
980 * map entries that need to be hogged, i.e. get+enabled until the system shuts
983 int pinmux_hog_maps(struct pinctrl_dev
*pctldev
)
985 struct device
*dev
= pctldev
->dev
;
986 const char *devname
= dev_name(dev
);
990 INIT_LIST_HEAD(&pctldev
->pinmux_hogs
);
991 mutex_init(&pctldev
->pinmux_hogs_lock
);
993 for (i
= 0; i
< pinmux_maps_num
; i
++) {
994 struct pinmux_map
const *map
= &pinmux_maps
[i
];
996 if (((map
->ctrl_dev
== dev
) ||
997 !strcmp(map
->ctrl_dev_name
, devname
)) &&
999 /* OK time to hog! */
1000 ret
= pinmux_hog_map(pctldev
, map
);
1009 * pinmux_unhog_maps() - unhog specific map entries on controller device
1010 * @pctldev: the pin control device to unhog entries on
1012 void pinmux_unhog_maps(struct pinctrl_dev
*pctldev
)
1014 struct list_head
*node
, *tmp
;
1016 mutex_lock(&pctldev
->pinmux_hogs_lock
);
1017 list_for_each_safe(node
, tmp
, &pctldev
->pinmux_hogs
) {
1018 struct pinmux_hog
*hog
=
1019 list_entry(node
, struct pinmux_hog
, node
);
1020 pinmux_disable(hog
->pmx
);
1021 pinmux_put(hog
->pmx
);
1025 mutex_unlock(&pctldev
->pinmux_hogs_lock
);
1028 #ifdef CONFIG_DEBUG_FS
1030 /* Called from pincontrol core */
1031 static int pinmux_functions_show(struct seq_file
*s
, void *what
)
1033 struct pinctrl_dev
*pctldev
= s
->private;
1034 const struct pinmux_ops
*pmxops
= pctldev
->desc
->pmxops
;
1035 unsigned func_selector
= 0;
1037 while (pmxops
->list_functions(pctldev
, func_selector
) >= 0) {
1038 const char *func
= pmxops
->get_function_name(pctldev
,
1040 const char * const *groups
;
1041 unsigned num_groups
;
1045 ret
= pmxops
->get_function_groups(pctldev
, func_selector
,
1046 &groups
, &num_groups
);
1048 seq_printf(s
, "function %s: COULD NOT GET GROUPS\n",
1051 seq_printf(s
, "function: %s, groups = [ ", func
);
1052 for (i
= 0; i
< num_groups
; i
++)
1053 seq_printf(s
, "%s ", groups
[i
]);
1063 static int pinmux_pins_show(struct seq_file
*s
, void *what
)
1065 struct pinctrl_dev
*pctldev
= s
->private;
1068 seq_puts(s
, "Pinmux settings per pin\n");
1069 seq_puts(s
, "Format: pin (name): pinmuxfunction\n");
1071 /* The pin number can be retrived from the pin controller descriptor */
1072 for (i
= 0; i
< pctldev
->desc
->npins
; i
++) {
1074 struct pin_desc
*desc
;
1076 pin
= pctldev
->desc
->pins
[i
].number
;
1077 desc
= pin_desc_get(pctldev
, pin
);
1078 /* Skip if we cannot search the pin */
1082 seq_printf(s
, "pin %d (%s): %s\n", pin
,
1083 desc
->name
? desc
->name
: "unnamed",
1084 desc
->mux_function
? desc
->mux_function
1091 static int pinmux_hogs_show(struct seq_file
*s
, void *what
)
1093 struct pinctrl_dev
*pctldev
= s
->private;
1094 struct pinmux_hog
*hog
;
1096 seq_puts(s
, "Pinmux map hogs held by device\n");
1098 list_for_each_entry(hog
, &pctldev
->pinmux_hogs
, node
)
1099 seq_printf(s
, "%s\n", hog
->map
->name
);
1104 static int pinmux_show(struct seq_file
*s
, void *what
)
1108 seq_puts(s
, "Requested pinmuxes and their maps:\n");
1109 list_for_each_entry(pmx
, &pinmux_list
, node
) {
1110 struct pinctrl_dev
*pctldev
= pmx
->pctldev
;
1111 const struct pinmux_ops
*pmxops
;
1112 const struct pinctrl_ops
*pctlops
;
1113 struct pinmux_group
*grp
;
1116 seq_puts(s
, "NO PIN CONTROLLER DEVICE\n");
1120 pmxops
= pctldev
->desc
->pmxops
;
1121 pctlops
= pctldev
->desc
->pctlops
;
1123 seq_printf(s
, "device: %s function: %s (%u),",
1124 pinctrl_dev_get_name(pmx
->pctldev
),
1125 pmxops
->get_function_name(pctldev
, pmx
->func_selector
),
1126 pmx
->func_selector
);
1128 seq_printf(s
, " groups: [");
1129 list_for_each_entry(grp
, &pmx
->groups
, node
) {
1130 seq_printf(s
, " %s (%u)",
1131 pctlops
->get_group_name(pctldev
, grp
->group_selector
),
1132 grp
->group_selector
);
1134 seq_printf(s
, " ]");
1136 seq_printf(s
, " users: %u map-> %s\n",
1138 pmx
->dev
? dev_name(pmx
->dev
) : "(system)");
1144 static int pinmux_maps_show(struct seq_file
*s
, void *what
)
1148 seq_puts(s
, "Pinmux maps:\n");
1150 for (i
= 0; i
< pinmux_maps_num
; i
++) {
1151 struct pinmux_map
const *map
= &pinmux_maps
[i
];
1153 seq_printf(s
, "%s:\n", map
->name
);
1154 if (map
->dev
|| map
->dev_name
)
1155 seq_printf(s
, " device: %s\n",
1156 map
->dev
? dev_name(map
->dev
) :
1159 seq_printf(s
, " SYSTEM MUX\n");
1160 seq_printf(s
, " controlling device %s\n",
1161 map
->ctrl_dev
? dev_name(map
->ctrl_dev
) :
1162 map
->ctrl_dev_name
);
1163 seq_printf(s
, " function: %s\n", map
->function
);
1164 seq_printf(s
, " group: %s\n", map
->group
? map
->group
:
1170 static int pinmux_functions_open(struct inode
*inode
, struct file
*file
)
1172 return single_open(file
, pinmux_functions_show
, inode
->i_private
);
1175 static int pinmux_pins_open(struct inode
*inode
, struct file
*file
)
1177 return single_open(file
, pinmux_pins_show
, inode
->i_private
);
1180 static int pinmux_hogs_open(struct inode
*inode
, struct file
*file
)
1182 return single_open(file
, pinmux_hogs_show
, inode
->i_private
);
1185 static int pinmux_open(struct inode
*inode
, struct file
*file
)
1187 return single_open(file
, pinmux_show
, NULL
);
1190 static int pinmux_maps_open(struct inode
*inode
, struct file
*file
)
1192 return single_open(file
, pinmux_maps_show
, NULL
);
1195 static const struct file_operations pinmux_functions_ops
= {
1196 .open
= pinmux_functions_open
,
1198 .llseek
= seq_lseek
,
1199 .release
= single_release
,
1202 static const struct file_operations pinmux_pins_ops
= {
1203 .open
= pinmux_pins_open
,
1205 .llseek
= seq_lseek
,
1206 .release
= single_release
,
1209 static const struct file_operations pinmux_hogs_ops
= {
1210 .open
= pinmux_hogs_open
,
1212 .llseek
= seq_lseek
,
1213 .release
= single_release
,
1216 static const struct file_operations pinmux_ops
= {
1217 .open
= pinmux_open
,
1219 .llseek
= seq_lseek
,
1220 .release
= single_release
,
1223 static const struct file_operations pinmux_maps_ops
= {
1224 .open
= pinmux_maps_open
,
1226 .llseek
= seq_lseek
,
1227 .release
= single_release
,
1230 void pinmux_init_device_debugfs(struct dentry
*devroot
,
1231 struct pinctrl_dev
*pctldev
)
1233 debugfs_create_file("pinmux-functions", S_IFREG
| S_IRUGO
,
1234 devroot
, pctldev
, &pinmux_functions_ops
);
1235 debugfs_create_file("pinmux-pins", S_IFREG
| S_IRUGO
,
1236 devroot
, pctldev
, &pinmux_pins_ops
);
1237 debugfs_create_file("pinmux-hogs", S_IFREG
| S_IRUGO
,
1238 devroot
, pctldev
, &pinmux_hogs_ops
);
1241 void pinmux_init_debugfs(struct dentry
*subsys_root
)
1243 debugfs_create_file("pinmuxes", S_IFREG
| S_IRUGO
,
1244 subsys_root
, NULL
, &pinmux_ops
);
1245 debugfs_create_file("pinmux-maps", S_IFREG
| S_IRUGO
,
1246 subsys_root
, NULL
, &pinmux_maps_ops
);
1249 #endif /* CONFIG_DEBUG_FS */