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 static 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
;
286 switch (setting
->type
) {
287 case PIN_MAP_TYPE_CONFIGS_PIN
:
288 setting
->data
.configs
.group_or_pin
=
289 pin_get_from_name(pctldev
,
290 map
->data
.configs
.group_or_pin
);
291 if (setting
->data
.configs
.group_or_pin
< 0)
292 return setting
->data
.configs
.group_or_pin
;
294 case PIN_MAP_TYPE_CONFIGS_GROUP
:
295 setting
->data
.configs
.group_or_pin
=
296 pinctrl_get_group_selector(pctldev
,
297 map
->data
.configs
.group_or_pin
);
298 if (setting
->data
.configs
.group_or_pin
< 0)
299 return setting
->data
.configs
.group_or_pin
;
305 setting
->data
.configs
.num_configs
= map
->data
.configs
.num_configs
;
306 setting
->data
.configs
.configs
= map
->data
.configs
.configs
;
311 void pinconf_free_setting(struct pinctrl_setting
const *setting
)
315 int pinconf_apply_setting(struct pinctrl_setting
const *setting
)
317 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
318 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
322 dev_err(pctldev
->dev
, "missing confops\n");
326 switch (setting
->type
) {
327 case PIN_MAP_TYPE_CONFIGS_PIN
:
328 if (!ops
->pin_config_set
) {
329 dev_err(pctldev
->dev
, "missing pin_config_set op\n");
332 for (i
= 0; i
< setting
->data
.configs
.num_configs
; i
++) {
333 ret
= ops
->pin_config_set(pctldev
,
334 setting
->data
.configs
.group_or_pin
,
335 setting
->data
.configs
.configs
[i
]);
337 dev_err(pctldev
->dev
,
338 "pin_config_set op failed for pin %d config %08lx\n",
339 setting
->data
.configs
.group_or_pin
,
340 setting
->data
.configs
.configs
[i
]);
345 case PIN_MAP_TYPE_CONFIGS_GROUP
:
346 if (!ops
->pin_config_group_set
) {
347 dev_err(pctldev
->dev
,
348 "missing pin_config_group_set op\n");
351 for (i
= 0; i
< setting
->data
.configs
.num_configs
; i
++) {
352 ret
= ops
->pin_config_group_set(pctldev
,
353 setting
->data
.configs
.group_or_pin
,
354 setting
->data
.configs
.configs
[i
]);
356 dev_err(pctldev
->dev
,
357 "pin_config_group_set op failed for group %d config %08lx\n",
358 setting
->data
.configs
.group_or_pin
,
359 setting
->data
.configs
.configs
[i
]);
371 #ifdef CONFIG_DEBUG_FS
373 void pinconf_show_map(struct seq_file
*s
, struct pinctrl_map
const *map
)
378 case PIN_MAP_TYPE_CONFIGS_PIN
:
379 seq_printf(s
, "pin ");
381 case PIN_MAP_TYPE_CONFIGS_GROUP
:
382 seq_printf(s
, "group ");
388 seq_printf(s
, "%s\n", map
->data
.configs
.group_or_pin
);
390 for (i
= 0; i
< map
->data
.configs
.num_configs
; i
++)
391 seq_printf(s
, "config %08lx\n", map
->data
.configs
.configs
[i
]);
394 void pinconf_show_setting(struct seq_file
*s
,
395 struct pinctrl_setting
const *setting
)
397 struct pinctrl_dev
*pctldev
= setting
->pctldev
;
398 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
399 struct pin_desc
*desc
;
402 switch (setting
->type
) {
403 case PIN_MAP_TYPE_CONFIGS_PIN
:
404 desc
= pin_desc_get(setting
->pctldev
,
405 setting
->data
.configs
.group_or_pin
);
406 seq_printf(s
, "pin %s (%d)",
407 desc
->name
? desc
->name
: "unnamed",
408 setting
->data
.configs
.group_or_pin
);
410 case PIN_MAP_TYPE_CONFIGS_GROUP
:
411 seq_printf(s
, "group %s (%d)",
412 pctlops
->get_group_name(pctldev
,
413 setting
->data
.configs
.group_or_pin
),
414 setting
->data
.configs
.group_or_pin
);
421 * FIXME: We should really get the pin controler to dump the config
422 * values, so they can be decoded to something meaningful.
424 for (i
= 0; i
< setting
->data
.configs
.num_configs
; i
++)
425 seq_printf(s
, " %08lx", setting
->data
.configs
.configs
[i
]);
430 static void pinconf_dump_pin(struct pinctrl_dev
*pctldev
,
431 struct seq_file
*s
, int pin
)
433 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
435 if (ops
&& ops
->pin_config_dbg_show
)
436 ops
->pin_config_dbg_show(pctldev
, s
, pin
);
439 static int pinconf_pins_show(struct seq_file
*s
, void *what
)
441 struct pinctrl_dev
*pctldev
= s
->private;
444 seq_puts(s
, "Pin config settings per pin\n");
445 seq_puts(s
, "Format: pin (name): pinmux setting array\n");
447 mutex_lock(&pinctrl_mutex
);
449 /* The pin number can be retrived from the pin controller descriptor */
450 for (i
= 0; i
< pctldev
->desc
->npins
; i
++) {
451 struct pin_desc
*desc
;
453 pin
= pctldev
->desc
->pins
[i
].number
;
454 desc
= pin_desc_get(pctldev
, pin
);
455 /* Skip if we cannot search the pin */
459 seq_printf(s
, "pin %d (%s):", pin
,
460 desc
->name
? desc
->name
: "unnamed");
462 pinconf_dump_pin(pctldev
, s
, pin
);
467 mutex_unlock(&pinctrl_mutex
);
472 static void pinconf_dump_group(struct pinctrl_dev
*pctldev
,
473 struct seq_file
*s
, unsigned selector
,
476 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
478 if (ops
&& ops
->pin_config_group_dbg_show
)
479 ops
->pin_config_group_dbg_show(pctldev
, s
, selector
);
482 static int pinconf_groups_show(struct seq_file
*s
, void *what
)
484 struct pinctrl_dev
*pctldev
= s
->private;
485 const struct pinctrl_ops
*pctlops
= pctldev
->desc
->pctlops
;
486 const struct pinconf_ops
*ops
= pctldev
->desc
->confops
;
487 unsigned selector
= 0;
489 if (!ops
|| !ops
->pin_config_group_get
)
492 seq_puts(s
, "Pin config settings per pin group\n");
493 seq_puts(s
, "Format: group (name): pinmux setting array\n");
495 mutex_lock(&pinctrl_mutex
);
497 while (pctlops
->list_groups(pctldev
, selector
) >= 0) {
498 const char *gname
= pctlops
->get_group_name(pctldev
, selector
);
500 seq_printf(s
, "%u (%s):", selector
, gname
);
501 pinconf_dump_group(pctldev
, s
, selector
, gname
);
507 mutex_unlock(&pinctrl_mutex
);
512 static int pinconf_pins_open(struct inode
*inode
, struct file
*file
)
514 return single_open(file
, pinconf_pins_show
, inode
->i_private
);
517 static int pinconf_groups_open(struct inode
*inode
, struct file
*file
)
519 return single_open(file
, pinconf_groups_show
, inode
->i_private
);
522 static const struct file_operations pinconf_pins_ops
= {
523 .open
= pinconf_pins_open
,
526 .release
= single_release
,
529 static const struct file_operations pinconf_groups_ops
= {
530 .open
= pinconf_groups_open
,
533 .release
= single_release
,
536 void pinconf_init_device_debugfs(struct dentry
*devroot
,
537 struct pinctrl_dev
*pctldev
)
539 debugfs_create_file("pinconf-pins", S_IFREG
| S_IRUGO
,
540 devroot
, pctldev
, &pinconf_pins_ops
);
541 debugfs_create_file("pinconf-groups", S_IFREG
| S_IRUGO
,
542 devroot
, pctldev
, &pinconf_groups_ops
);