2 * Core driver for the pin muxing portions of the pin control subsystem
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
8 * Author: Linus Walleij <linus.walleij@linaro.org>
10 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
12 * License terms: GNU General Public License (GPL) version 2
14 #define pr_fmt(fmt) "pinmux core: " fmt
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/device.h>
20 #include <linux/slab.h>
21 #include <linux/radix-tree.h>
22 #include <linux/err.h>
23 #include <linux/list.h>
24 #include <linux/string.h>
25 #include <linux/sysfs.h>
26 #include <linux/debugfs.h>
27 #include <linux/seq_file.h>
28 #include <linux/pinctrl/machine.h>
29 #include <linux/pinctrl/pinmux.h>
33 int pinmux_check_ops(struct pinctrl_dev
*pctldev
)
35 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
37 unsigned selector
= 0;
39 /* Check that we implement required operations */
41 !ops
->get_functions_count
||
42 !ops
->get_function_name
||
43 !ops
->get_function_groups
||
45 dev_err(pctldev
->dev
, "pinmux ops lacks necessary functions\n");
48 /* Check that all functions registered have names */
49 nfuncs
= ops
->get_functions_count(pctldev
);
50 while (selector
< nfuncs
) {
51 const char *fname
= ops
->get_function_name(pctldev
,
54 dev_err(pctldev
->dev
, "pinmux ops has no name for function%u\n",
64 int pinmux_validate_map(struct pinctrl_map
const *map
, int i
)
66 if (!map
->data
.mux
.function
) {
67 pr_err("failed to register map %s (%d): no function given\n",
76 * pin_request() - request a single pin to be muxed in, typically for GPIO
77 * @pin: the pin number in the global pin space
78 * @owner: a representation of the owner of this pin; typically the device
79 * name that controls its mux function, or the requested GPIO name
80 * @gpio_range: the range matching the GPIO pin if this is a request for a
83 static int pin_request(struct pinctrl_dev
*pctldev
,
84 int pin
, const char *owner
,
85 struct pinctrl_gpio_range
*gpio_range
)
87 struct pin_desc
*desc
;
88 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
91 desc
= pin_desc_get(pctldev
, pin
);
94 "pin %d is not registered so it cannot be requested\n",
99 dev_dbg(pctldev
->dev
, "request pin %d (%s) for %s\n",
100 pin
, desc
->name
, owner
);
103 /* There's no need to support multiple GPIO requests */
104 if (desc
->gpio_owner
) {
105 dev_err(pctldev
->dev
,
106 "pin %s already requested by %s; cannot claim for %s\n",
107 desc
->name
, desc
->gpio_owner
, owner
);
111 desc
->gpio_owner
= owner
;
113 if (desc
->mux_usecount
&& strcmp(desc
->mux_owner
, owner
)) {
114 dev_err(pctldev
->dev
,
115 "pin %s already requested by %s; cannot claim for %s\n",
116 desc
->name
, desc
->mux_owner
, owner
);
120 desc
->mux_usecount
++;
121 if (desc
->mux_usecount
> 1)
124 desc
->mux_owner
= owner
;
127 /* Let each pin increase references to this module */
128 if (!try_module_get(pctldev
->owner
)) {
129 dev_err(pctldev
->dev
,
130 "could not increase module refcount for pin %d\n",
137 * If there is no kind of request function for the pin we just assume
138 * we got it by default and proceed.
140 if (gpio_range
&& ops
->gpio_request_enable
)
141 /* This requests and enables a single GPIO pin */
142 status
= ops
->gpio_request_enable(pctldev
, gpio_range
, pin
);
143 else if (ops
->request
)
144 status
= ops
->request(pctldev
, pin
);
149 dev_err(pctldev
->dev
, "request() failed for pin %d\n", pin
);
150 module_put(pctldev
->owner
);
156 desc
->gpio_owner
= NULL
;
158 desc
->mux_usecount
--;
159 if (!desc
->mux_usecount
)
160 desc
->mux_owner
= NULL
;
165 dev_err(pctldev
->dev
, "pin-%d (%s) status %d\n",
172 * pin_free() - release a single muxed in pin so something else can be muxed
173 * @pctldev: pin controller device handling this pin
174 * @pin: the pin to free
175 * @gpio_range: the range matching the GPIO pin if this is a request for a
178 * This function returns a pointer to the previous owner. This is used
179 * for callers that dynamically allocate an owner name so it can be freed
180 * once the pin is free. This is done for GPIO request functions.
182 static const char *pin_free(struct pinctrl_dev
*pctldev
, int pin
,
183 struct pinctrl_gpio_range
*gpio_range
)
185 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
186 struct pin_desc
*desc
;
189 desc
= pin_desc_get(pctldev
, pin
);
191 dev_err(pctldev
->dev
,
192 "pin is not registered so it cannot be freed\n");
197 desc
->mux_usecount
--;
198 if (desc
->mux_usecount
)
203 * If there is no kind of request function for the pin we just assume
204 * we got it by default and proceed.
206 if (gpio_range
&& ops
->gpio_disable_free
)
207 ops
->gpio_disable_free(pctldev
, gpio_range
, pin
);
209 ops
->free(pctldev
, pin
);
212 owner
= desc
->gpio_owner
;
213 desc
->gpio_owner
= NULL
;
215 owner
= desc
->mux_owner
;
216 desc
->mux_owner
= NULL
;
217 desc
->mux_setting
= NULL
;
220 module_put(pctldev
->owner
);
226 * pinmux_request_gpio() - request pinmuxing for a GPIO pin
227 * @pctldev: pin controller device affected
228 * @pin: the pin to mux in for GPIO
229 * @range: the applicable GPIO range
231 int pinmux_request_gpio(struct pinctrl_dev
*pctldev
,
232 struct pinctrl_gpio_range
*range
,
233 unsigned pin
, unsigned gpio
)
238 /* Conjure some name stating what chip and pin this is taken by */
239 owner
= kasprintf(GFP_KERNEL
, "%s:%d", range
->name
, gpio
);
243 ret
= pin_request(pctldev
, pin
, owner
, range
);
251 * pinmux_free_gpio() - release a pin from GPIO muxing
252 * @pctldev: the pin controller device for the pin
253 * @pin: the affected currently GPIO-muxed in pin
254 * @range: applicable GPIO range
256 void pinmux_free_gpio(struct pinctrl_dev
*pctldev
, unsigned pin
,
257 struct pinctrl_gpio_range
*range
)
261 owner
= pin_free(pctldev
, pin
, range
);
266 * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
267 * @pctldev: the pin controller handling this pin
268 * @range: applicable GPIO range
269 * @pin: the affected GPIO pin in this controller
270 * @input: true if we set the pin as input, false for output
272 int pinmux_gpio_direction(struct pinctrl_dev
*pctldev
,
273 struct pinctrl_gpio_range
*range
,
274 unsigned pin
, bool input
)
276 const struct pinmux_ops
*ops
;
279 ops
= pctldev
->desc
->pmxops
;
281 if (ops
->gpio_set_direction
)
282 ret
= ops
->gpio_set_direction(pctldev
, range
, pin
, input
);
289 static int pinmux_func_name_to_selector(struct pinctrl_dev
*pctldev
,
290 const char *function
)
292 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
293 unsigned nfuncs
= ops
->get_functions_count(pctldev
);
294 unsigned selector
= 0;
296 /* See if this pctldev has this function */
297 while (selector
< nfuncs
) {
298 const char *fname
= ops
->get_function_name(pctldev
,
301 if (!strcmp(function
, fname
))
307 pr_err("%s does not support function %s\n",
308 pinctrl_dev_get_name(pctldev
), function
);
312 int pinmux_map_to_setting(struct pinctrl_map
const *map
,
313 struct pinctrl_setting
*setting
)
315 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
316 const struct pinmux_ops
*pmxops
= pctldev
->desc
->pmxops
;
317 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
318 char const * const *groups
;
323 const unsigned *pins
;
327 dev_err(pctldev
->dev
, "does not support mux function\n");
331 ret
= pinmux_func_name_to_selector(pctldev
, map
->data
.mux
.function
);
333 dev_err(pctldev
->dev
, "invalid function %s in map table\n",
334 map
->data
.mux
.function
);
337 setting
->data
.mux
.func
= ret
;
339 ret
= pmxops
->get_function_groups(pctldev
, setting
->data
.mux
.func
,
340 &groups
, &num_groups
);
342 dev_err(pctldev
->dev
, "can't query groups for function %s\n",
343 map
->data
.mux
.function
);
347 dev_err(pctldev
->dev
,
348 "function %s can't be selected on any group\n",
349 map
->data
.mux
.function
);
352 if (map
->data
.mux
.group
) {
354 group
= map
->data
.mux
.group
;
355 for (i
= 0; i
< num_groups
; i
++) {
356 if (!strcmp(group
, groups
[i
])) {
362 dev_err(pctldev
->dev
,
363 "invalid group \"%s\" for function \"%s\"\n",
364 group
, map
->data
.mux
.function
);
371 ret
= pinctrl_get_group_selector(pctldev
, group
);
373 dev_err(pctldev
->dev
, "invalid group %s in map table\n",
374 map
->data
.mux
.group
);
377 setting
->data
.mux
.group
= ret
;
379 ret
= pctlops
->get_group_pins(pctldev
, setting
->data
.mux
.group
, &pins
,
382 dev_err(pctldev
->dev
,
383 "could not get pins for device %s group selector %d\n",
384 pinctrl_dev_get_name(pctldev
), setting
->data
.mux
.group
);
388 /* Try to allocate all pins in this group, one by one */
389 for (i
= 0; i
< num_pins
; i
++) {
390 ret
= pin_request(pctldev
, pins
[i
], map
->dev_name
, NULL
);
392 dev_err(pctldev
->dev
,
393 "could not request pin %d on device %s\n",
394 pins
[i
], pinctrl_dev_get_name(pctldev
));
395 /* On error release all taken pins */
396 i
--; /* this pin just failed */
398 pin_free(pctldev
, pins
[i
], NULL
);
406 void pinmux_free_setting(struct pinctrl_setting
const *setting
)
408 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
409 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
410 const unsigned *pins
;
415 ret
= pctlops
->get_group_pins(pctldev
, setting
->data
.mux
.group
,
418 dev_err(pctldev
->dev
,
419 "could not get pins for device %s group selector %d\n",
420 pinctrl_dev_get_name(pctldev
), setting
->data
.mux
.group
);
424 for (i
= 0; i
< num_pins
; i
++)
425 pin_free(pctldev
, pins
[i
], NULL
);
428 int pinmux_enable_setting(struct pinctrl_setting
const *setting
)
430 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
431 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
432 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
434 const unsigned *pins
;
437 struct pin_desc
*desc
;
439 ret
= pctlops
->get_group_pins(pctldev
, setting
->data
.mux
.group
,
442 /* errors only affect debug data, so just warn */
443 dev_warn(pctldev
->dev
,
444 "could not get pins for group selector %d\n",
445 setting
->data
.mux
.group
);
449 for (i
= 0; i
< num_pins
; i
++) {
450 desc
= pin_desc_get(pctldev
, pins
[i
]);
452 dev_warn(pctldev
->dev
,
453 "could not get pin desc for pin %d\n",
457 desc
->mux_setting
= &(setting
->data
.mux
);
460 return ops
->enable(pctldev
, setting
->data
.mux
.func
,
461 setting
->data
.mux
.group
);
464 void pinmux_disable_setting(struct pinctrl_setting
const *setting
)
466 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
467 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
468 const struct pinmux_ops
*ops
= pctldev
->desc
->pmxops
;
470 const unsigned *pins
;
473 struct pin_desc
*desc
;
475 ret
= pctlops
->get_group_pins(pctldev
, setting
->data
.mux
.group
,
478 /* errors only affect debug data, so just warn */
479 dev_warn(pctldev
->dev
,
480 "could not get pins for group selector %d\n",
481 setting
->data
.mux
.group
);
485 for (i
= 0; i
< num_pins
; i
++) {
486 desc
= pin_desc_get(pctldev
, pins
[i
]);
488 dev_warn(pctldev
->dev
,
489 "could not get pin desc for pin %d\n",
493 desc
->mux_setting
= NULL
;
497 ops
->disable(pctldev
, setting
->data
.mux
.func
, setting
->data
.mux
.group
);
500 #ifdef CONFIG_DEBUG_FS
502 /* Called from pincontrol core */
503 static int pinmux_functions_show(struct seq_file
*s
, void *what
)
505 struct pinctrl_dev
*pctldev
= s
->private;
506 const struct pinmux_ops
*pmxops
= pctldev
->desc
->pmxops
;
508 unsigned func_selector
= 0;
513 mutex_lock(&pinctrl_mutex
);
514 nfuncs
= pmxops
->get_functions_count(pctldev
);
515 while (func_selector
< nfuncs
) {
516 const char *func
= pmxops
->get_function_name(pctldev
,
518 const char * const *groups
;
523 ret
= pmxops
->get_function_groups(pctldev
, func_selector
,
524 &groups
, &num_groups
);
526 seq_printf(s
, "function %s: COULD NOT GET GROUPS\n",
529 seq_printf(s
, "function: %s, groups = [ ", func
);
530 for (i
= 0; i
< num_groups
; i
++)
531 seq_printf(s
, "%s ", groups
[i
]);
537 mutex_unlock(&pinctrl_mutex
);
542 static int pinmux_pins_show(struct seq_file
*s
, void *what
)
544 struct pinctrl_dev
*pctldev
= s
->private;
545 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
546 const struct pinmux_ops
*pmxops
= pctldev
->desc
->pmxops
;
552 seq_puts(s
, "Pinmux settings per pin\n");
553 seq_puts(s
, "Format: pin (name): mux_owner gpio_owner hog?\n");
555 mutex_lock(&pinctrl_mutex
);
557 /* The pin number can be retrived from the pin controller descriptor */
558 for (i
= 0; i
< pctldev
->desc
->npins
; i
++) {
559 struct pin_desc
*desc
;
562 pin
= pctldev
->desc
->pins
[i
].number
;
563 desc
= pin_desc_get(pctldev
, pin
);
564 /* Skip if we cannot search the pin */
568 if (desc
->mux_owner
&&
569 !strcmp(desc
->mux_owner
, pinctrl_dev_get_name(pctldev
)))
572 seq_printf(s
, "pin %d (%s): %s %s%s", pin
,
573 desc
->name
? desc
->name
: "unnamed",
574 desc
->mux_owner
? desc
->mux_owner
576 desc
->gpio_owner
? desc
->gpio_owner
577 : "(GPIO UNCLAIMED)",
578 is_hog
? " (HOG)" : "");
580 if (desc
->mux_setting
)
581 seq_printf(s
, " function %s group %s\n",
582 pmxops
->get_function_name(pctldev
,
583 desc
->mux_setting
->func
),
584 pctlops
->get_group_name(pctldev
,
585 desc
->mux_setting
->group
));
590 mutex_unlock(&pinctrl_mutex
);
595 void pinmux_show_map(struct seq_file
*s
, struct pinctrl_map
const *map
)
597 seq_printf(s
, "group %s\nfunction %s\n",
598 map
->data
.mux
.group
? map
->data
.mux
.group
: "(default)",
599 map
->data
.mux
.function
);
602 void pinmux_show_setting(struct seq_file
*s
,
603 struct pinctrl_setting
const *setting
)
605 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
606 const struct pinmux_ops
*pmxops
= pctldev
->desc
->pmxops
;
607 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
609 seq_printf(s
, "group: %s (%u) function: %s (%u)\n",
610 pctlops
->get_group_name(pctldev
, setting
->data
.mux
.group
),
611 setting
->data
.mux
.group
,
612 pmxops
->get_function_name(pctldev
, setting
->data
.mux
.func
),
613 setting
->data
.mux
.func
);
616 static int pinmux_functions_open(struct inode
*inode
, struct file
*file
)
618 return single_open(file
, pinmux_functions_show
, inode
->i_private
);
621 static int pinmux_pins_open(struct inode
*inode
, struct file
*file
)
623 return single_open(file
, pinmux_pins_show
, inode
->i_private
);
626 static const struct file_operations pinmux_functions_ops
= {
627 .open
= pinmux_functions_open
,
630 .release
= single_release
,
633 static const struct file_operations pinmux_pins_ops
= {
634 .open
= pinmux_pins_open
,
637 .release
= single_release
,
640 void pinmux_init_device_debugfs(struct dentry
*devroot
,
641 struct pinctrl_dev
*pctldev
)
643 debugfs_create_file("pinmux-functions", S_IFREG
| S_IRUGO
,
644 devroot
, pctldev
, &pinmux_functions_ops
);
645 debugfs_create_file("pinmux-pins", S_IFREG
| S_IRUGO
,
646 devroot
, pctldev
, &pinmux_pins_ops
);
649 #endif /* CONFIG_DEBUG_FS */