blob: 43f474cdc11082717c881b757c6bcaf104bcbb97 [file] [log] [blame]
Linus Walleijae6b4d82011-10-19 18:14:33 +02001/*
2 * Core driver for the pin config portions of the pin control subsystem
3 *
4 * Copyright (C) 2011 ST-Ericsson SA
5 * Written on behalf of Linaro for ST-Ericsson
6 *
7 * Author: Linus Walleij <linus.walleij@linaro.org>
8 *
9 * License terms: GNU General Public License (GPL) version 2
10 */
11#define pr_fmt(fmt) "pinconfig core: " fmt
12
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>
23#include "core.h"
24#include "pinconf.h"
25
Stephen Warren2b694252012-02-19 23:45:46 -070026int pinconf_check_ops(struct pinctrl_dev *pctldev)
27{
28 const struct pinconf_ops *ops = pctldev->desc->confops;
29
30 /* We must be able to read out pin status */
John Crispinad6e1102012-04-26 16:47:11 +020031 if (!ops->pin_config_get && !ops->pin_config_group_get) {
32 dev_err(pctldev->dev,
33 "pinconf must be able to read out pin status\n");
Stephen Warren2b694252012-02-19 23:45:46 -070034 return -EINVAL;
John Crispinad6e1102012-04-26 16:47:11 +020035 }
Stephen Warren2b694252012-02-19 23:45:46 -070036 /* We have to be able to config the pins in SOME way */
John Crispinad6e1102012-04-26 16:47:11 +020037 if (!ops->pin_config_set && !ops->pin_config_group_set) {
38 dev_err(pctldev->dev,
39 "pinconf has to be able to set a pins config\n");
Stephen Warren2b694252012-02-19 23:45:46 -070040 return -EINVAL;
John Crispinad6e1102012-04-26 16:47:11 +020041 }
Stephen Warren2b694252012-02-19 23:45:46 -070042 return 0;
43}
44
Stephen Warren1e2082b2012-03-02 13:05:48 -070045int pinconf_validate_map(struct pinctrl_map const *map, int i)
46{
47 if (!map->data.configs.group_or_pin) {
48 pr_err("failed to register map %s (%d): no group/pin given\n",
49 map->name, i);
50 return -EINVAL;
51 }
52
Dong Aishengc95df2d2012-05-14 19:06:36 +080053 if (!map->data.configs.num_configs ||
Stephen Warren1e2082b2012-03-02 13:05:48 -070054 !map->data.configs.configs) {
Dong Aishengc95df2d2012-05-14 19:06:36 +080055 pr_err("failed to register map %s (%d): no configs given\n",
Stephen Warren1e2082b2012-03-02 13:05:48 -070056 map->name, i);
57 return -EINVAL;
58 }
59
60 return 0;
61}
62
Linus Walleij394349f2011-11-24 18:27:15 +010063int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
Linus Walleijae6b4d82011-10-19 18:14:33 +020064 unsigned long *config)
65{
66 const struct pinconf_ops *ops = pctldev->desc->confops;
67
68 if (!ops || !ops->pin_config_get) {
Stephen Warren51cd24e2011-12-09 16:59:05 -070069 dev_err(pctldev->dev, "cannot get pin configuration, missing "
Linus Walleijae6b4d82011-10-19 18:14:33 +020070 "pin_config_get() function in driver\n");
71 return -EINVAL;
72 }
73
74 return ops->pin_config_get(pctldev, pin, config);
75}
76
77/**
78 * pin_config_get() - get the configuration of a single pin parameter
Stephen Warren43699de2011-12-15 16:57:17 -070079 * @dev_name: name of the pin controller device for this pin
Linus Walleijae6b4d82011-10-19 18:14:33 +020080 * @name: name of the pin to get the config for
81 * @config: the config pointed to by this argument will be filled in with the
82 * current pin state, it can be used directly by drivers as a numeral, or
83 * it can be dereferenced to any struct.
84 */
Stephen Warren43699de2011-12-15 16:57:17 -070085int pin_config_get(const char *dev_name, const char *name,
Linus Walleijae6b4d82011-10-19 18:14:33 +020086 unsigned long *config)
87{
Stephen Warren43699de2011-12-15 16:57:17 -070088 struct pinctrl_dev *pctldev;
Linus Walleijae6b4d82011-10-19 18:14:33 +020089 int pin;
90
Stephen Warren57b676f2012-03-02 13:05:44 -070091 mutex_lock(&pinctrl_mutex);
92
Linus Walleij9dfac4f2012-02-01 18:02:47 +010093 pctldev = get_pinctrl_dev_from_devname(dev_name);
Stephen Warren57b676f2012-03-02 13:05:44 -070094 if (!pctldev) {
95 pin = -EINVAL;
96 goto unlock;
97 }
Stephen Warren43699de2011-12-15 16:57:17 -070098
Linus Walleijae6b4d82011-10-19 18:14:33 +020099 pin = pin_get_from_name(pctldev, name);
100 if (pin < 0)
Stephen Warren57b676f2012-03-02 13:05:44 -0700101 goto unlock;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200102
Stephen Warren57b676f2012-03-02 13:05:44 -0700103 pin = pin_config_get_for_pin(pctldev, pin, config);
104
105unlock:
106 mutex_unlock(&pinctrl_mutex);
107 return pin;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200108}
109EXPORT_SYMBOL(pin_config_get);
110
Stephen Warren2b694252012-02-19 23:45:46 -0700111static int pin_config_set_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
Linus Walleijae6b4d82011-10-19 18:14:33 +0200112 unsigned long config)
113{
114 const struct pinconf_ops *ops = pctldev->desc->confops;
115 int ret;
116
117 if (!ops || !ops->pin_config_set) {
Stephen Warren51cd24e2011-12-09 16:59:05 -0700118 dev_err(pctldev->dev, "cannot configure pin, missing "
Linus Walleijae6b4d82011-10-19 18:14:33 +0200119 "config function in driver\n");
120 return -EINVAL;
121 }
122
123 ret = ops->pin_config_set(pctldev, pin, config);
124 if (ret) {
Stephen Warren51cd24e2011-12-09 16:59:05 -0700125 dev_err(pctldev->dev,
Linus Walleijae6b4d82011-10-19 18:14:33 +0200126 "unable to set pin configuration on pin %d\n", pin);
127 return ret;
128 }
129
130 return 0;
131}
132
133/**
134 * pin_config_set() - set the configuration of a single pin parameter
Stephen Warren43699de2011-12-15 16:57:17 -0700135 * @dev_name: name of pin controller device for this pin
Linus Walleijae6b4d82011-10-19 18:14:33 +0200136 * @name: name of the pin to set the config for
137 * @config: the config in this argument will contain the desired pin state, it
138 * can be used directly by drivers as a numeral, or it can be dereferenced
139 * to any struct.
140 */
Stephen Warren43699de2011-12-15 16:57:17 -0700141int pin_config_set(const char *dev_name, const char *name,
Linus Walleijae6b4d82011-10-19 18:14:33 +0200142 unsigned long config)
143{
Stephen Warren43699de2011-12-15 16:57:17 -0700144 struct pinctrl_dev *pctldev;
Stephen Warren57b676f2012-03-02 13:05:44 -0700145 int pin, ret;
146
147 mutex_lock(&pinctrl_mutex);
Linus Walleijae6b4d82011-10-19 18:14:33 +0200148
Linus Walleij9dfac4f2012-02-01 18:02:47 +0100149 pctldev = get_pinctrl_dev_from_devname(dev_name);
Stephen Warren57b676f2012-03-02 13:05:44 -0700150 if (!pctldev) {
151 ret = -EINVAL;
152 goto unlock;
153 }
Stephen Warren43699de2011-12-15 16:57:17 -0700154
Linus Walleijae6b4d82011-10-19 18:14:33 +0200155 pin = pin_get_from_name(pctldev, name);
Stephen Warren57b676f2012-03-02 13:05:44 -0700156 if (pin < 0) {
157 ret = pin;
158 goto unlock;
159 }
Linus Walleijae6b4d82011-10-19 18:14:33 +0200160
Stephen Warren57b676f2012-03-02 13:05:44 -0700161 ret = pin_config_set_for_pin(pctldev, pin, config);
162
163unlock:
164 mutex_unlock(&pinctrl_mutex);
165 return ret;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200166}
167EXPORT_SYMBOL(pin_config_set);
168
Stephen Warren43699de2011-12-15 16:57:17 -0700169int pin_config_group_get(const char *dev_name, const char *pin_group,
Linus Walleijae6b4d82011-10-19 18:14:33 +0200170 unsigned long *config)
171{
Stephen Warren43699de2011-12-15 16:57:17 -0700172 struct pinctrl_dev *pctldev;
173 const struct pinconf_ops *ops;
Stephen Warren57b676f2012-03-02 13:05:44 -0700174 int selector, ret;
175
176 mutex_lock(&pinctrl_mutex);
Linus Walleijae6b4d82011-10-19 18:14:33 +0200177
Linus Walleij9dfac4f2012-02-01 18:02:47 +0100178 pctldev = get_pinctrl_dev_from_devname(dev_name);
Stephen Warren57b676f2012-03-02 13:05:44 -0700179 if (!pctldev) {
180 ret = -EINVAL;
181 goto unlock;
182 }
Stephen Warren43699de2011-12-15 16:57:17 -0700183 ops = pctldev->desc->confops;
184
Linus Walleijae6b4d82011-10-19 18:14:33 +0200185 if (!ops || !ops->pin_config_group_get) {
Stephen Warren51cd24e2011-12-09 16:59:05 -0700186 dev_err(pctldev->dev, "cannot get configuration for pin "
Linus Walleijae6b4d82011-10-19 18:14:33 +0200187 "group, missing group config get function in "
188 "driver\n");
Stephen Warren57b676f2012-03-02 13:05:44 -0700189 ret = -EINVAL;
190 goto unlock;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200191 }
192
193 selector = pinctrl_get_group_selector(pctldev, pin_group);
Stephen Warren57b676f2012-03-02 13:05:44 -0700194 if (selector < 0) {
195 ret = selector;
196 goto unlock;
197 }
Linus Walleijae6b4d82011-10-19 18:14:33 +0200198
Stephen Warren57b676f2012-03-02 13:05:44 -0700199 ret = ops->pin_config_group_get(pctldev, selector, config);
200
201unlock:
202 mutex_unlock(&pinctrl_mutex);
203 return ret;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200204}
205EXPORT_SYMBOL(pin_config_group_get);
206
Stephen Warren43699de2011-12-15 16:57:17 -0700207int pin_config_group_set(const char *dev_name, const char *pin_group,
Linus Walleijae6b4d82011-10-19 18:14:33 +0200208 unsigned long config)
209{
Stephen Warren43699de2011-12-15 16:57:17 -0700210 struct pinctrl_dev *pctldev;
211 const struct pinconf_ops *ops;
212 const struct pinctrl_ops *pctlops;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200213 int selector;
214 const unsigned *pins;
215 unsigned num_pins;
216 int ret;
217 int i;
218
Stephen Warren57b676f2012-03-02 13:05:44 -0700219 mutex_lock(&pinctrl_mutex);
220
Linus Walleij9dfac4f2012-02-01 18:02:47 +0100221 pctldev = get_pinctrl_dev_from_devname(dev_name);
Stephen Warren57b676f2012-03-02 13:05:44 -0700222 if (!pctldev) {
223 ret = -EINVAL;
224 goto unlock;
225 }
Stephen Warren43699de2011-12-15 16:57:17 -0700226 ops = pctldev->desc->confops;
227 pctlops = pctldev->desc->pctlops;
228
Linus Walleijae6b4d82011-10-19 18:14:33 +0200229 if (!ops || (!ops->pin_config_group_set && !ops->pin_config_set)) {
Stephen Warren51cd24e2011-12-09 16:59:05 -0700230 dev_err(pctldev->dev, "cannot configure pin group, missing "
Linus Walleijae6b4d82011-10-19 18:14:33 +0200231 "config function in driver\n");
Stephen Warren57b676f2012-03-02 13:05:44 -0700232 ret = -EINVAL;
233 goto unlock;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200234 }
235
236 selector = pinctrl_get_group_selector(pctldev, pin_group);
Stephen Warren57b676f2012-03-02 13:05:44 -0700237 if (selector < 0) {
238 ret = selector;
239 goto unlock;
240 }
Linus Walleijae6b4d82011-10-19 18:14:33 +0200241
242 ret = pctlops->get_group_pins(pctldev, selector, &pins, &num_pins);
243 if (ret) {
Stephen Warren51cd24e2011-12-09 16:59:05 -0700244 dev_err(pctldev->dev, "cannot configure pin group, error "
Linus Walleijae6b4d82011-10-19 18:14:33 +0200245 "getting pins\n");
Stephen Warren57b676f2012-03-02 13:05:44 -0700246 goto unlock;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200247 }
248
249 /*
250 * If the pin controller supports handling entire groups we use that
251 * capability.
252 */
253 if (ops->pin_config_group_set) {
254 ret = ops->pin_config_group_set(pctldev, selector, config);
255 /*
256 * If the pin controller prefer that a certain group be handled
257 * pin-by-pin as well, it returns -EAGAIN.
258 */
259 if (ret != -EAGAIN)
Stephen Warren57b676f2012-03-02 13:05:44 -0700260 goto unlock;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200261 }
262
263 /*
264 * If the controller cannot handle entire groups, we configure each pin
265 * individually.
266 */
Stephen Warren57b676f2012-03-02 13:05:44 -0700267 if (!ops->pin_config_set) {
268 ret = 0;
269 goto unlock;
270 }
Linus Walleijae6b4d82011-10-19 18:14:33 +0200271
272 for (i = 0; i < num_pins; i++) {
273 ret = ops->pin_config_set(pctldev, pins[i], config);
274 if (ret < 0)
Stephen Warren57b676f2012-03-02 13:05:44 -0700275 goto unlock;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200276 }
277
Stephen Warren57b676f2012-03-02 13:05:44 -0700278 ret = 0;
279
280unlock:
281 mutex_unlock(&pinctrl_mutex);
282
283 return ret;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200284}
285EXPORT_SYMBOL(pin_config_group_set);
286
Stephen Warren1e2082b2012-03-02 13:05:48 -0700287int pinconf_map_to_setting(struct pinctrl_map const *map,
288 struct pinctrl_setting *setting)
289{
290 struct pinctrl_dev *pctldev = setting->pctldev;
Linus Walleij70b36372012-03-12 21:38:29 +0100291 int pin;
Stephen Warren1e2082b2012-03-02 13:05:48 -0700292
293 switch (setting->type) {
294 case PIN_MAP_TYPE_CONFIGS_PIN:
Linus Walleij70b36372012-03-12 21:38:29 +0100295 pin = pin_get_from_name(pctldev,
296 map->data.configs.group_or_pin);
297 if (pin < 0) {
298 dev_err(pctldev->dev, "could not map pin config for \"%s\"",
299 map->data.configs.group_or_pin);
300 return pin;
301 }
302 setting->data.configs.group_or_pin = pin;
Stephen Warren1e2082b2012-03-02 13:05:48 -0700303 break;
304 case PIN_MAP_TYPE_CONFIGS_GROUP:
Linus Walleij70b36372012-03-12 21:38:29 +0100305 pin = pinctrl_get_group_selector(pctldev,
306 map->data.configs.group_or_pin);
307 if (pin < 0) {
308 dev_err(pctldev->dev, "could not map group config for \"%s\"",
309 map->data.configs.group_or_pin);
310 return pin;
311 }
312 setting->data.configs.group_or_pin = pin;
Stephen Warren1e2082b2012-03-02 13:05:48 -0700313 break;
314 default:
315 return -EINVAL;
316 }
317
318 setting->data.configs.num_configs = map->data.configs.num_configs;
319 setting->data.configs.configs = map->data.configs.configs;
320
321 return 0;
322}
323
324void pinconf_free_setting(struct pinctrl_setting const *setting)
325{
326}
327
328int pinconf_apply_setting(struct pinctrl_setting const *setting)
329{
330 struct pinctrl_dev *pctldev = setting->pctldev;
331 const struct pinconf_ops *ops = pctldev->desc->confops;
332 int i, ret;
333
334 if (!ops) {
335 dev_err(pctldev->dev, "missing confops\n");
336 return -EINVAL;
337 }
338
339 switch (setting->type) {
340 case PIN_MAP_TYPE_CONFIGS_PIN:
341 if (!ops->pin_config_set) {
342 dev_err(pctldev->dev, "missing pin_config_set op\n");
343 return -EINVAL;
344 }
345 for (i = 0; i < setting->data.configs.num_configs; i++) {
346 ret = ops->pin_config_set(pctldev,
347 setting->data.configs.group_or_pin,
348 setting->data.configs.configs[i]);
349 if (ret < 0) {
350 dev_err(pctldev->dev,
351 "pin_config_set op failed for pin %d config %08lx\n",
352 setting->data.configs.group_or_pin,
353 setting->data.configs.configs[i]);
354 return ret;
355 }
356 }
357 break;
358 case PIN_MAP_TYPE_CONFIGS_GROUP:
359 if (!ops->pin_config_group_set) {
360 dev_err(pctldev->dev,
361 "missing pin_config_group_set op\n");
362 return -EINVAL;
363 }
364 for (i = 0; i < setting->data.configs.num_configs; i++) {
365 ret = ops->pin_config_group_set(pctldev,
366 setting->data.configs.group_or_pin,
367 setting->data.configs.configs[i]);
368 if (ret < 0) {
369 dev_err(pctldev->dev,
370 "pin_config_group_set op failed for group %d config %08lx\n",
371 setting->data.configs.group_or_pin,
372 setting->data.configs.configs[i]);
373 return ret;
374 }
375 }
376 break;
377 default:
378 return -EINVAL;
379 }
380
381 return 0;
382}
383
Linus Walleijae6b4d82011-10-19 18:14:33 +0200384#ifdef CONFIG_DEBUG_FS
385
Stephen Warren1e2082b2012-03-02 13:05:48 -0700386void pinconf_show_map(struct seq_file *s, struct pinctrl_map const *map)
387{
Stephen Warren6cb41582012-04-13 10:49:06 -0600388 struct pinctrl_dev *pctldev;
389 const struct pinconf_ops *confops;
Stephen Warren1e2082b2012-03-02 13:05:48 -0700390 int i;
391
Stephen Warren6cb41582012-04-13 10:49:06 -0600392 pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name);
393 if (pctldev)
394 confops = pctldev->desc->confops;
395 else
396 confops = NULL;
397
Stephen Warren1e2082b2012-03-02 13:05:48 -0700398 switch (map->type) {
399 case PIN_MAP_TYPE_CONFIGS_PIN:
400 seq_printf(s, "pin ");
401 break;
402 case PIN_MAP_TYPE_CONFIGS_GROUP:
403 seq_printf(s, "group ");
404 break;
405 default:
406 break;
407 }
408
409 seq_printf(s, "%s\n", map->data.configs.group_or_pin);
410
Stephen Warren6cb41582012-04-13 10:49:06 -0600411 for (i = 0; i < map->data.configs.num_configs; i++) {
412 seq_printf(s, "config ");
413 if (confops && confops->pin_config_config_dbg_show)
414 confops->pin_config_config_dbg_show(pctldev, s,
415 map->data.configs.configs[i]);
416 else
417 seq_printf(s, "%08lx", map->data.configs.configs[i]);
418 seq_printf(s, "\n");
419 }
Stephen Warren1e2082b2012-03-02 13:05:48 -0700420}
421
422void pinconf_show_setting(struct seq_file *s,
423 struct pinctrl_setting const *setting)
424{
425 struct pinctrl_dev *pctldev = setting->pctldev;
426 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
Stephen Warren6cb41582012-04-13 10:49:06 -0600427 const struct pinconf_ops *confops = pctldev->desc->confops;
Stephen Warren1e2082b2012-03-02 13:05:48 -0700428 struct pin_desc *desc;
429 int i;
430
431 switch (setting->type) {
432 case PIN_MAP_TYPE_CONFIGS_PIN:
433 desc = pin_desc_get(setting->pctldev,
434 setting->data.configs.group_or_pin);
435 seq_printf(s, "pin %s (%d)",
436 desc->name ? desc->name : "unnamed",
437 setting->data.configs.group_or_pin);
438 break;
439 case PIN_MAP_TYPE_CONFIGS_GROUP:
440 seq_printf(s, "group %s (%d)",
441 pctlops->get_group_name(pctldev,
442 setting->data.configs.group_or_pin),
443 setting->data.configs.group_or_pin);
444 break;
445 default:
446 break;
447 }
448
449 /*
450 * FIXME: We should really get the pin controler to dump the config
451 * values, so they can be decoded to something meaningful.
452 */
Stephen Warren6cb41582012-04-13 10:49:06 -0600453 for (i = 0; i < setting->data.configs.num_configs; i++) {
454 seq_printf(s, " ");
455 if (confops && confops->pin_config_config_dbg_show)
456 confops->pin_config_config_dbg_show(pctldev, s,
457 setting->data.configs.configs[i]);
458 else
459 seq_printf(s, "%08lx",
460 setting->data.configs.configs[i]);
461 }
Stephen Warren1e2082b2012-03-02 13:05:48 -0700462
463 seq_printf(s, "\n");
464}
465
Linus Walleijae6b4d82011-10-19 18:14:33 +0200466static void pinconf_dump_pin(struct pinctrl_dev *pctldev,
467 struct seq_file *s, int pin)
468{
469 const struct pinconf_ops *ops = pctldev->desc->confops;
470
Linus Walleij394349f2011-11-24 18:27:15 +0100471 /* no-op when not using generic pin config */
472 pinconf_generic_dump_pin(pctldev, s, pin);
Linus Walleijae6b4d82011-10-19 18:14:33 +0200473 if (ops && ops->pin_config_dbg_show)
474 ops->pin_config_dbg_show(pctldev, s, pin);
475}
476
477static int pinconf_pins_show(struct seq_file *s, void *what)
478{
479 struct pinctrl_dev *pctldev = s->private;
Dong Aishengad8bb722012-04-10 12:41:34 +0800480 const struct pinconf_ops *ops = pctldev->desc->confops;
Chanho Park706e8522012-01-03 16:47:50 +0900481 unsigned i, pin;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200482
Dong Aishengad8bb722012-04-10 12:41:34 +0800483 if (!ops || !ops->pin_config_get)
484 return 0;
485
Linus Walleijae6b4d82011-10-19 18:14:33 +0200486 seq_puts(s, "Pin config settings per pin\n");
Dong Aisheng2aeefe02012-04-16 22:07:24 +0800487 seq_puts(s, "Format: pin (name): configs\n");
Linus Walleijae6b4d82011-10-19 18:14:33 +0200488
Stephen Warren57b676f2012-03-02 13:05:44 -0700489 mutex_lock(&pinctrl_mutex);
490
Chanho Park706e8522012-01-03 16:47:50 +0900491 /* The pin number can be retrived from the pin controller descriptor */
Stephen Warren546edd82012-01-06 13:38:31 -0700492 for (i = 0; i < pctldev->desc->npins; i++) {
Linus Walleijae6b4d82011-10-19 18:14:33 +0200493 struct pin_desc *desc;
494
Chanho Park706e8522012-01-03 16:47:50 +0900495 pin = pctldev->desc->pins[i].number;
Linus Walleijae6b4d82011-10-19 18:14:33 +0200496 desc = pin_desc_get(pctldev, pin);
Chanho Park706e8522012-01-03 16:47:50 +0900497 /* Skip if we cannot search the pin */
Linus Walleijae6b4d82011-10-19 18:14:33 +0200498 if (desc == NULL)
499 continue;
500
501 seq_printf(s, "pin %d (%s):", pin,
502 desc->name ? desc->name : "unnamed");
503
504 pinconf_dump_pin(pctldev, s, pin);
505
506 seq_printf(s, "\n");
507 }
508
Stephen Warren57b676f2012-03-02 13:05:44 -0700509 mutex_unlock(&pinctrl_mutex);
510
Linus Walleijae6b4d82011-10-19 18:14:33 +0200511 return 0;
512}
513
514static void pinconf_dump_group(struct pinctrl_dev *pctldev,
515 struct seq_file *s, unsigned selector,
516 const char *gname)
517{
518 const struct pinconf_ops *ops = pctldev->desc->confops;
519
Linus Walleij394349f2011-11-24 18:27:15 +0100520 /* no-op when not using generic pin config */
521 pinconf_generic_dump_group(pctldev, s, gname);
Linus Walleijae6b4d82011-10-19 18:14:33 +0200522 if (ops && ops->pin_config_group_dbg_show)
523 ops->pin_config_group_dbg_show(pctldev, s, selector);
524}
525
526static int pinconf_groups_show(struct seq_file *s, void *what)
527{
528 struct pinctrl_dev *pctldev = s->private;
529 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
530 const struct pinconf_ops *ops = pctldev->desc->confops;
Viresh Kumard1e90e92012-03-30 11:25:40 +0530531 unsigned ngroups = pctlops->get_groups_count(pctldev);
Linus Walleijae6b4d82011-10-19 18:14:33 +0200532 unsigned selector = 0;
533
534 if (!ops || !ops->pin_config_group_get)
535 return 0;
536
537 seq_puts(s, "Pin config settings per pin group\n");
Dong Aisheng2aeefe02012-04-16 22:07:24 +0800538 seq_puts(s, "Format: group (name): configs\n");
Linus Walleijae6b4d82011-10-19 18:14:33 +0200539
Stephen Warren57b676f2012-03-02 13:05:44 -0700540 mutex_lock(&pinctrl_mutex);
541
Viresh Kumard1e90e92012-03-30 11:25:40 +0530542 while (selector < ngroups) {
Linus Walleijae6b4d82011-10-19 18:14:33 +0200543 const char *gname = pctlops->get_group_name(pctldev, selector);
544
545 seq_printf(s, "%u (%s):", selector, gname);
546 pinconf_dump_group(pctldev, s, selector, gname);
Stephen Warrenf7b90062012-02-19 23:45:58 -0700547 seq_printf(s, "\n");
548
Linus Walleijae6b4d82011-10-19 18:14:33 +0200549 selector++;
550 }
551
Stephen Warren57b676f2012-03-02 13:05:44 -0700552 mutex_unlock(&pinctrl_mutex);
553
Linus Walleijae6b4d82011-10-19 18:14:33 +0200554 return 0;
555}
556
557static int pinconf_pins_open(struct inode *inode, struct file *file)
558{
559 return single_open(file, pinconf_pins_show, inode->i_private);
560}
561
562static int pinconf_groups_open(struct inode *inode, struct file *file)
563{
564 return single_open(file, pinconf_groups_show, inode->i_private);
565}
566
567static const struct file_operations pinconf_pins_ops = {
568 .open = pinconf_pins_open,
569 .read = seq_read,
570 .llseek = seq_lseek,
571 .release = single_release,
572};
573
574static const struct file_operations pinconf_groups_ops = {
575 .open = pinconf_groups_open,
576 .read = seq_read,
577 .llseek = seq_lseek,
578 .release = single_release,
579};
580
581void pinconf_init_device_debugfs(struct dentry *devroot,
582 struct pinctrl_dev *pctldev)
583{
584 debugfs_create_file("pinconf-pins", S_IFREG | S_IRUGO,
585 devroot, pctldev, &pinconf_pins_ops);
586 debugfs_create_file("pinconf-groups", S_IFREG | S_IRUGO,
587 devroot, pctldev, &pinconf_groups_ops);
588}
589
590#endif