2 * Core driver for the pin config portions of the pin control subsystem
4 * Copyright (C) 2011 ST-Ericsson SA
5 * Written on behalf of Linaro for ST-Ericsson
7 * Author: Linus Walleij <linus.walleij@linaro.org>
9 * License terms: GNU General Public License (GPL) version 2
11 #define pr_fmt(fmt) "pinconfig core: " fmt
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/device.h>
17 #include <linux/slab.h>
18 #include <linux/debugfs.h>
19 #include <linux/seq_file.h>
20 #include <linux/pinctrl/machine.h>
21 #include <linux/pinctrl/pinctrl.h>
22 #include <linux/pinctrl/pinconf.h>
26 int pinconf_check_ops(struct pinctrl_dev
*pctldev
)
28 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
30 /* We must be able to read out pin status */
31 if (!ops
->pin_config_get
&& !ops
->pin_config_group_get
)
33 /* We have to be able to config the pins in SOME way */
34 if (!ops
->pin_config_set
&& !ops
->pin_config_group_set
)
39 int pinconf_validate_map(struct pinctrl_map
const *map
, int i
)
41 if (!map
->data
.configs
.group_or_pin
) {
42 pr_err("failed to register map %s (%d): no group/pin given\n",
47 if (map
->data
.configs
.num_configs
&&
48 !map
->data
.configs
.configs
) {
49 pr_err("failed to register map %s (%d): no configs ptr given\n",
57 int pin_config_get_for_pin(struct pinctrl_dev
*pctldev
, unsigned pin
,
58 unsigned long *config
)
60 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
62 if (!ops
|| !ops
->pin_config_get
) {
63 dev_err(pctldev
->dev
, "cannot get pin configuration, missing "
64 "pin_config_get() function in driver\n");
68 return ops
->pin_config_get(pctldev
, pin
, config
);
72 * pin_config_get() - get the configuration of a single pin parameter
73 * @dev_name: name of the pin controller device for this pin
74 * @name: name of the pin to get the config for
75 * @config: the config pointed to by this argument will be filled in with the
76 * current pin state, it can be used directly by drivers as a numeral, or
77 * it can be dereferenced to any struct.
79 int pin_config_get(const char *dev_name
, const char *name
,
80 unsigned long *config
)
82 struct pinctrl_dev
*pctldev
;
85 mutex_lock(&pinctrl_mutex
);
87 pctldev
= get_pinctrl_dev_from_devname(dev_name
);
93 pin
= pin_get_from_name(pctldev
, name
);
97 pin
= pin_config_get_for_pin(pctldev
, pin
, config
);
100 mutex_unlock(&pinctrl_mutex
);
103 EXPORT_SYMBOL(pin_config_get
);
105 static int pin_config_set_for_pin(struct pinctrl_dev
*pctldev
, unsigned pin
,
106 unsigned long config
)
108 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
111 if (!ops
|| !ops
->pin_config_set
) {
112 dev_err(pctldev
->dev
, "cannot configure pin, missing "
113 "config function in driver\n");
117 ret
= ops
->pin_config_set(pctldev
, pin
, config
);
119 dev_err(pctldev
->dev
,
120 "unable to set pin configuration on pin %d\n", pin
);
128 * pin_config_set() - set the configuration of a single pin parameter
129 * @dev_name: name of pin controller device for this pin
130 * @name: name of the pin to set the config for
131 * @config: the config in this argument will contain the desired pin state, it
132 * can be used directly by drivers as a numeral, or it can be dereferenced
135 int pin_config_set(const char *dev_name
, const char *name
,
136 unsigned long config
)
138 struct pinctrl_dev
*pctldev
;
141 mutex_lock(&pinctrl_mutex
);
143 pctldev
= get_pinctrl_dev_from_devname(dev_name
);
149 pin
= pin_get_from_name(pctldev
, name
);
155 ret
= pin_config_set_for_pin(pctldev
, pin
, config
);
158 mutex_unlock(&pinctrl_mutex
);
161 EXPORT_SYMBOL(pin_config_set
);
163 int pin_config_group_get(const char *dev_name
, const char *pin_group
,
164 unsigned long *config
)
166 struct pinctrl_dev
*pctldev
;
167 const struct pinconf_ops
*ops
;
170 mutex_lock(&pinctrl_mutex
);
172 pctldev
= get_pinctrl_dev_from_devname(dev_name
);
177 ops
= pctldev
->desc
->confops
;
179 if (!ops
|| !ops
->pin_config_group_get
) {
180 dev_err(pctldev
->dev
, "cannot get configuration for pin "
181 "group, missing group config get function in "
187 selector
= pinctrl_get_group_selector(pctldev
, pin_group
);
193 ret
= ops
->pin_config_group_get(pctldev
, selector
, config
);
196 mutex_unlock(&pinctrl_mutex
);
199 EXPORT_SYMBOL(pin_config_group_get
);
201 int pin_config_group_set(const char *dev_name
, const char *pin_group
,
202 unsigned long config
)
204 struct pinctrl_dev
*pctldev
;
205 const struct pinconf_ops
*ops
;
206 const struct pinctrl_ops
*pctlops
;
208 const unsigned *pins
;
213 mutex_lock(&pinctrl_mutex
);
215 pctldev
= get_pinctrl_dev_from_devname(dev_name
);
220 ops
= pctldev
->desc
->confops
;
221 pctlops
= pctldev
->desc
->pctlops
;
223 if (!ops
|| (!ops
->pin_config_group_set
&& !ops
->pin_config_set
)) {
224 dev_err(pctldev
->dev
, "cannot configure pin group, missing "
225 "config function in driver\n");
230 selector
= pinctrl_get_group_selector(pctldev
, pin_group
);
236 ret
= pctlops
->get_group_pins(pctldev
, selector
, &pins
, &num_pins
);
238 dev_err(pctldev
->dev
, "cannot configure pin group, error "
244 * If the pin controller supports handling entire groups we use that
247 if (ops
->pin_config_group_set
) {
248 ret
= ops
->pin_config_group_set(pctldev
, selector
, config
);
250 * If the pin controller prefer that a certain group be handled
251 * pin-by-pin as well, it returns -EAGAIN.
258 * If the controller cannot handle entire groups, we configure each pin
261 if (!ops
->pin_config_set
) {
266 for (i
= 0; i
< num_pins
; i
++) {
267 ret
= ops
->pin_config_set(pctldev
, pins
[i
], config
);
275 mutex_unlock(&pinctrl_mutex
);
279 EXPORT_SYMBOL(pin_config_group_set
);
281 int pinconf_map_to_setting(struct pinctrl_map
const *map
,
282 struct pinctrl_setting
*setting
)
284 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
287 switch (setting
->type
) {
288 case PIN_MAP_TYPE_CONFIGS_PIN
:
289 pin
= pin_get_from_name(pctldev
,
290 map
->data
.configs
.group_or_pin
);
292 dev_err(pctldev
->dev
, "could not map pin config for \"%s\"",
293 map
->data
.configs
.group_or_pin
);
296 setting
->data
.configs
.group_or_pin
= pin
;
298 case PIN_MAP_TYPE_CONFIGS_GROUP
:
299 pin
= pinctrl_get_group_selector(pctldev
,
300 map
->data
.configs
.group_or_pin
);
302 dev_err(pctldev
->dev
, "could not map group config for \"%s\"",
303 map
->data
.configs
.group_or_pin
);
306 setting
->data
.configs
.group_or_pin
= pin
;
312 setting
->data
.configs
.num_configs
= map
->data
.configs
.num_configs
;
313 setting
->data
.configs
.configs
= map
->data
.configs
.configs
;
318 void pinconf_free_setting(struct pinctrl_setting
const *setting
)
322 int pinconf_apply_setting(struct pinctrl_setting
const *setting
)
324 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
325 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
329 dev_err(pctldev
->dev
, "missing confops\n");
333 switch (setting
->type
) {
334 case PIN_MAP_TYPE_CONFIGS_PIN
:
335 if (!ops
->pin_config_set
) {
336 dev_err(pctldev
->dev
, "missing pin_config_set op\n");
339 for (i
= 0; i
< setting
->data
.configs
.num_configs
; i
++) {
340 ret
= ops
->pin_config_set(pctldev
,
341 setting
->data
.configs
.group_or_pin
,
342 setting
->data
.configs
.configs
[i
]);
344 dev_err(pctldev
->dev
,
345 "pin_config_set op failed for pin %d config %08lx\n",
346 setting
->data
.configs
.group_or_pin
,
347 setting
->data
.configs
.configs
[i
]);
352 case PIN_MAP_TYPE_CONFIGS_GROUP
:
353 if (!ops
->pin_config_group_set
) {
354 dev_err(pctldev
->dev
,
355 "missing pin_config_group_set op\n");
358 for (i
= 0; i
< setting
->data
.configs
.num_configs
; i
++) {
359 ret
= ops
->pin_config_group_set(pctldev
,
360 setting
->data
.configs
.group_or_pin
,
361 setting
->data
.configs
.configs
[i
]);
363 dev_err(pctldev
->dev
,
364 "pin_config_group_set op failed for group %d config %08lx\n",
365 setting
->data
.configs
.group_or_pin
,
366 setting
->data
.configs
.configs
[i
]);
378 #ifdef CONFIG_DEBUG_FS
380 void pinconf_show_map(struct seq_file
*s
, struct pinctrl_map
const *map
)
382 struct pinctrl_dev
*pctldev
;
383 const struct pinconf_ops
*confops
;
386 pctldev
= get_pinctrl_dev_from_devname(map
->ctrl_dev_name
);
388 confops
= pctldev
->desc
->confops
;
393 case PIN_MAP_TYPE_CONFIGS_PIN
:
394 seq_printf(s
, "pin ");
396 case PIN_MAP_TYPE_CONFIGS_GROUP
:
397 seq_printf(s
, "group ");
403 seq_printf(s
, "%s\n", map
->data
.configs
.group_or_pin
);
405 for (i
= 0; i
< map
->data
.configs
.num_configs
; i
++) {
406 seq_printf(s
, "config ");
407 if (confops
&& confops
->pin_config_config_dbg_show
)
408 confops
->pin_config_config_dbg_show(pctldev
, s
,
409 map
->data
.configs
.configs
[i
]);
411 seq_printf(s
, "%08lx", map
->data
.configs
.configs
[i
]);
416 void pinconf_show_setting(struct seq_file
*s
,
417 struct pinctrl_setting
const *setting
)
419 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
420 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
421 const struct pinconf_ops
*confops
= pctldev
->desc
->confops
;
422 struct pin_desc
*desc
;
425 switch (setting
->type
) {
426 case PIN_MAP_TYPE_CONFIGS_PIN
:
427 desc
= pin_desc_get(setting
->pctldev
,
428 setting
->data
.configs
.group_or_pin
);
429 seq_printf(s
, "pin %s (%d)",
430 desc
->name
? desc
->name
: "unnamed",
431 setting
->data
.configs
.group_or_pin
);
433 case PIN_MAP_TYPE_CONFIGS_GROUP
:
434 seq_printf(s
, "group %s (%d)",
435 pctlops
->get_group_name(pctldev
,
436 setting
->data
.configs
.group_or_pin
),
437 setting
->data
.configs
.group_or_pin
);
444 * FIXME: We should really get the pin controler to dump the config
445 * values, so they can be decoded to something meaningful.
447 for (i
= 0; i
< setting
->data
.configs
.num_configs
; i
++) {
449 if (confops
&& confops
->pin_config_config_dbg_show
)
450 confops
->pin_config_config_dbg_show(pctldev
, s
,
451 setting
->data
.configs
.configs
[i
]);
453 seq_printf(s
, "%08lx",
454 setting
->data
.configs
.configs
[i
]);
460 static void pinconf_dump_pin(struct pinctrl_dev
*pctldev
,
461 struct seq_file
*s
, int pin
)
463 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
465 /* no-op when not using generic pin config */
466 pinconf_generic_dump_pin(pctldev
, s
, pin
);
467 if (ops
&& ops
->pin_config_dbg_show
)
468 ops
->pin_config_dbg_show(pctldev
, s
, pin
);
471 static int pinconf_pins_show(struct seq_file
*s
, void *what
)
473 struct pinctrl_dev
*pctldev
= s
->private;
474 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
477 if (!ops
|| !ops
->pin_config_get
)
480 seq_puts(s
, "Pin config settings per pin\n");
481 seq_puts(s
, "Format: pin (name): configs\n");
483 mutex_lock(&pinctrl_mutex
);
485 /* The pin number can be retrived from the pin controller descriptor */
486 for (i
= 0; i
< pctldev
->desc
->npins
; i
++) {
487 struct pin_desc
*desc
;
489 pin
= pctldev
->desc
->pins
[i
].number
;
490 desc
= pin_desc_get(pctldev
, pin
);
491 /* Skip if we cannot search the pin */
495 seq_printf(s
, "pin %d (%s):", pin
,
496 desc
->name
? desc
->name
: "unnamed");
498 pinconf_dump_pin(pctldev
, s
, pin
);
503 mutex_unlock(&pinctrl_mutex
);
508 static void pinconf_dump_group(struct pinctrl_dev
*pctldev
,
509 struct seq_file
*s
, unsigned selector
,
512 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
514 /* no-op when not using generic pin config */
515 pinconf_generic_dump_group(pctldev
, s
, gname
);
516 if (ops
&& ops
->pin_config_group_dbg_show
)
517 ops
->pin_config_group_dbg_show(pctldev
, s
, selector
);
520 static int pinconf_groups_show(struct seq_file
*s
, void *what
)
522 struct pinctrl_dev
*pctldev
= s
->private;
523 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
524 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
525 unsigned ngroups
= pctlops
->get_groups_count(pctldev
);
526 unsigned selector
= 0;
528 if (!ops
|| !ops
->pin_config_group_get
)
531 seq_puts(s
, "Pin config settings per pin group\n");
532 seq_puts(s
, "Format: group (name): configs\n");
534 mutex_lock(&pinctrl_mutex
);
536 while (selector
< ngroups
) {
537 const char *gname
= pctlops
->get_group_name(pctldev
, selector
);
539 seq_printf(s
, "%u (%s):", selector
, gname
);
540 pinconf_dump_group(pctldev
, s
, selector
, gname
);
546 mutex_unlock(&pinctrl_mutex
);
551 static int pinconf_pins_open(struct inode
*inode
, struct file
*file
)
553 return single_open(file
, pinconf_pins_show
, inode
->i_private
);
556 static int pinconf_groups_open(struct inode
*inode
, struct file
*file
)
558 return single_open(file
, pinconf_groups_show
, inode
->i_private
);
561 static const struct file_operations pinconf_pins_ops
= {
562 .open
= pinconf_pins_open
,
565 .release
= single_release
,
568 static const struct file_operations pinconf_groups_ops
= {
569 .open
= pinconf_groups_open
,
572 .release
= single_release
,
575 void pinconf_init_device_debugfs(struct dentry
*devroot
,
576 struct pinctrl_dev
*pctldev
)
578 debugfs_create_file("pinconf-pins", S_IFREG
| S_IRUGO
,
579 devroot
, pctldev
, &pinconf_pins_ops
);
580 debugfs_create_file("pinconf-groups", S_IFREG
| S_IRUGO
,
581 devroot
, pctldev
, &pinconf_groups_ops
);